Adriano Dal Pastro
835e0c8666
Quattro segnalazioni della revisione sui commit di oggi, tutte verificate e riparate. 1. book_execute.py (+ CLAUDE.md §5.7, memoria 40): «il disaster-SL rotolante si ri-ancora ogni ora» era falso — ensure_disaster_sl lascia il bracket finche' lo stop e' entro il 5% e la taglia entro il 10%; il giro orario CONTROLLA, ri-ancora oltre la tolleranza (mark +5,263%/-4,762%). Lo stop siede fra -26,3% e -33,3% dal mark corrente. 2. journal.rendimento_twr: limite dichiarato (D5) — l'intervallo che contiene un movimento certo esce intero dal rendimento, il suo P&L di mercato va in `certi`; errore massimo meta' del movimento per costruzione (25/08: ~$0,5). Non si stima (P12). Segmenti a lunghezza zero non prodotti; nessun tempo a mercato -> 0,0 dichiarato numero. 3. base di equity zero: `twr` E `trading` None con motivo (il salto 0->X e' invisibile al classificatore, `trading` valeva l'intero conto); il report stampa n/d. 4. test_book_cadenza: la guardia estrae ogni prescrizione «ogni/every N unita'» e pretende 60 minuti, con controllo positivo (M15); limite P13 dichiarato. Test +5 (847 verdi). Diari 02/09 e 02/09b con la sezione "Revisione". Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01RziUCB336YPUUyDJ29x4Ke
355 lines
20 KiB
Python
355 lines
20 KiB
Python
"""BOOK DERIBIT-ONLY LIVE EXECUTE — TP01 + SKH01 NETTATI in software su un solo conto Deribit mainnet.
|
|
|
|
Porta il conto reale al target NETTO per asset (vedi src/live/book.py): per ogni asset combina la
|
|
frazione long-flat di TP01 (peso 0.75) e il segno L/S di SKH01 (peso 0.25), e manda UN ordine con
|
|
segno (long/short/flip) per raggiungerlo. Poi assicura un disaster-SL on-book sulla posizione NETTA.
|
|
|
|
DOPPIO GATE DI SICUREZZA (entrambi necessari per inviare ordini reali):
|
|
1. config/live.json -> "execution_enabled": true (master switch, default false)
|
|
2. flag CLI --execute
|
|
Senza entrambi e' un DRY-RUN (stampa il piano, NON invia). Reconciliation dopo ogni ordine; log in
|
|
data/live/book_executions.jsonl.
|
|
|
|
⚠️ CADENZA: ORARIA — `47 * * * *` in `scripts/cron_book.sh` (il minuto e' spiegato li'). SKH01
|
|
decide su griglia 230m, ma il giro e' IDEMPOTENTE (riconcilia al target netto corrente: se non
|
|
cambia nulla -> HOLD), quindi girare piu' fitto della griglia non costa ordini e compra due cose
|
|
misurate: (1) gli ingressi/uscite SOFTWARE di SKH01 arrivano con latenza <=1h invece che fino a
|
|
230m; (2) il disaster-SL rotolante (-30%, l'unico on-book) viene CONTROLLATO ogni ora e
|
|
ri-ancorato solo oltre la tolleranza di `ensure_disaster_sl` (stop a >5% da quello piazzato, cioe'
|
|
mark +5,263%/-4,762%, o taglia >10%) — con questa isteresi a cadenza 1h in 7-8 anni BTC 0 scatti /
|
|
ETH 1, sulla riga 4h BTC ne fa 2 (`r0823_sl_anchor.py`). Lo stop siede quindi fra -26,3% e -33,3%
|
|
dal mark corrente, non a -30% dall'ultima ora: e' rotolante, non un massimo di perdita (CLAUDE.md §1).
|
|
🚨 NON "correggere" la cadenza a ~230 minuti: fino al 2026-09-02 questo docstring lo prescriveva,
|
|
ed era il docstring a essere sbagliato, non il cron (debito §5.7). `tests/test_book_cadenza.py`
|
|
tiene d'accordo docstring, `cron_book.sh` e crontab installata. NON il cron giornaliero: le entrate
|
|
di SKH01 le mancherebbe.
|
|
|
|
uv run python scripts/live/book_execute.py # DRY-RUN (piano, nessun ordine)
|
|
uv run python scripts/live/book_execute.py --execute # esegue SOLO se execution_enabled=true
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
from datetime import datetime, timezone
|
|
|
|
import pandas as pd
|
|
|
|
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
|
sys.path.insert(0, str(PROJECT_ROOT))
|
|
|
|
from src.live.book import ScalaNonAutorizzata, book_report
|
|
from src.live.execution import DeribitTrader
|
|
from src.live.notifier import notify
|
|
from src.live.venue_probe import diagnose, errori_dal_report
|
|
|
|
CONFIG = PROJECT_ROOT / "config" / "live.json"
|
|
LOG_DIR = PROJECT_ROOT / "data" / "live"
|
|
LOG = LOG_DIR / "book_executions.jsonl"
|
|
|
|
|
|
def load_config() -> dict:
|
|
cfg = json.loads(CONFIG.read_text()) if CONFIG.exists() else {}
|
|
cfg.setdefault("execution_enabled", False)
|
|
cfg.setdefault("max_notional_per_asset_usd", 300.0)
|
|
cfg.setdefault("min_order_usd", 5.0)
|
|
cfg.setdefault("disaster_sl_pct", 0.30)
|
|
cfg.setdefault("max_data_age_days", 2.0)
|
|
cfg.setdefault("skh_feed_max_age_min", 30.0)
|
|
return cfg
|
|
|
|
|
|
def _data_age_days(last_data) -> float | None:
|
|
"""Eta' in giorni dell'ultima barra del feed certificato. None se non interpretabile
|
|
(trattata come stantia: meglio non operare che operare su una data che non so leggere)."""
|
|
if last_data in (None, ""):
|
|
return None
|
|
try:
|
|
ts = pd.Timestamp(last_data)
|
|
ts = ts.tz_localize("UTC") if ts.tz is None else ts.tz_convert("UTC")
|
|
return float((pd.Timestamp.now(tz="UTC") - ts).total_seconds() / 86400.0)
|
|
except Exception:
|
|
return None
|
|
|
|
|
|
def log_event(rec: dict):
|
|
LOG_DIR.mkdir(parents=True, exist_ok=True)
|
|
with open(LOG, "a") as f:
|
|
f.write(json.dumps(rec) + "\n")
|
|
|
|
|
|
def _run():
|
|
cfg = load_config()
|
|
want_execute = "--execute" in sys.argv[1:]
|
|
enabled = bool(cfg["execution_enabled"])
|
|
do_execute = want_execute and enabled
|
|
min_order = float(cfg["min_order_usd"])
|
|
sl_pct = float(cfg["disaster_sl_pct"])
|
|
|
|
try:
|
|
r = book_report(live_feed=True) # target NETTO + conto/posizioni reali (feed SKH fresco)
|
|
except ScalaNonAutorizzata as e:
|
|
# G1(c): NON si taglia al tetto. Un clamp silenzioso farebbe girare una config che dichiara
|
|
# un numero e un libro che ne esegue un altro. Si ferma, non invia, e allerta.
|
|
msg = (f"🚨 SCALA NON AUTORIZZATA — book_execute FERMO, nessun ordine inviato.\n{e}\n"
|
|
f"Ripara: riporta `book_scale_k` a un gradino di SCALA_LADDER dentro il tetto, "
|
|
f"oppure rimuovi la chiave (assente = 1,00 = libro di oggi).")
|
|
print(msg)
|
|
try:
|
|
notify(msg)
|
|
except Exception as ne: # P3: l'errore si registra dove lo si ingoia
|
|
print(f" ⚠️ allerta NON inviata: {type(ne).__name__}: {ne}")
|
|
return
|
|
equity = r["equity"]
|
|
|
|
print("=" * 88)
|
|
print(" BOOK DERIBIT LIVE EXECUTE — TP01(0.75)+SKH01(0.25) NETTATI — Deribit mainnet (USDC linear)")
|
|
print("=" * 88)
|
|
mode = ("ESECUZIONE REALE" if do_execute else
|
|
("ARMATO ma manca --execute" if enabled else "DRY-RUN (execution_enabled=false)"))
|
|
print(f" modo : {mode}")
|
|
print(f" gate : execution_enabled={enabled} | --execute={want_execute}")
|
|
print(f" conto reale : ${r['real_equity']:,.2f}" if r["real_equity"] else f" conto: {r['eq_basis']}")
|
|
_sc = r.get("scala", 1.0)
|
|
_lordo = len(r["assets"]) * float(cfg.get("max_notional_per_asset_frac") or 0.0) * _sc
|
|
print(f" sizing base : ${equity:,.2f} | cap/asset ${r['cap_per_asset']:.0f} | "
|
|
f"min ${min_order:.0f} | disaster-SL -{sl_pct*100:.0f}%")
|
|
# La scala e' stampata SEMPRE, anche a 1,00: un parametro che muove il nozionale e non compare
|
|
# nel log e' invisibile proprio nel giro in cui e' cambiato (SPEC-scale-key §2.2).
|
|
print(f" scala libro : {_sc:.2f}x (tetto {r.get('leva_lorda_max', 1.25):.2f}x) | "
|
|
f"leva lorda max {_lordo:.3f}x dell'equity"
|
|
+ ("" if _sc != 1.0 else " [chiave assente o 1,00 = libro invariato]"))
|
|
print(f" ultima barra : {r['last_data']}\n")
|
|
|
|
if r.get("skh_error"): # SKH feed fallito -> book.py ha forzato flat IN SILENZIO
|
|
print(f" ⚠️ SKH FEED ERRORE (SKH forzato flat!): {r['skh_error']}")
|
|
notify("⚠️ BOOK — SKH feed fallito (sleeve forzato flat)", {"error": r["skh_error"]})
|
|
|
|
# --- FRESCHEZZA del feed 5m usato per il segnale SKH (2026-07-26) --------------------------
|
|
# `fresh_5m` ricade sul feed certificato IN SILENZIO se il fetch pubblico Deribit fallisce, e
|
|
# il certificato lo ricostruisce il cron una volta al giorno. Non solleva, non logga: senza
|
|
# questo controllo la latenza d'uscita di SKH01 passa da ~1h a ~1 GIORNO senza che nulla lo
|
|
# dica. E' proprio la latenza d'uscita dove vive la qualita' del path live (misura 2026-07-26).
|
|
# SCELTA DICHIARATA: allerta, NON blocca. Bloccare fermerebbe anche il ribilancio di TP01
|
|
# (sono nettati sullo stesso strumento) per un guasto di rete; e forzare SKH flat chiuderebbe
|
|
# posizioni buone su un glitch. La decisione resta all'operatore.
|
|
skh_age = r.get("skh_feed_age_min")
|
|
max_skh_age = float(cfg.get("skh_feed_max_age_min", 30.0))
|
|
if skh_age is None:
|
|
print(" ⚠️ freschezza feed SKH NON MISURATA (segnale su feed certificato?)")
|
|
elif skh_age > max_skh_age:
|
|
# La CAUSA e' misurata (livefeed.last_fetch_error), non piu' presunta: fino al 29/07 questa
|
|
# nota diceva sempre "fetch pubblico KO" a prescindere — una presunzione stampata come se
|
|
# fosse una misura. Quel giorno il feed e' stato stantio in 6 giri orari su 8 (fino a 685
|
|
# min) e la causa NON e' stata stabilita, proprio perche' l'unica riga disponibile era
|
|
# questa e non veniva dai dati.
|
|
errs = r.get("skh_feed_errors") or {}
|
|
causa = "; ".join(f"{a}: {e}" for a, e in sorted(errs.items())) if errs else \
|
|
"coda fresca attaccata: il feed certificato stesso e' vecchio (rebuild giornaliero?)"
|
|
print(f" ⚠️ FEED SKH STANTIO: ultima barra 5m di {skh_age:.0f} min fa "
|
|
f"(soglia {max_skh_age:.0f}) -> le uscite SKH sono in ritardo, NON blocco.")
|
|
print(f" causa: {causa}")
|
|
if do_execute:
|
|
notify("⚠️ BOOK — feed SKH stantio (uscite in ritardo)",
|
|
{"eta_min": round(skh_age), "soglia_min": round(max_skh_age),
|
|
"effetto": "SL/TP di SKH01 rilevati in ritardo",
|
|
"causa": causa[:300]})
|
|
else:
|
|
print(f" feed SKH : fresco ({skh_age:.0f} min)")
|
|
|
|
if not r["online"]:
|
|
# `online` e' falso quando il mark di BTC non viene da mainnet: la ragione sta in
|
|
# `mark_src` ("fallback close (<Eccezione>)") ma non veniva MAI stampata, quindi
|
|
# l'allerta diceva solo "conto offline" — vero e inutile. Stesso buco del feed SKH.
|
|
#
|
|
# DAL 2026-08-25 la riga dice anche DI CHI E' IL GUASTO (P4: *cosa* e *perche'*). Fino a
|
|
# ieri "conto offline" copriva due cause con azioni opposte: Deribit in manutenzione
|
|
# (attesa, rientra da sola, azione nessuna) e il nostro gateway rotto (4 dei 5 traceback
|
|
# in 63 giorni, ed e' l'unico pezzo riparabile). Vedi src/live/venue_probe.py.
|
|
srcs = "; ".join(f"{a['asset']}: {a.get('mark_src')}" for a in r["assets"])
|
|
d = diagnose(errori_dal_report(r))
|
|
print(f" conto non leggibile (offline) -> stop, non eseguo a cieco.\n mark: {srcs}")
|
|
print(f" diagnosi: {d.riga()}")
|
|
if do_execute:
|
|
# P9: un allarme MASSIMO speso per un evento ATTESO e' un allarme che non verra'
|
|
# letto il giorno che e' vero. `atteso` declassa la gravita', NON registra di meno.
|
|
notify(f"{d.gravita} BOOK LIVE — conto offline ({d.verdetto})",
|
|
{"nota": "salto l'esecuzione, non opero a cieco",
|
|
"perche": d.perche, "atteso": "si'" if d.atteso else "no",
|
|
"riparabile_da_noi": "si'" if d.riparabile_da_noi else "no",
|
|
"mark": srcs[:200], "prova": d.prova[:200]})
|
|
return
|
|
|
|
if r.get("pos_error"): # ONLINE ma posizione IGNOTA (read fallita -> assunta flat)
|
|
d = diagnose(errori_dal_report(r))
|
|
print(f" 🛑 POSIZIONE NON LEGGIBILE -> NON eseguo a cieco: {r['pos_error']}")
|
|
print(f" diagnosi: {d.riga()}")
|
|
if do_execute:
|
|
notify(f"{d.gravita} BOOK LIVE — posizione non leggibile ({d.verdetto})",
|
|
{"error": r["pos_error"], "nota": "salto l'esecuzione, non opero a cieco",
|
|
"perche": d.perche, "atteso": "si'" if d.atteso else "no",
|
|
"riparabile_da_noi": "si'" if d.riparabile_da_noi else "no",
|
|
"prova": d.prova[:200]})
|
|
return
|
|
|
|
stale_days = _data_age_days(r.get("last_data"))
|
|
# .get col default: un chiamante che passa una config senza la chiave deve ricadere sulla
|
|
# soglia sicura, non sollevare KeyError dentro il percorso d'esecuzione con soldi veri.
|
|
max_age = float(cfg.get("max_data_age_days", 2.0))
|
|
if stale_days is None or stale_days > max_age:
|
|
# FEED STANTIO -> non eseguo. Il 2026-07-14 il book ha comprato ETH con l'ultima barra
|
|
# ferma al 07-08 (feed congelato 6 giorni, diario 2026-07-15-feed-freeze): il conto era
|
|
# online e la posizione leggibile, quindi i due gate esistenti NON scattavano. Il segnale
|
|
# TP01 viene dal feed su disco: se e' vecchio, si opera alla cieca su dati morti.
|
|
# Il disaster-SL on-book resta la rete di sicurezza su eventuali posizioni aperte.
|
|
eta = "ignota" if stale_days is None else f"{stale_days:.0f}g"
|
|
print(f" 🛑 FEED STANTIO (ultima barra {r.get('last_data')}, eta' {eta} > {max_age:.0f}g)"
|
|
" -> NON eseguo su dati morti.")
|
|
print(" Sbloccare con: uv run python scripts/analysis/rebuild_history.py --asset BTC ETH")
|
|
if do_execute:
|
|
notify("🛑 BOOK LIVE — FEED STANTIO, esecuzione saltata",
|
|
{"ultima_barra": str(r.get("last_data")), "eta": eta,
|
|
"soglia": f"{max_age:.0f}g",
|
|
"azione": "rebuild_history.py --asset BTC ETH"})
|
|
return
|
|
|
|
if r.get("eq_fallback"): # equity reale non leggibile -> sizing su paper_cap
|
|
print(f" ⚠️ EQUITY FALLBACK (sizing su paper_cap, NON blocco): {r['eq_fallback']}")
|
|
if do_execute: # solo diagnostica: l'hard-cap $/asset limita il downside
|
|
notify("⚠️ BOOK LIVE — equity fallback (sizing su paper_cap)", {"nota": r["eq_fallback"]})
|
|
|
|
# Salto di equity: un versamento (conferma che il sizing lo ha seguito) oppure un movimento
|
|
# NON richiesto (prelievo, perdita anomala). In entrambi i casi va detto subito, e con il
|
|
# nuovo dimensionamento accanto, cosi' il messaggio si legge senza aprire il repo.
|
|
jump = r.get("equity_jump")
|
|
if jump:
|
|
verso = "VERSAMENTO" if jump["pct"] > 0 else "USCITA DI FONDI"
|
|
lordo = 2 * r["cap_per_asset"]
|
|
notify(f"💰 BOOK LIVE — {verso} rilevato ({jump['pct']:+.1%})", {
|
|
"equity prima": f"${jump['prev']:,.2f}",
|
|
"equity ora": f"${jump['new']:,.2f}",
|
|
"cap/asset ora": f"${r['cap_per_asset']:,.2f}",
|
|
"nozionale lordo max": f"${lordo:,.2f} = leva {lordo/jump['new']:.2f}x",
|
|
})
|
|
print(f" 💰 {verso}: ${jump['prev']:,.2f} -> ${jump['new']:,.2f} "
|
|
f"({jump['pct']:+.1%}) · cap/asset ora ${r['cap_per_asset']:,.2f}")
|
|
|
|
trader = DeribitTrader() if do_execute else None
|
|
actions = []
|
|
# ISOLAMENTO PER ASSET (2026-08-25). Prima, un'eccezione dentro il corpo del ciclo risaliva
|
|
# fino a `main()` e uccideva il GIRO INTERO: il 2026-07-21 alle 09:00 UTC un 502 dentro
|
|
# `ensure_disaster_sl` su BTC ha fatto si' che ETH non venisse nemmeno guardato — niente
|
|
# ribilancio e, soprattutto, **nessuna verifica della sua protezione**. Un guasto su un asset
|
|
# non deve togliere la rete di sicurezza all'altro.
|
|
falliti: list[str] = []
|
|
scoperti: list[str] = []
|
|
for a in r["assets"]:
|
|
asset, inst = a["asset"], a["instrument"]
|
|
net, cur, mark = a["net_target"], a["position_usd"], a["mark"]
|
|
sk = a["skh_state"]
|
|
sk_txt = "flat" if sk == "flat" else f"{sk['dir']}@{sk.get('entry')}"
|
|
order = a["order"]
|
|
if order is None:
|
|
act = "HOLD (a target)"
|
|
elif order.get("is_close"):
|
|
act = f"CLOSE ${cur:,.0f}"
|
|
elif order.get("needs_flip"):
|
|
act = f"FLIP -> ${net:,.0f}"
|
|
else:
|
|
act = f"{order['side'].upper()} ${order['delta']:+,.0f}"
|
|
print(f" {asset:<3} TP {a['tp_frac']:+.3f} · SKH {a['skh_sign']:+d}({sk_txt}) -> net ${net:+,.0f} "
|
|
f"| pos ${cur:+,.0f} -> {act}")
|
|
|
|
try:
|
|
if do_execute and order is not None:
|
|
fills = trader.rebalance_signed(inst, net, mark, min_usd=min_order)
|
|
newpos = trader.position_usd(inst)
|
|
for f in fills:
|
|
print(f" -> {f.side.upper()} {f.filled:.4f} @ ${f.price or 0:,.1f} fee {f.fee_usdc:.5f} "
|
|
f"({'OK' if f.verified else 'NON VERIFICATO: ' + f.notes})")
|
|
# `ts_utc` = ORA VERA del fill. Fino al 2026-08-23 qui c'era la data della
|
|
# BARRA di segnale (`r['last_data']`): 19 righe su 19 a 00:00:00, e un trade
|
|
# registrato SEI GIORNI prima di essere eseguito (ETH 0.04 del 14/07, scritto
|
|
# 08/07). La barra resta, sotto il suo nome: `bar_ts`.
|
|
log_event(dict(ts_utc=datetime.now(timezone.utc).isoformat(timespec="seconds"),
|
|
bar_ts=str(pd.Timestamp(r['last_data'])), asset=asset, action=act,
|
|
side=f.side, filled=f.filled, price=f.price, fee=f.fee_usdc,
|
|
verified=f.verified, notes=f.notes, net_target=net, pos_after=newpos,
|
|
tp_frac=a["tp_frac"], skh_sign=a["skh_sign"]))
|
|
det = dict(asset=asset, side=f.side, amount=round(f.filled, 4), price=round(f.price or 0, 1),
|
|
fee=round(f.fee_usdc, 5), net=round(net, 0), pos_after=round(newpos, 0))
|
|
notify(f"✅ BOOK {act}" if f.verified else "⚠️ BOOK ORDINE NON VERIFICATO",
|
|
det if f.verified else {**det, "notes": f.notes})
|
|
print(f" reconcile: pos ${newpos:,.0f}")
|
|
if do_execute:
|
|
ds = trader.ensure_disaster_sl(inst, sl_pct) # bracket su posizione NETTA (adatta long/short)
|
|
stato = ds.get("state")
|
|
print(f" disaster-SL: {stato}" + (f" @ ${ds['stop']:,.1f}" if ds.get("stop") else ""))
|
|
if stato == "placed":
|
|
notify("🛡️ BOOK disaster-SL piazzato", {"asset": asset, "stop": round(ds.get("stop") or 0, 1),
|
|
"amount": round(ds.get("amount") or 0, 4)})
|
|
elif stato == "place-failed":
|
|
notify("⚠️ BOOK disaster-SL FALLITO", {"asset": asset, "notes": ds.get("notes")})
|
|
elif stato == "naked":
|
|
# NON e' "non sono riuscito a proteggere": e' "HO TOLTO la protezione e non
|
|
# sono riuscito a rimetterla". Posizione aperta senza stop on-book -> gravita'
|
|
# massima, e MAI declassata da P9: una posizione scoperta non e' mai attesa.
|
|
scoperti.append(asset)
|
|
print(f" 🚨 {asset}: POSIZIONE SCOPERTA — {ds.get('notes')}")
|
|
notify("🚨 BOOK — POSIZIONE SCOPERTA (disaster-SL rimosso e non ripiazzato)",
|
|
{"asset": asset, "stop_voluto": round(ds.get("stop") or 0, 1),
|
|
"amount": round(ds.get("amount") or 0, 4),
|
|
"azione": "ripiazzare il bracket a mano, oppure chiudere la posizione",
|
|
"notes": str(ds.get("notes"))[:300]})
|
|
except Exception as e: # noqa: BLE001 — isolamento per asset: l'altro deve continuare
|
|
d = diagnose(errori_dal_report(r) + [f"{type(e).__name__}: {e}"])
|
|
falliti.append(asset)
|
|
act = f"{act} [FALLITO]"
|
|
print(f" 🛑 {asset}: giro fallito, PASSO ALL'ASSET SUCCESSIVO -> {type(e).__name__}: {e}")
|
|
print(f" diagnosi: {d.riga()}")
|
|
if do_execute:
|
|
notify(f"{d.gravita} BOOK — asset {asset} fallito ({d.verdetto})",
|
|
{"asset": asset, "error": f"{type(e).__name__}: {e}"[:200],
|
|
"perche": d.perche, "atteso": "si'" if d.atteso else "no",
|
|
"riparabile_da_noi": "si'" if d.riparabile_da_noi else "no",
|
|
"nota": "gli altri asset del book sono stati comunque elaborati"})
|
|
actions.append(act)
|
|
|
|
print()
|
|
if scoperti:
|
|
print(f" 🚨 POSIZIONI SCOPERTE (nessun disaster-SL on-book): {', '.join(scoperti)}")
|
|
if falliti:
|
|
print(f" 🛑 asset falliti in questo giro: {', '.join(falliti)}")
|
|
if not do_execute:
|
|
print(" => DRY-RUN: nessun ordine inviato." +
|
|
("" if enabled else " Per armare: config/live.json execution_enabled=true + --execute."))
|
|
elif all(x.startswith("HOLD") for x in actions):
|
|
print(" => Nessuna azione: conto gia' al target netto del book.")
|
|
else:
|
|
print(" => Esecuzione completata (vedi data/live/book_executions.jsonl).")
|
|
# Uscita non-zero se il giro e' stato DEGRADATO: il log del cron deve poterlo contare senza
|
|
# rileggere la prosa. Non cambia nulla operativamente (cron_book.sh non ha `set -e`).
|
|
if scoperti or falliti:
|
|
sys.exit(2)
|
|
|
|
|
|
def main():
|
|
try:
|
|
_run()
|
|
except Exception as e:
|
|
# Anche l'ultima rete porta la DIAGNOSI, non solo il tipo d'errore: e' l'allerta che
|
|
# arriva quando tutto il resto non ha funzionato, ed e' proprio li' che serve sapere se
|
|
# riaprire il gateway o aspettare che rientri il venue (P4).
|
|
d = diagnose([f"{type(e).__name__}: {e}"])
|
|
notify(f"{d.gravita} BOOK LIVE — ERRORE ({d.verdetto})",
|
|
{"error": f"{type(e).__name__}: {e}"[:250], "perche": d.perche,
|
|
"atteso": "si'" if d.atteso else "no",
|
|
"riparabile_da_noi": "si'" if d.riparabile_da_noi else "no"})
|
|
raise
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|