feat: option lab

backend/services/strategy_comparison.py

@@ -0,0 +1,169 @@
+"""
+Retrospective "what would have been optimal" comparison for an existing Portfolio position
+— reuses the Strategy Builder optimizer (services.strategy_optimizer.optimize) against the
+REAL historical option chain reconstructed as of the position's entry_date
+(services.option_chain.get_chain_slice's `as_of` param, backed by
+services.database.get_snapshot_rows_asof — the accumulated Saxo snapshot history, not
+synthetic data), scored against the REALIZED spot/IV move between entry and the comparison
+date rather than a guessed scenario — it's not a forecast, it's what actually happened.
+
+Results are compared in PERCENTAGE terms (return on capital / return on risk), never raw
+dollars: Strategy Builder's own pricer (services.strategy_engine, contract_size configurable,
+FX-lot-style default 100_000) and Portfolio's pricer (services.portfolio_pricing, hardcoded
+qty*100 equity-option-style) use different contract-size conventions for historical reasons —
+comparing their dollar outputs directly would silently misstate the comparison by orders of
+magnitude (the exact class of bug this project hit before with the COMEX copper scale issue).
+A % return is convention-agnostic since the contract size cancels out of the ratio.
+"""
+from datetime import date, datetime
+from typing import Any, Dict, Optional
+
+
+def _reprice_actual_legs_pct(
+    legs: list, chain_entry: Dict[str, Any], surface_entry, surface_realized,
+    horizon_days: int, capital_invested: float, ib_fees_entry: float,
+) -> Optional[float]:
+    """% return of the position's REAL legs, priced at entry (services.portfolio_pricing's
+    own qty*100 convention — mirrored here, not imported, since that module's functions are
+    tied to "now" market data, not a historical `as_of` chain) then repriced under the
+    realized move. Returns None if the position has no legs to price."""
+    from services.options_pricer import black_scholes
+    from services.option_chain import find_quote
+
+    if not legs:
+        return None
+    r = 0.05
+    S_entry = chain_entry["spot"]
+    S_realized = surface_realized.spot
+    T_remaining = max(horizon_days, 0) / 365
+
+    pnl = -ib_fees_entry
+    for leg in legs:
+        K = leg.get("strike") or S_entry
+        opt_type = leg.get("option_type", "call")
+        qty = leg.get("quantity", 1)
+        sign = 1 if leg.get("position", "long") == "long" else -1
+        days_to_expiry = leg.get("days_to_expiry", 90)
+
+        entry_premium = leg.get("premium_paid")
+        if entry_premium is None:
+            quote = find_quote(chain_entry, leg.get("expiry_date", ""), K, opt_type)
+            if quote and quote.get("bid", 0) > 0 and quote.get("ask", 0) > 0:
+                entry_premium = quote["mid"]
+            else:
+                sigma_entry = surface_entry.iv_at(K, days_to_expiry)
+                entry_premium = black_scholes(S_entry, K, max(days_to_expiry, 1) / 365, r, sigma_entry, opt_type)["price"]
+
+        remaining = max(days_to_expiry - horizon_days, 0.001)
+        sigma_realized = surface_realized.iv_at(K, remaining)
+        realized_price = (
+            black_scholes(S_realized, K, remaining / 365, r, sigma_realized, opt_type)["price"]
+            if T_remaining > 0 and remaining > 0.001
+            else (max(0.0, S_realized - K) if opt_type == "call" else max(0.0, K - S_realized))
+        )
+        pnl += sign * qty * 100 * (realized_price - entry_premium)
+
+    if not capital_invested:
+        return None
+    return round(pnl / capital_invested * 100, 2)
+
+
+def compute_retrospective_comparison(pos: Dict[str, Any], as_of: Optional[str] = None) -> Dict[str, Any]:
+    from services.database import get_saxo_option_symbol_for_ticker
+    from services.option_chain import get_chain_slice
+    from services.vol_surface import build_surface, apply_scenario
+    from services.strategy_optimizer import optimize as run_optimizer
+
+    underlying = pos["underlying"]
+    saxo_symbol = get_saxo_option_symbol_for_ticker(underlying)
+    if not saxo_symbol:
+        return {"available": False, "reason": f"'{underlying}' n'est pas lié à un chain Saxo (Config → Instruments Watchlist)."}
+
+    entry_date = pos["entry_date"][:10]
+    as_of_date = (as_of or pos.get("close_date") or date.today().isoformat())[:10]
+    if as_of_date <= entry_date:
+        return {"available": False, "reason": "La date de comparaison doit être postérieure à la date d'entrée."}
+
+    horizon_days = (
+        datetime.strptime(as_of_date, "%Y-%m-%d").date() - datetime.strptime(entry_date, "%Y-%m-%d").date()
+    ).days
+    target_days_entry = pos.get("expiry_days", 90)
+
+    try:
+        chain_entry = get_chain_slice(saxo_symbol, target_days=target_days_entry, n_expiries=3, as_of=entry_date)
+    except ValueError as e:
+        return {"available": False, "reason": f"Pas d'historique Saxo à la date d'entrée ({entry_date}) : {e}"}
+    try:
+        chain_realized = get_chain_slice(
+            saxo_symbol, target_days=max(target_days_entry - horizon_days, 1), n_expiries=3,
+            as_of=as_of_date if as_of else None,
+        )
+    except ValueError as e:
+        return {"available": False, "reason": f"Pas d'historique Saxo à la date de comparaison ({as_of_date}) : {e}"}
+
+    surface_entry = build_surface(chain_entry)
+    surface_realized_base = build_surface(chain_realized)
+
+    spot_entry = chain_entry["spot"]
+    spot_realized = chain_realized["spot"]
+    if not spot_entry or not spot_realized:
+        return {"available": False, "reason": "Spot manquant dans l'historique Saxo à l'une des deux dates."}
+
+    realized_spot_shock_pct = round((spot_realized - spot_entry) / spot_entry * 100, 2)
+    iv_entry = surface_entry.iv_at(spot_entry, target_days_entry)
+    iv_realized = surface_realized_base.iv_at(spot_realized, max(target_days_entry - horizon_days, 1))
+    realized_iv_shift = round(iv_realized - iv_entry, 4)
+
+    # The same realized shock, applied on top of the ENTRY surface — puts the "actual
+    # position" and "optimal candidates" repricing on the exact same footing (both start
+    # from what was really quoted at entry, both move by what really happened afterwards).
+    surface_realized = apply_scenario(surface_entry, spot_shock_pct=realized_spot_shock_pct, iv_level_shift=realized_iv_shift)
+
+    actual_return_pct = _reprice_actual_legs_pct(
+        pos.get("legs", []), chain_entry, surface_entry, surface_realized,
+        horizon_days, pos.get("capital_invested") or 0, pos.get("ib_fees_entry", 0),
+    )
+
+    optimal_candidates = run_optimizer(
+        symbol=saxo_symbol, horizon_days=horizon_days,
+        spot_shock_pct=realized_spot_shock_pct, iv_level_shift=realized_iv_shift,
+        skew_tilt=0.0, term_slope_shift=0.0, manual_grid=None, n_expiries=3, rate=0.05,
+        constraints={"max_legs": 4, "delta_threshold": None, "max_loss_cap": None},
+        objective="net_pnl", top_n=5, as_of=entry_date,
+    )
+
+    # NOT "return on max_loss": check_bounded_risk's worst-case search is unreliable for
+    # multi-expiry (calendar/diagonal) structures — the far leg is still alive and vol-
+    # dependent at the near leg's expiry, so its "max loss" can come out implausibly small
+    # regardless of precise=True/False, producing a nonsense ratio (verified empirically:
+    # >9000% "return on risk" on a diagonal in testing). Comparing against the SAME capital
+    # basis as the actual position (capital_invested) sidesteps that search entirely — "if
+    # you'd put the same money into this instead" is also a more direct answer to "what
+    # should I have done" than a max-loss ratio would be. Repriced at contract_size=100 to
+    # match Portfolio's own per-contract convention (see module docstring) rather than
+    # Strategy Builder's default FX-lot size, so the dollar P&L this produces is actually on
+    # the same footing as capital_invested, not just a same-shaped ratio.
+    from services.strategy_engine import price_combo
+    capital = pos.get("capital_invested") or 0
+    for c in optimal_candidates:
+        try:
+            precise = price_combo(
+                c["legs"], chain_entry, surface_entry, surface_realized, horizon_days,
+                r=0.05, contract_size=100, precise=True,
+            )
+            c["net_pnl"], c["max_gain"], c["max_loss"] = precise["net_pnl"], precise["max_gain"], precise["max_loss"]
+            c["net_delta_now"] = precise["net_delta_now"]
+            c["return_on_capital_pct"] = round(precise["net_pnl"] / capital * 100, 2) if capital else None
+        except Exception:
+            c["return_on_capital_pct"] = None
+
+    return {
+        "available": True,
+        "underlying": underlying, "saxo_symbol": saxo_symbol,
+        "entry_date": entry_date, "as_of": as_of_date, "horizon_days": horizon_days,
+        "spot_entry": round(spot_entry, 6), "spot_realized": round(spot_realized, 6),
+        "realized_spot_shock_pct": realized_spot_shock_pct,
+        "iv_entry": round(iv_entry, 4), "iv_realized": round(iv_realized, 4), "realized_iv_shift": realized_iv_shift,
+        "actual_return_pct": actual_return_pct,
+        "optimal_candidates": optimal_candidates,
+    }