Situational Awareness LP

# ── SA LP 13F data fetcher ─────────────────────────────────────────
# Fetches all 13F-HR filings from SEC EDGAR for Situational Awareness LP,
# parses the infotable XML, and resolves CUSIPs to tickers.
# Output: JSON with one entry per quarterly filing, each containing
#         the filing date, quarter label, and a list of holdings.
# Caches results in CACHE_DIR to avoid redundant SEC requests.

import urllib.request, re, json, sys, time, os, xml.etree.ElementTree as ET
from datetime import datetime

# ── Configuration (update these for your environment) ──────────────
SEC_UA = os.environ.get(
    'SEC_USER_AGENT',
    'stafforini.com situational-awareness-lp research; contact via stafforini.com')
CACHE_DIR = os.path.expanduser('~/.cache')

CIK = '2045724'
BASE = f'https://www.sec.gov/Archives/edgar/data/{CIK}'
NS = {'ns': 'http://www.sec.gov/edgar/document/thirteenf/informationtable'}
CACHE = os.path.join(CACHE_DIR, 'sa-lp-13f.json')

CUSIP_TICKER = {
    '038169207': 'APLD', '05614L209': 'BW',   '09173B107': 'BITF',
    '093712107': 'BE',   '093712AH0': 'BE',   '11135F101': 'AVGO',
    '12514G108': 'CIFR', '17253J106': 'CIFR', '17253JAA4': 'CIFR',
    '18452B209': 'CLSK', '19247G107': 'COHR', '21037T109': 'CEG',
    '21873S108': 'CRWV', '21874A106': 'CORZ', '26884L109': 'EQT',
    '36168Q104': 'GLXY', '36317J209': 'GLXY', '44282L109': 'HUT',
    '44812J104': 'HUT',  '456788108': 'INFY', '458140100': 'INTC',
    '49338L103': 'KRC',  '49427F108': 'KRC',  '53115L104': 'LBRT',
    '55024U109': 'LITE', '55024UAD1': 'LITE', '573874104': 'MRVL',
    '577933104': 'MRVL', '593787101': 'MU',   '593787105': 'MU',
    '595112103': 'MU',   '607828100': 'MOD',  '67066G104': 'NVDA',
    '683344105': 'ONTO', '68340J108': 'ONTO', '73933G202': 'PSIX',
    '73933H100': 'PSIX', '743344109': 'PUMP', '74347M108': 'PUMP',
    '76754A103': 'RIOT', '767292105': 'RIOT', '80004C200': 'SNDK',
    '80106M109': 'SNDK', '83418M103': 'SEI',  '87422Q109': 'TLN',
    '87425V106': 'TLN',  '874039100': 'TSM',  '89854H102': 'TSEM',
    '92189F106': 'SMH',  '92189F676': 'SMH',  '92535P101': 'VRT',
    '92537N108': 'VRT',  '92840M102': 'VST',  '958102105': 'WDC',
    '958102AT2': 'WDC',  '98321C108': 'WYFI',
    'G1110V104': 'BITF', 'G1189L107': 'BTDR', 'G11448100': 'BTDR',
    'G7945J104': 'STX',  'G7997R103': 'STX',  'G96115103': 'WYFI',
    'M87915274': 'TSEM', 'Q4982L109': 'IREN',
}

def fetch(url, timeout=10):
    time.sleep(0.5)
    req = urllib.request.Request(url, headers={'User-Agent': SEC_UA})
    with urllib.request.urlopen(req, timeout=timeout) as resp:
        return resp.read()

def find_infotable_filename(acc):
    """Discover the infotable XML filename for a filing via EFTS, then -index.htm."""
    # EFTS search (fast, reliable)
    try:
        efts = f'https://efts.sec.gov/LATEST/search-index?q=%22{acc}%22'
        data = json.loads(fetch(efts))
        for hit in data.get('hits', {}).get('hits', []):
            doc_id = hit['_id']  # format: "accession:filename"
            filename = doc_id.split(':', 1)[1] if ':' in doc_id else ''
            if filename.endswith('.xml') and 'primary_doc' not in filename:
                return filename
    except Exception:
        pass
    # Fallback: filing index page
    acc_path = acc.replace('-', '')
    try:
        html = fetch(f'{BASE}/{acc_path}/{acc}-index.htm').decode()
        for href in re.findall(r'href="([^"]*\.xml)"', html):
            fn = href.split('/')[-1]
            if fn != 'primary_doc.xml' and 'xslForm' not in href:
                return fn
    except Exception:
        pass
    return None

def parse_infotable(xml_data):
    root = ET.fromstring(xml_data)
    holdings = []
    for info in root.findall('.//ns:infoTable', NS):
        cusip = info.findtext('ns:cusip', '', NS).strip()
        value = int(info.findtext('ns:value', '0', NS))
        putcall = info.findtext('ns:putCall', '', NS).strip().lower()
        ticker = CUSIP_TICKER.get(cusip, '')
        if not ticker:
            issuer = info.findtext('ns:nameOfIssuer', '', NS)
            print(f"WARNING: Unknown CUSIP {cusip} ({issuer})", file=sys.stderr)
            ticker = f"UNKNOWN_{cusip}"
        pos_type = 'put' if putcall == 'put' else 'call' if putcall == 'call' else 'long'
        holdings.append({"ticker": ticker, "type": pos_type, "value": value})
    return holdings

def quarter_from_filing_date(fdate):
    d = datetime.strptime(fdate, '%Y-%m-%d')
    m, y = d.month, d.year
    if m <= 3:   return f'Q4_{y-1}', f'{y-1}-12-31'
    elif m <= 6: return f'Q1_{y}', f'{y}-03-31'
    elif m <= 9: return f'Q2_{y}', f'{y}-06-30'
    else:        return f'Q3_{y}', f'{y}-09-30'

def load_cache():
    if os.path.exists(CACHE):
        with open(CACHE) as f:
            return json.load(f)
    return {"filings": []}

def save_cache(data):
    os.makedirs(os.path.dirname(CACHE), exist_ok=True)
    with open(CACHE, 'w') as f:
        json.dump(data, f)

cached = load_cache()
cached_quarters = {f["quarter"] for f in cached["filings"]}
result = {"filings": list(cached["filings"])}

try:
    subs_url = f'https://data.sec.gov/submissions/CIK{CIK.zfill(10)}.json'
    subs = json.loads(fetch(subs_url))
    recent = subs['filings']['recent']
    accessions = sorted(
        [(recent['filingDate'][i], recent['accessionNumber'][i])
         for i in range(len(recent['form'])) if recent['form'][i] == '13F-HR'])

    for fdate, acc in accessions:
        quarter, quarter_end = quarter_from_filing_date(fdate)
        if quarter in cached_quarters:
            continue
        filename = find_infotable_filename(acc)
        if not filename:
            print(f"Could not find infotable for {acc}", file=sys.stderr)
            continue
        acc_path = acc.replace('-', '')
        xml = fetch(f'{BASE}/{acc_path}/{filename}')
        holdings = parse_infotable(xml)
        result["filings"].append({
            "quarter": quarter, "quarter_end": quarter_end,
            "filing_date": fdate, "holdings": holdings})

    result["filings"].sort(key=lambda f: f["filing_date"])
    save_cache(result)
except Exception as e:
    if result["filings"]:
        print(f"SEC fetch error ({e}); using cache", file=sys.stderr)
    else:
        raise

return json.dumps(result)

import json
import yfinance as yf
import pandas as pd
from datetime import datetime, timedelta
import numpy as np
import requests
import time
import os
import warnings
warnings.filterwarnings('ignore')

# Parse data from the scraper block
parsed = json.loads(data) if isinstance(data, str) else data
filings = parsed["filings"]

# Build internal structures
filing_dates = {f["quarter"]: f["filing_date"] for f in filings}
quarter_end_dates = {f["quarter"]: f["quarter_end"] for f in filings}
quarters = [f["quarter"] for f in filings]

# Convert holdings list to dict keyed by quarter.
# Multiple positions in the same ticker with different types are aggregated
# by value per (ticker, type) pair.
holdings = {}
for f in filings:
    positions = {}
    for h in f["holdings"]:
        ticker = h["ticker"]
        pos_type = h["type"]
        value = h["value"]
        key = (ticker, pos_type)
        positions[key] = positions.get(key, 0) + value
    holdings[f["quarter"]] = positions


def get_prices(tickers, dates):
    """Fetch close prices for tickers on specific dates."""
    unique_tickers = sorted(set(tickers))
    all_dates = [datetime.strptime(d, '%Y-%m-%d') for d in dates]
    start = min(all_dates) - timedelta(days=5)
    end = max(all_dates) + timedelta(days=5)

    df = yf.download(unique_tickers, start=start, end=end, progress=False, auto_adjust=True)
    if df.empty:
        return {}

    # yf.download returns MultiIndex columns (metric, ticker) for multiple tickers
    if isinstance(df.columns, pd.MultiIndex):
        close = df['Close']
    else:
        close = df[['Close']]
        close.columns = unique_tickers

    prices = {}
    for ticker in unique_tickers:
        if ticker not in close.columns:
            continue
        series = close[ticker].dropna()
        if series.empty:
            continue
        prices[ticker] = {}
        for date_str in dates:
            target = pd.Timestamp(datetime.strptime(date_str, '%Y-%m-%d'))
            after = series[series.index >= target]
            if not after.empty:
                prices[ticker][date_str] = float(after.iloc[0])
            else:
                before = series[series.index <= target]
                if not before.empty:
                    prices[ticker][date_str] = float(before.iloc[-1])
    return prices


def _price_on_or_after(px_by_date, target_date):
    """Return (date, price) for the first available price on/after target."""
    if not px_by_date:
        return None
    dates = sorted(d for d in px_by_date if d >= target_date)
    if not dates:
        return None
    d = dates[0]
    return d, px_by_date[d]


def _price_on_or_before(px_by_date, target_date):
    """Return (date, price) for the last available price on/before target."""
    if not px_by_date:
        return None
    dates = sorted(d for d in px_by_date if d <= target_date)
    if not dates:
        return None
    d = dates[-1]
    return d, px_by_date[d]


def _period_price_pair(px_by_date, start_date, end_date):
    """Return start/end prices for a period using sensible boundary alignment."""
    start = _price_on_or_after(px_by_date, start_date)
    end = _price_on_or_before(px_by_date, end_date)
    if start is None or end is None:
        return None
    start_actual, p0 = start
    end_actual, p1 = end
    if end_actual < start_actual:
        return None
    return start_actual, end_actual, p0, p1


def _option_position_key(ticker, pos_type):
    return (ticker, pos_type)


def compute_return(positions, prices, start_date, end_date, mode='equity_only',
                   option_prices=None, option_params=None):
    """Compute weighted portfolio return between two dates.

    For option positions (call/put): if option_prices contains actual
    historical option prices for the ticker, compute returns directly from
    those prices.  Otherwise fall back to Black-Scholes repricing using
    the parameters in option_params.
    """
    total_value = 0
    weighted_return = 0

    for (ticker, pos_type), value in positions.items():
        if mode == 'equity_only' and pos_type != 'long':
            continue

        is_option = pos_type in ('call', 'put')
        opt_key = _option_position_key(ticker, pos_type)
        opt_px = option_prices.get(opt_key) if option_prices else None
        use_option_px = bool(is_option and opt_px)
        use_bs = False

        if use_option_px:
            pair = _period_price_pair(opt_px, start_date, end_date)
            if pair is None:
                use_option_px = False
            else:
                start_actual, end_actual, p0, p1 = pair

        if not use_option_px:
            px = prices.get(ticker)
            pair = _period_price_pair(px, start_date, end_date)
            if pair is None:
                continue
            start_actual, end_actual, p0, p1 = pair

        if p0 == 0:
            continue

        ret = (p1 - p0) / p0
        # Fallback: BS repricing when no option price data
        if is_option and not use_option_px:
            params = option_params.get(ticker) if option_params else None
            if params:
                K_call, K_put, sigma = params
                K_over_S = K_call if pos_type == 'call' else K_put
                dt = days_between(start_actual, end_actual) / 365.25
                ret = bs_option_return(ret, K_over_S, OPTION_T, dt, sigma,
                                       pos_type)
                use_bs = True
        total_value += value
        # When using actual option/BS prices the return already reflects
        # the directional bet, so sign is +1.  The -1 for puts applies
        # only to the raw stock-price proxy path.
        sign = 1 if (use_option_px or use_bs) else (
            -1 if pos_type == 'put' else 1)
        weighted_return += value * sign * ret

    return weighted_return / total_value if total_value else None


def annualize(ret, days):
    """Annualize a return over a given number of calendar days."""
    if ret is None or days <= 0:
        return None
    return (1 + ret) ** (365.25 / days) - 1


def days_between(d1, d2):
    return (datetime.strptime(d2, '%Y-%m-%d') - datetime.strptime(d1, '%Y-%m-%d')).days


def fmt(ret):
    return f"{ret * 100:+.2f}%" if ret is not None else "N/A"


# Collect all tickers and dates
all_tickers = set()
for positions in holdings.values():
    for (ticker, _) in positions:
        all_tickers.add(ticker)
all_tickers.add('SPY')

today = datetime.now().strftime('%Y-%m-%d')
first_date = filing_dates[quarters[0]]
all_dates = set(filing_dates.values()) | set(quarter_end_dates.values()) | {today}

prices = get_prices(sorted(all_tickers), sorted(all_dates))

# Resolve `today` to the actual last available closing date.
# yfinance may not have data for today (market still open or holiday),
# so we look up what date SPY's price actually corresponds to.
def _resolve_price_date(prices, requested_date):
    """Return the actual trading date of the price stored under requested_date."""
    ref = 'SPY' if 'SPY' in prices else next(iter(prices), None)
    if not ref or requested_date not in prices[ref]:
        return requested_date
    target_price = prices[ref][requested_date]
    # Re-download a small window to find the real date of this price
    start = datetime.strptime(requested_date, '%Y-%m-%d') - timedelta(days=10)
    end = datetime.strptime(requested_date, '%Y-%m-%d') + timedelta(days=5)
    df = yf.download(ref, start=start, end=end, progress=False, auto_adjust=True)
    if df.empty:
        return requested_date
    if isinstance(df.columns, pd.MultiIndex):
        close = df['Close'][ref].dropna()
    elif 'Close' in df.columns:
        close = df['Close'].dropna()
    else:
        close = df.iloc[:, 0].dropna()
    for dt, px in close.items():
        val = float(px.iloc[0]) if isinstance(px, pd.Series) else float(px)
        if abs(val - target_price) < 0.01:
            ts = dt[0] if isinstance(dt, tuple) else dt
            return pd.Timestamp(ts).strftime('%Y-%m-%d')
    return requested_date

today_resolved = _resolve_price_date(prices, today)
if today_resolved != today:
    for ticker in prices:
        if today in prices[ticker]:
            prices[ticker][today_resolved] = prices[ticker].pop(today)
    today = today_resolved


def download_daily(tickers, start_date, end_date):
    """Download daily close prices from yfinance, handling MultiIndex.
    Dates are 'YYYY-MM-DD' strings. Adds a small buffer for trading-day alignment."""
    tickers_sorted = sorted(tickers)
    start = datetime.strptime(start_date, '%Y-%m-%d') - timedelta(days=5)
    end = datetime.strptime(end_date, '%Y-%m-%d') + timedelta(days=5)
    df = yf.download(tickers_sorted, start=start, end=end,
                     progress=False, auto_adjust=True)
    if df.empty:
        return pd.DataFrame()
    if isinstance(df.columns, pd.MultiIndex):
        return df['Close']
    close = df[['Close']]
    close.columns = tickers_sorted
    return close


# -- Historical option prices via Alpha Vantage ----------------------------

OPTION_CACHE_DIR = os.path.expanduser('~/My Drive/notes/.sa-lp-option-cache')
_AV_BASE = 'https://www.alphavantage.co/query'
_AV_RATE_DELAY = 0.85  # seconds between requests (75 req/min limit)
OPTION_CACHE_COLUMNS = [
    'date', 'option_type', 'strike', 'expiry', 'delta', 'price']


def _normalize_option_type(option_type):
    option_type = str(option_type).lower()
    if option_type not in ('call', 'put'):
        raise ValueError(f"Unsupported option type: {option_type}")
    return option_type


def _empty_option_cache():
    return pd.DataFrame(columns=OPTION_CACHE_COLUMNS)


def _option_cache_path(ticker, option_type, legacy=False):
    if legacy:
        return os.path.join(OPTION_CACHE_DIR, f'{ticker}.csv')
    option_type = _normalize_option_type(option_type)
    return os.path.join(OPTION_CACHE_DIR, f'{ticker}-{option_type}.csv')


def _load_option_cache(ticker, option_type):
    """Load cached option data for a ticker/type. Returns DataFrame or empty."""
    option_type = _normalize_option_type(option_type)
    paths = [_option_cache_path(ticker, option_type)]
    # Pre-fix caches were call-only and named TICKER.csv.  They are safe to
    # reuse for calls but must not be reused for puts.
    if option_type == 'call':
        legacy_path = _option_cache_path(ticker, option_type, legacy=True)
        if legacy_path not in paths:
            paths.append(legacy_path)

    frames = []
    for path in paths:
        if not os.path.exists(path):
            continue
        df = pd.read_csv(path)
        if df.empty:
            continue
        if 'option_type' not in df.columns:
            df['option_type'] = 'call'
        for col in OPTION_CACHE_COLUMNS:
            if col not in df.columns:
                df[col] = np.nan
        df['date'] = pd.to_datetime(df['date'], errors='coerce').dt.strftime(
            '%Y-%m-%d')
        df['option_type'] = df['option_type'].fillna(option_type).str.lower()
        frames.append(df[OPTION_CACHE_COLUMNS])

    if not frames:
        return _empty_option_cache()

    cache = pd.concat(frames, ignore_index=True)
    cache = cache[cache['option_type'] == option_type].copy()
    cache.dropna(subset=['date'], inplace=True)
    for col in ('strike', 'delta', 'price'):
        cache[col] = pd.to_numeric(cache[col], errors='coerce')
    cache.drop_duplicates(
        subset=['date', 'option_type', 'strike', 'expiry'],
        keep='last', inplace=True)
    cache.sort_values(['date', 'expiry', 'strike'], inplace=True)
    return cache[OPTION_CACHE_COLUMNS]


def _save_option_cache(ticker, option_type, df):
    """Persist typed option cache to CSV."""
    option_type = _normalize_option_type(option_type)
    os.makedirs(OPTION_CACHE_DIR, exist_ok=True)
    path = _option_cache_path(ticker, option_type)
    if df.empty:
        df = _empty_option_cache()
    else:
        df = df.copy()
    df['option_type'] = option_type
    for col in OPTION_CACHE_COLUMNS:
        if col not in df.columns:
            df[col] = np.nan
    df.drop_duplicates(
        subset=['date', 'option_type', 'strike', 'expiry'],
        keep='last', inplace=True)
    df.sort_values(['date', 'expiry', 'strike'], inplace=True)
    df.to_csv(path, index=False)


def _fetch_option_chain(ticker, date_str, api_key):
    """Fetch the full option chain for ticker on a given date from Alpha Vantage."""
    params = {
        'function': 'HISTORICAL_OPTIONS',
        'symbol': ticker,
        'date': date_str,
        'apikey': api_key,
    }
    try:
        resp = requests.get(_AV_BASE, params=params, timeout=30)
        resp.raise_for_status()
        body = resp.json()
        return body.get('data', [])
    except Exception:
        return []


def _contract_window(ref_date_str):
    ref = datetime.strptime(ref_date_str, '%Y-%m-%d')
    return ref + timedelta(days=270), ref + timedelta(days=456)


def _contract_from_cache_row(row, ref_date_str, option_type):
    option_type = _normalize_option_type(option_type)
    if str(row.get('option_type', option_type)).lower() != option_type:
        return None
    lo, hi = _contract_window(ref_date_str)
    try:
        exp = datetime.strptime(str(row['expiry']), '%Y-%m-%d')
    except (KeyError, TypeError, ValueError):
        return None
    if not (lo <= exp <= hi):
        return None
    strike = _safe_float(row.get('strike'))
    delta = _safe_float(row.get('delta'))
    price = _safe_float(row.get('price'))
    if strike is None or delta is None or price is None or price <= 0:
        return None
    return {
        'option_type': option_type,
        'strike': strike,
        'expiry': str(row['expiry']),
        'delta': delta,
        'price': price,
    }


def _select_cached_contract(cache, option_type, ref_date_str):
    rows = cache[(cache['date'] == ref_date_str)
                 & (cache['option_type'] == option_type)]
    candidates = []
    for _, row in rows.iterrows():
        contract = _contract_from_cache_row(row, ref_date_str, option_type)
        if contract:
            candidates.append(contract)
    if not candidates:
        return None
    candidates.sort(key=lambda x: abs(abs(x['delta']) - OPTION_DELTA))
    return candidates[0]


def _select_best_contract(chain, ref_date_str, option_type):
    """Select the best-matching call/put contract from an option chain.

    Criteria: matching option type, expiry 9-15 months from ref_date,
    absolute delta closest to 0.15.  Returns dict with type, strike, expiry,
    delta, price or None.
    """
    option_type = _normalize_option_type(option_type)
    lo, hi = _contract_window(ref_date_str)
    candidates = []
    for c in chain:
        if c.get('type', '').lower() != option_type:
            continue
        try:
            exp = datetime.strptime(c['expiration'], '%Y-%m-%d')
        except (KeyError, ValueError):
            continue
        if not (lo <= exp <= hi):
            continue
        delta = _safe_float(c.get('delta'))
        if delta is None:
            continue
        abs_delta = abs(delta)
        if abs_delta == 0:
            continue
        # Price: prefer mid if available, else last
        price = _parse_option_price(c)
        if price is None or price <= 0:
            continue
        candidates.append({
            'option_type': option_type,
            'strike': float(c['strike']),
            'expiry': c['expiration'],
            'delta': delta,
            'price': price,
        })

    if not candidates:
        return None
    # Pick contract with absolute delta closest to 0.15.
    candidates.sort(key=lambda x: abs(abs(x['delta']) - OPTION_DELTA))
    return candidates[0]


def _parse_option_price(contract):
    """Extract a price from an Alpha Vantage option contract record."""
    bid = _safe_float(contract.get('bid'))
    ask = _safe_float(contract.get('ask'))
    last = _safe_float(contract.get('last'))
    if bid and ask and bid > 0 and ask > 0:
        return (bid + ask) / 2
    if last and last > 0:
        return last
    return None


def _safe_float(val):
    try:
        return float(val)
    except (TypeError, ValueError):
        return None


def _cached_contract_price(cache, option_type, date_str, strike, expiry):
    rows = cache[(cache['date'] == date_str)
                 & (cache['option_type'] == option_type)
                 & (abs(cache['strike'] - strike) < 0.01)
                 & (cache['expiry'].astype(str) == str(expiry))]
    for _, row in rows.iterrows():
        price = _safe_float(row.get('price'))
        if price is not None and price > 0:
            return price
    return None


def _extract_contract_price(chain, strike, expiry, option_type):
    """Find the price of a specific option contract."""
    option_type = _normalize_option_type(option_type)
    for c in chain:
        if c.get('type', '').lower() != option_type:
            continue
        try:
            if (abs(float(c['strike']) - strike) < 0.01
                    and c.get('expiration') == expiry):
                return _parse_option_price(c)
        except (KeyError, TypeError, ValueError):
            continue
    return None


def download_option_prices(option_positions, quarters, holdings, filing_dates,
                           today):
    """Download historical option prices from Alpha Vantage.

    For each (ticker, option_type) and each filing period:
    1. On the first trading day, fetch the chain and select the best contract
       (matching type, expiry 9-15 months out, |delta| closest to 0.15).
    2. Lock in that contract for the period.
    3. Fetch the price of that contract on each subsequent trading day.

    Returns
    -------
    per_period : dict {quarter_str: {(ticker, type): {date_str: float}}}
        Option prices keyed by filing period then option position. Each period
        has its own contract's prices, avoiding cross-contract mixing at
        boundary dates where one period ends and the next begins.
    fallback_positions : set
        Option positions where no option data was found (need BS fallback).
    """
    option_positions = sorted({
        (ticker, _normalize_option_type(pos_type))
        for ticker, pos_type in option_positions})
    api_key = os.environ.get('ALPHA_VANTAGE_KEY', '')
    cache_only = not bool(api_key)
    if cache_only:
        print("WARNING: ALPHA_VANTAGE_KEY not set; using cached option "
              "prices where available and BS repricing elsewhere.")

    os.makedirs(OPTION_CACHE_DIR, exist_ok=True)
    per_period = {}    # {q: {(ticker, type): {date_str: price}}}
    fallback = set()
    fetched = 0

    for ticker, option_type in option_positions:
        opt_key = _option_position_key(ticker, option_type)
        cache = _load_option_cache(ticker, option_type)
        position_has_data = False
        new_rows = []

        for i, q in enumerate(quarters):
            # Skip quarters where this exact option position is absent.
            has_opts = opt_key in holdings[q]
            if not has_opts:
                continue

            period_start = filing_dates[q]
            period_end = (filing_dates[quarters[i + 1]]
                          if i < len(quarters) - 1 else today)
            trading_days = pd.bdate_range(period_start, period_end)
            if len(trading_days) == 0:
                continue

            first_day = trading_days[0].strftime('%Y-%m-%d')

            # -- Select contract on first trading day --
            from_cache = False
            contract = _select_cached_contract(cache, option_type, first_day)
            if contract:
                from_cache = True
            else:
                if not cache_only:
                    time.sleep(_AV_RATE_DELAY)
                    chain = _fetch_option_chain(ticker, first_day, api_key)
                    fetched += 1
                    contract = _select_best_contract(
                        chain, first_day, option_type)
                    if contract:
                        new_rows.append({
                            'date': first_day,
                            'option_type': option_type,
                            'strike': contract['strike'],
                            'expiry': contract['expiry'],
                            'delta': contract['delta'],
                            'price': contract['price'],
                        })

            if contract is None:
                fallback.add(opt_key)
                continue

            strike = contract['strike']
            expiry = contract['expiry']

            # -- Collect prices for this period (fresh dict per period) --
            period_prices = {}
            if from_cache:
                # Fast path: read all matching prices from cache (no API calls).
                rows = cache[
                    (cache['date'] >= period_start)
                    & (cache['date'] <= period_end)
                    & (cache['option_type'] == option_type)
                    & (abs(cache['strike'] - strike) < 0.01)
                    & (cache['expiry'].astype(str) == str(expiry))
                    & pd.notna(cache['price'])]
                for _, row in rows.iterrows():
                    period_prices[row['date']] = float(row['price'])
            else:
                # Slow path: fetch each trading day from API
                if contract.get('price'):
                    period_prices[first_day] = contract['price']
                for day in trading_days[1:]:
                    day_str = day.strftime('%Y-%m-%d')
                    cached_price = _cached_contract_price(
                        cache, option_type, day_str, strike, expiry)
                    if cached_price is not None:
                        period_prices[day_str] = cached_price
                        continue

                    time.sleep(_AV_RATE_DELAY)
                    chain = _fetch_option_chain(ticker, day_str, api_key)
                    fetched += 1
                    price = _extract_contract_price(
                        chain, strike, expiry, option_type)
                    if price is not None:
                        period_prices[day_str] = price
                    new_rows.append({
                        'date': day_str,
                        'option_type': option_type,
                        'strike': strike,
                        'expiry': expiry,
                        'delta': contract['delta'],
                        'price': price,
                    })

            # Accumulate per-period prices
            if period_prices:
                per_period.setdefault(q, {})[opt_key] = period_prices
                position_has_data = True

        # Persist new data to cache
        if new_rows:
            new_df = pd.DataFrame(new_rows)
            cache = pd.concat([cache, new_df], ignore_index=True)
            cache.drop_duplicates(
                subset=['date', 'option_type', 'strike', 'expiry'],
                keep='last', inplace=True)
            cache.sort_values(['date', 'expiry', 'strike'], inplace=True)
            _save_option_cache(ticker, option_type, cache)

        if not position_has_data:
            fallback.add(opt_key)

    if fetched:
        import sys
        print(f"[options] Fetched {fetched} chain snapshots from Alpha Vantage",
              file=sys.stderr)

    return per_period, fallback


# -- Fallback: Black-Scholes repricing for tickers without option data -----

from scipy.stats import norm as _norm


def compute_realized_vol(tickers, download_daily_fn, today_str):
    """Compute annualized realized vol from trailing 1-year daily returns."""
    vol_start = (datetime.strptime(today_str, '%Y-%m-%d')
                 - timedelta(days=400)).strftime('%Y-%m-%d')
    vol_df = download_daily_fn(tickers, vol_start, today_str)
    result = {}
    for ticker in tickers:
        if ticker in vol_df.columns:
            series = vol_df[ticker].dropna()
            if len(series) > 20:
                log_rets = np.log(series / series.shift(1)).dropna().tail(252)
                result[ticker] = float(log_rets.std() * np.sqrt(252))
    return result


def bs_price(S, K, T, sigma, option_type='call'):
    """Black-Scholes option price (assumes zero risk-free rate and dividends)."""
    if T <= 0 or sigma <= 0:
        if option_type == 'call':
            return max(S - K, 0)
        return max(K - S, 0)
    d1 = (np.log(S / K) + (sigma ** 2 / 2) * T) / (sigma * np.sqrt(T))
    d2 = d1 - sigma * np.sqrt(T)
    if option_type == 'call':
        return S * _norm.cdf(d1) - K * _norm.cdf(d2)
    return K * _norm.cdf(-d2) - S * _norm.cdf(-d1)


def bs_option_return(stock_return, K_over_S, T, delta_t, sigma,
                     option_type='call'):
    """Compute option return from stock return using Black-Scholes repricing.

    Normalizes S_0 = 1, so S_1 = 1 + stock_return and K = K_over_S.
    T is time to expiry at period start; delta_t is time elapsed.
    """
    V0 = bs_price(1.0, K_over_S, T, sigma, option_type)
    V1 = bs_price(1.0 + stock_return, K_over_S, max(T - delta_t, 0),
                  sigma, option_type)
    if V0 <= 0:
        return stock_return
    return V1 / V0 - 1


OPTION_DELTA = 0.15
OPTION_T     = 1.0


def build_option_params(option_tickers, ticker_vol):
    """Build {ticker: (K_over_S_call, K_over_S_put, sigma)} for BS fallback."""
    result = {}
    for t in option_tickers:
        if t not in ticker_vol:
            continue
        sigma = ticker_vol[t]
        srt = sigma * OPTION_T ** 0.5
        # Call: delta = N(d1) = OPTION_DELTA
        d1_call = _norm.ppf(OPTION_DELTA)
        K_call = np.exp(-d1_call * srt + sigma ** 2 * OPTION_T / 2)
        # Put: delta = N(d1) - 1 = -OPTION_DELTA, so N(d1) = 1 - OPTION_DELTA
        d1_put = _norm.ppf(1 - OPTION_DELTA)
        K_put = np.exp(-d1_put * srt + sigma ** 2 * OPTION_T / 2)
        result[t] = (K_call, K_put, sigma)
    return result


def daily_cumulative(holdings, quarters, filing_dates, close, today, mode,
                     per_period_opt=None, option_params=None):
    """Build a daily series of cumulative growth factors for a given mode.

    For each filing period the portfolio weights are fixed. Each trading
    day's weighted return is computed relative to the period's starting
    prices, then chained with the prior period's cumulative growth.

    For option positions: uses per-period option prices from per_period_opt
    when available; otherwise falls back to Black-Scholes repricing using
    option_params.
    """
    cum_growth = 1.0
    dates_out = []
    values_out = []

    for i, q in enumerate(quarters):
        period_start = filing_dates[q]
        period_end = filing_dates[quarters[i + 1]] if i < len(quarters) - 1 else today
        ps = pd.Timestamp(period_start)
        pe = pd.Timestamp(period_end)

        # Trading days in this period
        mask = (close.index >= ps) & (close.index <= pe)
        period_close = close[mask]
        if period_close.empty:
            continue

        # Option prices for this period (keyed by (ticker, type) → prices)
        quarter_opt = per_period_opt.get(q, {}) if per_period_opt else {}

        # Determine portfolio weights and starting prices
        positions = holdings[q]
        weights = {}
        start_prices = {}
        use_opt_px = {}   # track which positions use option prices
        total_value = 0

        for (ticker, pos_type), value in positions.items():
            if mode == 'equity_only' and pos_type != 'long':
                continue

            # Select price source for this position
            is_option = pos_type in ('call', 'put')
            opt_key = _option_position_key(ticker, pos_type)
            has_opt = is_option and opt_key in quarter_opt

            if has_opt:
                ticker_opt = quarter_opt[opt_key]
                opt_dates = sorted(d for d in ticker_opt if d >= period_start)
                if not opt_dates:
                    continue
                start_prices[(ticker, pos_type)] = ticker_opt[opt_dates[0]]
            elif ticker in close.columns:
                src = close[ticker].dropna()
                avail = src[src.index >= ps]
                if avail.empty:
                    continue
                start_prices[(ticker, pos_type)] = float(avail.iloc[0])
            else:
                continue

            weights[(ticker, pos_type)] = value
            use_opt_px[(ticker, pos_type)] = has_opt
            total_value += value

        if total_value == 0:
            continue

        # Daily weighted return relative to period start
        # Skip first day of subsequent periods (already recorded as last day
        # of the prior period) to avoid duplicate boundary dates.
        start_idx = 1 if i > 0 else 0
        # Forward-fill: track last known option price so that gaps in
        # option data don't cause positions to vanish mid-period.
        last_opt = {k: v for k, v in start_prices.items()
                    if use_opt_px.get(k)}
        for day_idx in range(start_idx, len(period_close)):
            day = period_close.index[day_idx]
            day_str = day.strftime('%Y-%m-%d')
            weighted_return = 0
            for (ticker, pos_type), value in weights.items():
                p0 = start_prices[(ticker, pos_type)]
                if p0 == 0:
                    continue

                if use_opt_px[(ticker, pos_type)]:
                    opt_key = _option_position_key(ticker, pos_type)
                    p1_val = quarter_opt.get(opt_key, {}).get(day_str)
                    if p1_val is not None:
                        last_opt[(ticker, pos_type)] = p1_val
                    else:
                        p1_val = last_opt.get((ticker, pos_type))
                    if p1_val is None:
                        continue
                elif ticker in period_close.columns:
                    p1_val = period_close[ticker].iloc[day_idx]
                    if pd.isna(p1_val):
                        continue
                else:
                    continue

                ret = (float(p1_val) - p0) / p0
                # Fallback: BS repricing for option positions without option data
                use_bs = False
                if (pos_type in ('call', 'put')
                        and not use_opt_px[(ticker, pos_type)]):
                    params = option_params.get(ticker) if option_params else None
                    if params:
                        K_call, K_put, sigma = params
                        K_over_S = K_call if pos_type == 'call' else K_put
                        dt = (day - ps).days / 365.25
                        ret = bs_option_return(ret, K_over_S, OPTION_T, dt,
                                               sigma, pos_type)
                        use_bs = True
                sign = 1 if (use_opt_px[(ticker, pos_type)] or use_bs) else (
                    -1 if pos_type == 'put' else 1)
                weighted_return += (value / total_value) * sign * ret

            dates_out.append(day)
            values_out.append(cum_growth * (1 + weighted_return))

        # Chain: next period starts from the last day's growth factor
        if values_out:
            cum_growth = values_out[-1]

    return dates_out, values_out

# Compute copycat returns
header = (f"{'Period':<16} {'Dates':<24} "
          f"{'Eq. only':>9} {'Full exp.':>9} {'SPY':>9}")
print("COPYCAT STRATEGY RETURNS")
print("=" * 72)
print(header)
print("-" * 72)

cum_eq = 1.0
cum_full = 1.0
cum_spy = 1.0

for i, q in enumerate(quarters):
    start = filing_dates[q]
    end = filing_dates[quarters[i + 1]] if i < len(quarters) - 1 else today
    suffix = " †" if i == len(quarters) - 1 else ""

    ret_eq = compute_return(holdings[q], prices, start, end, 'equity_only')
    ret_full = compute_return(holdings[q], prices, start, end, 'full')
    ret_spy = None
    if 'SPY' in prices and start in prices['SPY'] and end in prices['SPY']:
        spy_p0, spy_p1 = prices['SPY'][start], prices['SPY'][end]
        if spy_p0 != 0:
            ret_spy = (spy_p1 - spy_p0) / spy_p0

    if ret_eq is not None:
        cum_eq *= (1 + ret_eq)
    if ret_full is not None:
        cum_full *= (1 + ret_full)
    if ret_spy is not None:
        cum_spy *= (1 + ret_spy)

    dates_str = f"{start} to {end}"
    print(f"{q + suffix:<16} {dates_str:<24} "
          f"{fmt(ret_eq):>9} {fmt(ret_full):>9} {fmt(ret_spy):>9}")

print("-" * 72)
cum_eq_ret = cum_eq - 1
cum_full_ret = cum_full - 1
cum_spy_ret = cum_spy - 1
dates_str = f"{first_date} to {today}"
print(f"{'Cumulative':<16} {dates_str:<24} "
      f"{fmt(cum_eq_ret):>9} {fmt(cum_full_ret):>9} {fmt(cum_spy_ret):>9}")
print()
print("† = partial period (still holding; updates on re-evaluation)")
print("Eq. only = long equity positions only")
print("Full exp. = options treated as underlying exposure proxy")

# ── Risk-adjusted returns ──────────────────────────────────────────
daily_close = download_daily(all_tickers, first_date, today)


def daily_returns_series(holdings, quarters, filing_dates, daily_close,
                         today, mode, per_period_opt=None, option_params=None):
    """Compute daily portfolio return series for a given mode.

    Uses per-period option prices when available; falls back to
    Black-Scholes repricing using option_params otherwise.
    """
    if daily_close.empty:
        return pd.Series(dtype=float)
    returns, dates = [], []
    for i, q in enumerate(quarters):
        ps = pd.Timestamp(filing_dates[q])
        pe = pd.Timestamp(
            filing_dates[quarters[i + 1]] if i < len(quarters) - 1 else today)
        period = daily_close[(daily_close.index >= ps) &
                             (daily_close.index <= pe)]
        if len(period) < 2:
            continue

        quarter_opt = per_period_opt.get(q, {}) if per_period_opt else {}

        weights = {}
        use_opt = {}
        total_value = 0
        for (ticker, pos_type), value in holdings[q].items():
            if mode == 'equity_only' and pos_type != 'long':
                continue
            is_option = pos_type in ('call', 'put')
            opt_key = _option_position_key(ticker, pos_type)
            has_opt = is_option and opt_key in quarter_opt
            if not has_opt and ticker not in daily_close.columns:
                continue
            weights[(ticker, pos_type)] = value
            use_opt[(ticker, pos_type)] = has_opt
            total_value += value
        if total_value == 0:
            continue

        # Forward-fill: track last known option price per position
        last_opt = {}
        for day_idx in range(1, len(period)):
            daily_ret = 0
            day_curr = period.index[day_idx]
            day_prev = period.index[day_idx - 1]
            d_curr = day_curr.strftime('%Y-%m-%d')
            d_prev = day_prev.strftime('%Y-%m-%d')
            for (ticker, pos_type), value in weights.items():
                if use_opt[(ticker, pos_type)]:
                    opt_key = _option_position_key(ticker, pos_type)
                    ticker_opt = quarter_opt.get(opt_key, {})
                    p0 = ticker_opt.get(d_prev, last_opt.get(
                        (ticker, pos_type)))
                    raw_p1 = ticker_opt.get(d_curr)
                    p1 = raw_p1 if raw_p1 is not None else p0
                    if raw_p1 is not None:
                        last_opt[(ticker, pos_type)] = raw_p1
                    elif p0 is not None:
                        last_opt[(ticker, pos_type)] = p0
                    if p0 is None or p1 is None:
                        continue
                else:
                    if ticker not in period.columns:
                        continue
                    p0 = period[ticker].iloc[day_idx - 1]
                    p1 = period[ticker].iloc[day_idx]

                if pd.isna(p0) or pd.isna(p1) or p0 == 0:
                    continue
                ret = (float(p1) - float(p0)) / float(p0)
                use_bs = False
                if (pos_type in ('call', 'put')
                        and not use_opt[(ticker, pos_type)]):
                    params = option_params.get(ticker) if option_params else None
                    if params:
                        K_call, K_put, sigma = params
                        K_over_S = K_call if pos_type == 'call' else K_put
                        dt = (day_curr - ps).days / 365.25
                        # Reconstruct cumulative stock return for BS repricing
                        if ticker in period.columns:
                            s0 = period[ticker].iloc[0]
                            if s0 and not pd.isna(s0) and s0 != 0:
                                cum_stock_ret = (float(period[ticker].iloc[day_idx]) - float(s0)) / float(s0)
                                cum_opt_ret = bs_option_return(cum_stock_ret, K_over_S, OPTION_T, dt, sigma, pos_type)
                                dt_prev = (day_prev - ps).days / 365.25
                                cum_stock_ret_prev = (float(period[ticker].iloc[day_idx - 1]) - float(s0)) / float(s0)
                                cum_opt_ret_prev = bs_option_return(cum_stock_ret_prev, K_over_S, OPTION_T, dt_prev, sigma, pos_type)
                                ret = (1 + cum_opt_ret) / (1 + cum_opt_ret_prev) - 1 if (1 + cum_opt_ret_prev) != 0 else ret
                                use_bs = True
                sign = 1 if (use_opt[(ticker, pos_type)] or use_bs) else (
                    -1 if pos_type == 'put' else 1)
                daily_ret += (value / total_value) * sign * ret
            returns.append(daily_ret)
            dates.append(period.index[day_idx])
    return pd.Series(returns, index=dates)


ret_eq_d = daily_returns_series(holdings, quarters, filing_dates,
                                daily_close, today, 'equity_only')
ret_full_d = daily_returns_series(holdings, quarters, filing_dates,
                                  daily_close, today, 'full')

if 'SPY' in daily_close.columns:
    spy_close = daily_close['SPY'].dropna()
    spy_period = spy_close[spy_close.index >= pd.Timestamp(first_date)]
    ret_spy_d = spy_period.pct_change().dropna()
else:
    ret_spy_d = pd.Series(dtype=float)


def sharpe(daily_rets, rf_annual=0.04):
    if daily_rets.empty:
        return float('nan')
    rf_daily = (1 + rf_annual) ** (1 / 252) - 1
    excess = daily_rets - rf_daily
    if excess.std() == 0 or pd.isna(excess.std()):
        return float('nan')
    return float(excess.mean() / excess.std() * 252 ** 0.5)


def max_drawdown(daily_rets):
    if daily_rets.empty:
        return float('nan')
    cum = (1 + daily_rets).cumprod()
    return float(((cum - cum.cummax()) / cum.cummax()).min() * 100)


print()
print("RISK-ADJUSTED RETURNS")
print("=" * 55)
print(f"{'Metric':<25} {'Eq. only':>9} {'Full exp.':>9} {'SPY':>9}")
print("-" * 55)

vol_eq = float(ret_eq_d.std() * 252 ** 0.5 * 100)
vol_full = float(ret_full_d.std() * 252 ** 0.5 * 100)
vol_spy = float(ret_spy_d.std() * 252 ** 0.5 * 100)
print(f"{'Ann. volatility':<25} {vol_eq:>8.1f}% {vol_full:>8.1f}% {vol_spy:>8.1f}%")

sh_eq = sharpe(ret_eq_d)
sh_full = sharpe(ret_full_d)
sh_spy = sharpe(ret_spy_d)
print(f"{'Sharpe (rf=4%)':<25} {sh_eq:>9.2f} {sh_full:>9.2f} {sh_spy:>9.2f}")

mdd_eq = max_drawdown(ret_eq_d)
mdd_full = max_drawdown(ret_full_d)
mdd_spy = max_drawdown(ret_spy_d)
print(f"{'Max drawdown':<25} {mdd_eq:>8.1f}% {mdd_full:>8.1f}% {mdd_spy:>8.1f}%")