PythagorasGoal/scripts/research/alt/runs/VOL02.py

"""VOL02 — IV-RV spread directional strategy.

IDEA: Compare DVOL (Deribit implied vol index) to annualized realized vol (RV).
When DVOL >> RV (vol premium is large / market is stressed), de-risk to flat.
When DVOL <= RV (vol is cheap or normal), stay long (risk-on).

We test both directions:
  - "Stay long when DVOL <= RV" (risk-on when IV cheap)
  - "Stay long when DVOL > RV" (contrarian: buy stress)

Small param grid: spread threshold (0 or +5 vol points above RV) x RV window (21d or 42d).
DVOL history starts 2021-03, so effective backtest starts ~2021-Q1.
"""
import sys
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
import altlib as al
import numpy as np


def make_target(rv_win_days: int = 21, spread_thresh: float = 0.0, direction: str = "risk_on"):
    """
    direction='risk_on':  long when DVOL - RV_annualized <= spread_thresh (IV cheap/normal)
    direction='stress':   long when DVOL - RV_annualized > spread_thresh  (IV expensive/stressed)
    Both use vol-targeting so position size is volatility-controlled.
    """
    def target_fn(df):
        c = df["close"].values.astype(float)
        bpd = al.bars_per_day(df)
        bpy = bpd * 365.25

        # Realized vol: annualized, causal (uses data up to bar i)
        r = al.simple_returns(c)
        rv_raw = al.realized_vol(r, win=max(2, rv_win_days * bpd), bars_per_year=bpy)
        # Convert to vol points (DVOL is in vol points = percentage, e.g. 65.0 means 65% ann vol)
        rv_vp = rv_raw * 100.0  # e.g. 0.65 -> 65.0

        # DVOL: causal (known at bar open)
        iv_vp = al.dvol(df, df["close"].name if hasattr(df["close"], "name") else "BTC")

        # We need asset name - pass it via closure
        spread = iv_vp - rv_vp  # positive = IV > RV (vol premium)

        if direction == "risk_on":
            # Long when IV-RV <= threshold (IV is cheap/normal relative to RV)
            raw_dir = np.where(spread <= spread_thresh, 1.0, 0.0)
        else:
            # Long when IV-RV > threshold (buy when stressed / high vol premium)
            raw_dir = np.where(spread > spread_thresh, 1.0, 0.0)

        # Mask NaN in DVOL or RV -> flat
        mask_valid = np.isfinite(iv_vp) & np.isfinite(rv_vp)
        raw_dir = np.where(mask_valid, raw_dir, 0.0)

        # Vol-target the position
        return al.vol_target(raw_dir, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)

    return target_fn


def make_target_with_asset(asset: str, rv_win_days: int = 21, spread_thresh: float = 0.0, direction: str = "risk_on"):
    """Asset-aware version for study_weights (asset is passed per call)."""
    def target_fn(df):
        c = df["close"].values.astype(float)
        bpd = al.bars_per_day(df)
        bpy = bpd * 365.25

        r = al.simple_returns(c)
        rv_raw = al.realized_vol(r, win=max(2, rv_win_days * bpd), bars_per_year=bpy)
        rv_vp = rv_raw * 100.0

        iv_vp = al.dvol(df, asset)
        spread = iv_vp - rv_vp

        if direction == "risk_on":
            raw_dir = np.where(spread <= spread_thresh, 1.0, 0.0)
        else:
            raw_dir = np.where(spread > spread_thresh, 1.0, 0.0)

        mask_valid = np.isfinite(iv_vp) & np.isfinite(rv_vp)
        raw_dir = np.where(mask_valid, raw_dir, 0.0)

        return al.vol_target(raw_dir, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)

    return target_fn


def run_asset_aware(name, asset_configs, tfs=("1d",)):
    """
    Run study_weights with asset-aware DVOL lookup.
    asset_configs: dict of asset -> target_fn
    """
    import altlib as al
    import numpy as np

    cells = []
    for tf in tfs:
        per_asset = {}
        fee_ok_all = True
        for a, tgt_fn in asset_configs.items():
            df = al.get(a, tf)
            tgt = tgt_fn(df)
            base = al.eval_weights(df, tgt, fee_side=al.FEE_SIDE)
            sweep = {f"{2*f*100:.2f}%RT": al.eval_weights(df, tgt, fee_side=f)["full"]["sharpe"]
                     for f in al.FEE_SWEEP}
            fee_ok = sweep.get("0.20%RT", -9) > 0
            fee_ok_all = fee_ok_all and fee_ok
            per_asset[a] = dict(full=base["full"], holdout=base["holdout"],
                                tim=base["time_in_market"], turnover=base["turnover_per_year"],
                                fee_sweep=sweep, yearly=base["yearly"])
        min_full = min(per_asset[a]["full"]["sharpe"] for a in asset_configs)
        min_hold = min(per_asset[a]["holdout"].get("sharpe", 0.0) for a in asset_configs)
        cells.append(dict(tf=tf, per_asset=per_asset,
                          min_asset_full_sharpe=round(min_full, 3),
                          min_asset_holdout_sharpe=round(min_hold, 3),
                          full_sharpe=round(np.mean([per_asset[a]["full"]["sharpe"] for a in asset_configs]), 3),
                          fee_survives=fee_ok_all))
    verdict = al._verdict(cells)
    return dict(name=name, kind="weights", cells=cells, verdict=verdict)


if __name__ == "__main__":
    # Grid: 4 configs, each on 1d only -> 4 cells x 2 assets = 8 backtests (under limit)
    configs = [
        dict(rv_win=21, thresh=0.0,  direction="risk_on"),   # DVOL<=RV -> long
        dict(rv_win=21, thresh=5.0,  direction="risk_on"),   # DVOL<=RV+5 -> long
        dict(rv_win=21, thresh=0.0,  direction="stress"),    # DVOL>RV -> long (opposite)
        dict(rv_win=42, thresh=0.0,  direction="risk_on"),   # longer RV window
    ]

    best_rep = None
    best_min_hold = -999

    for cfg in configs:
        name = f"VOL02-{cfg['direction']}-rv{cfg['rv_win']}-t{cfg['thresh']}"
        asset_cfgs = {
            "BTC": make_target_with_asset("BTC", rv_win_days=cfg["rv_win"],
                                          spread_thresh=cfg["thresh"], direction=cfg["direction"]),
            "ETH": make_target_with_asset("ETH", rv_win_days=cfg["rv_win"],
                                          spread_thresh=cfg["thresh"], direction=cfg["direction"]),
        }
        rep = run_asset_aware(name, asset_cfgs, tfs=("1d",))
        print(al.fmt(rep))
        print()
        mh = rep["verdict"].get("best_holdout_sharpe", -999)
        if best_rep is None or mh > best_min_hold:
            best_rep = rep
            best_min_hold = mh

    # Override name to canonical VOL02
    best_rep["name"] = "VOL02"
    print("\n=== BEST CONFIG ===")
    print(al.fmt(best_rep))
    print("JSON:", al.as_json(best_rep))