crolli: il libro perde nel giorno e chiude > 0 in 8/8 finestre dal 2022 (SKH01 short); crollo catturato a vol bassa, XRP diluisce come SOL
Quattro misure (r0909_*), nessun cambio a libro/pesi/config: - libro nei crolli: −0,48%/g nei 160 giorni ≤ −5%, positivo per finestra dal 2022 per la gamba short di SKH01 (108% dei guadagni); beta 0,0769 riprodotto (§46); il peso di SKH01 resta chiuso dal gate (in-sample). - crollo catturato 1-5/06/2026 a quote vere: f_net 0,74 = rally; put δ−0,10 1,92× il modello; a vol bassa e fuori dal gate di VRP01 → §3 non si riapre. - XRP terza gamba (harness r0822_sol_leg): hold-out −0,169 in 0/24, un anno buono. - universo Deribit: liquidi solo BTC/ETH/XRP/SOL; XS01 13/19; BTCDVOL future non negoziabile; PAXG non misurato. Revisione fable: due conclusioni smontate (MTM 2,6× era un artefatto di quote; «8/12 guadagna» era l'ordine delle classi). Debito §5.18: cblib.spot_series + asof guarda un'ora avanti (feed 1h etichettato all'apertura). Test Opus: 92 nuovi, suite 1008/1008; due difetti del verdetto XRP corretti. Docs: diario, RESULTS §74-77, CLAUDE.md, memoria 20/50, README; journal 07-08/09. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_017zJjHUS7mf4pnGE6pq9RTt
This commit is contained in:
Adriano Dal Pastro
@@ -0,0 +1,508 @@
|
||||
"""Test di `scripts/research/r0909_crash_catturato.py` (2026-09-09) — il `f` di stress su quote vere.
|
||||
|
||||
Questo script porta l'UNICA condizione che riapre la decisione vincolante del 19/06 ("niente
|
||||
short-vol da modello in deploy"): un `f` di stress reale misurato su un crash catturato. Un
|
||||
numero con quel peso ha bisogno di guardie sul MECCANISMO, non solo sull'esito:
|
||||
|
||||
* il prezzatore vettorizzato dev'essere *lo stesso* di `cblib.bs_put`, elemento per elemento e
|
||||
nei casi degeneri (T≤0, sig=0 → intrinseco): se diverge, il denominatore di ogni `f` e' un
|
||||
altro modello e il rapporto non significa piu' niente;
|
||||
* **lo spot dev'essere CAUSALE.** Il feed 1h e' etichettato all'APERTURA: la barra 20:00 chiude
|
||||
alle 21:00, quindi `S.asof(ts)` guardava un'ora AVANTI. `spot_causale` sposta l'indice di
|
||||
+1h. E' un look-ahead di un'ora dentro una misura di stress — piccolo e letale;
|
||||
* **il costo di chiusura si TAGLIA alla larghezza.** Uno spread a rischio definito non costa
|
||||
mai piu' della larghezza per chiudersi: si lascia regolare. Senza il taglio il "peggior MTM"
|
||||
era un artefatto di quote (2,6× il modello; col taglio 1,08);
|
||||
* la geometria fuori tolleranza va MARCATA, non aggiustata: `pick_legs` prende sempre la delta
|
||||
piu' vicina, quindi senza `in_geom` una griglia rada produrrebbe silenziosamente un'altra
|
||||
struttura (e' cio' che ha reso BTC non misurabile);
|
||||
* un `f` fra un reale negativo e un modello positivo NON e' un `f`: dev'essere NaN (P12).
|
||||
|
||||
I test sintetici costruiscono quote a mano, dove ogni numero atteso si calcola a matita. Il test
|
||||
d'integrazione (~11 s) riproduce la misura pubblicata su ETH.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
import pytest
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT))
|
||||
sys.path.insert(0, str(ROOT / "scripts" / "research"))
|
||||
|
||||
import cblib as CB # noqa: E402
|
||||
import r0909_crash_catturato as C # noqa: E402
|
||||
|
||||
INS_S = "ETH-19JUN26-1900-P"
|
||||
INS_L = "ETH-19JUN26-1600-P"
|
||||
K_S, K_L = 1900.0, 1600.0
|
||||
LARGHEZZA = K_S - K_L
|
||||
TS0 = pd.Timestamp("2026-06-05 00:00", tz="UTC")
|
||||
ORE = pd.date_range(TS0, periods=4, freq="h")
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ impalcature sintetiche
|
||||
|
||||
def _serie_spot(entrata: float = 2000.0, scadenza: float | None = None) -> pd.Series:
|
||||
"""Spot orario dal 01/06 a EXP: `entrata` fino a 12h dopo l'ingresso, poi `scadenza`
|
||||
(cosi' `S.asof(EXP)` e' pilotabile senza toccare le quote della finestra d'ingresso)."""
|
||||
idx = pd.date_range(pd.Timestamp("2026-06-01", tz="UTC"), C.EXP, freq="h")
|
||||
fine = TS0 + pd.Timedelta(hours=12)
|
||||
v = np.where(idx <= fine, entrata, entrata if scadenza is None else scadenza)
|
||||
return pd.Series(v.astype(float), index=idx)
|
||||
|
||||
|
||||
def _serie_dvol(dvol: float = 50.0) -> pd.Series:
|
||||
idx = pd.date_range(pd.Timestamp("2026-06-01", tz="UTC"), C.EXP, freq="h")
|
||||
return pd.Series(float(dvol), index=idx)
|
||||
|
||||
|
||||
def _seg(bid_s=0.030, ask_s=0.032, bid_l=0.010, ask_l=0.012,
|
||||
ore=ORE, salta_lunga=()) -> pd.DataFrame:
|
||||
"""Tabella di quote (ts × strumento). `salta_lunga` toglie la gamba LUNGA a quelle ore:
|
||||
e' il caso "una gamba sola", che non e' meta' struttura ma un'altra strategia."""
|
||||
righe = []
|
||||
for k, t in enumerate(ore):
|
||||
righe.append(dict(ts=t, instrument_name=INS_S, bid=bid_s, ask=ask_s, iv=48.0 + k))
|
||||
if k not in salta_lunga:
|
||||
righe.append(dict(ts=t, instrument_name=INS_L, bid=bid_l, ask=ask_l, iv=57.0 + k))
|
||||
return pd.DataFrame(righe)
|
||||
|
||||
|
||||
def _quote(bid_s=0.030, ask_s=0.032, bid_l=0.010, ask_l=0.012, salta_lunga=()) -> C.Quote:
|
||||
return C.Quote(_seg(bid_s, ask_s, bid_l, ask_l, salta_lunga=salta_lunga),
|
||||
_serie_spot(), _serie_dvol())
|
||||
|
||||
|
||||
def _snap(d_short: float, d_long: float, bid_s=0.030, ask_s=0.032,
|
||||
bid_l=0.010, ask_l=0.012) -> pd.DataFrame:
|
||||
return pd.DataFrame([
|
||||
dict(instrument_name=INS_S, strike=K_S, delta=d_short,
|
||||
bid=bid_s, ask=ask_s, iv=48.0, mid=(bid_s + ask_s) / 2),
|
||||
dict(instrument_name=INS_L, strike=K_L, delta=d_long,
|
||||
bid=bid_l, ask=ask_l, iv=57.0, mid=(bid_l + ask_l) / 2),
|
||||
])
|
||||
|
||||
|
||||
def _trade(d_short: float, d_long: float, bid_s=0.030, ask_s=0.032, bid_l=0.010,
|
||||
ask_l=0.012, spot=2000.0, ST=None) -> dict | None:
|
||||
S, V = _serie_spot(spot, ST), _serie_dvol()
|
||||
Q = C.Quote(_seg(bid_s, ask_s, bid_l, ask_l), S, V)
|
||||
return C.trade("ETH", TS0, _snap(d_short, d_long, bid_s, ask_s, bid_l, ask_l), Q, S, V)
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# spot_causale — il look-ahead di un'ora
|
||||
# ===========================================================================================
|
||||
|
||||
def test_spot_causale_restituisce_l_ultima_chiusura_CONOSCIUTA():
|
||||
"""🚨 Il feed 1h e' etichettato all'APERTURA: la barra 01:00 chiude alle 02:00. Senza lo
|
||||
spostamento, `asof(02:00)` restituiva la chiusura delle 02:00 — cioe' un'ora di futuro
|
||||
dentro un ingresso. DEVE FALLIRE SE: qualcuno "semplifica" togliendo lo shift.
|
||||
|
||||
⚠️ `cblib.spot_series` ha ancora il difetto (e quindi il f 0,714 di §11): dichiarato nel
|
||||
docstring dello script, non toccato qui."""
|
||||
idx = pd.date_range("2026-06-01", periods=5, freq="h", tz="UTC")
|
||||
S = pd.Series([10.0, 11.0, 12.0, 13.0, 14.0], index=idx)
|
||||
Sc = C.spot_causale(S)
|
||||
|
||||
assert list(Sc.index) == list(idx + pd.Timedelta(hours=1))
|
||||
assert Sc.asof(idx[2]) == 11.0, "a 02:00 e' nota la chiusura della barra 01:00"
|
||||
assert S.asof(idx[2]) == 12.0, "il difetto che la funzione ripara (controllo positivo)"
|
||||
assert np.isnan(Sc.asof(idx[0])), "prima della prima chiusura nota non c'e' spot, non c'e' 10.0"
|
||||
assert Sc.iloc[0] == 10.0 and S.iloc[0] == 10.0, "i VALORI non si toccano, solo le etichette"
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# bs_put_vec == cblib.bs_put, elemento per elemento
|
||||
# ===========================================================================================
|
||||
|
||||
def test_bs_put_vec_e_IDENTICA_a_cblib_bs_put_elemento_per_elemento():
|
||||
"""DEVE FALLIRE SE: la vettorizzata devia dal prezzatore del sleeve — il denominatore di
|
||||
ogni `f` smetterebbe di essere "lo stesso trade nel modello"."""
|
||||
S = np.array([2400.0, 2000.0, 1900.0, 1800.0, 1500.0, 900.0])
|
||||
T = np.array([0.10, 0.0383, 0.0192, 0.0027, 0.0027, 0.20])
|
||||
sig = np.array([0.35, 0.50, 0.65, 1.10, 0.50, 0.05])
|
||||
for K in (K_S, K_L, 2200.0):
|
||||
v = C.bs_put_vec(S, K, T, sig)
|
||||
atteso = [CB.bs_put(float(s), K, float(t), float(g)) for s, t, g in zip(S, T, sig)]
|
||||
assert v == pytest.approx(atteso, rel=0, abs=1e-10), K
|
||||
|
||||
|
||||
def test_bs_put_vec_a_T_o_sigma_nulli_da_l_INTRINSECO():
|
||||
"""I casi degeneri entrano nel conto: all'ora di scadenza T=0 e il valore e' il payoff, non
|
||||
un prezzo. DEVE FALLIRE SE: qualcuno toglie la maschera `ok` e lascia passare log/0 o NaN
|
||||
dentro `mod_spread`."""
|
||||
S = np.array([2400.0, 1900.0, 1500.0, 1000.0])
|
||||
for T, sig in ((np.zeros(4), np.full(4, 0.5)),
|
||||
(np.full(4, -1.0), np.full(4, 0.5)),
|
||||
(np.full(4, 0.05), np.zeros(4))):
|
||||
v = C.bs_put_vec(S, K_S, T, sig)
|
||||
assert v == pytest.approx(np.maximum(K_S - S, 0.0), abs=1e-12)
|
||||
assert np.isfinite(v).all()
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# Quote + percorso su quote sintetiche
|
||||
# ===========================================================================================
|
||||
|
||||
def test_percorso_costa_lo_spread_nel_VERSO_GIUSTO():
|
||||
"""chiudi_short = (ASK corta − BID lunga)·spot: si ricompra cio' che si e' venduto e si
|
||||
rivende cio' che si e' comprato, cioe' si attraversa lo spread due volte.
|
||||
liquida_long = (BID corta − ASK lunga)·spot e' lo specchio.
|
||||
DEVE FALLIRE SE: qualcuno "corregge" i lati — a mid il percorso costerebbe meno e il fatto
|
||||
misurato si ammorbidirebbe da solo."""
|
||||
Q = _quote(salta_lunga=(1,))
|
||||
|
||||
assert list(Q.bid.index) == list(ORE)
|
||||
assert Q.spot.iloc[0] == 2000.0
|
||||
assert Q.dvol.iloc[0] == pytest.approx(0.50), "il DVOL entra in frazione, non in punti"
|
||||
|
||||
p = C.percorso(Q, ORE[0] - pd.Timedelta(hours=1), INS_S, INS_L, K_S, K_L)
|
||||
assert len(p) == 3, "l'ora con la sola gamba corta dev'essere ESCLUSA"
|
||||
assert list(p["ts"]) == [ORE[0], ORE[2], ORE[3]]
|
||||
assert p["ts"].is_monotonic_increasing
|
||||
|
||||
assert p["chiudi_grezzo"].tolist() == pytest.approx([(0.032 - 0.010) * 2000.0] * 3)
|
||||
assert p["chiudi_short"].tolist() == pytest.approx([(0.032 - 0.010) * 2000.0] * 3), (
|
||||
"dentro la larghezza il taglio non deve mordere: sarebbe un costo inventato")
|
||||
assert p["liquida_long"].tolist() == pytest.approx([(0.030 - 0.012) * 2000.0] * 3)
|
||||
assert p["liquida_put"].tolist() == pytest.approx([0.010 * 2000.0] * 3)
|
||||
assert p["iv_s"].tolist() == pytest.approx([48.0, 50.0, 51.0])
|
||||
assert p["iv_l"].tolist() == pytest.approx([57.0, 59.0, 60.0])
|
||||
assert p["spot"].tolist() == pytest.approx([2000.0] * 3)
|
||||
|
||||
# il valore MODELLATO e' quello del sleeve, agli stessi strike e alla stessa ora
|
||||
for i, t in enumerate([ORE[0], ORE[2], ORE[3]]):
|
||||
T = max((C.EXP - t).total_seconds(), 0.0) / 86400.0 / 365.25
|
||||
atteso = CB.bs_put(2000.0, K_S, T, 0.5) - CB.bs_put(2000.0, K_L, T, 0.5)
|
||||
assert p["mod_spread"].iloc[i] == pytest.approx(atteso, abs=1e-10)
|
||||
assert p["mod_put"].iloc[i] == pytest.approx(CB.bs_put(2000.0, K_L, T, 0.5), abs=1e-10)
|
||||
|
||||
|
||||
def test_percorso_TAGLIA_il_costo_di_chiusura_alla_LARGHEZZA():
|
||||
"""🚨 Uno spread a rischio definito non puo' costare piu' della larghezza per chiudersi: si
|
||||
lascia regolare. A T→0 le quote arrivano al 158% di spread relativo, e senza il taglio il
|
||||
"peggior MTM" era un artefatto di book (2,6× il modello, corretto in revisione a 1,08).
|
||||
`chiudi_grezzo` resta accanto perche' il taglio va CONTATO, non nascosto (P12)."""
|
||||
Q = _quote(bid_s=0.005, ask_s=0.200, bid_l=0.010, ask_l=0.012)
|
||||
p = C.percorso(Q, ORE[0] - pd.Timedelta(hours=1), INS_S, INS_L, K_S, K_L)
|
||||
|
||||
assert p["chiudi_grezzo"].tolist() == pytest.approx([(0.200 - 0.010) * 2000.0] * 4) # 380
|
||||
assert p["chiudi_short"].tolist() == pytest.approx([LARGHEZZA] * 4) # 300
|
||||
assert (p["chiudi_short"] <= LARGHEZZA + 1e-12).all()
|
||||
assert (p["chiudi_grezzo"] > p["chiudi_short"]).all(), "il grezzo deve restare visibile"
|
||||
# la gamba lunga liquidata non puo' valere meno di zero
|
||||
assert p["liquida_long"].tolist() == pytest.approx([0.0] * 4)
|
||||
|
||||
|
||||
def test_percorso_taglia_liquida_long_anche_in_ALTO():
|
||||
"""L'altro estremo della stessa regola: un debit spread non vale piu' della sua larghezza."""
|
||||
Q = _quote(bid_s=0.200, ask_s=0.210, bid_l=0.005, ask_l=0.010)
|
||||
p = C.percorso(Q, ORE[0] - pd.Timedelta(hours=1), INS_S, INS_L, K_S, K_L)
|
||||
assert p["liquida_long"].tolist() == pytest.approx([LARGHEZZA] * 4)
|
||||
|
||||
|
||||
def test_percorso_parte_DOPO_l_ingresso_e_non_lo_include():
|
||||
"""Il mark-to-market comincia all'ora successiva: includere l'ora d'ingresso metterebbe
|
||||
dentro un P&L noto a priori (il mezzo spread pagato entrando)."""
|
||||
Q = _quote()
|
||||
p = C.percorso(Q, ORE[0], INS_S, INS_L, K_S, K_L)
|
||||
assert list(p["ts"]) == [ORE[1], ORE[2], ORE[3]]
|
||||
assert C.percorso(Q, ORE[-1], INS_S, INS_L, K_S, K_L).empty
|
||||
|
||||
|
||||
def test_percorso_e_vuoto_se_uno_strumento_non_esiste_nella_tabella():
|
||||
"""P5: "non vedo" ha uno stato suo (DataFrame vuoto → `trade` ritorna None), non un valore
|
||||
inventato."""
|
||||
Q = _quote()
|
||||
assert C.percorso(Q, ORE[0], INS_S, "ETH-19JUN26-9999-P", K_S, 9999.0).empty
|
||||
assert C.percorso(Q, ORE[0], "ETH-19JUN26-9999-P", INS_L, 9999.0, K_L).empty
|
||||
|
||||
|
||||
def test_Quote_scarta_le_quote_NON_quotate():
|
||||
"""bid o ask a zero (o assenti) non sono prezzi: entrano come "non quotato", non come 0."""
|
||||
seg = _seg()
|
||||
seg.loc[seg["instrument_name"] == INS_L, "bid"] = 0.0 # gamba lunga senza bid
|
||||
Q = C.Quote(seg, _serie_spot(), _serie_dvol())
|
||||
assert INS_L not in Q.bid.columns
|
||||
assert C.percorso(Q, ORE[0], INS_S, INS_L, K_S, K_L).empty
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# la guardia di geometria in_geom (TOL_D)
|
||||
# ===========================================================================================
|
||||
|
||||
def test_in_geom_e_FALSO_quando_le_delta_disponibili_sono_lontane():
|
||||
"""`pick_legs` prende SEMPRE la delta piu' vicina: su una griglia rada restituisce una
|
||||
struttura che non e' VRP01 e non lo dice. `in_geom` e' il pezzo che lo dice.
|
||||
DEVE FALLIRE SE: qualcuno allarga TOL_D o toglie il flag — i 78 snapshot BTC scartati
|
||||
il 09/09 sono esattamente quelli che quel flag ha fermato."""
|
||||
t = _trade(-0.50, -0.01)
|
||||
assert t is not None
|
||||
assert t["in_geom"] is False
|
||||
assert t["d_short"] == -0.50 and t["d_long"] == -0.01
|
||||
|
||||
|
||||
def test_in_geom_e_VERO_sulla_geometria_di_VRP01():
|
||||
"""Controllo POSITIVO (M15): un rilevatore tarato per non segnalare va provato su un caso
|
||||
che DEVE passare, altrimenti "nessun trade fuori geometria" non significa niente."""
|
||||
t = _trade(C.SHORT_D, C.LONG_D)
|
||||
assert t["in_geom"] is True
|
||||
assert t["d_short"] == pytest.approx(C.SHORT_D) and t["d_long"] == pytest.approx(C.LONG_D)
|
||||
|
||||
|
||||
def test_in_geom_il_confine_e_esattamente_TOL_D():
|
||||
"""I due confini si DERIVANO da `TOL_D`/`SHORT_D`/`LONG_D`, non si riscrivono (P1).
|
||||
|
||||
⚠️ Il confine ESATTO non e' asseribile in virgola mobile: `-0.28 - 0.08` vale
|
||||
-0.36000000000000004, quindi la delta "sul confine" cade FUORI. Si prova un micron dentro
|
||||
e un micron fuori — e' il confine che conta, non il suo ultimo bit."""
|
||||
dentro_s, fuori_s = C.SHORT_D - C.TOL_D[0] + 1e-6, C.SHORT_D - C.TOL_D[0] - 1e-6
|
||||
dentro_l, fuori_l = C.LONG_D - C.TOL_D[1] + 1e-6, C.LONG_D - C.TOL_D[1] - 1e-6
|
||||
assert _trade(dentro_s, dentro_l)["in_geom"] is True, "un micron dentro deve passare"
|
||||
assert _trade(fuori_s, dentro_l)["in_geom"] is False, "gamba corta appena fuori"
|
||||
assert _trade(dentro_s, fuori_l)["in_geom"] is False, "gamba lunga appena fuori"
|
||||
|
||||
|
||||
def test_P1_le_delta_bersaglio_vengono_dal_SLEEVE():
|
||||
"""DEVE FALLIRE SE: qualcuno ridichiara −0,28/−0,10 nello script — la misura punterebbe su
|
||||
una geometria diversa da quella del sleeve che dovrebbe descrivere."""
|
||||
from src.portfolio.sleeves import VRP_CFG
|
||||
assert C.SHORT_D is VRP_CFG["short_delta"]
|
||||
assert C.LONG_D is VRP_CFG["long_delta"]
|
||||
assert C.FEE_FRAC is VRP_CFG["fee_frac"]
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# trade() — i conti, e cio' che si RIFIUTA di calcolare
|
||||
# ===========================================================================================
|
||||
|
||||
def test_f_exp_e_f_mtm_sono_NAN_a_SEGNI_DISCORDI():
|
||||
"""Un rapporto fra un reale NEGATIVO e un modello POSITIVO non e' un fattore di stress:
|
||||
e' due fatti diversi messi in frazione. Qui il credito reale (0,2 $) sta sotto le fee
|
||||
d'ingresso (1,2 $) mentre il credito modellato e' pieno → pnl_real < 0 < pnl_mod.
|
||||
DEVE FALLIRE SE: qualcuno toglie le condizioni di segno e pubblica un `f` negativo."""
|
||||
t = _trade(C.SHORT_D, C.LONG_D, bid_s=0.0101, ask_s=0.0102, bid_l=0.009, ask_l=0.010)
|
||||
assert t["pnl_real"] < 0 < t["pnl_mod"], (t["pnl_real"], t["pnl_mod"])
|
||||
assert np.isnan(t["f_exp"])
|
||||
assert t["mtm_real_min"] < 0 < t["mtm_mod_min"], (t["mtm_real_min"], t["mtm_mod_min"])
|
||||
assert np.isnan(t["f_mtm"])
|
||||
|
||||
|
||||
def test_f_exp_e_UN_NUMERO_quando_perdono_entrambi():
|
||||
"""Controllo POSITIVO del test qui sopra: con lo spot a 1500 a scadenza perdono sia il
|
||||
reale sia il modello, e allora `f_exp` esiste ed e' esattamente il rapporto delle perdite."""
|
||||
t = _trade(C.SHORT_D, C.LONG_D, bid_s=0.0101, ask_s=0.0102, bid_l=0.009, ask_l=0.010,
|
||||
ST=1500.0)
|
||||
assert t["pnl_real"] < 0 and t["pnl_mod"] < 0
|
||||
assert t["f_exp"] == pytest.approx(t["pnl_real"] / t["pnl_mod"], abs=1e-12)
|
||||
assert np.isfinite(t["f_exp"]) and t["f_exp"] > 0
|
||||
|
||||
|
||||
def test_itm_pieno_dichiara_quando_f_exp_e_TAUTOLOGICO():
|
||||
"""Se ENTRAMBE le gambe finiscono ITM il payoff e' la larghezza per il reale e per il
|
||||
modello: `f_exp` si riduce a una funzione di `f_net` e non e' piu' un'informazione nuova.
|
||||
Il flag esiste per poterlo DIRE (l'83% dei trade ETH del 09/09), non per correggerlo."""
|
||||
assert _trade(C.SHORT_D, C.LONG_D, ST=1500.0)["itm_pieno"] is True # 1500 <= K_L
|
||||
assert _trade(C.SHORT_D, C.LONG_D, ST=2000.0)["itm_pieno"] is False
|
||||
assert _trade(C.SHORT_D, C.LONG_D, ST=K_L)["itm_pieno"] is True # confine incluso
|
||||
assert _trade(C.SHORT_D, C.LONG_D, ST=K_L + 1.0)["itm_pieno"] is False
|
||||
|
||||
|
||||
def test_trade_CONTA_le_ore_tagliate_invece_di_nasconderle():
|
||||
"""P12/D5: una riparazione silenziosa e' un'invenzione. Il taglio alla larghezza cambia il
|
||||
peggior MTM, quindi le ore in cui morde vanno contate e stampate accanto al numero."""
|
||||
normale = _trade(C.SHORT_D, C.LONG_D)
|
||||
assert normale["n_ore"] == 3 and normale["n_tagli"] == 0
|
||||
|
||||
tagliato = _trade(C.SHORT_D, C.LONG_D, ask_s=0.200) # (0,200 − 0,010)·2000 = 380 > 300
|
||||
assert tagliato["n_ore"] == 3 and tagliato["n_tagli"] == 3
|
||||
assert tagliato["mtm_real_min"] == pytest.approx(tagliato["cred_real"] - LARGHEZZA)
|
||||
|
||||
|
||||
def test_f_net_e_il_credito_reale_su_quello_modellato():
|
||||
"""Il credito reale si incassa al BID della corta e si paga all'ASK della lunga: e' la
|
||||
convenzione conservativa di `cblib.f_factors`, e vale 0,74 su ETH nel crollo."""
|
||||
t = _trade(C.SHORT_D, C.LONG_D)
|
||||
assert t["cred_real"] == pytest.approx((0.030 - 0.012) * 2000.0)
|
||||
T = (C.EXP - TS0).total_seconds() / 86400.0 / 365.25
|
||||
assert t["cred_mod"] == pytest.approx(
|
||||
CB.bs_put(2000.0, K_S, T, 0.5) - CB.bs_put(2000.0, K_L, T, 0.5), abs=1e-10)
|
||||
assert t["f_net"] == pytest.approx(t["cred_real"] / t["cred_mod"], abs=1e-12)
|
||||
assert t["risk"] == pytest.approx(LARGHEZZA - t["cred_real"])
|
||||
|
||||
|
||||
def test_trade_e_None_se_il_credito_non_e_positivo():
|
||||
"""Un credit spread a credito ≤ 0 non e' la struttura che si sta studiando."""
|
||||
assert _trade(C.SHORT_D, C.LONG_D, bid_s=0.010, ask_s=0.011, bid_l=0.020, ask_l=0.030) is None
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# verdetto() — i rami
|
||||
# ===========================================================================================
|
||||
|
||||
ESITO = ("IL CROLLO E' CATTURATO MA A VOL BASSA E FUORI DAL GATE DI VRP01: il f di stress che "
|
||||
"la regola del 19/06 aspettava NON e' misurato nella sostanza — cio' che e' misurato "
|
||||
"e' che il rapporto di credito f_net non cambia col regime")
|
||||
|
||||
|
||||
def _r(f_exp=1.04, f_mtm=1.08, n=569, n_pre=286, n_fuori=2, f_net=0.74, q_itm=0.83,
|
||||
n_strutture=4, n_tagli=8779, n_ore=213477, gate=0.0,
|
||||
dur_f_net=0.71, dur_q_perde=0.46) -> dict:
|
||||
return dict(n=n, n_pre=n_pre, n_fuori=n_fuori, f_net=f_net, f_exp=f_exp, f_mtm=f_mtm,
|
||||
q_itm_pieno=q_itm, n_strutture=n_strutture, n_tagli=n_tagli, n_ore=n_ore,
|
||||
gate_aperto=gate, durante=dict(f_net=dur_f_net, q_perde=dur_q_perde))
|
||||
|
||||
|
||||
def test_verdetto_l_esito_e_una_CONCLUSIONE_non_un_esito_numerico():
|
||||
"""La conclusione del 09/09 non e' "f vale x": e' che il crollo catturato sta a vol BASSA e
|
||||
fuori dal gate, quindi il `f` di stress che la regola del 19/06 aspetta non e' misurato
|
||||
nella sostanza. DEVE FALLIRE SE: qualcuno rimette un verdetto che dipende dal solo numero —
|
||||
e' la lettura che il numero da solo autorizzava e che la revisione ha tolto."""
|
||||
for s in ({"BTC": _r(), "ETH": _r()},
|
||||
{"BTC": _r(f_exp=3.0), "ETH": _r(f_exp=0.2)},
|
||||
{"BTC": None, "ETH": None}):
|
||||
v = C.verdetto(s)
|
||||
assert v.startswith(ESITO)
|
||||
assert v.endswith("— n = 1 crollo, 1 scadenza per asset, famiglia INVERSE")
|
||||
|
||||
|
||||
def test_verdetto_NON_MISURABILE_quando_un_asset_non_ha_snapshot_in_geometria():
|
||||
"""P5: lo stato "non vedo" ha un ramo suo e nomina la causa (griglia di strike rada)."""
|
||||
v = C.verdetto({"BTC": dict(n=0, n_fuori=78), "ETH": None})
|
||||
assert "BTC: NON misurabile — 78 snapshot tutti FUORI geometria (griglia di strike rada)" in v
|
||||
assert "ETH: NON misurabile — 0 snapshot tutti FUORI geometria" in v
|
||||
|
||||
|
||||
def test_verdetto_distingue_ZERO_SNAPSHOT_da_NESSUN_INGRESSO_PRE_CROLLO():
|
||||
"""Due guasti diversi con la stessa azione (P5): "tutti fuori geometria" e "in geometria ma
|
||||
nessun ingresso PRIMA del crollo" sono cause diverse e vanno dette diverse — e' esattamente
|
||||
il caso di BTC il 09/09, dove resta solo la lente DURANTE."""
|
||||
v = C.verdetto({"BTC": _r(f_exp=float("nan"), n=247, n_pre=0, n_fuori=78,
|
||||
dur_f_net=0.79, dur_q_perde=0.3724696356275304),
|
||||
"ETH": _r()})
|
||||
assert "BTC: nessun ingresso pre-crollo in geometria (solo DURANTE: f_net 0.79, perde il 37%)" in v
|
||||
assert "FUORI geometria" not in v.split("BTC:")[1].split(";")[0]
|
||||
|
||||
|
||||
def test_verdetto_dichiara_che_il_f_a_scadenza_e_TAUTOLOGICO():
|
||||
"""M13/§2: un numero si cita con la sua risoluzione. 286 snapshot su 4 strutture non sono
|
||||
286 osservazioni, e a gambe entrambe ITM il `f` a scadenza e' una funzione di `f_net`.
|
||||
Senza queste due note la riga "f 1,04" verrebbe letta come una misura indipendente."""
|
||||
v = C.verdetto({"BTC": _r(), "ETH": _r()})
|
||||
assert "a scadenza f 1.04 ma TAUTOLOGICO nel 83% dei trade" in v
|
||||
assert "4 strutture, non 286 osservazioni" in v
|
||||
assert "peggior MTM tagliato alla larghezza f 1.08" in v
|
||||
assert "quote oltre la larghezza nel 4.1% delle ore" in v
|
||||
|
||||
|
||||
def test_verdetto_dice_se_il_gate_di_VRP01_era_APERTO():
|
||||
"""E' il fatto che decide se la misura parla del sleeve o di un altro trade: col gate chiuso
|
||||
VRP01 quel trade NON lo avrebbe fatto."""
|
||||
assert "gate IV-rank CHIUSO nel 0% delle ore" in C.verdetto({"BTC": _r(), "ETH": _r()})
|
||||
assert "gate IV-rank APERTO nel 60% delle ore" in C.verdetto(
|
||||
{"BTC": _r(gate=0.6), "ETH": _r(gate=0.6)})
|
||||
# confine: 0,5 esatto non e' "aperto" (il confronto e' `>`)
|
||||
assert "gate IV-rank CHIUSO nel 50% delle ore" in C.verdetto(
|
||||
{"BTC": _r(gate=0.5), "ETH": _r(gate=0.5)})
|
||||
|
||||
|
||||
def test_verdetto_non_divide_per_zero_quando_non_ci_sono_ore():
|
||||
"""Un campione vuoto non deve far esplodere la riga: la quota di ore tagliate va a 0,0%."""
|
||||
v = C.verdetto({"BTC": _r(n_tagli=0, n_ore=0), "ETH": _r()})
|
||||
assert "quote oltre la larghezza nel 0.0% delle ore" in v
|
||||
|
||||
|
||||
def test_verdetto_riproduce_ALLA_LETTERA_la_riga_pubblicata_il_09_09():
|
||||
"""M23: la macchina deve ristampare il numero vecchio. Sono i valori esatti usciti da
|
||||
`sintesi()` il 09/09 — se il testo cambia, cambia anche cio' che il diario cita, e va
|
||||
cambiato nei due posti insieme."""
|
||||
s = {"BTC": _r(f_exp=float("nan"), f_mtm=float("nan"), n=247, n_pre=0, n_fuori=78,
|
||||
f_net=0.7941019699391642, q_itm=float("nan"), n_strutture=0, n_tagli=0,
|
||||
n_ore=0, gate=0.0, dur_f_net=0.7941019699391642,
|
||||
dur_q_perde=0.3724696356275304),
|
||||
"ETH": _r(f_exp=1.0383032287675409, f_mtm=1.0790935015712533, n=569, n_pre=286,
|
||||
n_fuori=2, f_net=0.7405178198702741, q_itm=0.8286713286713286,
|
||||
n_strutture=4, n_tagli=8779, n_ore=213477, gate=0.0)}
|
||||
assert C.verdetto(s) == (
|
||||
ESITO + " — "
|
||||
"BTC: nessun ingresso pre-crollo in geometria (solo DURANTE: f_net 0.79, perde il 37%); "
|
||||
"ETH: f_net 0.74 (22/08 in rally 0,714); a scadenza f 1.04 ma TAUTOLOGICO nel 83% dei "
|
||||
"trade (entrambe le gambe ITM ⇒ dipende solo da f_net; 4 strutture, non 286 "
|
||||
"osservazioni); peggior MTM tagliato alla larghezza f 1.08 (quote oltre la larghezza "
|
||||
"nel 4.1% delle ore); gate IV-rank CHIUSO nel 0% delle ore "
|
||||
"— n = 1 crollo, 1 scadenza per asset, famiglia INVERSE")
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# carica() e l'integrazione sull'archivio VERO
|
||||
# ===========================================================================================
|
||||
|
||||
def test_carica_tiene_solo_put_una_scadenza_la_finestra_e_nessun_duplicato():
|
||||
"""L'archivio ereditato copre molte scadenze e molti tipi: se il filtro si allentasse, il
|
||||
`f` verrebbe misurato su una struttura diversa da quella dichiarata nel docstring."""
|
||||
if not C.ARCHIVIO.exists():
|
||||
pytest.skip(f"archivio ereditato assente: {C.ARCHIVIO} (data/raw e' gitignored)")
|
||||
a = C.carica()
|
||||
assert len(a) > 0
|
||||
assert set(pd.unique(a["option_type"])) == {"P"}, "call rimaste dentro"
|
||||
assert (a["exp"] == C.EXP).all(), "piu' di una scadenza"
|
||||
assert a["ts"].min() >= C.INGRESSI[0], "quote prima della finestra dichiarata"
|
||||
assert a["ts"].max() <= C.EXP, "quote dopo la scadenza"
|
||||
assert not a.duplicated(subset=["ts", "instrument_name"]).any()
|
||||
assert (a["dte"] >= 0).all()
|
||||
assert a["dte"].max() <= (C.EXP - C.INGRESSI[0]).total_seconds() / 86400.0 + 1e-9
|
||||
assert {"BTC", "ETH"} <= set(pd.unique(a["asset"]))
|
||||
|
||||
|
||||
def test_integrazione_la_misura_del_09_09_si_riproduce():
|
||||
"""~11 s. Riproduce cio' su cui poggia la (non) riapertura della decisione del 19/06.
|
||||
|
||||
I fatti che decidono, e che il test tiene fermi:
|
||||
* il gate IV-rank di VRP01 e' CHIUSO nel 100% delle ore → il sleeve questo trade non lo
|
||||
avrebbe fatto, quindi il `f` misurato non e' il suo `f` di stress;
|
||||
* il `f` a scadenza (1,04) e' TAUTOLOGICO nella grande maggioranza dei trade;
|
||||
* 286 snapshot stanno su POCHE strutture: la risoluzione non e' 286 (M13);
|
||||
* BTC resta NON misurabile pre-crollo;
|
||||
* col taglio alla larghezza il peggior MTM e' vicino a 1, non 2,6 (che era book, non
|
||||
rischio) — qui si controlla la TAGLIA, non la terza cifra."""
|
||||
if not C.ARCHIVIO.exists():
|
||||
pytest.skip(f"archivio ereditato assente: {C.ARCHIVIO}")
|
||||
s = C.sintesi(C.misura())
|
||||
|
||||
eth = s["ETH"]
|
||||
assert eth["n_pre"] > 200, "il campione pre-crollo si e' svuotato"
|
||||
assert eth["f_net"] == pytest.approx(0.74, abs=0.03)
|
||||
assert eth["f_exp"] == pytest.approx(1.04, abs=0.03)
|
||||
assert eth["q_itm_pieno"] == pytest.approx(0.83, abs=0.10), (
|
||||
"la quota di trade a f_exp tautologico e' cambiata: cambia la lettura del 1,04")
|
||||
assert eth["n_strutture"] <= 10, (
|
||||
f"{eth['n_pre']} snapshot su {eth['n_strutture']} strutture: se le strutture "
|
||||
"diventassero tante, la nota sulla risoluzione andrebbe riscritta")
|
||||
assert eth["gate_aperto"] == pytest.approx(0.0, abs=1e-12), (
|
||||
"il gate IV-rank di VRP01 risulta APERTO: cambia il senso della misura, che oggi dice "
|
||||
"'lo sleeve questo trade non lo avrebbe fatto'")
|
||||
assert eth["perdita_su_risk"] == pytest.approx(1.01, abs=0.05)
|
||||
assert 0.9 < eth["f_mtm"] < 1.5, (
|
||||
f"peggior MTM {eth['f_mtm']:.2f}: col taglio alla larghezza sta attorno a 1; sopra 1,5 "
|
||||
"vuol dire che il taglio non morde piu' e il numero torna a essere book, non rischio")
|
||||
assert 0 < eth["n_tagli"] < eth["n_ore"] * 0.20, (
|
||||
"il taglio deve mordere su una minoranza di ore: se e' zero non serve, se e' la "
|
||||
"maggioranza il campione e' un altro")
|
||||
|
||||
btc = s["BTC"]
|
||||
assert btc["n_pre"] == 0 and np.isnan(btc["f_exp"]), (
|
||||
"BTC era NON misurabile pre-crollo: se ora lo e', il verdetto cambia e va riscritto, "
|
||||
"non aggiustato")
|
||||
assert btc["durante"]["n"] > 0 and 0.0 < btc["durante"]["q_perde"] < 1.0
|
||||
|
||||
v = C.verdetto(s)
|
||||
assert v.startswith(ESITO)
|
||||
assert "BTC: nessun ingresso pre-crollo in geometria" in v
|
||||
assert "gate IV-rank CHIUSO nel 0% delle ore" in v
|
||||
assert v.endswith("famiglia INVERSE")
|
||||
@@ -0,0 +1,324 @@
|
||||
"""Test di `scripts/research/r0909_deribit_universo.py` (2026-09-09) — l'universo Deribit letto oggi.
|
||||
|
||||
Lo script e' il filtro che decide COSA vale la pena misurare (C6): se sbaglia a leggere il venue,
|
||||
sbaglia l'elenco delle monete candidate, e la misura successiva parte dalla domanda sbagliata.
|
||||
Qui si congelano i tre pezzi che possono sbagliare in silenzio:
|
||||
|
||||
* i FILTRI — un perpetual `state != "open"` non e' negoziabile e non deve comparire in una
|
||||
tabella intitolata "aperti"; un future datato non e' un perpetual;
|
||||
* lo SPREAD assente — senza bid o senza ask lo spread e' NaN, non zero (P5: "non vedo" non e'
|
||||
"spread perfetto", e uno zero stampato in quella colonna direbbe il contrario del vero);
|
||||
* l'universo di XS01 — si IMPORTA da `sleeves.XS_UNIVERSE` (P1). Una lista ricopiata qui
|
||||
risponderebbe "13/19 quotate" anche dopo che qualcuno ha cambiato le gambe del sleeve.
|
||||
|
||||
⚠️ NESSUN test tocca la rete e nessuno scrive in `data/`: la cache viene deviata in `tmp_path`
|
||||
e `get()` e' sostituita da una che fallisce se qualcuno la chiama.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import inspect
|
||||
import json
|
||||
import sys
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT))
|
||||
sys.path.insert(0, str(ROOT / "scripts" / "research"))
|
||||
|
||||
import r0909_deribit_universo as U # noqa: E402
|
||||
|
||||
LETTO_A = "2026-09-09T15:05:43+00:00"
|
||||
|
||||
|
||||
def _ms(giorno: str) -> int:
|
||||
return int(time.mktime(time.strptime(giorno, "%Y-%m-%d")) * 1000) + int(
|
||||
time.timezone * 1000)
|
||||
|
||||
|
||||
def _instr(coin: str, nome: str, stato: str, listato: str, min_amt: float) -> dict:
|
||||
# creation_timestamp e' letto con time.gmtime -> si costruisce in UTC puro
|
||||
import calendar
|
||||
ts = calendar.timegm(time.strptime(listato + " 12:00", "%Y-%m-%d %H:%M")) * 1000
|
||||
return dict(base_currency=coin, instrument_name=nome, state=stato,
|
||||
creation_timestamp=ts, min_trade_amount=min_amt)
|
||||
|
||||
|
||||
def _bs(nome: str, bid, ask, mark, vol, oi=0.0, funding=0.0) -> dict:
|
||||
return dict(instrument_name=nome, bid_price=bid, ask_price=ask, mark_price=mark,
|
||||
volume_usd=vol, open_interest=oi, funding_8h=funding)
|
||||
|
||||
|
||||
def _lettura() -> dict:
|
||||
"""Una lettura sintetica del venue: 4 perpetual aperti, 1 INATTIVO, 2 future datati (di cui
|
||||
uno sul DVOL — l'unico strumento long-vol diretto del venue)."""
|
||||
fut = [
|
||||
_instr("XRP", "XRP_USDC-PERPETUAL", "open", "2022-03-16", 1.0),
|
||||
_instr("ETH", "ETH_USDC-PERPETUAL", "open", "2022-03-14", 0.01),
|
||||
_instr("ADA", "ADA_USDC-PERPETUAL", "open", "2022-03-21", 10.0),
|
||||
_instr("PAXG", "PAXG_USDC-PERPETUAL", "open", "2024-12-02", 0.001),
|
||||
_instr("APT", "APT_USDC-PERPETUAL", "inactive", "2022-11-02", 1.0),
|
||||
_instr("BTC", "BTC_USDC-27JUN26", "open", "2022-03-09", 0.001),
|
||||
_instr("BTCDVOL", "BTCDVOL_USDC-30SEP26", "open", "2026-06-01", 1.0),
|
||||
]
|
||||
bs = [
|
||||
_bs("XRP_USDC-PERPETUAL", 2.0, 2.002, 2.0, 38.13e6, oi=3.0e6, funding=4.0e-5),
|
||||
_bs("ETH_USDC-PERPETUAL", 3000.0, 3000.3, 3000.0, 32.72e6, oi=8.0e3, funding=1.05e-4),
|
||||
_bs("ADA_USDC-PERPETUAL", None, 0.6, 0.6, 3.33e6, oi=1.0e6, funding=None),
|
||||
_bs("PAXG_USDC-PERPETUAL", 0.0, 3600.0, 3600.0, 0.18e6, oi=2.0e3, funding=0.0),
|
||||
_bs("APT_USDC-PERPETUAL", 1.0, 1.1, 1.0, 999e6, oi=1.0, funding=0.0),
|
||||
_bs("BTC_USDC-27JUN26", 100000.0, 100001.0, 100000.0, 500e6, oi=1.0, funding=0.0),
|
||||
_bs("BTCDVOL_USDC-30SEP26", 30.0, 60.0, 45.0, 0.0, oi=12.0, funding=None),
|
||||
]
|
||||
return dict(letto_a=LETTO_A, fut=fut, bs=bs,
|
||||
opt_usdc=[dict(base_currency="SOL")] * 3 + [dict(base_currency="BTC")] * 2,
|
||||
opt_inv={"BTC": 912, "ETH": 790})
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# (a) tabella / sintesi / verdetto su una lettura SINTETICA
|
||||
# ===========================================================================================
|
||||
|
||||
def test_tabella_esclude_i_perpetual_NON_APERTI():
|
||||
"""Un perpetual `state != "open"` non e' negoziabile: se entrasse, sarebbe pure il piu'
|
||||
liquido della tabella (999 M$ di volume stantio) e comparirebbe in cima all'elenco dei
|
||||
candidati. DEVE FALLIRE SE: qualcuno toglie il filtro sullo stato."""
|
||||
d = _lettura()
|
||||
rows = U.tabella(d)
|
||||
assert "APT" not in {r["coin"] for r in rows}
|
||||
s = U.sintesi(rows, d)
|
||||
assert s["inattivi"] == ["APT_USDC-PERPETUAL"], (
|
||||
"un perpetual inattivo non va nella tabella, ma va DETTO: e' la differenza fra "
|
||||
"'non esiste' e 'esiste e non si puo' negoziare' (P5)")
|
||||
|
||||
|
||||
def test_un_perpetual_INATTIVO_conta_come_gamba_XS01_MANCANTE():
|
||||
"""APT e' in XS01 ed e' listato sul venue, ma inattivo: la riga "N/19 quotate" deve
|
||||
contarlo fra i mancanti, o il filtro di eseguibilita' direbbe il falso (C6)."""
|
||||
d = _lettura()
|
||||
s = U.sintesi(U.tabella(d), d)
|
||||
assert "APT" in s["xs01_mancanti"] and "APT" not in s["xs01_listate"]
|
||||
|
||||
|
||||
def test_tabella_esclude_i_FUTURE_DATATI_ma_la_sintesi_li_CONTA():
|
||||
"""`kind=future` su Deribit contiene anche i future con scadenza: la domanda della tabella
|
||||
e' sui PERPETUAL, e un future datato non e' una gamba direzionale continua. Restano contati
|
||||
(`n_datati`) perche' e' li' dentro che vive il future sul DVOL."""
|
||||
d = _lettura()
|
||||
rows = U.tabella(d)
|
||||
assert {r["coin"] for r in rows} == {"XRP", "ETH", "ADA", "PAXG"}
|
||||
assert len(rows) == 4
|
||||
assert U.sintesi(rows, d)["n_datati"] == 2
|
||||
|
||||
|
||||
def test_il_future_sul_DVOL_viene_isolato_coi_suoi_numeri_di_negoziabilita():
|
||||
"""C5/C6: e' l'unico strumento long-vol DIRETTO del venue, quindi va guardato — e va
|
||||
guardato con bid/ask e OI accanto, perche' e' li' che si vede che non e' negoziabile
|
||||
(bid 30 / ask 60 = 67% di spread). Un elenco di nomi non basterebbe."""
|
||||
d = _lettura()
|
||||
s = U.sintesi(U.tabella(d), d)
|
||||
assert [f["nome"] for f in s["dvol_fut"]] == ["BTCDVOL_USDC-30SEP26"], (
|
||||
"il future datato SENZA 'DVOL' nel nome non deve entrare qui")
|
||||
f = s["dvol_fut"][0]
|
||||
assert (f["stato"], f["min_amt"], f["bid"], f["ask"], f["oi"]) == ("open", 1.0, 30.0, 60.0, 12.0)
|
||||
assert f["vol_usd"] == 0.0
|
||||
|
||||
|
||||
def test_tabella_e_ORDINATA_per_volume_decrescente():
|
||||
rows = U.tabella(_lettura())
|
||||
vol = [r["vol_usd"] for r in rows]
|
||||
assert vol == sorted(vol, reverse=True)
|
||||
assert [r["coin"] for r in rows] == ["XRP", "ETH", "ADA", "PAXG"]
|
||||
|
||||
|
||||
def test_lo_spread_e_NAN_senza_bid_o_senza_ask():
|
||||
"""P5: senza un lato del book lo spread non e' 0 bps (che vorrebbe dire "perfetto"), e'
|
||||
"non misurabile". DEVE FALLIRE SE: qualcuno mette un `or 0.0` anche su bid/ask."""
|
||||
rows = {r["coin"]: r for r in U.tabella(_lettura())}
|
||||
assert np.isnan(rows["ADA"]["spread_bps"]), "bid assente -> spread non misurabile"
|
||||
assert np.isnan(rows["PAXG"]["spread_bps"]), "bid a zero -> spread non misurabile"
|
||||
assert rows["XRP"]["spread_bps"] == pytest.approx((2.002 - 2.0) / 2.001 * 1e4)
|
||||
assert rows["ETH"]["spread_bps"] == pytest.approx(0.3 / 3000.15 * 1e4)
|
||||
|
||||
|
||||
def test_il_lotto_minimo_e_in_DOLLARI_non_in_unita():
|
||||
"""C3: prima di misurare il rendimento a un capitale dato si misura il lotto minimo del
|
||||
venue — e il confronto col pavimento $5 si fa in dollari, non in unita' della moneta."""
|
||||
rows = {r["coin"]: r for r in U.tabella(_lettura())}
|
||||
assert rows["XRP"]["min_usd"] == pytest.approx(1.0 * 2.0)
|
||||
assert rows["ADA"]["min_usd"] == pytest.approx(10.0 * 0.6)
|
||||
assert rows["ETH"]["min_amt"] == 0.01
|
||||
|
||||
|
||||
def test_la_data_di_listing_e_quella_del_venue():
|
||||
rows = {r["coin"]: r for r in U.tabella(_lettura())}
|
||||
assert rows["XRP"]["listato"] == "2022-03-16"
|
||||
assert rows["PAXG"]["listato"] == "2024-12-02"
|
||||
|
||||
|
||||
def test_P1_le_gambe_di_XS01_si_IMPORTANO_dal_sleeve():
|
||||
"""*Un controllo puntato su una configurazione diversa da quella che gira passa sempre.*
|
||||
Se l'elenco fosse ricopiato nello script, "13/19 quotate" resterebbe vero anche dopo un
|
||||
cambio di universo del sleeve — cioe' smetterebbe di controllare qualcosa."""
|
||||
from src.portfolio import sleeves
|
||||
assert U.XS_UNIVERSE is sleeves.XS_UNIVERSE
|
||||
src = inspect.getsource(U)
|
||||
assert "from src.portfolio.sleeves import XS_UNIVERSE" in src
|
||||
assert "XS_UNIVERSE = [" not in src, "universo XS01 ridichiarato nello script"
|
||||
|
||||
|
||||
def test_le_gambe_XS01_mancanti_si_CALCOLANO_dall_universo():
|
||||
"""La riga "mancano [...]" e' l'elenco delle gambe di XS01 non quotate sul venue: si
|
||||
ricava dall'universo importato, quindi si aggiorna da sola se il sleeve cambia."""
|
||||
from src.portfolio.sleeves import XS_UNIVERSE
|
||||
rows = U.tabella(_lettura())
|
||||
s = U.sintesi(rows, _lettura())
|
||||
quotate = {"XRP", "ETH", "ADA"} # PAXG non e' in XS01
|
||||
assert s["xs01_listate"] == sorted(c for c in XS_UNIVERSE if c in quotate)
|
||||
assert s["xs01_mancanti"] == [c for c in XS_UNIVERSE if c not in quotate]
|
||||
assert set(s["xs01_listate"]) | set(s["xs01_mancanti"]) == set(XS_UNIVERSE)
|
||||
assert {r["coin"] for r in rows if r["xs01"]} == quotate
|
||||
|
||||
|
||||
def test_liquidi_usa_la_soglia_dichiarata_e_il_confine_e_incluso():
|
||||
"""La soglia $10M/giorno e' dichiarata nel modulo: il test la DERIVA, non la ricopia."""
|
||||
d = _lettura()
|
||||
for b in d["bs"]:
|
||||
if b["instrument_name"] == "ADA_USDC-PERPETUAL":
|
||||
b["volume_usd"] = U.SOGLIA_LIQUIDO_USD # esattamente in soglia -> liquido
|
||||
if b["instrument_name"] == "PAXG_USDC-PERPETUAL":
|
||||
b["volume_usd"] = U.SOGLIA_LIQUIDO_USD - 1.0 # un dollaro sotto -> no
|
||||
s = U.sintesi(U.tabella(d), d)
|
||||
assert s["liquidi"] == ["XRP", "ETH", "ADA"]
|
||||
|
||||
|
||||
def test_sintesi_riporta_le_famiglie_di_opzioni_e_l_ora_della_lettura():
|
||||
"""N10/§7: un numero letto dal venue vale con la sua ora. Senza `letto_a` la riga
|
||||
diventerebbe una verita' senza data."""
|
||||
d = _lettura()
|
||||
s = U.sintesi(U.tabella(d), d)
|
||||
assert s["letto_a"] == LETTO_A
|
||||
assert s["opt_inv"] == {"BTC": 912, "ETH": 790}
|
||||
assert s["opt_usdc"] == [("SOL", 3), ("BTC", 2)]
|
||||
assert s["n_perp"] == 4
|
||||
|
||||
|
||||
def test_verdetto_su_una_lettura_sintetica():
|
||||
d = _lettura()
|
||||
s = U.sintesi(U.tabella(d), d)
|
||||
v = U.verdetto(s)
|
||||
assert v.startswith("4 perpetual USDC; LIQUIDI (≥$10M/g): XRP, ETH; ")
|
||||
assert "XS01 3/19 quotate" in v
|
||||
assert "opzioni USDC-lineari su 2 sottostanti" in v
|
||||
assert f"lettura del {LETTO_A}" in v
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# (b) leggi() — la cache, e la garanzia che NESSUN test vada in rete
|
||||
# ===========================================================================================
|
||||
|
||||
@pytest.fixture()
|
||||
def cache_in_tmp(tmp_path, monkeypatch):
|
||||
"""Devia la cache fuori da `data/_cache/` (debito §5.12: la suite non scrive nei file vivi)."""
|
||||
p = tmp_path / "r0909_deribit_universo.json"
|
||||
monkeypatch.setattr(U, "CACHE", p)
|
||||
return p
|
||||
|
||||
|
||||
def test_leggi_con_cache_presente_NON_tocca_la_rete(cache_in_tmp, monkeypatch):
|
||||
"""DEVE FALLIRE SE: qualcuno rende la lettura sempre fresca — la suite comincerebbe a
|
||||
dipendere dalla rete e dal venue, e un test rosso non direbbe piu' niente sul codice."""
|
||||
def _vietato(path):
|
||||
raise AssertionError(f"chiamata di rete durante un test: {path}")
|
||||
monkeypatch.setattr(U, "get", _vietato)
|
||||
|
||||
atteso = _lettura()
|
||||
cache_in_tmp.write_text(json.dumps(atteso))
|
||||
d = U.leggi(usa_cache=True)
|
||||
assert d["letto_a"] == LETTO_A
|
||||
assert len(d["fut"]) == len(atteso["fut"])
|
||||
# (i NaN dello spread non sono confrontabili con ==: si confronta il resto)
|
||||
chiave = lambda rows: [(r["coin"], r["listato"], r["vol_usd"], r["min_usd"], r["xs01"])
|
||||
for r in rows]
|
||||
assert chiave(U.tabella(d)) == chiave(U.tabella(atteso))
|
||||
|
||||
|
||||
def test_leggi_senza_cache_interroga_il_venue_UNA_volta_e_la_scrive(cache_in_tmp, monkeypatch):
|
||||
"""La cache non e' un'ottimizzazione: e' la FONTE del numero stampato (una lettura e' un
|
||||
istante). Deve finire su disco con la sua ora, o la riga del diario non ha piu' fonte."""
|
||||
chiamate = []
|
||||
|
||||
def _finto(path):
|
||||
chiamate.append(path)
|
||||
if "get_book_summary" in path:
|
||||
return _lettura()["bs"]
|
||||
if "kind=option" in path and "currency=USDC" in path:
|
||||
return _lettura()["opt_usdc"]
|
||||
if "kind=option" in path:
|
||||
return [0] * 912
|
||||
return _lettura()["fut"]
|
||||
monkeypatch.setattr(U, "get", _finto)
|
||||
|
||||
assert not cache_in_tmp.exists()
|
||||
d = U.leggi(usa_cache=True)
|
||||
assert cache_in_tmp.exists(), "la lettura non e' stata salvata: il numero resta senza fonte"
|
||||
assert json.loads(cache_in_tmp.read_text())["letto_a"] == d["letto_a"]
|
||||
assert d["letto_a"].endswith("+00:00"), "l'ora della lettura dev'essere in UTC dichiarato"
|
||||
assert d["opt_inv"] == {"BTC": 912, "ETH": 912}
|
||||
assert len(chiamate) == 5, "una chiamata per famiglia: fut, book summary, opzioni USDC, BTC, ETH"
|
||||
|
||||
# e una seconda lettura con cache NON ripete le chiamate
|
||||
prima = len(chiamate)
|
||||
U.leggi(usa_cache=True)
|
||||
assert len(chiamate) == prima
|
||||
|
||||
|
||||
def test_fresh_ignora_la_cache(cache_in_tmp, monkeypatch):
|
||||
"""`--fresh` deve rileggere davvero: e' l'unico modo di aggiornare una tabella che per
|
||||
costruzione invecchia (i perpetual del 18/08/2026 non c'erano un mese prima)."""
|
||||
cache_in_tmp.write_text(json.dumps(_lettura()))
|
||||
chiamate = []
|
||||
monkeypatch.setattr(U, "get", lambda path: chiamate.append(path) or [])
|
||||
U.leggi(usa_cache=False)
|
||||
assert chiamate, "con usa_cache=False la cache non va usata"
|
||||
|
||||
|
||||
def test_il_flag_fresh_e_DOCUMENTATO_e_cablato():
|
||||
"""P15: una regola operativa va provata contro il codice che dovrebbe eseguirla. Qui:
|
||||
il flag esiste nel `main`, e' l'unico modo di bypassare la cache, ed e' scritto nell'uso
|
||||
che lo script stampa (chi legge la tabella deve sapere che puo' essere vecchia)."""
|
||||
src = inspect.getsource(U)
|
||||
assert 'leggi(usa_cache="--fresh" not in sys.argv)' in src, "il flag non e' cablato"
|
||||
assert "--fresh per rileggere" in src, (
|
||||
"il flag non e' documentato nell'uso che lo script stampa: chi legge la tabella non "
|
||||
"sa come aggiornarla, e la lettura in cache invecchia in silenzio")
|
||||
|
||||
|
||||
def test_lo_script_NON_ha_credenziali_ne_ordini():
|
||||
"""L'API interrogata e' quella PUBBLICA: nessun token, nessun endpoint privato, nessun
|
||||
ordine. Se un giorno servisse il conto, e' una decisione (debito §5.11), non un refactor."""
|
||||
src = inspect.getsource(U)
|
||||
assert U.API == "https://www.deribit.com/api/v2/public/"
|
||||
for vietato in ("private/", "buy", "sell", "CERBERO", "api_key", "client_id"):
|
||||
assert vietato not in src, f"lo script pubblico contiene '{vietato}'"
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# la lettura VERA in cache (se c'e'): il file su cui poggia la riga del 09/09
|
||||
# ===========================================================================================
|
||||
|
||||
def test_la_cache_vera_se_c_e_regge_la_tabella_pubblicata():
|
||||
"""Non e' un test di rete: legge il JSON che lo script ha gia' salvato. Se manca, si salta."""
|
||||
if not U.CACHE.exists():
|
||||
pytest.skip(f"nessuna lettura in cache ({U.CACHE}): il test non va in rete")
|
||||
d = json.loads(U.CACHE.read_text())
|
||||
rows = U.tabella(d)
|
||||
s = U.sintesi(rows, d)
|
||||
assert s["n_perp"] == len(rows) > 0
|
||||
assert [r["vol_usd"] for r in rows] == sorted([r["vol_usd"] for r in rows], reverse=True)
|
||||
assert {"BTC", "ETH"} <= {r["coin"] for r in rows}, "il venue non quota piu' BTC/ETH?"
|
||||
assert set(s["xs01_listate"]) | set(s["xs01_mancanti"]) == set(U.XS_UNIVERSE)
|
||||
assert U.verdetto(s).endswith(f"lettura del {d['letto_a']}")
|
||||
@@ -0,0 +1,385 @@
|
||||
"""Test di `scripts/research/r0909_libro_nei_crolli.py` (2026-09-09) — il libro nei crolli.
|
||||
|
||||
Cosa protegge, in due strati:
|
||||
|
||||
* il MECCANISMO su dati SINTETICI, dove la risposta e' nota per costruzione — le classi
|
||||
ESCLUSIVE col loro ordine, le finestre peggiori non sovrapposte, il beta con pendenza
|
||||
imposta, i rami del verdetto. Qui un test rosso significa "il codice ha cambiato
|
||||
comportamento", mai "il mercato ha cambiato idea".
|
||||
* la RIPRODUZIONE del risultato pubblicato il 09/09 sui dati veri: 4 POSITIVO / 6 immune /
|
||||
2 PERDE su 12 finestre, libro > 0 in 8 (dal 2022: 8/8), e beta +0,0769 sulla finestra di
|
||||
§46 che riproduce il +0,076 della memoria. E' M23: prima di pubblicare un numero nuovo, la
|
||||
macchina deve ristampare quello vecchio.
|
||||
|
||||
🚨 LA REGRESSIONE PIU' IMPORTANTE DI QUESTO FILE. `classifica()` prova **immune PRIMA di
|
||||
POSITIVO**, e l'ordine non e' un dettaglio: con l'ordine opposto lo stesso identico dato dava
|
||||
"8/12 episodi in utile" invece di "4 POSITIVO / 6 immune". *L'ordine delle regole ERA il
|
||||
verdetto* (corretto in revisione il 09/09). Un test lo congela.
|
||||
|
||||
⚠️ P1: i pesi del libro NON si ridichiarano — un test congela l'identita' fra i pesi usati dallo
|
||||
script e `src.live.book.W_TP01` / `W_SKH`.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import inspect
|
||||
import re
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
import pytest
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT))
|
||||
sys.path.insert(0, str(ROOT / "scripts" / "research"))
|
||||
|
||||
import r0909_libro_nei_crolli as M # noqa: E402
|
||||
|
||||
RAW = ROOT / "data" / "raw"
|
||||
|
||||
|
||||
def _feed_certificato_presente() -> bool:
|
||||
return all((RAW / f"{a}_{tf}.parquet").exists()
|
||||
for a in ("btc", "eth") for tf in ("1h", "5m"))
|
||||
|
||||
|
||||
def _giorni(n: int, inizio: str = "2021-01-01") -> pd.DatetimeIndex:
|
||||
return pd.date_range(inizio, periods=n, freq="D", tz="UTC")
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# classifica() — classi ESCLUSIVE, e l'ORDINE in cui si provano
|
||||
# ===========================================================================================
|
||||
|
||||
def test_classifica_prova_IMMUNE_PRIMA_di_POSITIVO():
|
||||
"""🚨 La regressione del 09/09. Sugli stessi numeri l'ordine "POSITIVO prima" dava 8/12
|
||||
episodi in utile; l'ordine dichiarato (immune prima) da' 4 POSITIVO + 6 immune.
|
||||
DEVE FALLIRE SE: qualcuno rimette il test del segno davanti alla banda di immunita' —
|
||||
non e' un refactor, e' un altro verdetto."""
|
||||
# peggiore #8 del 09/09: +0,21% di libro contro −26,54% di indice. E' dentro un decimo.
|
||||
assert M.classifica(0.0021, -0.2654) == "immune+"
|
||||
# peggiore #5: +4,26% contro −31,61% -> fuori dalla banda, e allora e' POSITIVO
|
||||
assert M.classifica(0.0426, -0.3161) == "POSITIVO"
|
||||
|
||||
|
||||
def test_classifica_immune_porta_il_SEGNO_con_se():
|
||||
""""immune" non e' una classe cieca: +0,21% e −0,52% su un crollo del 26% sono entrambi
|
||||
immunita', ma non sono la stessa notizia. DEVE FALLIRE SE: le due si fondono in una."""
|
||||
assert M.classifica(0.0021, -0.2654) == "immune+"
|
||||
assert M.classifica(-0.0052, -0.2583) == "immune-"
|
||||
assert set(M.classifica(x, -0.30) for x in (0.001, -0.001)) == {"immune+", "immune-"}
|
||||
|
||||
|
||||
def test_classifica_fuori_dalla_banda_resta_il_segno():
|
||||
assert M.classifica(+0.05, -0.30) == "POSITIVO"
|
||||
assert M.classifica(-0.05, -0.30) == "PERDE"
|
||||
assert M.classifica(-0.0637, -0.3411) == "PERDE" # peggiore #1 del 09/09
|
||||
|
||||
|
||||
def test_classifica_il_confine_della_banda_e_STRETTO():
|
||||
"""Esattamente un decimo NON e' immune: il confronto e' `<`, non `<=`.
|
||||
DEVE FALLIRE SE: qualcuno lo rilassa e sposta episodi dentro la banda."""
|
||||
assert M.classifica(-0.010, -0.10) == "PERDE"
|
||||
assert M.classifica(-0.010000001, -0.10) == "PERDE"
|
||||
assert M.classifica(-0.009999999, -0.10) == "immune-"
|
||||
assert M.classifica(+0.010, -0.10) == "POSITIVO"
|
||||
assert M.classifica(+0.009999999, -0.10) == "immune+"
|
||||
|
||||
|
||||
def test_classifica_a_indice_zero_non_esiste_immunita():
|
||||
"""Caso limite DICHIARATO (non un bug): con indice 0 la banda ha ampiezza 0, quindi nulla
|
||||
e' immune. Non morde negli episodi (per costruzione hanno indice molto negativo), ma chi
|
||||
riusa `classifica()` altrove deve saperlo."""
|
||||
assert M.classifica(0.0, 0.0) == "PERDE"
|
||||
assert M.classifica(+0.001, 0.0) == "POSITIVO"
|
||||
|
||||
|
||||
def test_classifica_un_libro_esattamente_fermo_e_immune_col_segno_MENO():
|
||||
"""Zero non e' positivo: `libro > 0` e' falso, quindi la classe e' "immune-".
|
||||
E' una convenzione, e va scritta perche' non e' l'unica possibile."""
|
||||
assert M.classifica(0.0, -0.20) == "immune-"
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# finestre_peggiori() — non sovrapposte, ordinate, al piu' N, e la peggiore e' la peggiore
|
||||
# ===========================================================================================
|
||||
|
||||
def _serie_con_crolli(crolli: list[tuple[int, float]], n: int = 300) -> pd.Series:
|
||||
"""Serie giornaliera piatta con crolli piantati a posizioni note: ogni `(i0, r)` mette
|
||||
20 giorni consecutivi a rendimento `r` a partire dalla posizione `i0`."""
|
||||
r = pd.Series(0.0, index=_giorni(n))
|
||||
for i0, val in crolli:
|
||||
r.iloc[i0:i0 + M.FINESTRA] = val
|
||||
return r
|
||||
|
||||
|
||||
CROLLI = [(30, -0.010), (100, -0.005), (180, -0.002)]
|
||||
|
||||
|
||||
def test_finestre_peggiori_non_si_sovrappongono_e_sono_ordinate():
|
||||
"""DEVE FALLIRE SE: il greedy smette di marcare gli intervalli occupati — senza quel filtro
|
||||
le 12 "peggiori finestre" sarebbero 12 traslazioni di UNO stesso episodio, e la riga
|
||||
"4/12" conterebbe 12 volte lo stesso crollo."""
|
||||
idx = _serie_con_crolli(CROLLI)
|
||||
prese = M.finestre_peggiori(idx, n=3)
|
||||
assert len(prese) == 3
|
||||
assert prese == sorted(prese), "l'elenco esce ordinato per data d'inizio"
|
||||
for (s0, e0, _), (s1, _, _) in zip(prese, prese[1:]):
|
||||
assert s1 > e0, f"finestre sovrapposte: {e0} e {s1}"
|
||||
for s, e, _ in prese:
|
||||
assert e - s == pd.Timedelta(days=M.FINESTRA - 1)
|
||||
|
||||
|
||||
def test_finestre_peggiori_trova_DAVVERO_la_peggiore():
|
||||
"""Il primo episodio dev'essere il minimo globale del rolling, non un minimo locale.
|
||||
DEVE FALLIRE SE: qualcuno sostituisce il greedy dal peggiore con una scansione in avanti."""
|
||||
idx = _serie_con_crolli(CROLLI)
|
||||
prese = M.finestre_peggiori(idx, n=3)
|
||||
roll = (1 + idx).rolling(M.FINESTRA).apply(np.prod, raw=True) - 1
|
||||
peggiore = min(prese, key=lambda t: t[2])
|
||||
assert peggiore[2] == pytest.approx(float(roll.min()), abs=1e-12)
|
||||
assert peggiore[2] == pytest.approx((1 - 0.010) ** M.FINESTRA - 1, abs=1e-12)
|
||||
assert peggiore[0] == idx.index[30] and peggiore[1] == idx.index[49]
|
||||
valori = sorted(v for _, _, v in prese)
|
||||
attesi = sorted((1 + r) ** M.FINESTRA - 1 for _, r in CROLLI)
|
||||
assert valori == pytest.approx(attesi, abs=1e-12)
|
||||
|
||||
|
||||
def test_finestre_peggiori_rispetta_il_tetto_n():
|
||||
idx = _serie_con_crolli(CROLLI)
|
||||
assert len(M.finestre_peggiori(idx, n=2)) == 2
|
||||
assert len(M.finestre_peggiori(idx, n=1)) == 1
|
||||
assert len(M.finestre_peggiori(idx, n=100)) <= 100
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# beta_pieno / beta_ribasso — pendenza NOTA per costruzione
|
||||
# ===========================================================================================
|
||||
|
||||
def test_beta_pieno_ritrova_una_pendenza_nota():
|
||||
rng = np.random.default_rng(909)
|
||||
i = pd.Series(rng.normal(0.0, 0.03, 400), index=_giorni(400))
|
||||
assert M.beta_pieno(0.30 * i, i) == pytest.approx(0.30, abs=1e-9)
|
||||
assert M.beta_pieno(0.0 * i, i) == pytest.approx(0.0, abs=1e-12)
|
||||
assert M.beta_pieno(-0.75 * i, i) == pytest.approx(-0.75, abs=1e-9)
|
||||
|
||||
|
||||
def test_beta_ribasso_guarda_SOLO_i_giorni_giu():
|
||||
"""Controllo POSITIVO: su una serie asimmetrica (0,50 in salita, 0,10 in discesa) il beta
|
||||
pieno NON puo' rispondere alla domanda del crollo — il beta al ribasso si'.
|
||||
DEVE FALLIRE SE: il filtro `idx < soglia` sparisce e le due misure collassano in una."""
|
||||
rng = np.random.default_rng(46)
|
||||
i = pd.Series(rng.normal(0.0, 0.03, 600), index=_giorni(600))
|
||||
libro = pd.Series(np.where(i.values < 0, 0.10 * i.values, 0.50 * i.values), index=i.index)
|
||||
assert M.beta_ribasso(libro, i) == pytest.approx(0.10, abs=1e-9)
|
||||
assert M.beta_pieno(libro, i) > 0.20, "il beta pieno MEDIA i due regimi: e' un'altra domanda"
|
||||
|
||||
|
||||
def test_beta_ribasso_usa_la_soglia_che_riceve():
|
||||
"""La riga [1] stampa quattro beta (pieno, finestra §46, idx<0, idx≤−3%): sono lenti
|
||||
diverse, non una."""
|
||||
rng = np.random.default_rng(3)
|
||||
i = pd.Series(rng.normal(0.0, 0.03, 800), index=_giorni(800))
|
||||
forte = i.values < -0.03
|
||||
libro = pd.Series(np.where(forte, 0.90 * i.values, 0.10 * i.values), index=i.index)
|
||||
assert (i < -0.03).sum() >= 20, "campione insufficiente: il test non avrebbe potenza"
|
||||
b3 = M.beta_ribasso(libro, i, -0.03)
|
||||
b0 = M.beta_ribasso(libro, i, 0.0)
|
||||
assert b3 == pytest.approx(0.90, abs=1e-9), "sotto −3% la pendenza e' quella imposta"
|
||||
assert abs(b0 - b3) > 0.05, (
|
||||
"la soglia non entra nel calcolo: le lenti darebbero lo stesso numero e la riga [1] "
|
||||
"stamperebbe quattro volte la stessa cosa")
|
||||
|
||||
|
||||
def test_beta_ribasso_e_NAN_sotto_venti_osservazioni():
|
||||
"""P5: "non vedo" non e' "beta zero". DEVE FALLIRE SE: qualcuno toglie la guardia e
|
||||
pubblica una pendenza stimata su tre giorni."""
|
||||
i = pd.Series(np.linspace(-0.05, -0.01, 10), index=_giorni(10))
|
||||
assert np.isnan(M.beta_ribasso(0.3 * i, i)), "10 giorni non fanno una pendenza"
|
||||
i25 = pd.Series(np.linspace(-0.05, -0.01, 25), index=_giorni(25))
|
||||
assert M.beta_ribasso(0.3 * i25, i25) == pytest.approx(0.30, abs=1e-9)
|
||||
|
||||
|
||||
def test_la_finestra_di_46_e_dichiarata_e_non_e_tutta_la_storia():
|
||||
"""§46 e' un numero NATO su una finestra che comincia col DVOL (2021-03-24): confrontarlo
|
||||
col beta di tutta la storia sarebbe P7 al contrario (etichettare un numero con la finestra
|
||||
sbagliata). Lo script tiene le due misure separate — questo test lo congela."""
|
||||
assert M.FINESTRA_46 == pd.Timestamp("2021-03-24", tz="UTC")
|
||||
assert M.BETA_MEMORIA == 0.076 and M.TOL_BETA == 0.01
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# verdetto() — TRE affermazioni, tre domande diverse
|
||||
# ===========================================================================================
|
||||
|
||||
def _m(guadagna=4, immune=6, n=12, beta_46=0.0769, giorni_libro=-0.0048,
|
||||
giorni_pos=0.175, positivi=8, dal22=(8, 8), quota=1.08) -> dict:
|
||||
return dict(beta_46=beta_46,
|
||||
sintesi=dict(n_episodi=n, guadagna=guadagna, immune=immune,
|
||||
perde=n - guadagna - immune, positivi=positivi, dal22=dal22,
|
||||
giorni_pos=giorni_pos, giorni_libro=giorni_libro,
|
||||
quota_short_nei_guadagni=quota))
|
||||
|
||||
|
||||
def test_verdetto_separa_il_GIORNO_dalla_FINESTRA():
|
||||
"""Le due domande hanno risposte OPPOSTE sugli stessi dati (nel giorno perde, per finestra
|
||||
e' immune-o-positivo), ed e' il fatto centrale del 09/09: SKH01 e' marcato all'uscita, e
|
||||
uno short aperto nel crollo viene accreditato dopo. Un solo aggettivo mentirebbe."""
|
||||
v = M.verdetto(_m())
|
||||
assert v.startswith("NEL GIORNO DEL CROLLO IL LIBRO PERDE")
|
||||
assert "IMMUNE-O-POSITIVO per finestra" in v
|
||||
assert M.verdetto(_m(giorni_libro=+0.0012)).startswith(
|
||||
"NEL GIORNO DEL CROLLO IL LIBRO GUADAGNA")
|
||||
|
||||
|
||||
def test_verdetto_i_tre_rami_della_FINESTRA():
|
||||
"""Le soglie sono 2/3 sui POSITIVO e 2/3 su POSITIVO+immune.
|
||||
DEVE FALLIRE SE: qualcuno le sposta guardando l'esito (selezione sull'hold-out)."""
|
||||
assert "POSITIVO per finestra" in M.verdetto(_m(guadagna=8, immune=2))
|
||||
assert "IMMUNE-O-POSITIVO per finestra" in M.verdetto(_m(guadagna=4, immune=6))
|
||||
assert "PERDE per finestra" in M.verdetto(_m(guadagna=3, immune=2))
|
||||
|
||||
|
||||
def test_verdetto_i_confini_delle_due_soglie():
|
||||
v8 = M.verdetto(_m(guadagna=8, immune=0)) # 8 >= 8.0
|
||||
assert "POSITIVO per finestra" in v8 and "IMMUNE-O-POSITIVO" not in v8
|
||||
assert "IMMUNE-O-POSITIVO per finestra" in M.verdetto(_m(guadagna=7, immune=1))
|
||||
assert "PERDE per finestra" in M.verdetto(_m(guadagna=7, immune=0))
|
||||
|
||||
|
||||
def test_verdetto_dice_se_il_beta_RIPRODUCE_la_memoria_e_su_QUALE_finestra():
|
||||
"""La tolleranza e' TOL_BETA e il beta confrontato e' quello della finestra di §46, non il
|
||||
beta pieno: due numeri diversi (0,0769 contro 0,086), e solo il primo va confrontato."""
|
||||
# ⚠️ il confine esatto non e' asseribile in virgola mobile: 0,076 + 0,01 vale 0,086 e la
|
||||
# differenza torna 0,009999999999999995, cioe' DENTRO. Si prova un micron di qua e di la'.
|
||||
dentro = M.BETA_MEMORIA + M.TOL_BETA - 1e-6
|
||||
fuori = M.BETA_MEMORIA + M.TOL_BETA + 1e-6
|
||||
assert "(riproduce il" in M.verdetto(_m(beta_46=dentro))
|
||||
assert "(NON riproduce il" not in M.verdetto(_m(beta_46=dentro))
|
||||
assert "(NON riproduce il" in M.verdetto(_m(beta_46=fuori))
|
||||
assert "sulla finestra di §46" in M.verdetto(_m())
|
||||
assert f"+{M.BETA_MEMORIA:.3f}" in M.verdetto(_m())
|
||||
|
||||
|
||||
def test_verdetto_dichiara_che_SKH01_e_marcato_all_uscita():
|
||||
"""P4: l'allerta (qui: la riga) risponde anche al "perche'". Senza quella nota, il lettore
|
||||
vede SKH01 ≈ 0 nella tabella per giorno e il guadagno nella tabella per finestra, e non ha
|
||||
modo di sapere che e' la stessa serie letta in due modi."""
|
||||
assert "marcata all'uscita" in M.verdetto(_m())
|
||||
|
||||
|
||||
def test_verdetto_riproduce_ALLA_LETTERA_la_riga_pubblicata_il_09_09():
|
||||
"""M23: la macchina deve ristampare il numero vecchio. Sono i valori esatti usciti da
|
||||
`misura()` il 09/09 — se il testo cambia, cambia anche cio' che il diario cita, e va
|
||||
cambiato nei due posti insieme."""
|
||||
m = _m(guadagna=4, immune=6, n=12, beta_46=0.07691539529362904,
|
||||
giorni_libro=-0.004841811670794324, giorni_pos=0.175, positivi=8, dal22=(8, 8),
|
||||
quota=1.0793712686517833)
|
||||
assert M.verdetto(m) == (
|
||||
"NEL GIORNO DEL CROLLO IL LIBRO PERDE (-0.48%/g, positivo nel 18% dei giorni ≤ −5%); "
|
||||
"IMMUNE-O-POSITIVO per finestra: 4 POSITIVO / 6 immune / 2 PERDE su 12 "
|
||||
"(libro > 0 in 8, dal 2022 in 8/8); beta +0.0769 sulla finestra di §46 "
|
||||
"(riproduce il +0.076); la gamba short di SKH01 (marcata all'uscita) fa il 108% "
|
||||
"dei guadagni negli episodi con libro > 0")
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# P1 — i pesi si IMPORTANO dal book live
|
||||
# ===========================================================================================
|
||||
|
||||
def test_P1_i_pesi_sono_QUELLI_del_book_live_non_una_copia():
|
||||
"""*Un controllo puntato su una configurazione diversa da quella che gira passa sempre.*
|
||||
L'identita' (`is`) vale solo se i nomi sono legati allo STESSO oggetto dell'import: un
|
||||
`W_TP01 = 0.75` riscritto nello script la romperebbe anche a valore uguale."""
|
||||
import src.live.book as B
|
||||
|
||||
assert M.W_TP01 is B.W_TP01, "TP01: peso ridichiarato invece che importato da src/live/book"
|
||||
assert M.W_SKH is B.W_SKH, "SKH01: peso ridichiarato invece che importato da src/live/book"
|
||||
assert M.W_TP01 + M.W_SKH == pytest.approx(1.0)
|
||||
|
||||
src = inspect.getsource(M)
|
||||
assert "from src.live.book import" in src
|
||||
assert not re.search(r"^W_TP01\s*=", src, re.M), "peso TP01 ridichiarato a livello di modulo"
|
||||
assert not re.search(r"^W_SKH\s*=", src, re.M), "peso SKH01 ridichiarato a livello di modulo"
|
||||
|
||||
|
||||
def test_la_riga_informativa_37_5_62_5_NON_e_il_peso_del_libro():
|
||||
"""§26 compare come riga informativa. DEVE FALLIRE SE: qualcuno la promuove a peso di
|
||||
default — il 75/25 e' decisione vincolante, la riapre solo `weights_tilt_null`."""
|
||||
assert M.W_INFO == (0.375, 0.625)
|
||||
assert (M.W_TP01, M.W_SKH) != M.W_INFO
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# INTEGRAZIONE sui dati veri
|
||||
# ===========================================================================================
|
||||
|
||||
def test_la_scomposizione_di_SKH01_in_long_e_short_e_ESATTA():
|
||||
"""~2 s. Due guardie, entrambe P1:
|
||||
(a) la versione "tutto" dev'essere BIT-EXACT con `sleeves._skyhook_returns` — se non lo
|
||||
fosse, l'attribuzione descriverebbe un altro sleeve;
|
||||
(b) long + short == intera. In principio filtrare gli entry-dict potrebbe cambiare il
|
||||
non-overlap (un long che non occupa piu' la barra lascia entrare uno short): la
|
||||
misura dice che qui non succede, e il test lo tiene vero."""
|
||||
if not _feed_certificato_presente():
|
||||
pytest.skip("feed certificato BTC/ETH 5m/1h assente in data/raw (gitignored)")
|
||||
from src.portfolio.sleeves import _skyhook_returns
|
||||
|
||||
d = M.skh_per_direzione()
|
||||
assert set(d) == {"tutto", "long", "short"}
|
||||
J = pd.concat(d, axis=1, join="inner")
|
||||
assert float((J["long"] + J["short"] - J["tutto"]).abs().max()) < 1e-12, (
|
||||
"long + short != intera: la scomposizione non e' un'attribuzione, e' un'altra misura")
|
||||
|
||||
ref = _skyhook_returns()
|
||||
if ref.index.tz is None:
|
||||
ref.index = ref.index.tz_localize("UTC")
|
||||
comune = d["tutto"].index.intersection(ref.index)
|
||||
assert len(comune) > 1000
|
||||
assert float((d["tutto"].loc[comune] - ref.loc[comune]).abs().max()) == 0.0, (
|
||||
"la versione 'tutto' non e' piu' bit-exact col sleeve di ricerca")
|
||||
|
||||
|
||||
def test_integrazione_il_risultato_pubblicato_del_09_09_si_riproduce():
|
||||
"""~2 s. Se questo test diventa rosso NON va "aggiornato": va capito se e' cambiato il
|
||||
dato (rebuild del feed) o il codice, e la riga citata nel diario va rifatta.
|
||||
|
||||
I due fatti che decidono: (1) per FINESTRA il libro non perde quasi mai — 4 POSITIVO +
|
||||
6 immune su 12, e libro > 0 in 8/8 episodi dal 2022; (2) NEL GIORNO del crollo perde
|
||||
(−0,48%/g, positivo solo nel 18% dei giorni ≤ −5%). Sono due risposte opposte alla stessa
|
||||
domanda dell'operatore, e stanno insieme perche' SKH01 e' marcato all'uscita."""
|
||||
if not _feed_certificato_presente():
|
||||
pytest.skip("feed certificato BTC/ETH 5m/1h assente in data/raw (gitignored)")
|
||||
|
||||
m = M.misura()
|
||||
|
||||
assert m["beta"] == pytest.approx(0.086, abs=0.03), "beta pieno fuori dal valore pubblicato"
|
||||
assert abs(m["beta_46"] - M.BETA_MEMORIA) < M.TOL_BETA, (
|
||||
f"il beta sulla finestra di §46 ({m['beta_46']:+.4f}) non riproduce piu' il "
|
||||
f"+{M.BETA_MEMORIA:.3f}: e' la riproduzione che giustifica la lente")
|
||||
|
||||
s = m["sintesi"]
|
||||
assert s["n_episodi"] == 12
|
||||
assert (s["guadagna"], s["immune"], s["perde"]) == (4, 6, 2)
|
||||
assert s["guadagna"] + s["immune"] + s["perde"] == s["n_episodi"]
|
||||
assert s["positivi"] == 8, "il conteggio nudo libro > 0 e' l'altra lettura, e va stampata"
|
||||
assert s["dal22"] == (8, 8), "dal 2022 ogni episodio ha il libro in utile"
|
||||
assert s["giorni_libro"] < 0, "nel GIORNO del crollo il libro perde: e' la meta' scomoda"
|
||||
assert s["giorni_pos"] == pytest.approx(0.175, abs=0.05)
|
||||
|
||||
classi = [r["classe"] for r in m["episodi"]]
|
||||
assert classi.count("POSITIVO") == s["guadagna"]
|
||||
assert sum(c.startswith("immune") for c in classi) == s["immune"]
|
||||
assert classi.count("PERDE") == s["perde"]
|
||||
|
||||
dal_2022 = [r for r in m["episodi"] if int(r["da"][:4]) >= 2022]
|
||||
assert len(dal_2022) == 8
|
||||
assert all(r["libro"] > 0 for r in dal_2022), (
|
||||
"un episodio dal 2022 in poi non ha piu' il libro in utile: "
|
||||
+ str([(r["nome"], r["da"], r["libro"]) for r in dal_2022]))
|
||||
|
||||
v = M.verdetto(m)
|
||||
assert v.startswith("NEL GIORNO DEL CROLLO IL LIBRO PERDE")
|
||||
assert "IMMUNE-O-POSITIVO per finestra" in v
|
||||
assert "(riproduce il +0.076)" in v
|
||||
@@ -0,0 +1,351 @@
|
||||
"""Test di `scripts/research/r0909_xrp_terza_gamba.py` (2026-09-09) — XRP come terza gamba.
|
||||
|
||||
Tre cose vanno protette, e nessuna e' il numero finale:
|
||||
|
||||
1. **Il paginatore.** `_fetch_1h` esiste nella forma che ha perche' Coinbase ha un BUCO su XRP
|
||||
(delistato 2021-01, rilistato 2023-07 dopo la sentenza SEC): un batch vuoto NON deve
|
||||
fermare il ciclo. Un paginatore che si ferma al primo vuoto avrebbe certificato XRP su
|
||||
mezzo campione — e la certificazione decide QUALE lente si usa, cioe' decide il risultato.
|
||||
2. **La regola L-PULITA.** "Dal primo anno in cui tutti i successivi restano sotto soglia":
|
||||
un anno pulito ISOLATO non e' un regime. E' la regola che sceglie la finestra, ed e'
|
||||
dichiarata prima di guardare l'esito — quindi va congelata prima che qualcuno la ritocchi.
|
||||
3. **I tre rami del verdetto**, coi loro AND: AGGIUNGE richiede hold-out E de-levering E anni.
|
||||
|
||||
Piu' il guardrail del namespace: XRP vive in `alt_xrp_*`, e `load_data("XRP")` deve continuare
|
||||
a fallire (il "solo dati certi" di CLAUDE.md non e' codice, e' l'assenza del file).
|
||||
|
||||
⚠️ NESSUN test va in rete: il riferimento Coinbase/Bitstamp o e' in cache o il test si salta.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
import pytest
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT))
|
||||
sys.path.insert(0, str(ROOT / "scripts" / "research"))
|
||||
|
||||
import r0909_xrp_terza_gamba as M # noqa: E402
|
||||
|
||||
RAW = ROOT / "data" / "raw"
|
||||
ORA_MS = 3_600_000
|
||||
T0 = pd.Timestamp("2026-01-01", tz="UTC")
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# (a) _fetch_1h — un batch vuoto NON ferma il ciclo
|
||||
# ===========================================================================================
|
||||
|
||||
class ExFinto:
|
||||
"""Exchange finto e DETERMINISTICO: restituisce un batch vuoto alle chiamate elencate in
|
||||
`vuote` (indici 0-based), altrove `limit` barre orarie a partire da `since`."""
|
||||
|
||||
def __init__(self, vuote=(), righe_prima_di_since=False):
|
||||
self.vuote = set(vuote)
|
||||
self.righe_prima_di_since = righe_prima_di_since
|
||||
self.since_visti: list[int] = []
|
||||
|
||||
def fetch_ohlcv(self, symbol, tf, since=None, limit=None):
|
||||
n = len(self.since_visti)
|
||||
self.since_visti.append(since)
|
||||
assert tf == "1h" and symbol and limit
|
||||
if n in self.vuote:
|
||||
return []
|
||||
base = since - 10 * ORA_MS if self.righe_prima_di_since else since
|
||||
return [[base + i * ORA_MS, 1.0, 1.0, 1.0, 10.0 + n + i, 1.0] for i in range(limit)]
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def orologio_fermo(monkeypatch):
|
||||
"""`_fetch_1h` chiude il ciclo su `time.time()`: qui lo si ferma a T0+72h, cosi' il numero
|
||||
di pagine e' un fatto e non il meteo della macchina. (Il patch vive solo dentro il test.)"""
|
||||
fine = T0 + pd.Timedelta(hours=72)
|
||||
monkeypatch.setattr(M.time, "time", lambda: fine.timestamp())
|
||||
return fine
|
||||
|
||||
|
||||
def test_fetch_1h_AVANZA_dopo_un_batch_vuoto(orologio_fermo):
|
||||
"""IL test di questo file. Coinbase su XRP restituisce vuoto per due anni e mezzo: se il
|
||||
ciclo si fermasse (break) o non facesse avanzare `since` (loop infinito), la certificazione
|
||||
girerebbe su un campione mutilato — e la lente L-PULITA la sceglie la certificazione.
|
||||
DEVE FALLIRE SE: qualcuno sostituisce `since += limit*3_600_000; continue` con un `break`."""
|
||||
ex = ExFinto(vuote={0})
|
||||
s = M._fetch_1h(ex, "XRP/USD", T0, 24)
|
||||
|
||||
assert len(ex.since_visti) >= 2, "il ciclo si e' fermato al primo batch vuoto"
|
||||
assert ex.since_visti[1] == ex.since_visti[0] + 24 * ORA_MS, (
|
||||
"dopo un batch vuoto `since` deve avanzare di un'intera pagina")
|
||||
assert len(s) == 48
|
||||
assert s.index.min() == T0 + pd.Timedelta(hours=24), "la prima pagina era il buco"
|
||||
assert s.index.is_monotonic_increasing and s.index.is_unique
|
||||
|
||||
|
||||
def test_fetch_1h_scavalca_un_buco_IN_MEZZO_e_riprende(orologio_fermo):
|
||||
"""Il buco vero di XRP e' in mezzo (2021-01 → 2023-07), non in testa: il dato PRIMA e quello
|
||||
DOPO devono stare tutti e due nella serie, col buco che resta un buco (D2: una riga assente
|
||||
non si inventa)."""
|
||||
ex = ExFinto(vuote={1})
|
||||
s = M._fetch_1h(ex, "XRP/USD", T0, 24)
|
||||
|
||||
assert len(s) == 48
|
||||
assert s.index.min() == T0
|
||||
assert s.index.max() == T0 + pd.Timedelta(hours=71)
|
||||
buco = s[(s.index >= T0 + pd.Timedelta(hours=24)) & (s.index < T0 + pd.Timedelta(hours=48))]
|
||||
assert len(buco) == 0, "il buco e' stato riempito con qualcosa: non c'era niente da riempire"
|
||||
|
||||
|
||||
def test_fetch_1h_scarta_le_righe_PRIMA_di_since_e_avanza_lo_stesso(orologio_fermo):
|
||||
"""Alcuni venue ignorano `since` e ritornano sempre la stessa pagina: il filtro
|
||||
`x[0] >= since` la svuota, e a quel punto vale la stessa regola del batch vuoto."""
|
||||
ex = ExFinto(righe_prima_di_since=True)
|
||||
s = M._fetch_1h(ex, "XRP/USD", T0, 24)
|
||||
# le prime 10 barre di ogni pagina cadono prima di `since` e vengono scartate
|
||||
assert len(ex.since_visti) >= 2
|
||||
assert ex.since_visti[1] > ex.since_visti[0], "il ciclo si e' impantanato"
|
||||
assert (s.index >= T0).all()
|
||||
|
||||
|
||||
def test_fetch_1h_non_si_impianta_su_una_pagina_da_una_riga(monkeypatch):
|
||||
"""La guardia `since = nxt if nxt > since else since + pagina` esiste per non girare a
|
||||
vuoto: qui ogni chiamata rende UNA barra a `since`, e il ciclo deve comunque terminare."""
|
||||
fine = T0 + pd.Timedelta(hours=5)
|
||||
monkeypatch.setattr(M.time, "time", lambda: fine.timestamp())
|
||||
|
||||
class UnaRiga:
|
||||
def __init__(self):
|
||||
self.n = 0
|
||||
|
||||
def fetch_ohlcv(self, symbol, tf, since=None, limit=None):
|
||||
self.n += 1
|
||||
assert self.n < 50, "ciclo infinito"
|
||||
return [[since, 1.0, 1.0, 1.0, 10.0, 1.0]]
|
||||
|
||||
s = M._fetch_1h(UnaRiga(), "XRP/USD", T0, 24)
|
||||
assert len(s) == 5
|
||||
assert list(s.index) == list(pd.date_range(T0, periods=5, freq="h"))
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# (b) la regola L-PULITA dentro certifica()
|
||||
# ===========================================================================================
|
||||
|
||||
ANNI = (2022, 2023, 2024, 2025, 2026)
|
||||
|
||||
|
||||
def _finto_feed(sporchi: dict[int, int], n: int = 700):
|
||||
"""Feed sintetico: per ogni anno `n` barre orarie, di cui `sporchi[y]` a +2% dal
|
||||
riferimento (cioe' sopra la soglia >1% che definisce una barra sporca)."""
|
||||
dd, rr = [], []
|
||||
for y in ANNI:
|
||||
idx = pd.date_range(f"{y}-01-01", periods=n, freq="h", tz="UTC")
|
||||
rif = np.full(n, 100.0)
|
||||
mio = rif.copy()
|
||||
mio[:sporchi.get(y, 0)] = 102.0
|
||||
dd.append(pd.DataFrame(dict(datetime=idx, close=mio, high=mio + 1.0, low=mio - 1.0)))
|
||||
rr.append(pd.DataFrame(dict(ts=idx, close=rif, fonte="CB")))
|
||||
D = pd.concat(dd, ignore_index=True)
|
||||
R = pd.concat(rr, ignore_index=True).set_index("ts")
|
||||
return D, R
|
||||
|
||||
|
||||
def _certifica(monkeypatch, sporchi: dict[int, int], n: int = 700) -> dict:
|
||||
D, R = _finto_feed(sporchi, n)
|
||||
monkeypatch.setattr(M, "dati", lambda asset, tf: D)
|
||||
monkeypatch.setattr(M, "riferimento_1h", lambda start: R)
|
||||
return M.certifica()
|
||||
|
||||
|
||||
def test_L_PULITA_parte_dal_primo_anno_con_TUTTI_i_successivi_puliti(monkeypatch):
|
||||
"""Lo scenario vero: 2022 e 2023 sporchi (0,57% nel 2023), 2024-2026 puliti → 2024-01-01."""
|
||||
c = _certifica(monkeypatch, {2022: 8, 2023: 4})
|
||||
assert c["per_anno"][2023]["q_1pct"] == pytest.approx(4 / 700, abs=1e-6)
|
||||
assert c["per_anno"][2022]["q_1pct"] > M.SOGLIA_PULITA
|
||||
assert c["puliti"] == [2024, 2025, 2026]
|
||||
assert c["pulita_da"] == pd.Timestamp("2024-01-01", tz="UTC")
|
||||
|
||||
|
||||
def test_L_PULITA_ignora_un_anno_pulito_ISOLATO(monkeypatch):
|
||||
"""La regressione che la regola esiste per impedire: 2022 pulito, 2023 sporco, 2024+ puliti.
|
||||
Un anno pulito isolato NON e' un regime — la lente parte dalla coda pulita finale (2024),
|
||||
non dal 2022. DEVE FALLIRE SE: qualcuno semplifica in `min(puliti)`."""
|
||||
c = _certifica(monkeypatch, {2023: 8})
|
||||
assert c["puliti"] == [2022, 2024, 2025, 2026], "il 2022 e' pulito, e va detto"
|
||||
assert c["pulita_da"] == pd.Timestamp("2024-01-01", tz="UTC"), (
|
||||
"la lente non puo' partire dal 2022: il 2023 in mezzo e' sporco")
|
||||
|
||||
|
||||
def test_L_PULITA_e_tutta_la_storia_se_non_c_e_niente_di_sporco(monkeypatch):
|
||||
c = _certifica(monkeypatch, {})
|
||||
assert c["puliti"] == list(ANNI)
|
||||
assert c["pulita_da"] == pd.Timestamp("2022-01-01", tz="UTC")
|
||||
|
||||
|
||||
def test_L_PULITA_e_NONE_se_nessun_anno_e_pulito(monkeypatch):
|
||||
"""P5: "non c'e' una finestra pulita" ha uno stato suo. `misura()` allora non aggiunge la
|
||||
lente e `verdetto()` ripiega sul 2024+ dichiarato (la lente di SOL)."""
|
||||
c = _certifica(monkeypatch, {y: 8 for y in ANNI})
|
||||
assert c["puliti"] == []
|
||||
assert c["pulita_da"] is None
|
||||
|
||||
|
||||
def test_la_soglia_di_pulizia_e_INCLUSIVA_e_vale_SOGLIA_PULITA(monkeypatch):
|
||||
"""Il confronto e' `<=`: esattamente in soglia l'anno e' pulito. Con n=1000 barre la
|
||||
soglia 0,5% cade su un intero (5 barre), quindi il confine e' asseribile."""
|
||||
c = _certifica(monkeypatch, {2022: 5, 2023: 5, 2024: 5, 2025: 5, 2026: 5}, n=1000)
|
||||
assert c["per_anno"][2022]["q_1pct"] == pytest.approx(M.SOGLIA_PULITA)
|
||||
assert c["puliti"] == list(ANNI)
|
||||
c2 = _certifica(monkeypatch, {2022: 6, 2023: 5, 2024: 5, 2025: 5, 2026: 5}, n=1000)
|
||||
assert 2022 not in c2["puliti"]
|
||||
assert c2["pulita_da"] == pd.Timestamp("2023-01-01", tz="UTC")
|
||||
|
||||
|
||||
def test_certifica_riporta_per_ogni_anno_le_misure_che_la_tabella_stampa(monkeypatch):
|
||||
c = _certifica(monkeypatch, {2022: 8})
|
||||
for y, r in c["per_anno"].items():
|
||||
assert set(r) == {"n", "q_1pct", "med_bps", "fonte", "flat_1h", "flat_5m"}
|
||||
assert r["n"] == 700
|
||||
assert r["flat_1h"] == 0.0, "high != low per costruzione"
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# (c) verdetto() — i tre rami, tutti con AND
|
||||
# ===========================================================================================
|
||||
|
||||
NOME = "L-PULITA (2024+)"
|
||||
|
||||
|
||||
def _m(hold, sh3, sh2k, anni_dsh, nome: str = NOME, k: float = 0.827) -> dict:
|
||||
h = np.asarray(hold, float)
|
||||
z = np.zeros(len(h))
|
||||
return dict(lenti={nome: dict(sh=z, hold=h, dd=z, cagr=z)},
|
||||
delev={nome: dict(k=k, sh3=sh3, sh2k=sh2k, cagr3=0.146, cagr2k=0.134)},
|
||||
anno={2024 + i: dict(dsh=float(v)) for i, v in enumerate(anni_dsh)})
|
||||
|
||||
|
||||
def test_verdetto_AGGIUNGE_solo_se_passano_tutte_e_tre_le_condizioni():
|
||||
v = M.verdetto(_m([0.10] * 24, sh3=1.60, sh2k=1.50, anni_dsh=[0.5, 0.4, -0.1]))
|
||||
assert v.startswith("XRP AGGIUNGE")
|
||||
|
||||
|
||||
def test_verdetto_DILUISCE_quando_cadono_hold_out_E_de_levering():
|
||||
v = M.verdetto(_m([-0.169] * 24, sh3=1.54, sh2k=1.53, anni_dsh=[0.54, -0.44, -0.25]))
|
||||
assert v.startswith("XRP DILUISCE")
|
||||
|
||||
|
||||
def test_verdetto_PARI_quando_le_condizioni_si_contraddicono():
|
||||
"""N5/M8: quando una condizione passa e l'altra no, il verdetto non sceglie la piu' comoda —
|
||||
dichiara che non e' selezionabile."""
|
||||
solo_hold = M.verdetto(_m([0.10] * 24, sh3=1.50, sh2k=1.60, anni_dsh=[0.5, 0.4, -0.1]))
|
||||
assert solo_hold.startswith("XRP: PARI / NON SELEZIONABILE")
|
||||
solo_delev = M.verdetto(_m([-0.10] * 24, sh3=1.60, sh2k=1.50, anni_dsh=[0.5, 0.4, -0.1]))
|
||||
assert solo_delev.startswith("XRP: PARI / NON SELEZIONABILE")
|
||||
|
||||
|
||||
def test_verdetto_chiede_il_75_percento_delle_ancore_non_la_sola_mediana():
|
||||
"""M7/§2: la banda d'ancora NON e' un intervallo di confidenza, ma la robustezza alla scelta
|
||||
dell'ancora e' una condizione a se'. Mediana > 0 con solo il 70% delle ancore positive non
|
||||
basta. DEVE FALLIRE SE: qualcuno lascia solo la mediana."""
|
||||
hold = [0.10] * 16 + [-0.10] * 8 # mediana +0,10, ma >0 solo nel 67% delle ancore
|
||||
v = M.verdetto(_m(hold, sh3=1.60, sh2k=1.50, anni_dsh=[0.5, 0.4, -0.1]))
|
||||
assert not v.startswith("XRP AGGIUNGE")
|
||||
hold_ok = [0.10] * 18 + [-0.10] * 6 # esattamente 75%
|
||||
assert M.verdetto(_m(hold_ok, sh3=1.60, sh2k=1.50,
|
||||
anni_dsh=[0.5, 0.4, -0.1])).startswith("XRP AGGIUNGE")
|
||||
|
||||
|
||||
def test_verdetto_il_de_levering_chiede_un_margine_di_0_02():
|
||||
"""M5: il null del de-levering non si passa "per un pelo" — un vantaggio dentro 0,02 di
|
||||
Sharpe e' de-levering travestito, ed e' esattamente il caso di XRP (1,54 contro 1,53)."""
|
||||
quasi = M.verdetto(_m([0.10] * 24, sh3=1.52, sh2k=1.50, anni_dsh=[0.5, 0.4, -0.1]))
|
||||
assert not quasi.startswith("XRP AGGIUNGE")
|
||||
appena = M.verdetto(_m([0.10] * 24, sh3=1.521, sh2k=1.50, anni_dsh=[0.5, 0.4, -0.1]))
|
||||
assert appena.startswith("XRP AGGIUNGE")
|
||||
|
||||
|
||||
def test_verdetto_ripiega_sulla_lente_di_SOL_se_non_c_e_una_coda_pulita():
|
||||
"""Quando `pulita_da` e' None, `misura()` non crea la lente L-PULITA: il verdetto deve
|
||||
leggere quella dichiarata di riserva, non la prima che capita."""
|
||||
m = _m([-0.10] * 24, sh3=1.50, sh2k=1.60, anni_dsh=[-0.1, -0.2, -0.3],
|
||||
nome="2024+ (lente di SOL)")
|
||||
m["lenti"]["L-FULL"] = dict(sh=np.zeros(24), hold=np.full(24, 9.0),
|
||||
dd=np.zeros(24), cagr=np.zeros(24))
|
||||
m["delev"]["L-FULL"] = dict(k=1.0, sh3=9.0, sh2k=0.0, cagr3=0.0, cagr2k=0.0)
|
||||
v = M.verdetto(m)
|
||||
assert "lente 2024+ (lente di SOL)" in v
|
||||
assert v.startswith("XRP DILUISCE"), "ha letto la L-FULL invece della lente dichiarata"
|
||||
|
||||
|
||||
def test_verdetto_riproduce_ALLA_LETTERA_la_riga_pubblicata_il_09_09():
|
||||
"""M23: i valori sono quelli usciti dalla misura a 24 ancore del 09/09."""
|
||||
m = _m([-0.169] * 24, sh3=1.54, sh2k=1.53, anni_dsh=[0.54, -0.44, -0.25])
|
||||
assert M.verdetto(m) == (
|
||||
"XRP DILUISCE — lente L-PULITA (2024+): dSharpe hold-out mediano -0.169 "
|
||||
"(>0 nel 0% di 24 ancore); de-levering: Sh 3 gambe 1.54 vs 2 gambe×0.827 1.53; "
|
||||
"anni 2024+ con dSh>0: 1/3")
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# (d) il GUARDRAIL del namespace
|
||||
# ===========================================================================================
|
||||
|
||||
def test_il_divieto_su_data_raw_xrp_e_gia_DERIVATO_dal_codice():
|
||||
"""`tests/test_sol_leg.py::test_nessun_asset_fuori_universo_nel_namespace_NUDO` deriva gli
|
||||
asset vietati da `rebuild_history.DERIBIT_INSTR`: finche' XRP e' li' dentro, quel test
|
||||
copre gia' `data/raw/xrp_*.parquet` e qui NON si duplica. Questo test congela la premessa
|
||||
— se qualcuno togliesse XRP dal dict, la guardia sparirebbe in silenzio."""
|
||||
from scripts.analysis.rebuild_history import DERIBIT_INSTR
|
||||
assert "XRP" in DERIBIT_INSTR, (
|
||||
"XRP fuori da DERIBIT_INSTR: il divieto su data/raw/xrp_*.parquet non e' piu' derivato "
|
||||
"da nessuna parte — riscrivere la guardia in test_sol_leg.py prima di toglierlo")
|
||||
|
||||
|
||||
def test_load_data_XRP_continua_a_FALLIRE():
|
||||
"""L'altra meta': il dato XRP dello studio vive in `alt_xrp_*` e il feed attivo non lo vede.
|
||||
Se un giorno `load_data("XRP")` funzionasse, il cron (`--asset BTC ETH`) non lo
|
||||
rinfrescherebbe comunque -> dato stantio che sembra attivo."""
|
||||
from src.data.downloader import load_data
|
||||
with pytest.raises(FileNotFoundError):
|
||||
load_data("XRP", "1h")
|
||||
|
||||
|
||||
def test_lo_studio_legge_il_namespace_di_RICERCA():
|
||||
"""`dati()` importata da r0822_sol_leg instrada XRP su `alt_xrp_*`: se non c'e' il file,
|
||||
l'errore deve dire come rigenerarlo, non fingere che l'asset non esista."""
|
||||
assert M.ASSET == "XRP" and M.TRE == ("BTC", "ETH", "XRP")
|
||||
if (RAW / "alt_xrp_1h.parquet").exists():
|
||||
d = M.dati("XRP", "1h")
|
||||
assert {"close", "datetime"} <= set(d.columns) and len(d) > 0
|
||||
|
||||
|
||||
# ===========================================================================================
|
||||
# (e) INTEGRAZIONE (opzionale: salta senza i dati o senza la cache del riferimento)
|
||||
# ===========================================================================================
|
||||
|
||||
def test_integrazione_xrp_diluisce_anche_a_due_ancore(monkeypatch):
|
||||
"""~2 s. Non riproduce i numeri a 24 ancore (2 ancore sono un'altra misura): riproduce la
|
||||
DIREZIONE, che e' la cosa che decide — dSharpe hold-out mediano negativo e verdetto
|
||||
"XRP DILUISCE", cioe' l'ipotesi a priori confermata."""
|
||||
if not all((RAW / f"alt_xrp_{tf}.parquet").exists() for tf in ("1h", "5m")):
|
||||
pytest.skip("namespace di ricerca alt_xrp_* assente (rigenerabile, gitignored)")
|
||||
if not all((RAW / f"{a}_{tf}.parquet").exists() for a in ("btc", "eth") for tf in ("1h", "5m")):
|
||||
pytest.skip("feed certificato BTC/ETH assente")
|
||||
if not M.CACHE.exists():
|
||||
pytest.skip(f"cache del riferimento assente ({M.CACHE}): il test NON va in rete")
|
||||
|
||||
# cintura: anche se la cache sparisse a meta' test, nessuno tocca la rete
|
||||
def _vietato(*a, **k):
|
||||
raise AssertionError("il test ha provato ad andare in rete (_fetch_1h)")
|
||||
monkeypatch.setattr(M, "_fetch_1h", _vietato)
|
||||
|
||||
m = M.misura(2)
|
||||
assert m["n_anchors"] == 2
|
||||
assert m["cert"]["pulita_da"] == pd.Timestamp("2024-01-01", tz="UTC")
|
||||
|
||||
nome = ([n for n in m["lenti"] if n.startswith("L-PULITA")] or ["2024+ (lente di SOL)"])[0]
|
||||
assert np.median(m["lenti"][nome]["hold"]) < 0, "il dSharpe hold-out ha cambiato segno"
|
||||
assert M.verdetto(m).startswith("XRP DILUISCE")
|
||||
assert m["corr"]["L-FULL"] < 0.74, "la correlazione col book supera la soglia del 19/06"
|
||||
Reference in New Issue
Block a user