Adriano/PythagorasGoal
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
116abf520325cf50ca8319c76c5e63a87afef5ad
PythagorasGoal/tests/test_book_live.py
T
Adriano Dal Pastro 567046953d fix(book): gate fail-safe posizione + diagnostica equity — niente errori silenziosi nel path live 
Terza+quarta chiusura del pattern "eccezione ingoiata -> stato safe silenzioso"
in src/live, dopo skh_error (31369b3). Emerse durante la verifica del gate SKH01.

Opzione A (gate fail-safe posizione):
- shadow._positions: se la read della posizione reale Deribit lancia, assume flat
  MA ora ritorna un pos_error esplicito (prima solo una note mai propagata).
- Propagato shadow_report -> book_report -> book_execute: se ONLINE ma posizione
  IGNOTA, l'esecutore NON opera a cieco (return + alert), come gia' per 'online'.

Opzione B (diagnostica equity, no halt):
- shadow._equity/shadow_report: se ONLINE ma equity reale non leggibile, il book
  ripiega su paper_cap (~$2000) invece del conto reale (~$598) -> sovradimensiona
  ~33%, ma l'hard-cap $300/asset limita il downside. Nuovo flag eq_fallback ->
  book_execute stampa warning + alert Telegram MA prosegue (niente gate: la scelta
  e' solo diagnostica, l'hard-cap gia' protegge).

Test: +8 (4 gate A, 4 diagnostica B). Suite 156/156. Path live pulito
(skh_error/pos_error/eq_fallback = None). Diario 2026-07-01-book-live-error-surfacing.md.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-07-01 22:39:59 +00:00

401 lines
20 KiB
Python
Raw Blame History

"""Test del BOOK DERIBIT-ONLY live (TP01+SKH01 nettati in software, un solo conto).
Coprono: la formula di netting (sizing 75/25 + cap, long/short/flat/flip), la PARITA' coi pesi del
backtest (deribit_book_sleeves), la sicurezza del gate (disarmato -> nessun ordine), e il reconcile
CON SEGNO (close+open sui flip, reduce reduce_only) — senza toccare la rete (trader fittizio).
"""
import sys
from pathlib import Path
PROJECT_ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(PROJECT_ROOT))
from src.live.book import W_SKH, W_TP01, book_net_target, build_book_order
from src.live.execution import Fill
# ---------------------------------------------------------------------------
# Formula di netting: 75/25, cap, combinazioni long/short/flat.
# ---------------------------------------------------------------------------
def test_net_target_sizing():
E, cap = 600.0, 300.0
assert book_net_target(0.0, 0, E, cap) == 0.0 # tutto flat
assert book_net_target(0.0, 1, E, cap) == 75.0 # solo SKH long = 0.25*0.5*600
assert book_net_target(0.0, -1, E, cap) == -75.0 # solo SKH short
assert book_net_target(1.0, 0, E, cap) == 225.0 # solo TP01 pieno = 0.75*0.5*600
assert book_net_target(1.0, -1, E, cap) == 150.0 # TP long + SKH short (hedge parziale)
assert book_net_target(1.0, 1, E, cap) == 300.0 # capped
assert book_net_target(2.0, 1, E, cap) == 300.0 # cap superiore
assert book_net_target(2.0, -1, E, cap) == 300.0 # 0.5*600*(1.5-0.25)=375 -> cap 300
def test_net_target_clamps_negative():
# TP flat e SKH short forte non sfora il cap negativo
assert book_net_target(0.0, -1, 4000.0, 300.0) == -300.0
# tp_frac negativo trattato come 0 (TP01 e' long-flat)
assert book_net_target(-5.0, 1, 600.0, 300.0) == 75.0
def test_weights_match_backtest_sleeves():
"""I pesi del book live DEVONO coincidere con quelli del backtest (deribit_book_sleeves)."""
from src.portfolio.sleeves import deribit_book_sleeves
w = {s.name.split("_")[0]: s.weight for s in deribit_book_sleeves()}
assert abs(w["TP01"] - W_TP01) < 1e-12 and abs(w["SKH01"] - W_SKH) < 1e-12
assert abs((W_TP01 + W_SKH) - 1.0) < 1e-12
# ---------------------------------------------------------------------------
# Costruzione ordine: side, reduce_only, flip, close, soglia minima.
# ---------------------------------------------------------------------------
def test_build_order_open_long():
o = build_book_order("BTC_USDC-PERPETUAL", 75.0, 0.0, 60000.0, min_usd=5.0)
assert o["side"] == "buy" and not o["reduce_only"] and not o["needs_flip"] and not o["is_close"]
def test_build_order_reduce_same_sign():
o = build_book_order("BTC_USDC-PERPETUAL", 75.0, 150.0, 60000.0)
assert o["side"] == "sell" and o["reduce_only"] and not o["needs_flip"]
def test_build_order_flip():
o = build_book_order("BTC_USDC-PERPETUAL", -75.0, 75.0, 60000.0)
assert o["needs_flip"] and o["side"] == "sell"
def test_build_order_close_to_flat():
o = build_book_order("BTC_USDC-PERPETUAL", 0.0, 75.0, 60000.0)
assert o["is_close"] and o["reduce_only"] and o["side"] == "sell"
def test_build_order_below_min_is_none():
assert build_book_order("BTC_USDC-PERPETUAL", 75.0, 73.0, 60000.0, min_usd=5.0) is None
assert build_book_order("BTC_USDC-PERPETUAL", 0.0, 0.0, 60000.0) is None
# ---------------------------------------------------------------------------
# Sicurezza del GATE: disarmato (execution_enabled=false) -> do_execute False.
# ---------------------------------------------------------------------------
def test_gate_requires_both_switches():
def do_execute(enabled, want_execute):
return bool(want_execute) and bool(enabled)
assert not do_execute(False, False)
assert not do_execute(True, False) # armato ma senza --execute
assert not do_execute(False, True) # --execute ma disarmato
assert do_execute(True, True) # solo con entrambi
def test_config_default_disarmed(tmp_path, monkeypatch):
"""load_config di book_execute mette execution_enabled=False di default (fail-safe)."""
import importlib
be = importlib.import_module("scripts.live.book_execute") if False else None
# carica il modulo via path (scripts/ non e' un package importabile per nome)
import importlib.util
spec = importlib.util.spec_from_file_location("book_execute", PROJECT_ROOT / "scripts/live/book_execute.py")
mod = importlib.util.module_from_spec(spec); spec.loader.exec_module(mod)
monkeypatch.setattr(mod, "CONFIG", tmp_path / "nope.json") # config assente
assert mod.load_config()["execution_enabled"] is False
# ---------------------------------------------------------------------------
# Reconcile CON SEGNO (long/short/flip) senza rete: trader fittizio.
# ---------------------------------------------------------------------------
class FakeTrader:
"""Replica la logica di DeribitTrader.rebalance_signed registrando le chiamate, senza rete."""
def __init__(self, pos):
self.pos = float(pos)
self.calls = []
def position_usd(self, instrument):
return self.pos
def _mk(self, side, amount, reduce_only, label):
self.calls.append((label, side, round(amount, 6), reduce_only))
return Fill(instrument="X", side=side, amount=amount, filled=amount, price=60000.0,
fee_usdc=0.0, order_id="1", state="filled", verified=True)
def close(self, instrument, label="x"):
if abs(self.pos) < 1.0:
return None
f = self._mk("sell" if self.pos > 0 else "buy", abs(self.pos) / 60000.0, True, label)
self.pos = 0.0
return f
def open(self, instrument, side, amount, label="x"):
f = self._mk(side, amount, False, label)
self.pos += (amount * 60000.0) * (1 if side == "buy" else -1)
return f
def _submit(self, instrument, side, amount, *, reduce_only, label, **k):
f = self._mk(side, amount, reduce_only, label)
self.pos += (amount * 60000.0) * (1 if side == "buy" else -1)
return f
# importa il metodo reale da DeribitTrader (testiamo proprio quella logica)
from src.live.execution import DeribitTrader as _DT
rebalance_signed = _DT.rebalance_signed
def test_reconcile_open_from_flat():
t = FakeTrader(0.0)
t.rebalance_signed("BTC_USDC-PERPETUAL", 75.0, 60000.0, min_usd=5.0)
labels = [c[0] for c in t.calls]
assert labels == ["book-open"] and t.calls[0][1] == "buy"
def test_reconcile_flip_closes_then_opens():
t = FakeTrader(75.0) # long, target short -> flip
t.rebalance_signed("BTC_USDC-PERPETUAL", -75.0, 60000.0, min_usd=5.0)
labels = [c[0] for c in t.calls]
assert labels == ["book-flip-close", "book-open"]
assert t.calls[1][1] == "sell" # apre short dopo il close
def test_reconcile_reduce_same_sign_is_reduce_only():
t = FakeTrader(150.0)
t.rebalance_signed("BTC_USDC-PERPETUAL", 75.0, 60000.0, min_usd=5.0)
assert [c[0] for c in t.calls] == ["book-reduce"]
assert t.calls[0][3] is True # reduce_only
def test_reconcile_target_flat_closes():
t = FakeTrader(75.0)
t.rebalance_signed("BTC_USDC-PERPETUAL", 0.0, 60000.0, min_usd=5.0)
assert [c[0] for c in t.calls] == ["book-exit"]
def test_reconcile_below_min_noop():
t = FakeTrader(73.0)
t.rebalance_signed("BTC_USDC-PERPETUAL", 75.0, 60000.0, min_usd=5.0)
assert t.calls == []
# ---------------------------------------------------------------------------
# PARITA' d'integrazione: il report reale (offline, niente rete) applica ESATTAMENTE
# la formula pura per ogni asset -> wiring corretto e riproducibile.
# ---------------------------------------------------------------------------
# ---------------------------------------------------------------------------
# Feed live effimero (src/live/livefeed): merge/dedup, fallback, loader onorato.
# Nessuna rete (la coda fresca è iniettata / il fetch è stubbato a errore).
# ---------------------------------------------------------------------------
def test_merge_tail_dedups_and_tail_wins():
import pandas as pd
from src.live.livefeed import merge_tail
base = pd.DataFrame({"timestamp": [0, 300000, 600000], "open": [1, 2, 3], "high": [1, 2, 3],
"low": [1, 2, 3], "close": [1, 2, 3], "volume": [1, 1, 1],
"datetime": pd.to_datetime([0, 300000, 600000], unit="ms", utc=True)})
tail = pd.DataFrame({"timestamp": [600000, 900000], "open": [9, 4], "high": [9, 4],
"low": [9, 4], "close": [9, 4], "volume": [2, 2]})
m = merge_tail(base, tail)
assert list(m["timestamp"]) == [0, 300000, 600000, 900000] # esteso + ordinato
assert m.loc[m["timestamp"] == 600000, "close"].iloc[0] == 9 # la coda VINCE sul duplicato
assert "datetime" in m.columns and m["datetime"].is_monotonic_increasing
def test_merge_tail_empty_returns_base():
import pandas as pd
from src.live.livefeed import merge_tail
base = pd.DataFrame({"timestamp": [0], "open": [1], "high": [1], "low": [1], "close": [1], "volume": [1]})
assert merge_tail(base, pd.DataFrame()).equals(base)
def test_fresh_5m_falls_back_to_certified_on_error(monkeypatch):
import src.live.livefeed as lf
from src.data.downloader import load_data
monkeypatch.setattr(lf, "_fetch_recent_5m", lambda *a, **k: (_ for _ in ()).throw(RuntimeError("net")))
got = lf.fresh_5m("BTC")
base = load_data("BTC", "5m")
assert len(got) == len(base) and got["timestamp"].iloc[-1] == base["timestamp"].iloc[-1]
def test_skyhook_positions_honors_custom_loader():
from src.portfolio import sleeves
calls = []
def spy(a):
calls.append(a)
return sleeves.load_data(a, "5m")
pos = sleeves._skyhook_positions(load5m=spy)
assert set(pos.keys()) == {"BTC", "ETH"} and calls == ["BTC", "ETH"]
def test_book_report_uses_pure_formula_offline():
from src.live.book import book_report
r = book_report(offline=True, equity_override=600.0)
assert r["equity"] == 600.0 and r["cap_per_asset"] > 0
for a in r["assets"]:
expect = book_net_target(a["tp_frac"], a["skh_sign"], 600.0, r["cap_per_asset"])
assert abs(a["net_target"] - expect) < 1e-6, f"{a['asset']}: net incoerente con la formula"
assert a["skh_sign"] in (-1, 0, 1)
# offline -> conto assunto flat -> nessuna posizione reale, report deterministico
assert all(a["position_usd"] == 0.0 for a in r["assets"])
# ---------------------------------------------------------------------------
# SKH feed fallito: book_report NON crasha (forza flat + flagga skh_error) e
# book_execute DEVE farlo emergere (log + alert), non ingoiarlo silenziosamente.
# ---------------------------------------------------------------------------
def test_book_report_flags_skh_feed_error(monkeypatch):
import src.live.book as book
monkeypatch.setattr(book, "_skyhook_positions",
lambda *a, **k: (_ for _ in ()).throw(RuntimeError("feed 5m giu")))
r = book.book_report(offline=True, equity_override=600.0)
assert "skh_error" in r and "feed 5m giu" in r["skh_error"] # errore catturato + esposto
assert all(a["skh_sign"] == 0 for a in r["assets"]) # SKH forzato flat (fail-safe)
def test_book_execute_surfaces_skh_error(monkeypatch, capsys):
"""Se il report porta skh_error, _run() lo stampa E chiama notify (niente flat silenzioso)."""
import importlib.util
spec = importlib.util.spec_from_file_location("book_execute", PROJECT_ROOT / "scripts/live/book_execute.py")
mod = importlib.util.module_from_spec(spec); spec.loader.exec_module(mod)
canned = dict(
last_data="2026-07-01", online=True, real_equity=600.0, equity=600.0, eq_basis="test",
cap_per_asset=300.0, skh_error="RuntimeError: feed 5m giu",
assets=[dict(asset="BTC", instrument="BTC_USDC-PERPETUAL", tp_frac=0.0, skh_sign=0,
skh_state="flat", net_target=0.0, position_usd=0.0, mark=60000.0, order=None)],
orders=[],
)
alerts = []
monkeypatch.setattr(mod, "book_report", lambda **k: canned)
monkeypatch.setattr(mod, "notify", lambda title, det=None: alerts.append((title, det)))
monkeypatch.setattr(mod, "load_config",
lambda: dict(execution_enabled=False, min_order_usd=5.0, disaster_sl_pct=0.30))
monkeypatch.setattr(sys, "argv", ["book_execute.py"]) # niente --execute -> dry-run
mod._run()
out = capsys.readouterr().out
assert "SKH FEED ERRORE" in out # stampato nel log
assert any("SKH feed fallito" in title for title, _ in alerts) # alert inviato
# ---------------------------------------------------------------------------
# GATE FAIL-SAFE posizione: se la read della posizione reale fallisce (ONLINE ma
# posizione IGNOTA -> assunta flat), l'esecutore NON deve operare a cieco.
# ---------------------------------------------------------------------------
def test_positions_flags_read_failure():
from src.live.shadow import ASSETS, _positions
class BadClient:
def position_usd(self, inst):
raise RuntimeError("api 500")
pos, note, err = _positions(BadClient())
assert all(pos[a] == 0.0 for a in ASSETS) # assunta flat (fail-safe)
assert err is not None and "non leggibile" in err # ma SEGNALATA (non silenziosa)
def test_positions_ok_and_offline_have_no_error():
from src.live.shadow import ASSETS, _positions
class GoodClient:
def position_usd(self, inst):
return 123.0
_, _, err_ok = _positions(GoodClient())
_, _, err_off = _positions(None) # offline -> gestito dal gate 'online'
assert err_ok is None and err_off is None
def test_book_report_propagates_pos_error(monkeypatch):
import src.live.book as book
base = book.shadow_report(offline=True, equity_override=600.0)
monkeypatch.setattr(book, "shadow_report", lambda **k: {**base, "pos_error": "IGNOTA"})
r = book.book_report(offline=True, equity_override=600.0)
assert r.get("pos_error") == "IGNOTA" # propagato fino al book
def test_book_execute_halts_on_unreadable_position(monkeypatch, capsys):
"""ARMATO + --execute + ordine presente: il gate DEVE fermarsi PRIMA di costruire il trader."""
import importlib.util
spec = importlib.util.spec_from_file_location("book_execute", PROJECT_ROOT / "scripts/live/book_execute.py")
mod = importlib.util.module_from_spec(spec); spec.loader.exec_module(mod)
canned = dict(
last_data="2026-07-01", online=True, real_equity=598.0, equity=598.0, eq_basis="mainnet USDC",
cap_per_asset=300.0, skh_error=None,
pos_error="posizione non leggibile, assunta FLAT: BTC (RuntimeError: api 500)",
assets=[dict(asset="BTC", instrument="BTC_USDC-PERPETUAL", tp_frac=1.0, skh_sign=1,
skh_state="flat", net_target=225.0, position_usd=0.0, mark=60000.0,
order=dict(side="buy"))], # ordine presente: senza gate proverebbe a eseguire
orders=[dict(side="buy")],
)
alerts = []
monkeypatch.setattr(mod, "book_report", lambda **k: canned)
monkeypatch.setattr(mod, "notify", lambda title, det=None: alerts.append((title, det)))
monkeypatch.setattr(mod, "load_config",
lambda: dict(execution_enabled=True, min_order_usd=5.0, disaster_sl_pct=0.30))
monkeypatch.setattr(sys, "argv", ["book_execute.py", "--execute"]) # ARMATO + execute
def boom(*a, **k):
raise AssertionError("DeribitTrader NON deve essere costruito: il gate deve fermarsi prima")
monkeypatch.setattr(mod, "DeribitTrader", boom)
mod._run()
out = capsys.readouterr().out
assert "POSIZIONE NON LEGGIBILE" in out # stampato
assert any("posizione non leggibile" in t for t, _ in alerts) # alert inviato
# ---------------------------------------------------------------------------
# DIAGNOSTICA equity (Opzione B): ONLINE ma equity reale non leggibile -> sizing su
# paper_cap. NON blocca (l'hard-cap $/asset protegge), ma DEVE essere segnalato.
# ---------------------------------------------------------------------------
def test_shadow_flags_eq_fallback_when_online_but_equity_unreadable(monkeypatch):
import src.live.shadow as sh
monkeypatch.setattr(sh, "_safe_client", lambda: object()) # online
monkeypatch.setattr(sh, "_marks", lambda c, d: ({a: 60000.0 for a in sh.ASSETS},
{a: "mainnet" for a in sh.ASSETS}))
monkeypatch.setattr(sh, "_positions", lambda c: ({a: 0.0 for a in sh.ASSETS}, "mainnet", None))
monkeypatch.setattr(sh, "_equity", lambda c, m: (None, "conto flat / non finanziato")) # equity IGNOTA
r = sh.shadow_report() # online, no override
assert r["online"] is True and r["real_equity"] is None
assert r.get("eq_fallback") and "paper_cap" in r["eq_fallback"] # fallback SEGNALATO
def test_shadow_no_eq_fallback_offline_or_override():
from src.live.shadow import shadow_report
assert shadow_report(offline=True, equity_override=600.0).get("eq_fallback") is None # override
assert shadow_report(offline=True).get("eq_fallback") is None # offline != fallback-online
def test_book_report_propagates_eq_fallback(monkeypatch):
import src.live.book as book
base = book.shadow_report(offline=True, equity_override=600.0)
monkeypatch.setattr(book, "shadow_report", lambda **k: {**base, "eq_fallback": "PAPER_CAP"})
assert book.book_report(offline=True, equity_override=600.0).get("eq_fallback") == "PAPER_CAP"
def test_book_execute_eq_fallback_warns_but_proceeds(monkeypatch, capsys):
"""eq_fallback: avvisa + notify MA PROSEGUE (non e' un halt, a differenza di pos_error)."""
import importlib.util
spec = importlib.util.spec_from_file_location("book_execute", PROJECT_ROOT / "scripts/live/book_execute.py")
mod = importlib.util.module_from_spec(spec); spec.loader.exec_module(mod)
canned = dict(
last_data="2026-07-01", online=True, real_equity=None, equity=2000.0,
eq_basis="paper capital (ipotetico)", cap_per_asset=300.0, skh_error=None, pos_error=None,
eq_fallback="equity reale non leggibile (conto flat) -> sizing su paper_cap $2,000",
assets=[dict(asset="BTC", instrument="BTC_USDC-PERPETUAL", tp_frac=0.0, skh_sign=0,
skh_state="flat", net_target=0.0, position_usd=0.0, mark=60000.0, order=None)],
orders=[],
)
alerts = []
class FakeDT:
def ensure_disaster_sl(self, inst, sl_pct): return {"state": "flat"}
def position_usd(self, inst): return 0.0
monkeypatch.setattr(mod, "book_report", lambda **k: canned)
monkeypatch.setattr(mod, "notify", lambda title, det=None: alerts.append((title, det)))
monkeypatch.setattr(mod, "DeribitTrader", lambda: FakeDT())
monkeypatch.setattr(mod, "load_config",
lambda: dict(execution_enabled=True, min_order_usd=5.0, disaster_sl_pct=0.30))
monkeypatch.setattr(sys, "argv", ["book_execute.py", "--execute"])
mod._run()
out = capsys.readouterr().out
assert "EQUITY FALLBACK" in out # avvisato
assert any("equity fallback" in t for t, _ in alerts) # alert inviato
assert "Nessuna azione" in out # HA PROSEGUITO (non halt)
Reference in New Issue View Git Blame Copy Permalink