PythagorasGoal/scripts/research/r0910_macro_riskoff.py

#!/usr/bin/env python
"""r0910_macro_riskoff.py — «risk-off» di TP01 nella finestra ±2h intorno a FOMC e CPI: vale qualcosa?

DOMANDA (operatore, 2026-09-10, da un articolo su EA forex con «agente fondamentale»): se TP01 si
mettesse FLAT nelle due ore prima e dopo la dichiarazione FOMC (14:00 ET) e la release CPI
(08:30 ET), guadagnerebbe Sharpe o drift? E' un risk-off, quindi per la regola di §3 («non
de-esporre il weekend») PARTE REFUTED e deve superare il null del de-levering (M5) e un null
location-matched (M18) prima di essere creduto.

VERDETTO PRE-REGISTRATO (scritto PRIMA di vedere un numero):
  LEAD solo se TUTTE: (a) ΔSharpe(riskoff − base) > 0 con le fee di chiusura/riapertura;
  (b) il Δ vero sta al ≥95° percentile del null location-matched (stesso numero di eventi per
  anno, stesse ore del giorno, giorni estratti a caso); (c) Δ positivo in ≥70% degli anni con ≥5
  eventi (M9). Altrimenti REFUTED. E l'effetto si cita anche in €/giorno all'equity di oggi.

COSA NON C'E' (dichiarato): il funding (mai in nessun backtest, −2,16%/anno di drift) — irrilevante
qui perche' identico nelle due varianti salvo ~1% delle ore; il rimbalzo di prezzo nella finestra
(slippage: TP01 chiude e riapre a mid, in un'ora in cui lo spread e' largo — se il risultato fosse
positivo andrebbe rimisurato col costo vero della finestra, C1). SKH01 non e' qui: e' un breakout su
barra 230m, appiattirlo cambierebbe il percorso del segnale.

CALENDARIO (letto dal web il 2026-09-10, non ricordato — regola globale):
  FOMC: federalreserve.gov/monetarypolicy/fomccalendars.htm (2021-2026) e fomchistorical2019/2020.
        Ore: 14:00 ET per le riunioni programmate (standard Fed); le due d'emergenza del 2020
        (03/03 10:00 ET, 15/03 17:00 ET) con la loro ora; i «notation vote» ESCLUSI (nessuna
        dichiarazione a orario). ET→UTC con America/New_York (DST).
  CPI:  bls.gov/bls/news-release/cpi.htm (archivio 2019-2026), 08:30 ET (bls.gov/schedule).
        L'archivio raggruppa per anno di RIFERIMENTO: le release di gennaio/febbraio stanno sotto
        l'anno prima — corrette qui (+1 anno), e la correzione e' verificata sul 2026 (13/01 e
        13/02 stanno nella schedule ufficiale 2026).

TP01 ORARIO: posizione decisa alla chiusura giornaliera (00:00 UTC) e tenuta per le 24 barre 1h del
giorno (la stessa `held` di sleeves._tp01_returns, spalmata sulle ore); P&L orario = held × rendimento
1h; fee sul turnover giornaliero. RISK-OFF: held = 0 nelle barre 1h che intersecano [t−2h, t+2h],
con fee_side su chiusura e riapertura (|held| × 2 × fee).

    uv run python scripts/research/r0910_macro_riskoff.py
"""
from __future__ import annotations

import sys
from datetime import datetime
from pathlib import Path
from zoneinfo import ZoneInfo

import numpy as np
import pandas as pd

ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT))

from src.data.downloader import load_data                                   # noqa: E402
from src.strategies.trend_portfolio import CANONICAL, TrendPortfolio, resample_1d  # noqa: E402

ASSETS = ("BTC", "ETH")
ET = ZoneInfo("America/New_York")
FINESTRA_H = 2.0
N_NULL = 1000
SEED = 20260910
EQUITY_OGGI = 4454.83          # trades_db --report 10/09 14:21Z, per il €/giorno
EURUSD = 1.08                  # ordine di grandezza, dichiarato: serve solo per la riga in €/g

# ------------------------------------------------------------------ calendario
FOMC_PROGRAMMATE = """
2019-01-30 2019-03-20 2019-05-01 2019-06-19 2019-07-31 2019-09-18 2019-10-30 2019-12-11
2020-01-29 2020-04-29 2020-06-10 2020-07-29 2020-09-16 2020-11-05 2020-12-16
2021-01-27 2021-03-17 2021-04-28 2021-06-16 2021-07-28 2021-09-22 2021-11-03 2021-12-15
2022-01-26 2022-03-16 2022-05-04 2022-06-15 2022-07-27 2022-09-21 2022-11-02 2022-12-14
2023-02-01 2023-03-22 2023-05-03 2023-06-14 2023-07-26 2023-09-20 2023-11-01 2023-12-13
2024-01-31 2024-03-20 2024-05-01 2024-06-12 2024-07-31 2024-09-18 2024-11-07 2024-12-18
2025-01-29 2025-03-19 2025-05-07 2025-06-18 2025-07-30 2025-09-17 2025-10-29 2025-12-10
2026-01-28 2026-03-18 2026-04-29 2026-06-17 2026-07-29
""".split()
FOMC_EMERGENZA = [("2020-03-03", "10:00"), ("2020-03-15", "17:00")]

# archivio BLS, ordine della pagina (per anno di riferimento): le release di gen/feb vanno +1 anno
CPI_ARCHIVIO = """
2026-08-12 2026-07-14 2026-06-10 2026-05-12 2026-04-10 2026-03-11 2026-02-13
2025-01-13 2025-12-18 2025-10-24 2025-09-11 2025-08-12 2025-07-15 2025-06-11 2025-05-13 2025-04-10 2025-03-12 2025-02-12
2024-01-15 2024-12-11 2024-11-13 2024-10-10 2024-09-11 2024-08-14 2024-07-11 2024-06-12 2024-05-15 2024-04-10 2024-03-12 2024-02-13
2023-01-11 2023-12-12 2023-11-14 2023-10-12 2023-09-13 2023-08-10 2023-07-12 2023-06-13 2023-05-10 2023-04-12 2023-03-14
2022-02-14 2022-01-12 2022-12-13 2022-11-10 2022-10-13 2022-09-13 2022-08-10 2022-07-13 2022-06-10 2022-05-11 2022-04-12 2022-03-10
2021-02-10 2021-01-12 2021-12-10 2021-11-10 2021-10-13 2021-09-14 2021-08-11 2021-07-13 2021-06-10 2021-05-12 2021-04-13 2021-03-10
2020-02-10 2020-01-13 2020-12-10 2020-11-12 2020-10-13 2020-09-11 2020-08-12 2020-07-14 2020-06-10 2020-05-12 2020-04-10 2020-03-11
2019-02-13 2019-01-14 2019-12-11 2019-11-13 2019-10-10 2019-09-12 2019-08-13 2019-07-11 2019-06-12 2019-05-10 2019-04-10 2019-03-12
""".split()


def cpi_date_corrette(seq: list[str]) -> list[str]:
    """Una data di gen/feb che PRECEDE (nell'ordine della pagina, discendente) una data di
    marzo-dicembre dello STESSO anno e' la release dell'anno dopo."""
    out = []
    for i, d in enumerate(seq):
        y, m = int(d[:4]), int(d[5:7])
        if m <= 2:
            j = i + 1
            while j < len(seq) and int(seq[j][5:7]) <= 2:
                j += 1
            if j < len(seq) and int(seq[j][:4]) == y:
                d = f"{y + 1}{d[4:]}"
        out.append(d)
    return sorted(set(out))


def eventi() -> pd.DataFrame:
    rows = []
    for d in FOMC_PROGRAMMATE:
        rows.append(("FOMC", datetime.fromisoformat(f"{d} 14:00").replace(tzinfo=ET)))
    for d, hm in FOMC_EMERGENZA:
        rows.append(("FOMC", datetime.fromisoformat(f"{d} {hm}").replace(tzinfo=ET)))
    for d in cpi_date_corrette(CPI_ARCHIVIO):
        rows.append(("CPI", datetime.fromisoformat(f"{d} 08:30").replace(tzinfo=ET)))
    ev = pd.DataFrame(rows, columns=["tipo", "t_et"])
    ev["t"] = ev["t_et"].map(lambda x: pd.Timestamp(x.astimezone(ZoneInfo("UTC"))))
    return ev.sort_values("t").reset_index(drop=True)


# ------------------------------------------------------------------ TP01 orario
def tp01_orario() -> pd.DataFrame:
    """-> DataFrame orario con held_BTC, held_ETH, r_BTC, r_ETH, fee_day (fee del turnover
    giornaliero, sulla prima barra del giorno)."""
    tp = TrendPortfolio(**CANONICAL)
    parts = {}
    for a in ASSETS:
        h = load_data(a, "1h")
        hidx = pd.to_datetime(h["datetime"], utc=True)
        r1h = pd.Series(h["close"].values.astype(float), index=hidx).pct_change().fillna(0.0)
        d = resample_1d(h)
        tgt = tp.target_series(d)
        held = np.zeros(len(tgt)); held[1:] = tgt[:-1]
        didx = pd.to_datetime(d["datetime"], utc=True).dt.floor("D")
        held_d = pd.Series(held, index=didx)
        turn_d = pd.Series(np.abs(np.diff(held, prepend=0.0)) * tp.fee_side, index=didx)
        day_of_h = hidx.dt.floor("D")
        held_h = held_d.reindex(day_of_h).values
        fee_h = np.where(hidx.dt.hour.values == 0, turn_d.reindex(day_of_h).values, 0.0)
        parts[a] = pd.DataFrame({f"held_{a}": held_h, f"r_{a}": r1h.values, f"fee_{a}": fee_h}, index=hidx)
    J = pd.concat(parts.values(), axis=1, join="inner").dropna()
    return J


def pnl(J: pd.DataFrame, flat_mask: np.ndarray | None, fee_side: float) -> pd.Series:
    """Rendimento orario del portafoglio 50/50. `flat_mask` True = barra a esposizione zero
    (con fee di chiusura all'ingresso nella finestra e di riapertura all'uscita)."""
    out = np.zeros(len(J))
    for a in ASSETS:
        held = J[f"held_{a}"].values.copy()
        fee = J[f"fee_{a}"].values.copy()
        if flat_mask is not None:
            h0 = held.copy()
            held = np.where(flat_mask, 0.0, held)
            # transizioni dentro/fuori finestra: |Δheld| × fee, oltre al turnover giornaliero
            extra = np.abs(np.diff(held, prepend=held[0])) - np.abs(np.diff(h0, prepend=h0[0]))
            fee = fee + np.clip(extra, 0, None) * fee_side
        out += 0.5 * (held * J[f"r_{a}"].values - fee)
    return pd.Series(out, index=J.index)


def maschera(J: pd.DataFrame, tempi: pd.Series, w_h: float = FINESTRA_H) -> np.ndarray:
    """Barre 1h (open-labeled) che intersecano [t−w, t+w] per almeno un evento."""
    idx = J.index.values.astype("datetime64[ns]")
    m = np.zeros(len(J), dtype=bool)
    w = np.timedelta64(int(w_h * 3600), "s")
    one_h = np.timedelta64(3600, "s")
    for t in tempi:
        t64 = np.datetime64(pd.Timestamp(t).tz_convert("UTC").tz_localize(None))
        lo, hi = np.searchsorted(idx, t64 - w - one_h, side="right"), np.searchsorted(idx, t64 + w, side="left")
        m[lo:hi] = True
    return m


def sharpe_h(s: pd.Series) -> float:
    return float(s.mean() / s.std() * np.sqrt(24 * 365.25)) if s.std() > 0 else float("nan")


def sharpe_d(s: pd.Series) -> float:
    d = s.groupby(s.index.floor("D")).sum()
    return float(d.mean() / d.std() * np.sqrt(365.25)) if d.std() > 0 else float("nan")


def drift_annuo(s: pd.Series) -> float:
    return float(s.mean() * 24 * 365.25)


# ------------------------------------------------------------------ misura
def misura() -> dict:
    J = tp01_orario()
    fee_side = TrendPortfolio(**CANONICAL).fee_side
    ev = eventi()
    ev = ev[(ev["t"] >= J.index[0]) & (ev["t"] <= J.index[-1])].reset_index(drop=True)
    base = pnl(J, None, fee_side)
    m_all = maschera(J, ev["t"])
    ro = pnl(J, m_all, fee_side)
    ro_nofee = pnl(J, m_all, 0.0)

    out = dict(n_ore=len(J), da=str(J.index[0]), a=str(J.index[-1]), n_ev=len(ev),
               n_fomc=int((ev.tipo == "FOMC").sum()), n_cpi=int((ev.tipo == "CPI").sum()),
               ore_finestra=int(m_all.sum()), quota_ore=float(m_all.mean()),
               base=dict(sh_d=sharpe_d(base), sh_h=sharpe_h(base), drift=drift_annuo(base)),
               riskoff=dict(sh_d=sharpe_d(ro), sh_h=sharpe_h(ro), drift=drift_annuo(ro)),
               riskoff_nofee=dict(sh_d=sharpe_d(ro_nofee), drift=drift_annuo(ro_nofee)))
    out["d_sh_d"] = out["riskoff"]["sh_d"] - out["base"]["sh_d"]
    out["d_drift"] = out["riskoff"]["drift"] - out["base"]["drift"]
    # cosa succede DENTRO la finestra (il P&L che il risk-off rinuncia)
    dentro = base[m_all]; fuori = base[~m_all]
    esposto = (J.loc[m_all, [f"held_{a}" for a in ASSETS]].abs().sum(axis=1) > 0)
    out["dentro"] = dict(n=int(m_all.sum()), n_esposte=int(esposto.sum()), media_h=float(dentro.mean()),
                         t=float(dentro.mean() / dentro.std() * np.sqrt(len(dentro))) if dentro.std() > 0 else float("nan"),
                         somma=float(dentro.sum()), media_fuori_h=float(fuori.mean()))
    # per tipo
    out["per_tipo"] = {}
    for tipo in ("FOMC", "CPI"):
        m = maschera(J, ev.loc[ev.tipo == tipo, "t"])
        r = pnl(J, m, fee_side)
        out["per_tipo"][tipo] = dict(n=int((ev.tipo == tipo).sum()), d_sh_d=sharpe_d(r) - out["base"]["sh_d"],
                                    d_drift=drift_annuo(r) - out["base"]["drift"], somma_dentro=float(base[m].sum()))
    # per anno (M9)
    anni = {}
    for y, g in base.groupby(base.index.year):
        my = m_all[base.index.year == y]
        ry = ro[base.index.year == y]
        ney = int((ev["t"].dt.year == y).sum())
        anni[int(y)] = dict(n_ev=ney, d_sh_d=sharpe_d(ry) - sharpe_d(g), somma_dentro=float(g[my].sum()),
                            d_cum=float((1 + ry).prod() - (1 + g).prod()))
    out["anni"] = anni
    # null location-matched (M18): stessi conteggi per anno e stesse ORE del giorno, giorni a caso
    rng = np.random.default_rng(SEED)
    giorni_per_anno = {y: np.array(sorted(set(J.index[J.index.year == y].normalize()))) for y in J.index.year.unique()}
    d_null = np.empty(N_NULL)
    for k in range(N_NULL):
        t_fake = []
        for y, g in ev.groupby(ev["t"].dt.year):
            pool = giorni_per_anno.get(int(y))
            if pool is None or len(pool) == 0:
                continue
            days = rng.choice(pool, size=len(g), replace=False)
            for d, t in zip(days, g["t"]):
                t_fake.append(pd.Timestamp(d) + (t - t.normalize()))
        mk = maschera(J, pd.Series(t_fake))
        d_null[k] = sharpe_d(pnl(J, mk, fee_side)) - out["base"]["sh_d"]
    out["null"] = dict(n=N_NULL, media=float(d_null.mean()), p50=float(np.median(d_null)),
                       p95=float(np.percentile(d_null, 95)), p05=float(np.percentile(d_null, 5)),
                       pctl_vero=float((d_null < out["d_sh_d"]).mean() * 100))
    # €/giorno all'equity di oggi
    out["eur_giorno"] = out["d_drift"] * EQUITY_OGGI / EURUSD / 365.25
    return out


def verdetto(m: dict) -> tuple[str, list[str]]:
    a = m["d_sh_d"] > 0
    b = m["null"]["pctl_vero"] >= 95.0
    anni_ok = [y for y, v in m["anni"].items() if v["n_ev"] >= 5]
    pos = sum(1 for y in anni_ok if m["anni"][y]["d_sh_d"] > 0)
    c = anni_ok and pos / len(anni_ok) >= 0.70
    righe = [f"(a) ΔSharpe giornaliero con fee > 0: {m['d_sh_d']:+.3f} → {'PASS' if a else 'FAIL'}",
             f"(b) Δ vero al ≥95° pctl del null location-matched: {m['null']['pctl_vero']:.1f}° → {'PASS' if b else 'FAIL'}",
             f"(c) Δ > 0 in ≥70% degli anni con ≥5 eventi: {pos}/{len(anni_ok)} → {'PASS' if c else 'FAIL'}"]
    return ("LEAD" if (a and b and c) else "REFUTED"), righe


def main() -> int:
    print("=" * 88)
    print("  r0910 — RISK-OFF ±2h intorno a FOMC e CPI su TP01 (lente oraria, posizione giornaliera)")
    print("=" * 88)
    m = misura()
    print(f"  ore: {m['n_ore']}  {m['da'][:10]} → {m['a'][:10]}   eventi: {m['n_ev']} "
          f"(FOMC {m['n_fomc']}, CPI {m['n_cpi']})   ore in finestra: {m['ore_finestra']} = {m['quota_ore']:.2%}")
    print(f"\n  {'':14s} {'Sh giorn.':>10s} {'Sh orario':>10s} {'drift/anno':>11s}")
    for k in ("base", "riskoff"):
        v = m[k]; print(f"  {k:14s} {v['sh_d']:>10.3f} {v['sh_h']:>10.3f} {v['drift']:>+11.2%}")
    v = m["riskoff_nofee"]; print(f"  {'riskoff nofee':14s} {v['sh_d']:>10.3f} {'':>10s} {v['drift']:>+11.2%}")
    print(f"\n  Δ riskoff − base: Sharpe giornaliero {m['d_sh_d']:+.3f} · drift {m['d_drift']:+.2%}/anno "
          f"· ≈ {m['eur_giorno']:+.3f} €/giorno a ${EQUITY_OGGI:,.0f}")
    d = m["dentro"]
    print(f"  dentro la finestra: {d['n']} ore ({d['n_esposte']} esposte), media {d['media_h']*1e4:+.2f} bp/h "
          f"(fuori {d['media_fuori_h']*1e4:+.2f} bp/h), t = {d['t']:+.2f}, somma {d['somma']:+.2%}")
    print("\n  per tipo:")
    for t, v in m["per_tipo"].items():
        print(f"    {t:5s} n={v['n']:3d}  ΔSh {v['d_sh_d']:+.3f}  Δdrift {v['d_drift']:+.2%}  P&L dentro {v['somma_dentro']:+.2%}")
    print("\n  per anno (M9):")
    print(f"    {'anno':>4s} {'ev':>3s} {'ΔSh':>7s} {'P&L dentro':>11s} {'Δcum':>8s}")
    for y, v in m["anni"].items():
        print(f"    {y:>4d} {v['n_ev']:>3d} {v['d_sh_d']:>+7.3f} {v['somma_dentro']:>+11.2%} {v['d_cum']:>+8.2%}")
    n = m["null"]
    print(f"\n  null location-matched (M18, {n['n']} estrazioni): ΔSh mediana {n['p50']:+.3f} "
          f"[p05 {n['p05']:+.3f}, p95 {n['p95']:+.3f}] — il Δ vero sta al {n['pctl_vero']:.1f}° percentile")
    v, righe = verdetto(m)
    print("\n  VERDETTO PRE-REGISTRATO:")
    for r in righe:
        print("    " + r)
    print(f"\n  ⇒ {v}")
    print("\n  non modellato: funding (identico nelle due varianti salvo ~1% delle ore), slippage della "
          "finestra (spread largo: se il risultato fosse positivo andrebbe rimisurato col costo vero, C1).")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())