Syntax cookbook

# Always intersect with the columns that actually loaded
cols = [c for c in ASSETS if c in prices.columns]
close = prices[cols]

close.index          # DatetimeIndex, tz-naive, sorted ascending
close.columns        # loaded tickers, in ASSETS order
close.shape          # (n_days, n_symbols)
prices.attrs.get("load_errors")  # list[str] when some symbols failed

close.loc[dt]        # Series: one row, indexed by symbol
close["SPY"]         # Series: one column, indexed by date
close.at[dt, "SPY"]  # scalar — the fastest single-cell access
close.iloc[-1]       # last row (avoid inside on_day: it hides the date)

close = prices[cols]

# --- Trend ---------------------------------------------------------------
sma_200 = close.rolling(200, min_periods=200).mean()
ema_50 = close.ewm(span=50, adjust=False).mean()
above = close > sma_200                      # boolean DataFrame

# --- Returns and momentum ----------------------------------------------
daily = close.pct_change()                   # 1-day simple returns
mom_12m = close.pct_change(252)              # trailing 12-month return
mom_6m = close.pct_change(126)               # trailing 6-month return
log_ret = np.log(close).diff()               # log returns

# --- Volatility and risk ------------------------------------------------
vol_20 = daily.rolling(20).std() * np.sqrt(252)      # annualised
downside = daily.clip(upper=0).rolling(60).std()

# --- Mean reversion -----------------------------------------------------
mu = close.rolling(20, min_periods=20).mean()
sd = close.rolling(20, min_periods=20).std(ddof=0)
zscore = (close - mu) / sd.replace(0, np.nan)         # guard divide-by-zero

# --- Range and drawdown -------------------------------------------------
high_252 = close.rolling(252).max()
dd_from_high = close / high_252 - 1
rsi_up = daily.clip(lower=0).rolling(14).mean()
rsi_dn = (-daily.clip(upper=0)).rolling(14).mean()
rsi = 100 - 100 / (1 + rsi_up / rsi_dn.replace(0, np.nan))

# Rank across symbols on each date: axis=1 is the cross-section
mom = close.pct_change(126)

ranks = mom.rank(axis=1, ascending=False)     # 1 = strongest that day
top3 = ranks <= 3                             # boolean mask

# Cross-sectional z-score (relative strength, market-neutral in spirit)
row_mu = mom.mean(axis=1)
row_sd = mom.std(axis=1).replace(0, np.nan)
rel = mom.sub(row_mu, axis=0).div(row_sd, axis=0)

# Inside on_day: pick names from a single row
def pick_top(dt, n=3):
    row = mom.loc[dt].dropna()
    if row.empty:
        return []
    ranked = row.sort_values(ascending=False)
    return [s for s in ranked.head(n).index if ranked[s] > 0]

# Equal weight over the selected names
def equal_weight(picks: list[str]) -> dict[str, float]:
    if not picks:
        return {}                             # {} means go to cash
    w = 1.0 / len(picks)
    return {s: w for s in picks}


# Inverse-volatility weights (risk parity flavour)
def inverse_vol(dt, picks, vol) -> dict[str, float]:
    inv = {s: 1.0 / float(vol.at[dt, s]) for s in picks
           if pd.notna(vol.at[dt, s]) and vol.at[dt, s] > 1e-8}
    total = sum(inv.values())
    return {s: v / total for s, v in inv.items()} if total > 0 else {}


# Volatility targeting: scale exposure, leave the remainder in cash
def vol_scaled(dt, symbol, vol, target=0.10) -> dict[str, float]:
    v = float(vol.at[dt, symbol])
    return {symbol: min(1.0, target / v)} if v > 1e-8 else {}


# Fixed sleeves with a deliberate cash buffer
CORE = {"SPY": 0.45, "TLT": 0.25, "GLD": 0.15}   # 85% invested, 15% cash

# Combine conditions with & | ~ — and always parenthesise
trend_up = close > sma_200
cheap = zscore < -1.0
signal = trend_up & cheap                  # elementwise AND
risk_off = ~trend_up["SPY"]                # elementwise NOT

# Row-level reductions (these are pandas methods, not the missing builtins)
sma_200.loc[dt].isna().all()      # nothing ready yet
trend_up.loc[dt].any()            # at least one asset in an uptrend
int(trend_up.loc[dt].sum())       # how many are in an uptrend

# Shift to enforce "decide today, act on the next bar"
delayed = signal.shift(1)

dt.year, dt.month, dt.day          # ints
dt.dayofweek                       # Monday = 0 … Sunday = 6
dt.isocalendar()[:2]               # (ISO year, ISO week) — weekly gating
dt.strftime("%Y-%m-%d")            # string form used in Trade.date
dt in prices.index                 # membership test before .at lookups

# Month-end resampling, then aligned back to daily trading dates
monthly = close.resample("ME").last()
monthly_mom = monthly.pct_change(12).reindex(close.index).ffill()