Situational Awareness LP

# ── SA LP 13F data fetcher ─────────────────────────────────────────
# Fetches all 13F-HR and 13F-HR/A filings from SEC EDGAR for
# Situational Awareness LP, parses the infotable XML, and resolves CUSIPs.
# Output: JSON with one entry per report quarter, each containing the
#         rebalance filing date, source filing metadata, and 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)
            raise RuntimeError(
                f"Unknown CUSIP {cusip} ({issuer}); add it to CUSIP_TICKER")
        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 quarter_from_report_date(rdate):
    d = datetime.strptime(rdate, '%Y-%m-%d')
    q = (d.month - 1) // 3 + 1
    return f'Q{q}_{d.year}', d.strftime('%Y-%m-%d')

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_by_quarter = {f["quarter"]: f for f in cached["filings"]}
result = {"filings": list(cached_by_quarter.values())}

try:
    subs_url = f'https://data.sec.gov/submissions/CIK{CIK.zfill(10)}.json'
    subs = json.loads(fetch(subs_url))
    recent = subs['filings']['recent']

    def recent_field(field, i, default=''):
        vals = recent.get(field, [])
        return vals[i] if i < len(vals) else default

    filings_by_quarter = {}
    for i, form in enumerate(recent['form']):
        if form not in ('13F-HR', '13F-HR/A'):
            continue
        fdate = recent_field('filingDate', i)
        acc = recent_field('accessionNumber', i)
        rdate = recent_field('reportDate', i)
        if rdate:
            quarter, quarter_end = quarter_from_report_date(rdate)
        else:
            quarter, quarter_end = quarter_from_filing_date(fdate)
        filings_by_quarter.setdefault(quarter, []).append({
            "quarter": quarter, "quarter_end": quarter_end,
            "filing_date": fdate, "form": form, "accession": acc})

    accessions = []
    for quarter, rows in filings_by_quarter.items():
        rows.sort(key=lambda r: (r["filing_date"], r["accession"]))
        selected = rows[-1].copy()
        # Use the original filing date as the rebalance date. If an amendment
        # exists, treat it as a restatement of that quarter's disclosed holdings.
        selected["original_filing_date"] = rows[0]["filing_date"]
        accessions.append(selected)
    accessions.sort(key=lambda r: r["quarter_end"])

    for filing in accessions:
        quarter = filing["quarter"]
        quarter_end = filing["quarter_end"]
        fdate = filing["filing_date"]
        acc = filing["accession"]
        form = filing["form"]
        original_fdate = filing["original_filing_date"]
        cached_filing = cached_by_quarter.get(quarter)
        if cached_filing and cached_filing.get("accession") == acc:
            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)
        cached_by_quarter[quarter] = {
            "quarter": quarter, "quarter_end": quarter_end,
            "filing_date": original_fdate,
            "source_filing_date": fdate, "form": form,
            "accession": acc, "holdings": holdings}

    result["filings"] = sorted(
        cached_by_quarter.values(),
        key=lambda f: f.get("quarter_end", 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 _extract_close_series(df, ticker):
    """Extract a single close-price series from a yfinance result."""
    if df.empty:
        return pd.Series(dtype=float)
    if isinstance(df.columns, pd.MultiIndex):
        if 'Close' not in df.columns.get_level_values(0):
            return pd.Series(dtype=float)
        close = df['Close']
        if isinstance(close, pd.DataFrame):
            if ticker in close.columns:
                series = close[ticker]
            elif len(close.columns) == 1:
                series = close.iloc[:, 0]
            else:
                return pd.Series(dtype=float)
        else:
            series = close
    elif 'Close' in df.columns:
        series = df['Close']
        if isinstance(series, pd.DataFrame):
            series = series.iloc[:, 0]
    else:
        return pd.Series(dtype=float)
    return pd.to_numeric(series, errors='coerce').dropna()


def _download_close_series(ticker, start, end):
    """Download one ticker's close series; used to repair flaky batch misses."""
    df = yf.download(ticker, start=start, end=end, progress=False,
                     auto_adjust=True)
    return _extract_close_series(df, ticker)


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)
    # yf.download returns MultiIndex columns (metric, ticker) for multiple tickers
    if df.empty:
        close = pd.DataFrame()
    elif isinstance(df.columns, pd.MultiIndex) and 'Close' in df.columns.get_level_values(0):
        close = df['Close'].copy()
    elif 'Close' in df.columns:
        close = df[['Close']].copy()
        close.columns = unique_tickers
    else:
        close = pd.DataFrame()

    prices = {}
    for ticker in unique_tickers:
        if ticker in close.columns:
            series = pd.to_numeric(close[ticker], errors='coerce').dropna()
        else:
            series = pd.Series(dtype=float)
        if series.empty:
            series = _download_close_series(ticker, start, end)
        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 _linear_underlying_sign(pos_type):
    """Direction when option rows are converted to underlying equity exposure."""
    return -1 if pos_type == 'put' else 1


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

    The 13F value for an option row is treated as underlying notional, not
    option premium.  Option contracts are sized from that notional, but the
    portfolio denominator is estimated deployed capital: stock value plus option
    premium cost.  This avoids treating the gap between option notional and
    option premium as cash.  In 'full' mode, every option row requires a
    MarketData price series; missing data raises rather than falling back.
    """
    total_cost = 0
    portfolio_pnl = 0

    for (ticker, pos_type), value in positions.items():
        is_option = pos_type in ('call', 'put')
        stock_px = prices.get(ticker)

        if mode == 'equity_only':
            if pos_type not in ('long', 'call', 'put'):
                continue
            pair = _period_price_pair(stock_px, start_date, end_date)
            if pair is None:
                continue
            start_actual, end_actual, p0, p1 = pair
            if p0 == 0:
                continue
            stock_ret = (p1 - p0) / p0
            total_cost += value
            portfolio_pnl += value * _linear_underlying_sign(pos_type) * stock_ret
            continue

        if is_option:
            opt_key = _option_position_key(ticker, pos_type)
            opt_px = option_prices.get(opt_key) if option_prices else None
            if not opt_px:
                raise RuntimeError(
                    f"No MarketData option prices for {opt_key} in period "
                    f"{start_date}..{end_date}")
            pair = _period_price_pair(opt_px, start_date, end_date)
            if pair is None:
                raise RuntimeError(
                    f"MarketData option price series for {opt_key} does not "
                    f"cover {start_date}..{end_date}")
            start_actual, end_actual, opt_p0, opt_p1 = pair
            stock_start = _price_on_or_after(stock_px, start_actual)
            if stock_start is None or stock_start[1] <= 0:
                stock_start = _price_on_or_after(stock_px, start_date)
            if stock_start is None or stock_start[1] <= 0:
                raise RuntimeError(
                    f"No underlying price for {ticker} at {start_date}")
            p0, p1 = opt_p0, opt_p1
            underlying_p0 = stock_start[1]
            if p0 <= 0 or underlying_p0 <= 0:
                continue
            position_cost = value * (p0 / underlying_p0)
            position_pnl = value * ((p1 - p0) / underlying_p0)
        else:
            pair = _period_price_pair(stock_px, start_date, end_date)
            if pair is None:
                continue
            start_actual, end_actual, p0, p1 = pair
            if p0 == 0:
                continue
            stock_ret = (p1 - p0) / p0
            position_cost = value
            position_pnl = value * stock_ret

        if position_cost <= 0:
            continue
        total_cost += position_cost
        portfolio_pnl += position_pnl

    return portfolio_pnl / total_cost if total_cost 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 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')
all_tickers.add('AIS')

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:
        close = pd.DataFrame()
    elif isinstance(df.columns, pd.MultiIndex) and 'Close' in df.columns.get_level_values(0):
        close = df['Close'].copy()
    elif 'Close' in df.columns:
        close = df[['Close']].copy()
        close.columns = tickers_sorted
    else:
        close = pd.DataFrame()

    for ticker in tickers_sorted:
        if ticker in close.columns and not close[ticker].dropna().empty:
            continue
        series = _download_close_series(ticker, start, end)
        if not series.empty:
            close[ticker] = series
    return close.sort_index()


# -- Historical option prices via MarketData --------------------------------

OPTION_CACHE_DIR = os.path.expanduser('~/My Drive/notes/.sa-lp-option-cache')
_MD_BASE = 'https://api.marketdata.app/v1'
_MD_RATE_DELAY = 0.15
OPTION_CACHE_COLUMNS = [
    'date', 'selected_on', 'option_type', 'symbol', 'strike', 'expiry',
    'delta', 'price']

# Default contract selection parameters. The option proxy picks a contract
# matching option type, with expiry between min_days and max_days of the
# period start, and |delta| closest to delta_target. When the chain is
# sparse, the achieved |delta| may be far from the target; the sensitivity
# block reports achieved |delta| so this is visible rather than silent.
OPTION_DELTA = 0.15
EXPIRY_MIN_DAYS = 270     # ~9 months
EXPIRY_MAX_DAYS = 456     # ~15 months


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, delta_target=OPTION_DELTA,
                       min_days=EXPIRY_MIN_DAYS, max_days=EXPIRY_MAX_DAYS):
    """Return the cache CSV path for (ticker, type, delta_target, window).

    When the parameter triple equals the baseline (0.15, 270-456 days), the
    historical filename ``TICKER-TYPE.csv`` is used so the main-backtest
    cache is reused automatically. Any non-baseline combo lives in a
    separate ``TICKER-TYPE-d<delta>-e<min>-<max>.csv`` file so a sensitivity
    sweep never pollutes the baseline cache (which the portfolio calculator
    reads to pick the representative contract for the current filing).
    """
    option_type = _normalize_option_type(option_type)
    is_baseline = (
        abs(delta_target - OPTION_DELTA) < 1e-9
        and min_days == EXPIRY_MIN_DAYS
        and max_days == EXPIRY_MAX_DAYS)
    if is_baseline:
        return os.path.join(OPTION_CACHE_DIR, f'{ticker}-{option_type}.csv')
    return os.path.join(
        OPTION_CACHE_DIR,
        f'{ticker}-{option_type}-d{delta_target:g}-e{min_days}-{max_days}.csv')


def _load_option_cache(ticker, option_type, delta_target=OPTION_DELTA,
                       min_days=EXPIRY_MIN_DAYS, max_days=EXPIRY_MAX_DAYS):
    """Load cached MarketData rows for a ticker/type/target/window. Returns DataFrame or empty."""
    option_type = _normalize_option_type(option_type)
    path = _option_cache_path(ticker, option_type, delta_target,
                              min_days, max_days)
    if not os.path.exists(path):
        return _empty_option_cache()
    df = pd.read_csv(path)
    if df.empty:
        return _empty_option_cache()
    for col in OPTION_CACHE_COLUMNS:
        if col not in df.columns:
            df[col] = np.nan
    for col in ('date', 'selected_on'):
        df[col] = pd.to_datetime(
            df[col], errors='coerce').dt.strftime('%Y-%m-%d')
    df['option_type'] = df['option_type'].fillna(option_type).str.lower()

    cache = df[OPTION_CACHE_COLUMNS].copy()
    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', 'selected_on', '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, delta_target=OPTION_DELTA,
                       min_days=EXPIRY_MIN_DAYS, max_days=EXPIRY_MAX_DAYS):
    """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, delta_target,
                              min_days, max_days)
    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', 'selected_on', 'option_type', 'strike', 'expiry'],
        keep='last', inplace=True)
    df.sort_values(['date', 'expiry', 'strike'], inplace=True)
    df.to_csv(path, index=False)


def _contract_window(ref_date_str, min_days=EXPIRY_MIN_DAYS,
                     max_days=EXPIRY_MAX_DAYS):
    ref = datetime.strptime(ref_date_str, '%Y-%m-%d')
    return ref + timedelta(days=min_days), ref + timedelta(days=max_days)


def _contract_from_cache_row(row, ref_date_str, option_type,
                             min_days=EXPIRY_MIN_DAYS,
                             max_days=EXPIRY_MAX_DAYS):
    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, min_days, max_days)
    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 {
        'selected_on': row.get('selected_on'),
        'option_type': option_type,
        'symbol': row.get('symbol'),
        'strike': strike,
        'expiry': str(row['expiry']),
        'delta': delta,
        'price': price,
    }


def _select_cached_contract(cache, option_type, ref_date_str,
                            delta_target=OPTION_DELTA,
                            min_days=EXPIRY_MIN_DAYS,
                            max_days=EXPIRY_MAX_DAYS,
                            require_selected=False):
    rows = cache[(cache['date'] == ref_date_str)
                 & (cache['option_type'] == option_type)]
    selected_rows = rows[rows['selected_on'] == ref_date_str]
    if not selected_rows.empty:
        rows = selected_rows
    elif require_selected:
        rows = selected_rows
    candidates = []
    for _, row in rows.iterrows():
        contract = _contract_from_cache_row(row, ref_date_str, option_type,
                                            min_days, max_days)
        if contract:
            candidates.append(contract)
    if not candidates:
        return None
    candidates.sort(key=lambda x: abs(abs(x['delta']) - delta_target))
    return candidates[0]


def _parse_option_price(contract):
    """Extract a mark price from an option contract record."""
    mid = _safe_float(contract.get('mid'))
    if mid and mid > 0:
        return mid
    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:
        out = float(val)
        if np.isnan(out):
            return None
        return out
    except (TypeError, ValueError):
        return None


def _marketdata_key():
    """Return the MarketData API key, or None if unavailable.

    Resolution order:
    1. ``MARKETDATA_KEY`` / ``MARKETDATA_API_KEY`` environment variables.
    2. ``pass env/marketdata-token`` (local ``pass`` store).

    The result is memoised on the function object so repeated lookups
    during a sweep do not reshell. Fetch helpers raise themselves when
    called without a key, so a fully cached run still succeeds without
    requiring either source.
    """
    if hasattr(_marketdata_key, '_cached'):
        return _marketdata_key._cached
    key = (os.environ.get('MARKETDATA_KEY', '')
           or os.environ.get('MARKETDATA_API_KEY', ''))
    if not key:
        try:
            import subprocess
            out = subprocess.run(
                ['pass', 'show', 'env/marketdata-token'],
                capture_output=True, text=True, timeout=5, check=False)
            if out.returncode == 0:
                key = out.stdout.strip().splitlines()[0] if out.stdout else ''
        except (FileNotFoundError, subprocess.TimeoutExpired):
            key = ''
    _marketdata_key._cached = key or None
    return _marketdata_key._cached


def _marketdata_get(path, params, api_key):
    """Fetch a MarketData endpoint, returning normalized row dictionaries.

    Raises on HTTP errors or a non-'ok' status. 'no_data' is returned as
    an empty list so that callers can distinguish 'nothing available' from
    'request failed'.
    """
    headers = {'Accept': 'application/json', 'Authorization': f'Bearer {api_key}'}
    resp = requests.get(_MD_BASE + path, params=params, headers=headers,
                        timeout=30)
    resp.raise_for_status()
    body = resp.json()
    status = body.get('s')
    if status == 'no_data':
        return []
    if status != 'ok':
        raise RuntimeError(
            f"MarketData {path} returned status={status!r}: "
            f"{body.get('errmsg') or body}")
    lengths = [len(v) for v in body.values() if isinstance(v, list)]
    n = max(lengths) if lengths else 0
    rows = []
    for i in range(n):
        row = {}
        for key, val in body.items():
            if isinstance(val, list):
                row[key] = val[i] if i < len(val) else None
            else:
                row[key] = val
        rows.append(row)
    return rows


def _marketdata_date(timestamp):
    try:
        return datetime.utcfromtimestamp(int(timestamp)).strftime('%Y-%m-%d')
    except (TypeError, ValueError, OSError):
        return None


def _occ_symbol(ticker, option_type, strike, expiry):
    """Build a standard OCC option symbol from contract fields."""
    cp = 'C' if _normalize_option_type(option_type) == 'call' else 'P'
    exp = datetime.strptime(str(expiry), '%Y-%m-%d').strftime('%y%m%d')
    strike_int = int(round(float(strike) * 1000))
    root = ticker.upper().replace('.', '')
    return f'{root}{exp}{cp}{strike_int:08d}'


# Chains are always fetched with a broad expiry window so they can be cached
# and reused for in-memory selection across any (delta_target, expiry window)
# combination in the sensitivity sweep.
CHAIN_FETCH_MIN_DAYS = 30
CHAIN_FETCH_MAX_DAYS = 760


def _fetch_marketdata_chain(ticker, date_str, option_type, api_key,
                            min_days=CHAIN_FETCH_MIN_DAYS,
                            max_days=CHAIN_FETCH_MAX_DAYS):
    lo, hi = _contract_window(date_str, min_days, max_days)
    params = {
        'date': date_str,
        'from': lo.strftime('%Y-%m-%d'),
        'to': hi.strftime('%Y-%m-%d'),
        'side': _normalize_option_type(option_type),
        'expiration': 'all',
    }
    return _marketdata_get(f'/options/chain/{ticker}/', params, api_key)


# Chain cache: one CSV per (ticker, type, date) storing the broad-window chain.
# Lets the sensitivity sweep re-select contracts for different delta targets
# and expiry windows without refetching.
CHAIN_CACHE_DIR = os.path.join(OPTION_CACHE_DIR, 'chains')


def _chain_cache_path(ticker, option_type, date_str):
    option_type = _normalize_option_type(option_type)
    return os.path.join(CHAIN_CACHE_DIR,
                        f'{ticker}-{option_type}-{date_str}.csv')


def _load_chain_cache(ticker, option_type, date_str):
    path = _chain_cache_path(ticker, option_type, date_str)
    if not os.path.exists(path):
        return None
    df = pd.read_csv(path)
    if df.empty:
        return []
    return df.to_dict('records')


def _save_chain_cache(ticker, option_type, date_str, chain):
    if not chain:
        return
    os.makedirs(CHAIN_CACHE_DIR, exist_ok=True)
    path = _chain_cache_path(ticker, option_type, date_str)
    pd.DataFrame(chain).to_csv(path, index=False)


def _get_or_fetch_chain(ticker, date_str, option_type, api_key,
                        fetched_counter=None):
    """Return the cached broad chain for (ticker, type, date), fetching if absent.

    Requires ``api_key`` only when a fetch is actually needed.
    """
    chain = _load_chain_cache(ticker, option_type, date_str)
    if chain is not None:
        return chain
    if not api_key:
        raise RuntimeError(
            "MARKETDATA_KEY is not set but a chain fetch is required for "
            f"{ticker} {option_type} on {date_str}.")
    time.sleep(_MD_RATE_DELAY)
    chain = _fetch_marketdata_chain(ticker, date_str, option_type, api_key)
    if fetched_counter is not None:
        fetched_counter['marketdata_chains'] += 1
    _save_chain_cache(ticker, option_type, date_str, chain)
    return chain


def _fetch_marketdata_quotes(symbol, start_date, end_date, api_key):
    to_date = (datetime.strptime(end_date, '%Y-%m-%d')
               + timedelta(days=1)).strftime('%Y-%m-%d')
    rows = _marketdata_get(f'/options/quotes/{symbol}/',
                           {'from': start_date, 'to': to_date}, api_key)
    prices = {}
    for row in rows:
        date_str = _marketdata_date(row.get('updated'))
        if not date_str:
            continue
        price = _parse_option_price(row)
        if price is not None and price > 0:
            prices[date_str] = price
    return prices


def _implied_vol_from_price(S, K, T, option_price, option_type):
    """Infer Black-Scholes volatility from an observed option mid price."""
    if any(x is None for x in (S, K, T, option_price)):
        return None
    if S <= 0 or K <= 0 or T <= 0 or option_price <= 0:
        return None
    intrinsic = max(S - K, 0) if option_type == 'call' else max(K - S, 0)
    upper = S if option_type == 'call' else K
    if option_price < intrinsic - 1e-6 or option_price > upper * 1.5:
        return None
    lo, hi = 1e-4, 5.0
    try:
        if (option_price < bs_price(S, K, T, lo, option_type) - 1e-4
                or option_price > bs_price(S, K, T, hi, option_type) + 1e-4):
            return None
        for _ in range(80):
            mid = (lo + hi) / 2
            if bs_price(S, K, T, mid, option_type) < option_price:
                lo = mid
            else:
                hi = mid
        return (lo + hi) / 2
    except (FloatingPointError, ValueError, ZeroDivisionError):
        return None


def _marketdata_delta(row, ref_date_str, expiry, option_type, price):
    """Use vendor delta when present; otherwise infer it from the quote."""
    native = _safe_float(row.get('delta'))
    if native is not None and native != 0:
        return native
    S = _safe_float(row.get('underlyingPrice'))
    K = _safe_float(row.get('strike'))
    ref = datetime.strptime(ref_date_str, '%Y-%m-%d')
    exp = datetime.strptime(expiry, '%Y-%m-%d')
    T = max((exp - ref).days / 365.25, 1e-6)
    sigma = _safe_float(row.get('iv'))
    if sigma is None or sigma <= 0:
        sigma = _implied_vol_from_price(S, K, T, price, option_type)
    if S is None or K is None or sigma is None or sigma <= 0:
        return None
    return bs_delta(S, K, T, sigma, option_type)


def _select_marketdata_contract(chain, ref_date_str, option_type,
                                delta_target=OPTION_DELTA,
                                min_days=EXPIRY_MIN_DAYS,
                                max_days=EXPIRY_MAX_DAYS):
    option_type = _normalize_option_type(option_type)
    lo, hi = _contract_window(ref_date_str, min_days, max_days)
    candidates = []
    for c in chain:
        if str(c.get('side', '')).lower() != option_type:
            continue
        expiry = _marketdata_date(c.get('expiration'))
        if not expiry:
            continue
        exp = datetime.strptime(expiry, '%Y-%m-%d')
        if not (lo <= exp <= hi):
            continue
        price = _parse_option_price(c)
        if price is None or price <= 0:
            continue
        delta = _marketdata_delta(c, ref_date_str, expiry, option_type, price)
        if delta is None or delta == 0:
            continue
        strike = _safe_float(c.get('strike'))
        symbol = c.get('optionSymbol')
        if strike is None or not symbol:
            continue
        candidates.append({
            'option_type': option_type,
            'symbol': symbol,
            'strike': strike,
            'expiry': expiry,
            'delta': delta,
            'price': price,
        })
    if not candidates:
        return None
    candidates.sort(key=lambda x: abs(abs(x['delta']) - delta_target))
    return candidates[0]


def download_option_prices(option_positions, quarters, holdings, filing_dates,
                           today, delta_target=OPTION_DELTA,
                           min_days=EXPIRY_MIN_DAYS,
                           max_days=EXPIRY_MAX_DAYS):
    """Download historical representative option prices from MarketData.

    MarketData is the sole supported provider. MARKETDATA_KEY must be set.
    For each (ticker, option_type) and each filing period in which that
    position is held:

    1. On the first trading day, select a contract matching type, with
       expiry between ``min_days`` and ``max_days`` of the period start, and
       |delta| closest to ``delta_target``. MarketData's Starter plan often
       returns null Greeks, so delta is inferred from the observed mid price
       via Black-Scholes when the vendor delta is missing.
    2. Lock in that contract for the period.
    3. Track its historical mid price through the period.

    The broad option chain for each (ticker, type, first_day) is cached to
    disk so that sensitivity sweeps over (delta_target, expiry window) reuse
    a single fetch.

    Raises ``RuntimeError`` if no suitable contract can be selected for any
    required (ticker, type, period), or if MarketData returns no price series
    for the selected contract.

    Parameters
    ----------
    delta_target : float
        Target |delta| for contract selection (default ``OPTION_DELTA``).
    min_days, max_days : int
        Contract expiry window in days from period start (default 270-456,
        i.e. 9-15 months).

    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.
    """
    option_positions = sorted({
        (ticker, _normalize_option_type(pos_type))
        for ticker, pos_type in option_positions})
    md_key = _marketdata_key()

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

    for ticker, option_type in option_positions:
        opt_key = _option_position_key(ticker, option_type)
        cache = _load_option_cache(ticker, option_type, delta_target,
                                   min_days, max_days)
        new_rows = []

        for i, q in enumerate(quarters):
            # Skip quarters where this exact option position is absent.
            if opt_key not in holdings[q]:
                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 --
            contract = _select_cached_contract(
                cache, option_type, first_day,
                delta_target=delta_target,
                min_days=min_days, max_days=max_days,
                require_selected=True)
            if contract is None:
                chain = _get_or_fetch_chain(
                    ticker, first_day, option_type, md_key, fetched)
                contract = _select_marketdata_contract(
                    chain, first_day, option_type,
                    delta_target=delta_target,
                    min_days=min_days, max_days=max_days)
                if contract is None:
                    raise RuntimeError(
                        f"MarketData returned no usable {option_type} contract "
                        f"for {ticker} on {first_day} (period {q}) at "
                        f"delta={delta_target}, "
                        f"expiry {min_days}-{max_days}d")
                new_rows.append({
                    'date': first_day,
                    'selected_on': first_day,
                    'option_type': option_type,
                    'symbol': contract.get('symbol'),
                    'strike': contract['strike'],
                    'expiry': contract['expiry'],
                    'delta': contract['delta'],
                    'price': contract['price'],
                })

            strike = contract['strike']
            expiry = contract['expiry']
            symbol = contract.get('symbol') or _occ_symbol(
                ticker, option_type, strike, expiry)

            # -- Collect prices for this period (fresh dict per period) --
            period_prices = {}

            # Fast path: read matching prices from cache.
            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'])]
            selected_rows = rows[rows['selected_on'] == first_day]
            if not selected_rows.empty:
                rows = selected_rows
            for _, row in rows.iterrows():
                period_prices[row['date']] = float(row['price'])

            # Decide whether to refresh quotes. With a key, refresh whenever
            # the cached series does not reach period_end. Without a key,
            # only fail if the cached series is empty; a slightly stale
            # tail is acceptable for cache-only runs (e.g. sensitivity
            # sweeps replaying the baseline contract).
            has_partial = bool(period_prices)
            reaches_end = has_partial and max(period_prices) >= period_end
            if md_key and not reaches_end:
                time.sleep(_MD_RATE_DELAY)
                quote_prices = _fetch_marketdata_quotes(
                    symbol, period_start, period_end, md_key)
                fetched['marketdata_quotes'] += 1
                for day_str, price in quote_prices.items():
                    if period_start <= day_str <= period_end:
                        period_prices[day_str] = price
                        new_rows.append({
                            'date': day_str,
                            'selected_on': first_day,
                            'option_type': option_type,
                            'symbol': symbol,
                            'strike': strike,
                            'expiry': expiry,
                            'delta': contract['delta'],
                            'price': price,
                        })
                if contract.get('price') and first_day not in period_prices:
                    period_prices[first_day] = contract['price']
            elif not md_key and not has_partial:
                raise RuntimeError(
                    "MARKETDATA_KEY is not set and no cached quotes exist "
                    f"for {symbol} in {period_start}..{period_end}.")

            if not period_prices:
                raise RuntimeError(
                    f"MarketData returned no quotes for {symbol} "
                    f"({opt_key}) in {period_start}..{period_end}")

            per_period.setdefault(q, {})[opt_key] = period_prices

        # 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', 'selected_on', 'option_type', 'strike', 'expiry'],
                keep='last', inplace=True)
            cache.sort_values(['date', 'expiry', 'strike'], inplace=True)
            _save_option_cache(ticker, option_type, cache, delta_target,
                               min_days, max_days)

    if any(fetched.values()):
        import sys
        parts = []
        if fetched['marketdata_chains']:
            parts.append(f"{fetched['marketdata_chains']} MarketData chains")
        if fetched['marketdata_quotes']:
            parts.append(f"{fetched['marketdata_quotes']} MarketData quote series")
        print(f"[options] Fetched {', '.join(parts)}", file=sys.stderr)

    return per_period


# -- Black-Scholes helpers (used only to infer delta when MarketData's
#    Starter-plan historical Greeks are null; never to reprice returns) -----

from scipy.stats import norm as _norm


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_delta(S, K, T, sigma, option_type='call'):
    """Black-Scholes delta (assumes zero risk-free rate and dividends)."""
    if T <= 0 or sigma <= 0:
        if option_type == 'call':
            return 1.0 if S > K else 0.0
        return -1.0 if S < K else 0.0
    d1 = (np.log(S / K) + (sigma ** 2 / 2) * T) / (sigma * np.sqrt(T))
    if option_type == 'call':
        return _norm.cdf(d1)
    return _norm.cdf(d1) - 1


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

    For each filing period, stock shares and option contracts are fixed. In
    equity-proxy mode, option rows are converted to linear underlying exposure:
    calls are long underlying and puts are short underlying. In option-proxy
    mode, option rows are sized by 13F underlying notional and returns come
    from MarketData quotes; returns are divided by deployed capital (stock
    value plus option premium cost). Option-proxy mode raises if MarketData
    prices are missing for any required position.
    """
    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 starting prices, fixed exposure, and deployed capital.
        positions = holdings[q]
        exposure = {}
        costs = {}
        start_prices = {}
        start_underlying = {}
        use_opt_px = {}   # track which positions use option prices
        total_cost = 0

        for (ticker, pos_type), value in positions.items():
            is_option = pos_type in ('call', 'put')
            opt_key = _option_position_key(ticker, pos_type)

            if mode == 'equity_only':
                if pos_type not in ('long', 'call', 'put'):
                    continue
                if ticker not in close.columns:
                    continue
                src = close[ticker].dropna()
                avail = src[src.index >= ps]
                if avail.empty:
                    continue
                stock_start = float(avail.iloc[0])
                if stock_start <= 0:
                    continue
                start_prices[(ticker, pos_type)] = stock_start
                start_underlying[(ticker, pos_type)] = stock_start
                costs[(ticker, pos_type)] = value
                exposure[(ticker, pos_type)] = value
                use_opt_px[(ticker, pos_type)] = False
                total_cost += value
                continue

            # mode == 'full' (option proxy)
            if is_option:
                if opt_key not in quarter_opt:
                    raise RuntimeError(
                        f"No MarketData option prices for {opt_key} in "
                        f"period {q}")
                ticker_opt = quarter_opt[opt_key]
                opt_dates = sorted(d for d in ticker_opt if d >= period_start)
                if not opt_dates:
                    raise RuntimeError(
                        f"MarketData option prices for {opt_key} in period "
                        f"{q} contain no dates at or after {period_start}")
                if ticker not in close.columns:
                    raise RuntimeError(
                        f"No underlying close series for {ticker}")
                src = close[ticker].dropna()
                avail = src[src.index >= ps]
                if avail.empty:
                    raise RuntimeError(
                        f"No underlying price for {ticker} at {period_start}")
                opt_start = ticker_opt[opt_dates[0]]
                underlying_start = float(avail.iloc[0])
                if opt_start <= 0 or underlying_start <= 0:
                    raise RuntimeError(
                        f"Non-positive starting price for {opt_key} in "
                        f"period {q}")
                start_prices[(ticker, pos_type)] = opt_start
                start_underlying[(ticker, pos_type)] = underlying_start
                costs[(ticker, pos_type)] = value * opt_start / underlying_start
                exposure[(ticker, pos_type)] = value
                use_opt_px[(ticker, pos_type)] = True
                total_cost += costs[(ticker, pos_type)]
                continue

            # Plain stock in full mode
            if ticker not in close.columns:
                continue
            src = close[ticker].dropna()
            avail = src[src.index >= ps]
            if avail.empty:
                continue
            stock_start = float(avail.iloc[0])
            if stock_start <= 0:
                continue
            start_prices[(ticker, pos_type)] = stock_start
            start_underlying[(ticker, pos_type)] = stock_start
            costs[(ticker, pos_type)] = value
            exposure[(ticker, pos_type)] = value
            use_opt_px[(ticker, pos_type)] = False
            total_cost += value

        if total_cost == 0:
            continue

        # Daily P&L 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')
            period_pnl = 0
            for (ticker, pos_type), value in exposure.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
                    underlying_p0 = start_underlying.get((ticker, pos_type))
                    if not underlying_p0 or underlying_p0 <= 0:
                        continue
                    position_pnl = value * (float(p1_val) - p0) / underlying_p0
                else:
                    if ticker not in period_close.columns:
                        continue
                    p1_val = period_close[ticker].iloc[day_idx]
                    if pd.isna(p1_val):
                        continue
                    stock_ret = (float(p1_val) - p0) / p0
                    if mode == 'equity_only':
                        position_pnl = (
                            value * _linear_underlying_sign(pos_type) * stock_ret)
                    else:
                        position_pnl = value * stock_ret
                period_pnl += position_pnl

            dates_out.append(day)
            values_out.append(cum_growth * (1 + period_pnl / total_cost))

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

    return dates_out, values_out

# Download representative option prices from MarketData (raises on missing data).
option_positions = sorted({
    (t, pt)
    for q in quarters
    for (t, pt) in holdings[q]
    if pt in ('call', 'put')
})
per_period_opt = download_option_prices(
    option_positions, quarters, holdings, filing_dates, today)

# Compute copycat returns
header = (f"{'Period':<16} {'Dates':<24} "
          f"{'Eq. proxy':>9} {'Opt. proxy':>10} {'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',
                              option_prices=per_period_opt.get(q, {}))
    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. proxy = stocks plus option rows as linear underlying exposure")
print("Opt. proxy = options sized to 13F notional; returns on deployed capital")

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


def daily_returns_from_cumulative(mode, per_period_opt=None):
    if daily_close.empty:
        return pd.Series(dtype=float)
    dates, values = daily_cumulative(
        holdings, quarters, filing_dates, daily_close, today, mode,
        per_period_opt=per_period_opt)
    if not dates:
        return pd.Series(dtype=float)
    growth = pd.Series(values, index=dates)
    return growth.pct_change().dropna()


ret_eq_d = daily_returns_from_cumulative('equity_only')
ret_full_d = daily_returns_from_cumulative(
    'full', per_period_opt=per_period_opt)

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.proxy':>9} {'Opt.proxy':>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}%")