# config.py — Centralized project configuration
TICKERS = {
    'energy': ['CNQ.TO', 'SU.TO', 'CVE.TO', 'IMO.TO', 'TOU.TO'],
    'benchmarks': ['^GSPTSE', 'XEG.TO'],
    'commodities': ['CL=F', 'NG=F'],
}
ALL_TICKERS = [t for group in TICKERS.values() for t in group]
START_DATE = '2018-01-01'
END_DATE = '2024-12-31'
TRADING_DAYS = 252
RISK_FREE_RATE = 0.04
CONFIDENCE_LEVEL = 0.95
INITIAL_CAPITAL = 1_000_000
print(f"Tickers: {TICKERS['energy']}; Risk-free rate: {RISK_FREE_RATE}")

Tickers: ['CNQ.TO', 'SU.TO', 'CVE.TO', 'IMO.TO', 'TOU.TO']; Risk-free rate: 0.04

import numpy as np
import pandas as pd

class Portfolio:
    def __init__(self, tickers: list, weights: np.ndarray, name: str = 'Unnamed'):
        if len(tickers) != len(weights):
            raise ValueError("Tickers and weights must have equal length.")
        if not np.isclose(weights.sum(), 1.0):
            raise ValueError(f"Weights must sum to 1.0, got {weights.sum():.4f}")
        self._tickers = list(tickers)
        self._weights = np.array(weights, dtype=np.float64)
        self.name = name
        self._returns = None

    @property
    def n_assets(self):
        return len(self._tickers)

    def __repr__(self):
        alloc = ', '.join(f"{t}: {w:.1%}" for t, w in zip(self._tickers, self._weights))
        return f"Portfolio('{self.name}', [{alloc}])"

    def set_returns(self, returns_df: pd.DataFrame):
        self._returns = returns_df[self._tickers].copy()

    def portfolio_returns(self) -> pd.Series:
        if self._returns is None:
            raise RuntimeError("Call set_returns() first.")
        return (self._returns * self._weights).sum(axis=1)

    def annualized_return(self, trading_days=252) -> float:
        pr = self.portfolio_returns()
        return (1 + pr).prod() ** (trading_days / len(pr)) - 1

    def annualized_volatility(self, trading_days=252) -> float:
        return self.portfolio_returns().std() * np.sqrt(trading_days)

    def sharpe_ratio(self, rf=0.04, trading_days=252) -> float:
        return (self.annualized_return(trading_days) - rf) / self.annualized_volatility(trading_days)

    def max_drawdown(self) -> float:
        cumulative = (1 + self.portfolio_returns()).cumprod()
        return ((cumulative - cumulative.cummax()) / cumulative.cummax()).min()

    def summary(self) -> pd.Series:
        return pd.Series({
            'Ann. Return': f"{self.annualized_return():.2%}",
            'Ann. Volatility': f"{self.annualized_volatility():.2%}",
            'Sharpe Ratio': f"{self.sharpe_ratio():.3f}",
            'Max Drawdown': f"{self.max_drawdown():.2%}",
            'N Assets': self.n_assets,
        }, name=self.name)
print("Portfolio class defined.")

Portfolio class defined.

np.random.seed(42)
n_days, n_assets = 252, 3
synth_returns = pd.DataFrame(
    np.random.normal(0.0004, 0.02, (n_days, n_assets)),
    columns=['CNQ.TO', 'SU.TO', 'CVE.TO']
)
p = Portfolio(['CNQ.TO', 'SU.TO', 'CVE.TO'], np.array([0.5, 0.3, 0.2]), name='Energy Core')
p.set_returns(synth_returns)
print(p)
print(p.summary())

Portfolio('Energy Core', [CNQ.TO: 50.0%, SU.TO: 30.0%, CVE.TO: 20.0%])
Ann. Return          4.44%
Ann. Volatility     18.24%
Sharpe Ratio         0.024
Max Drawdown       -16.40%
N Assets                 3
Name: Energy Core, dtype: object

returns_matrix = np.random.normal(0.0004, 0.02, (252, 5))
print(f"Shape: {returns_matrix.shape}, Memory: {returns_matrix.nbytes/1024:.1f} KB")
monthly_blocks = returns_matrix.reshape(12, 21, 5)
crash_days = np.any(returns_matrix < -0.03, axis=1)
print(f"Crash days (return < -3%): {crash_days.sum()}")
cum_vectorized = np.cumprod(1 + returns_matrix[:, 0])
print(f"Cumulative return (first asset): {cum_vectorized[-1]:.4f}")

Shape: (252, 5), Memory: 9.8 KB
Crash days (return < -3%): 60
Cumulative return (first asset): 1.0571

try:
    import yfinance as yf
    import time
    # Download each ticker separately to avoid yfinance "database is locked" (e.g. CVE.TO)
    dfs = []
    for t in TICKERS['energy']:
        try:
            d = yf.download(t, start=START_DATE, end=END_DATE, auto_adjust=True, progress=False, threads=False)
            if d is not None and not d.empty:
                close = d['Close'] if 'Close' in d.columns else d.iloc[:, 0]
                close.name = t
                dfs.append(close)
        except Exception as e:
            print(f"Skip {t}: {e}")
        time.sleep(0.2)
    if len(dfs) >= 2:
        prices = pd.concat(dfs, axis=1).dropna(how='all').ffill().bfill()
        log_returns = np.log(prices / prices.shift(1)).dropna()
        print("Data from yfinance (Canadian energy equities)")
    else:
        raise RuntimeError("Too few tickers downloaded")
except Exception as e:
    print(f"yfinance not available ({e}); using synthetic returns.")
    dates = pd.date_range(start=START_DATE, end=END_DATE, freq='B')
    n = len(dates)
    prices = pd.DataFrame(
        np.cumprod(1 + np.random.normal(0.0004, 0.02, (n, len(TICKERS['energy']))), axis=0) * 100,
        index=dates, columns=TICKERS['energy']
    )
    log_returns = np.log(prices / prices.shift(1)).dropna()
print(log_returns.describe().round(6))

Data from yfinance (Canadian energy equities)
Ticker       CNQ.TO        SU.TO       CVE.TO       IMO.TO       TOU.TO
count   1755.000000  1755.000000  1755.000000  1755.000000  1755.000000
mean       0.000584     0.000207     0.000394     0.000560     0.000824
std        0.026459     0.024320     0.034535     0.023183     0.023999
min       -0.345035    -0.231382    -0.726612    -0.195084    -0.127964
25%       -0.011651    -0.010645    -0.015274    -0.010626    -0.012846
50%        0.001063     0.000247     0.001375     0.000770     0.000424
75%        0.012680     0.011144     0.015247     0.011779     0.014047
max        0.203858     0.220522     0.208328     0.160773     0.139924

meta_df = pd.DataFrame([
    ('CNQ.TO', 'Oil & Gas', 'Large'), ('SU.TO', 'Integrated', 'Large'),
    ('CVE.TO', 'Oil & Gas', 'Mid'), ('IMO.TO', 'Integrated', 'Mid'),
    ('TOU.TO', 'Natural Gas', 'Mid'),
], columns=['Ticker', 'Sector', 'Cap'])
cols = [c for c in meta_df['Ticker'] if c in log_returns.columns]
ann = log_returns[cols].agg(['mean', 'std']).T.reset_index()
ann.columns = ['Ticker', 'daily_mean', 'daily_std']
merged = pd.merge(ann, meta_df, on='Ticker')
sector_summary = merged.groupby('Sector').agg(avg_daily_return=('daily_mean', 'mean'), count=('Ticker', 'count'))
print(sector_summary)

             avg_daily_return  count
Sector                              
Integrated           0.000384      2
Natural Gas          0.000824      1
Oil & Gas            0.000489      2

from scipy.stats import norm

class RiskEngine:
    def __init__(self, returns, confidence=0.95, portfolio_value=1_000_000):
        self.returns = np.array(returns)
        self.alpha = 1 - confidence
        self.portfolio_value = portfolio_value

    def var_historical(self):
        return -np.percentile(self.returns, self.alpha * 100) * self.portfolio_value

    def var_parametric(self):
        mu, sigma = self.returns.mean(), self.returns.std()
        return -norm.ppf(self.alpha, loc=mu, scale=sigma) * self.portfolio_value

    def cvar_historical(self):
        threshold = np.percentile(self.returns, self.alpha * 100)
        return -self.returns[self.returns <= threshold].mean() * self.portfolio_value

rets = log_returns['CNQ.TO'].dropna().values if 'CNQ.TO' in log_returns.columns else synth_returns['CNQ.TO'].values
risk = RiskEngine(rets, confidence=0.95)
print(f"VaR (Historical):  ${risk.var_historical():,.0f}")
print(f"VaR (Parametric):  ${risk.var_parametric():,.0f}")
print(f"CVaR (Historical): ${risk.cvar_historical():,.0f}")

VaR (Historical):  $34,684
VaR (Parametric):  $42,925
CVaR (Historical): $57,495

class BSMOption:
    def __init__(self, S, K, T, r, sigma, option_type='call'):
        self.S, self.K, self.T, self.r, self.sigma = S, K, T, r, sigma
        self.option_type = option_type.lower()

    @property
    def d1(self):
        return (np.log(self.S/self.K) + (self.r + 0.5*self.sigma**2)*self.T) / (self.sigma*np.sqrt(self.T))

    @property
    def d2(self):
        return self.d1 - self.sigma * np.sqrt(self.T)

    def price(self):
        if self.option_type == 'call':
            return self.S * norm.cdf(self.d1) - self.K * np.exp(-self.r*self.T) * norm.cdf(self.d2)
        return self.K * np.exp(-self.r*self.T) * norm.cdf(-self.d2) - self.S * norm.cdf(-self.d1)

    def delta(self):
        return norm.cdf(self.d1) if self.option_type == 'call' else norm.cdf(self.d1) - 1

    def gamma(self):
        return norm.pdf(self.d1) / (self.S * self.sigma * np.sqrt(self.T))

bsm = BSMOption(S=50, K=50, T=0.5, r=0.04, sigma=0.30)
print(f"Call price: {bsm.price():.4f}")
print(f"Delta: {bsm.delta():.4f}, Gamma: {bsm.gamma():.6f}")

Call price: 4.6952
Delta: 0.5794, Gamma: 0.036865

class GeometricBrownianMotion:
    def __init__(self, S0, mu, sigma, T, n_steps, n_paths, seed=42):
        self.S0, self.mu, self.sigma = S0, mu, sigma
        self.T, self.n_steps, self.n_paths = T, n_steps, n_paths
        self.dt = T / n_steps
        self.rng = np.random.default_rng(seed)

    def simulate(self):
        Z = self.rng.standard_normal((self.n_steps, self.n_paths))
        drift = (self.mu - 0.5*self.sigma**2) * self.dt
        log_paths = np.vstack([np.zeros(self.n_paths), np.cumsum(drift + self.sigma*np.sqrt(self.dt)*Z, axis=0)])
        return self.S0 * np.exp(log_paths)

gbm = GeometricBrownianMotion(S0=100, mu=0.08, sigma=0.25, T=1, n_steps=252, n_paths=5000)
paths = gbm.simulate()
print(f"Paths shape: {paths.shape}; terminal mean: {paths[-1].mean():.2f}, std: {paths[-1].std():.2f}")

Paths shape: (253, 5000); terminal mean: 108.79, std: 28.05

import matplotlib.pyplot as plt
fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(paths[:, :100], alpha=0.7, linewidth=0.8)
ax.set_title('GBM Sample Paths (S0=100, μ=8%, σ=25%)')
ax.set_xlabel('Time step')
ax.set_ylabel('Price')
plt.tight_layout()
plt.show()

def kelly_criterion_continuous(mu, sigma, rf=0.04):
    return (mu - rf) / (sigma**2)

mu_ann = rets.mean() * 252
sigma_ann = np.std(rets) * np.sqrt(252)
kelly_f = kelly_criterion_continuous(mu_ann, sigma_ann)
print(f"Full Kelly fraction: {kelly_f:.4f}; Half Kelly: {kelly_f/2:.4f}")

Full Kelly fraction: 0.6074; Half Kelly: 0.3037

Book Chapter	Topic	Project Section
Ch. 3–6	Data types, NumPy, pandas, OOP	§2–5
Ch. 8–9	Time series, I/O	§5–6, §8
Ch. 10–12	Performance, math, stochastics	§4, §10
Ch. 13–16	Statistics, optimization, risk, Kelly	§12, §14, §17
Ch. 17–21	Derivatives (BSM, MC, LSMC)	§15

Adaptive Portfolio Intelligence System (APIS) — Capstone Project¶

Executive Summary¶

2. Configuration¶

3. Portfolio Class (OOP)¶

4. NumPy — Vectorization¶

5. pandas — Data & Returns¶

14. Risk Analytics — VaR & CVaR¶

15. Derivatives — BSM Option & Greeks¶

10. Stochastic Modeling — GBM¶

17. Kelly Criterion¶

Complete Coverage Map¶