Adriano/PythagorasGoal
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

research(wave-0822): BASIS-CALENDAR scartato — il basis dei datati E' il funding del perp; ma in regalo 240k barre di futures scaduti col 2022 dentro

Browse Source
This commit is contained in:
Adriano Dal Pastro
2026-08-22 17:39:55 +00:00
parent 32ed18222e
commit b6c0deb866
5 changed files with 1071 additions and 229 deletions
Download Patch File Download Diff File Expand all files Collapse all files
scripts/research/r0822_alt_options.py
+318 -224
View File
@@ -3,53 +3,57 @@
CONTESTO. Il filone VRP-QUOTE-VERE di questa stessa ondata ha trovato che `collect_chain.py`
interroga `{"currency": "BTC"|"ETH"}`, che su Deribit restituisce le sole opzioni INVERSE
(regolate in BTC/ETH). Il conto e' in USDC. Esiste accanto una famiglia USDC-LINEARE con lotti
~10x piu' piccoli, e su alcuni sottostanti (SOL, XRP, HYPE, AVAX) e' molto piu' popolata di
BTC_USDC. Il progetto non l'ha mai misurata.
molto piu' piccoli, e contando l'open interest sembra che su SOL/XRP/HYPE/AVAX sia molto piu'
popolata di BTC_USDC. Il progetto non l'ha mai misurata.
DOMANDA. Esiste su questa famiglia una struttura a RISCHIO DEFINITO (put credit spread, la stessa
geometria di VRP01: vendi ~-0.28, compri ~-0.10) eseguibile con qualche centinaio di dollari,
con spread e liquidita' che non se la mangino?
geometria di VRP01: vendi ~-0.28, compri ~-0.10) eseguibile con qualche centinaio di dollari, con
spread e liquidita' che non se la mangino?
COSA MISURA, in ordine, e si FERMA appena un vincolo la uccide:
1. i fatti del venue letti dall'API pubblica (min_trade_amount, tick_size, contract_size,
costo in $ di UN lotto), e la LIQUIDITA' vera: spread relativo (ask-bid)/mid ai delta che
servono davvero, non sull'ATM, + profondita' in cima al book;
2. il collaterale: margine della gamba corta secondo la formula pubblicata dal venue, e
max-loss della struttura (i due numeri differiscono per un fatto — se il venue netta le
gambe — che l'API PUBBLICA NON dice: e' dichiarato come tale, non indovinato);
3. quanta storia c'e' (risposta: nessuna) e quindi cosa si potrebbe al massimo concludere.
IPOTESI DICHIARATA PRIMA DI MISURARE: che il vincolo binding fosse la TAGLIA DEL LOTTO (e' cosi'
che il progetto ha sempre bocciato le opzioni: "BTC min 0.1 = $6.210/lotto -> FUORI a $3.000") e
che le famiglie alt, con lotti da poche decine di dollari, la superassero. Sbagliata due volte:
il lotto non e' il vincolo, e la classifica di liquidita' su cui poggia la domanda si ROVESCIA.
COSA NON PUO' FARE, e va detto prima dei numeri: **non esiste un backtest possibile**. Il nostro
collettore raccoglie solo le inverse BTC/ETH e l'archivio ereditato pure. Questo file misura le
condizioni di UN ISTANTE. Il massimo verdetto ottenibile e' `LEAD` = "vale la pena raccogliere il
dato", con il costo di raccolta stimato in chiamate/ora sul giro esistente.
COSA MISURA, in ordine, fermandosi appena un vincolo la uccide:
0. l'UNITA' dei contratti — due test empirici, perche' leggerla male sposta ogni cifra in
dollari di un fattore 10-1000 (errore commesso nella prima stesura di questo file);
1. i fatti del venue (min_trade_amount, tick_size, contract_size, $ di UN lotto);
2. la liquidita' misurata in DUE modi che danno risposte opposte: open interest vs quote
effettivamente presenti. E' il risultato principale del file;
3. la struttura: delta REALIZZATI, credito eseguibile vs credito al mark, spread, fee, max-loss;
4. il collaterale e quante strutture entrano in $635;
5. quanto costerebbe raccogliere il dato (perche' il verdetto massimo qui e' LEAD).
COSA NON PUO' FARE, detto prima dei numeri: **non esiste un backtest possibile**. Il nostro
collettore raccoglie solo le inverse BTC/ETH e l'archivio ereditato pure: zero giorni di storia su
queste famiglie. Questo file misura UN ISTANTE.
VINCOLI DI PROGETTO CITATI, non aggirati:
(a) "niente short-vol da modello in deploy" (19/06). Qui i prezzi sono VERI, non modellati —
che e' un'altra cosa — ma la regola resta finche' non esiste un campione che contenga uno
STRESS. Un istante di calma non e' un campione.
(b) SOL e' escluso dall'universo DIREZIONALE per decisione dell'operatore del 22/08. Quella
decisione riguarda TP01/SKH01 congelati come terza gamba di trend, e il suo stesso testo
dichiara che un meccanismo diverso la riapre. Un put credit spread non e' direzionale nel
senso di quella decisione. Ma il guardrail sul DATO vale lo stesso: nessun file nuovo in
`data/raw/`, e i prezzi del sottostante qui vengono da `underlying_price` della catena,
mai da `load_data`.
(c) il gate IV-rank>0.30 e' l'unico alpha misurato di VRP01, e su questi sottostanti NON e'
decisione riguarda TP01/SKH01 congelati come terza gamba di TREND, e il suo stesso testo
dichiara che un meccanismo diverso la riapre; un put credit spread non e' direzionale in
quel senso. Ma il guardrail sul DATO vale identico: nessun file nuovo in `data/raw/`, e i
prezzi del sottostante qui vengono da `underlying_price` della catena, mai da `load_data`.
(Nota: qui SOL non viene proposto — viene BOCCIATO, e sulla misura, non sulla decisione.)
(c) il gate IV-rank>0.30 e' l'unico alpha misurato di VRP01 e su questi sottostanti NON e'
calcolabile: non abbiamo un giorno di storia di vol implicita. Senza quel gate la struttura
non e' VRP01, e' vendere vol a caso.
CONVENZIONE DI UNITA' (la trappola di questo file): le opzioni INVERSE si quotano in CRIPTO per
contratto, le USDC-LINEARI in USDC per unita' di sottostante. Confrontare i due premi senza
convertire darebbe numeri sbagliati di un fattore ~10^4-10^5. Qui ogni importo in dollari passa
per `prem_usd()`, e le colonne unit-free (spread relativo, costo/credito) sono le uniche
direttamente confrontabili fra le due famiglie.
CONVENZIONE DI UNITA' (la trappola di questo file, verificata al §0): le opzioni INVERSE si
quotano in CRIPTO per contratto, le USDC-LINEARI in USDC per UNITA' DI SOTTOSTANTE; e
`min_trade_amount` e' in unita' di sottostante, NON in contratti — quindi non va moltiplicato per
`contract_size` (farlo gonfia XRP_USDC da $1.469 a $1.469.000 per lotto).
RETE: sole letture pubbliche, nessun ordine, pacing a ~2 richieste/s, e il file SI RIFIUTA di
RETE: sole letture pubbliche, nessun ordine, pacing ~2 richieste/s, e il file SI RIFIUTA di
partire nella finestra :24-:29 (e' quando `cron_chain` usa lo stesso IP: il rate limit Deribit e'
per-IP e il progetto ha gia' avuto un guasto per questo, 29/07).
nice -n 19 timeout 900 uv run python scripts/research/r0822_alt_options.py
nice -n 19 timeout 900 uv run python scripts/research/r0822_alt_options.py --cache # riusa
nice -n 19 timeout 900 uv run python scripts/research/r0822_alt_options.py --cache
"""
from __future__ import annotations
@@ -70,13 +74,15 @@ CACHE = Path("/tmp/claude-1001/-opt-docker-PythagorasGoal/"
"b6cc75e7-14f8-4c32-bd07-ab8a0d2aaee6/scratchpad/altopt_cache.json")
SHORT_DELTA, LONG_DELTA = -0.28, -0.10 # la geometria di VRP01, non ri-scelta qui
DTE_LO, DTE_HI = 4.0, 45.0 # dal settimanale di VRP01 (4-10) fino a ~1.5 mesi
OI_MIN = 100.0 # la stessa soglia di collect_chain.py
DTE_LO, DTE_HI = 4.0, 45.0 # dal settimanale di VRP01 (4-10) a ~1.5 mesi
OI_MIN = 100.0 # la soglia che usa collect_chain.py, qui sotto esame
CAPITAL = 635.0 # il conto vero
RISK_BUDGET = 0.20 # quota di conto a rischio, per la capacita'
TAKER_CAP = 0.125 # cap fee opzioni Deribit: 12.5% del premio
LINEAR = ("SOL_USDC", "XRP_USDC", "ETH_USDC", "HYPE_USDC", "AVAX_USDC", "BTC_USDC")
LINEAR = ("ETH_USDC", "BTC_USDC", "SOL_USDC", "XRP_USDC", "HYPE_USDC", "AVAX_USDC")
INVERSE = ("BTC", "ETH") # termine di paragone: il progetto le conosce
FAMS = LINEAR + INVERSE
# ---------------------------------------------------------------- rete (parca, sola lettura)
@@ -132,11 +138,6 @@ def fetch_all(b: Budget) -> dict:
{"currency": cur, "kind": "option", "expired": "false"}, b) or []
out[f"summ_{cur}"] = get("get_book_summary_by_currency",
{"currency": cur, "kind": "option"}, b) or []
if not out["inst_USDC"]: # il venue potrebbe non accettare currency=USDC
out["inst_USDC"] = get("get_instruments",
{"currency": "any", "kind": "option", "expired": "false"}, b) or []
out["summ_USDC"] = get("get_book_summary_by_currency",
{"currency": "any", "kind": "option"}, b) or []
return out
@@ -153,37 +154,40 @@ def put_delta(S: float, K: float, T: float, sig: float) -> float:
# ---------------------------------------------------------------- unita'
def is_inverse(fam: str) -> bool:
def is_inv(fam: str) -> bool:
return fam in INVERSE
def prem_usd(price: float, r: dict) -> float:
"""Premio in DOLLARI di `min_trade_amount` contratti quotati a `price`.
def usd(price: float | None, r: dict) -> float:
"""Prezzo di UN LOTTO MINIMO, in dollari.
Lineare: il prezzo e' gia' in USDC per unita' di sottostante.
Inverse: il prezzo e' in CRIPTO per contratto -> si moltiplica per il sottostante.
Lineare: il prezzo e' gia' in USDC per unita' di sottostante -> x min_trade_amount.
Inverse: il prezzo e' in CRIPTO per contratto -> x min_trade_amount x sottostante.
`contract_size` NON entra: `min_trade_amount` e' gia' in unita' di sottostante (§0).
"""
k = r["csize"] * r["minamt"]
return price * k * (r["S"] if is_inverse(r["fam"]) else 1.0)
if price is None:
return float("nan")
return price * r["minamt"] * (r["S"] if is_inv(r["fam"]) else 1.0)
def loss_usd(Ks: float, Kl: float, r: dict) -> float:
"""Perdita massima strutturale in dollari, per `min_trade_amount` contratti.
"""Perdita massima strutturale, per un lotto minimo.
Lineare: esatta, (Ks-Kl) x quantita'. Inverse: il payoff e' in cripta (max(0,K-S)/S), il
peggiore e' a S=Kl e vale (Ks-Kl)/Kl cripto = (Ks-Kl) dollari a quel prezzo -> stessa
formula, ma APPROSSIMATA (il valore in dollari della perdita dipende da dove finisce S).
Lineare: esatta, (Ks-Kl) x quantita'. Inverse: il payoff e' in cripto (max(0,K-S)/S), il caso
peggiore e' a S=Kl e vale (Ks-Kl)/Kl cripto = (Ks-Kl) dollari A QUEL PREZZO -> stessa formula,
ma APPROSSIMATA (il valore in dollari dipende da dove finisce S). Dichiarata, non nascosta.
"""
return (Ks - Kl) * r["csize"] * r["minamt"]
return (Ks - Kl) * r["minamt"]
# ---------------------------------------------------------------- margine (FONTE SECONDARIA)
def im_short_put_usd(S: float, K: float, mark_usd: float, qty: float) -> float:
"""Initial margin di una short put, in USDC, secondo la formula PUBBLICATA da Deribit.
def im_short_put(S: float, K: float, mark_lot: float, r: dict) -> float:
"""Initial margin di una short put, in USDC, per UN LOTTO, formula PUBBLICATA da Deribit:
IM = max(max(0.15 - OTM/S, 0.10), 0.075) x S + mark [per unita' di sottostante]
⚠️ FONTE SECONDARIA, dichiarata: l'API PUBBLICA non espone il margine. Il numero che decide
⚠️ FONTE SECONDARIA, dichiarata: l'API PUBBLICA non espone il margine. E il numero che decide
davvero — se Deribit NETTA le due gambe di uno spread in margine standard — non e' leggibile
da qui: si conferma con `private/get_margins`, che richiede una chiave (lettura, ma non
pubblica) e quindi NON e' stato usato.
@@ -191,11 +195,10 @@ def im_short_put_usd(S: float, K: float, mark_usd: float, qty: float) -> float:
if not (S > 0 and K > 0):
return float("nan")
otm = max(0.0, S - K) / S # una put e' OTM quando K < S
per_contratto = max(max(0.15 - otm, 0.10) * S, 0.075 * S) + max(0.0, mark_usd / max(qty, 1e-12))
return per_contratto * qty
return max(max(0.15 - otm, 0.10), 0.075) * S * r["minamt"] + max(0.0, mark_lot)
# ---------------------------------------------------------------- costruzione della vista
# ---------------------------------------------------------------- vista
def build(raw: dict) -> list[dict]:
@@ -205,8 +208,7 @@ def build(raw: dict) -> list[dict]:
inst[i["instrument_name"]] = i
for s in raw.get(f"summ_{cur}") or []:
summ[s["instrument_name"]] = s
rows = []
now_ms = datetime.now(UTC).timestamp() * 1000.0
rows, now_ms = [], datetime.now(UTC).timestamp() * 1000.0
for name, i in inst.items():
s = summ.get(name)
if s is None:
@@ -217,21 +219,21 @@ def build(raw: dict) -> list[dict]:
bid = float(bid) if bid else None # Deribit manda 0/None per "nessun lato"
ask = float(ask) if ask else None
iv, S = s.get("mark_iv"), s.get("underlying_price")
K = float(i.get("strike") or 0)
K, T = float(i.get("strike") or 0), max(dte, 0.0) / 365.25
typ = "P" if i.get("option_type") == "put" else "C"
T = max(dte, 0.0) / 365.25
d = (put_delta(float(S), K, T, float(iv) / 100.0)
if (S and iv and K and T > 0 and typ == "P") else float("nan"))
rows.append(dict(
name=name, fam=fam, typ=typ, K=K, dte=dte, S=float(S) if S else float("nan"),
iv=float(iv) if iv else float("nan"), delta_bs=d,
iv=float(iv) if iv else float("nan"),
delta=(put_delta(float(S), K, T, float(iv) / 100.0)
if (S and iv and K and T > 0 and typ == "P") else float("nan")),
bid=bid, ask=ask, mid=((bid + ask) / 2 if (bid and ask) else None),
mark=float(s.get("mark_price") or 0.0),
oi=float(s.get("open_interest") or 0.0), vol=float(s.get("volume") or 0.0),
tick=float(i.get("tick_size") or 0.0), steps=i.get("tick_size_steps") or [],
minamt=float(i.get("min_trade_amount") or 0.0),
vol_usd=float(s.get("volume_usd") or 0.0),
tick=float(i.get("tick_size") or 0.0), minamt=float(i.get("min_trade_amount") or 0.0),
csize=float(i.get("contract_size") or 0.0),
taker=i.get("taker_commission"), settle=i.get("settlement_currency"),
blockmin=float(i.get("block_trade_min_trade_amount") or 0.0),
taker=float(i.get("taker_commission") or 0.0003), settle=i.get("settlement_currency"),
))
return rows
@@ -242,217 +244,310 @@ def rel_spread(r: dict) -> float:
return (r["ask"] - r["bid"]) / r["mid"]
# ---------------------------------------------------------------- 1. i fatti del venue
# ---------------------------------------------------------------- §0 le unita'
def unita(rows: list[dict], b: Budget, rete: bool) -> None:
print("\n" + "=" * 104)
print("0. L'UNITA' DEI CONTRATTI — due test empirici, prima di qualunque cifra in dollari")
print("=" * 104)
print(" Test 1 (dai dati gia' scaricati): `volume_usd / (volume x mark_price)`.")
print(" = 1 se `volume` e' in UNITA' DI SOTTOSTANTE; = contract_size se e' in CONTRATTI;")
print(" = prezzo del sottostante se il mark e' in cripto (inverse).")
print(f"\n {'famiglia':<10} {'n oss':>6} {'vol_usd/(vol*mark)':>20} {'c_size':>8} "
f"{'sottost.':>10} {'lettura':>26}")
for f in FAMS:
rr = [r for r in rows if r["fam"] == f and r["vol"] > 0 and r["mark"] > 0]
if not rr:
continue
q = float(np.median([r["vol_usd"] / (r["vol"] * r["mark"]) for r in rr]))
cs, S = rr[0]["csize"], float(np.nanmedian([r["S"] for r in rr]))
if abs(q - 1.0) < 0.35:
lettura = "unita' di sottostante"
elif abs(q - cs) / max(cs, 1) < 0.35:
lettura = "CONTRATTI"
elif abs(q - S) / max(S, 1) < 0.35:
lettura = "cripto/contratto (inverse)"
else:
lettura = "?? non concludente"
print(f" {f:<10} {len(rr):>6} {q:>20.4f} {cs:>8g} {S:>10.2f} {lettura:>26}")
if not rete:
print("\n Test 2 (size minima nel book): non girato (--cache non usa la rete).")
return
print("\n Test 2 (rete): la size MINIMA presente nel book. Se compare esattamente")
print(" `min_trade_amount`, allora e' quello il lotto minimo IN UNITA' DI SOTTOSTANTE.")
print(f"\n {'famiglia':<10} {'min_amt':>9} {'c_size':>8} {'min size vista':>15} "
f"{'libri':>6} {'verdetto':>12}")
for f in LINEAR:
cand = sorted([r for r in rows if r["fam"] == f and (r["bid"] or r["ask"])],
key=lambda r: -r["oi"])[:4]
sizes, nb = [], 0
for r in cand:
ob = get("get_order_book", {"instrument_name": r["name"], "depth": 10}, b)
if not ob:
continue
nb += 1
for side in ("bids", "asks"):
sizes += [float(l[1]) for l in (ob.get(side) or [])]
if not sizes:
continue
mn, ma, cs = min(sizes), cand[0]["minamt"], cand[0]["csize"]
v = "confermato" if abs(mn - ma) < 1e-9 else ("CONTRATTI" if abs(mn - ma * cs) < 1e-9
else "non concl.")
print(f" {f:<10} {ma:>9g} {cs:>8g} {mn:>15g} {nb:>6} {v:>12}")
print("\n ⚠️ Errore commesso e corretto in sessione: la prima stesura moltiplicava")
print(" min_trade_amount x contract_size, e dava XRP_USDC a $1.468.900 di nozionale per")
print(" lotto. Un numero assurdo e' un test: nessun venue retail quota un minimo da $1,5M.")
# ---------------------------------------------------------------- §1 fatti del venue
def famiglie(rows: list[dict]) -> dict:
print("\n" + "=" * 104)
print("1a. I FATTI DEL VENUE — public/get_instruments + get_book_summary_by_currency")
print("1. I FATTI DEL VENUE — public/get_instruments + get_book_summary_by_currency")
print("=" * 104)
print(f"{'famiglia':<10} {'strum':>6} {'OI>=100':>8} {'min_amt':>9} {'c_size':>7} "
f"{'tick':>9} {'sottost.$':>11} {'$/lotto':>10} {'taker':>8} {'settle':>7}")
print(f"{'famiglia':<10} {'strum':>6} {'min_amt':>9} {'c_size':>7} {'tick':>9} "
f"{'sottost.$':>11} {'$/lotto':>9} {'taker':>7} {'settle':>7}")
tab = {}
for f in sorted({r["fam"] for r in rows}):
for f in FAMS:
sub = [r for r in rows if r["fam"] == f]
liq = [r for r in sub if r["oi"] >= OI_MIN]
if not sub:
continue
S = float(np.nanmedian([r["S"] for r in sub]))
mins = {r["minamt"] for r in sub}
cs = {r["csize"] for r in sub}
a = sub[0]
lot = a["minamt"] * a["csize"] * S
tab[f] = dict(n=len(sub), nliq=len(liq), minamt=a["minamt"], csize=a["csize"],
tick=a["tick"], S=S, lot=lot, taker=a["taker"])
if f in LINEAR or f in INVERSE:
avv = "" if (len(mins) == 1 and len(cs) == 1) else " <- min/c_size NON uniformi"
print(f"{f:<10} {len(sub):>6} {len(liq):>8} {a['minamt']:>9.4g} {a['csize']:>7.4g} "
f"{a['tick']:>9.5g} {S:>11.2f} {lot:>10.2f} {str(a['taker']):>8} "
f"{str(a['settle']):>7}{avv}")
print("\n `$/lotto` = min_trade_amount x contract_size x sottostante = il NOZIONALE di un")
print(" lotto (NON il premio, che e' molto minore). E' la granularita' minima imposta dal venue.")
tab[f] = dict(n=len(sub), minamt=a["minamt"], csize=a["csize"], tick=a["tick"], S=S,
lot=a["minamt"] * S, taker=a["taker"],
nliq=sum(1 for r in sub if r["oi"] >= OI_MIN))
print(f"{f:<10} {len(sub):>6} {a['minamt']:>9.4g} {a['csize']:>7.4g} {a['tick']:>9.5g} "
f"{S:>11.2f} {tab[f]['lot']:>9.2f} {a['taker']:>7.4g} {str(a['settle']):>7}")
print("\n `$/lotto` = min_trade_amount x sottostante = il NOZIONALE di un lotto (NON il premio,")
print(" che e' molto minore). E' la granularita' minima imposta dal venue.")
print(" `taker` per le opzioni Deribit e' una frazione del SOTTOSTANTE con cap al 12.5% del")
print(" premio: su un'ala molto OTM morde il CAP, non la percentuale.")
print(" premio: sull'ala molto OTM morde il CAP, non la percentuale.")
print(" 📌 Il lotto minimo NON e' il vincolo: da $242 (ETH_USDC) a $1.469 (XRP_USDC), contro")
print(" i $7.738 di BTC inverse su cui il progetto aveva costruito il muro delle opzioni.")
return tab
def replica(tab: dict) -> None:
print("\n" + "-" * 104)
print("1b. CONTROLLO POSITIVO — riproduco i conteggi dichiarati dal coordinatore (22/08)?")
print("-" * 104)
atteso = {"BTC": (1038, 415), "ETH": (932, 548), "BTC_USDC": (686, 5), "ETH_USDC": (660, 119),
"SOL_USDC": (574, 341), "XRP_USDC": (522, 250), "HYPE_USDC": (396, 172),
"AVAX_USDC": (294, 146), "TRX_USDC": (310, 115)}
print(f"{'famiglia':<10} {'strum att':>10} {'strum oggi':>11} {'liq att':>8} {'liq oggi':>9}")
for f, (n_a, l_a) in atteso.items():
t = tab.get(f)
if t is None:
print(f"{f:<10} {n_a:>10} {'ASSENTE':>11} {l_a:>8} {'-':>9}")
else:
print(f"{f:<10} {n_a:>10} {t['n']:>11} {l_a:>8} {t['nliq']:>9}")
print(" La catena si muove di ora in ora (scadenze che nascono, OI che cambia): scarti di")
print(" poche unita' sono la misura, non un disaccordo. Uno scarto GRANDE sarebbe un problema.")
# ---------------------------------------------------------------- §2 liquidita', due modi
# ---------------------------------------------------------------- 2. liquidita' ai delta utili
def liquidita(rows: list[dict], tab: dict) -> None:
print("\n" + "=" * 104)
print("2. LA LIQUIDITA', MISURATA IN DUE MODI CHE DANNO RISPOSTE OPPOSTE")
print("=" * 104)
print(" A) open interest >= 100 = quante POSIZIONI sono aperte (il filtro che usa")
print(" `collect_chain.py`, ereditato da bite, e la misura su cui poggia la domanda).")
print(" B) quote a DUE LATI presenti adesso = quanti strumenti sono NEGOZIABILI a un prezzo")
print(" noto. Sui soli put nella finestra 4-45 giorni, cioe' dove vive la struttura.")
print(f"\n{'famiglia':<10} {'A: OI>=100':>11} {'rango A':>8} {'put 4-45g':>10} "
f"{'B: 2 lati':>10} {'% quotati':>10} {'rango B':>8}")
stat = {}
for f in FAMS:
puts = [r for r in rows if r["fam"] == f and r["typ"] == "P" and DTE_LO <= r["dte"] <= DTE_HI]
two = [r for r in puts if r["bid"] is not None and r["ask"] is not None]
stat[f] = dict(oi=tab[f]["nliq"], puts=len(puts), two=len(two),
pct=(len(two) / len(puts) if puts else float("nan")))
rA = {f: i + 1 for i, f in enumerate(sorted(stat, key=lambda x: -stat[x]["oi"]))}
rB = {f: i + 1 for i, f in enumerate(sorted(stat, key=lambda x: -stat[x]["pct"]))}
for f in sorted(FAMS, key=lambda x: -stat[x]["oi"]):
s = stat[f]
print(f"{f:<10} {s['oi']:>11} {rA[f]:>8} {s['puts']:>10} {s['two']:>10} "
f"{s['pct']:>9.0%} {rB[f]:>8}")
print("\n 📌 LA CLASSIFICA SI ROVESCIA. SOL_USDC e' 1° per open interest e ULTIMO per quote")
print(" presenti; BTC_USDC, dichiarato 'praticamente morto' (5 strumenti con OI>=100), ha")
print(" quasi tutti i put quotati a due lati. L'open interest misura posizioni ACCUMULATE,")
print(" non la possibilita' di negoziare ADESSO — e sull'universo lineare le due cose non")
print(" hanno quasi nulla a che vedere.")
print(" ⚠️ Ricaduta sul codice di produzione: `collect_chain.py` prefiltra a OI>=100. Sulle")
print(" inverse non fa danno (sono quotate comunque), ma NON e' un filtro di liquidita' e il")
print(" suo nome lo lascia credere. 4ª occorrenza di 'una riga presente non e' un dato")
print(" presente' — qui in versione: 'una posizione aperta non e' un prezzo negoziabile'.")
def gambe(rows: list[dict], fam: str) -> list[dict]:
# ---------------------------------------------------------------- §3 la struttura
def scegli(rows: list[dict], fam: str, eseguibile: bool) -> list[dict]:
"""Per ogni scadenza: la put piu' vicina a -0.28 (corta) e a -0.10 (lunga).
`eseguibile=False` -> fra TUTTI gli strike (la struttura che si vorrebbe).
`eseguibile=True` -> solo fra gli strike che hanno il LATO che serve: per APRIRE bisogna
vendere la corta al BID e comprare l'ala all'ASK. E' una restrizione
asimmetrica, ed e' quella giusta: un book a un lato solo non e' un
book vuoto, e' un book che serve solo una direzione.
"""
puts = [r for r in rows if r["fam"] == fam and r["typ"] == "P"
and DTE_LO <= r["dte"] <= DTE_HI and np.isfinite(r["delta_bs"])]
and DTE_LO <= r["dte"] <= DTE_HI and np.isfinite(r["delta"])]
out = []
for e in sorted({round(r["dte"], 4) for r in puts}):
g = [r for r in puts if round(r["dte"], 4) == e]
s = min(g, key=lambda r: abs(r["delta_bs"] - SHORT_DELTA))
lo = min(g, key=lambda r: abs(r["delta_bs"] - LONG_DELTA))
gs = [r for r in g if r["bid"] is not None] if eseguibile else g
gl = [r for r in g if r["ask"] is not None] if eseguibile else g
if not gs or not gl:
continue
s = min(gs, key=lambda r: abs(r["delta"] - SHORT_DELTA))
lo = min(gl, key=lambda r: abs(r["delta"] - LONG_DELTA))
if s["K"] > lo["K"]:
out.append({"dte": e, "short": s, "long": lo, "n_strike": len(g)})
out.append({"dte": e, "short": s, "long": lo, "n": len(g)})
return out
def liquidita(rows: list[dict]) -> dict:
def fee_lotto(r: dict) -> float:
"""Fee taker di UNA gamba, un lotto: min(0.03% del nozionale, 12.5% del premio)."""
return min(r["taker"] * r["S"] * r["minamt"], TAKER_CAP * usd(r["mark"], r))
def struttura(rows: list[dict]) -> dict:
print("\n" + "=" * 104)
print(f"2. LA LIQUIDITA' AI DELTA CHE SERVONO ({SHORT_DELTA} corta / {LONG_DELTA} lunga),")
print(f" NON sull'ATM. Finestra {DTE_LO:.0f}-{DTE_HI:.0f} giorni. Delta = BS su mark_iv, r=0.")
print(f"3. LA STRUTTURA — put credit spread {SHORT_DELTA}/{LONG_DELTA}, finestra "
f"{DTE_LO:.0f}-{DTE_HI:.0f} giorni, per UN LOTTO MINIMO")
print("=" * 104)
print(f"{'famiglia':<10} {'scad':>5} {'2lati':>6} {'d corta':>8} {'d lunga':>8} "
f"{'spr% corta':>11} {'spr% lunga':>11} {'credito$':>9} {'costo/cred':>11} "
print(" `f_venue` = (bid_corta - ask_ala) / (mark_corta - mark_ala) = quanta parte del")
print(" credito che il venue stesso considera equo resta dopo aver attraversato lo spread.")
print(" E' il gemello del `f` misurato dal progetto il 30/07 (0,73 = errore del MODELLO):")
print(" qui il modello non c'entra, il riferimento e' il mark del venue.")
print(f"\n{'famiglia':<10} {'scad':>4} {'d corta':>8} {'d ala':>7} {'spr% corta':>11} "
f"{'spr% ala':>9} {'cred mark$':>11} {'cred eseg$':>11} {'f_venue':>8} "
f"{'fee/cred':>9} {'maxloss$':>9}")
res = {}
for fam in list(LINEAR) + list(INVERSE):
gg = gambe(rows, fam)
for f in FAMS:
gg = scegli(rows, f, eseguibile=True)
if not gg:
print(f"{fam:<10} {'0':>5} nessuna scadenza utilizzabile nella finestra")
print(f"{f:<10} {'0':>4} nessuna scadenza con corta-bid E ala-ask presenti")
continue
ss, ll, ds, dl, cred, cost, fee, ml = [], [], [], [], [], [], [], []
due = neg = 0
acc = {k: [] for k in ("ds", "dl", "ss", "sl", "cm", "ce", "fee", "ml")}
for g in gg:
s, lo = g["short"], g["long"]
rs, rl = rel_spread(s), rel_spread(lo)
if not (np.isfinite(rs) and np.isfinite(rl)):
cm = usd(s["mark"], s) - usd(lo["mark"], lo)
ce = usd(s["bid"], s) - usd(lo["ask"], lo)
if cm <= 0:
continue
due += 1
c_mid = prem_usd(s["mid"], s) - prem_usd(lo["mid"], lo)
c_exe = prem_usd(s["bid"], s) - prem_usd(lo["ask"], lo)
if c_mid <= 0:
neg += 1
continue
# fee taker Deribit: min(0.03% del sottostante, 12.5% del premio) per gamba, x2 gambe,
# x2 (apertura + chiusura/esercizio). Conservativo ma e' il listino.
def _fee(r: dict) -> float:
notion = r["S"] * r["csize"] * r["minamt"]
return min(float(r["taker"] or 0.0003) * notion, TAKER_CAP * prem_usd(r["mid"], r))
ss.append(rs); ll.append(rl)
ds.append(s["delta_bs"]); dl.append(lo["delta_bs"])
cred.append(c_mid)
cost.append((c_mid - c_exe) / c_mid)
fee.append(2.0 * (_fee(s) + _fee(lo)) / c_mid)
ml.append(loss_usd(s["K"], lo["K"], s) - c_exe)
if not cred:
print(f"{fam:<10} {len(gg):>5} {due:>6} nessuna struttura con credito positivo a mid "
f"({neg} a credito<=0)")
acc["ds"].append(s["delta"]); acc["dl"].append(lo["delta"])
acc["ss"].append(rel_spread(s)); acc["sl"].append(rel_spread(lo))
acc["cm"].append(cm); acc["ce"].append(ce)
acc["fee"].append(2.0 * (fee_lotto(s) + fee_lotto(lo)) / cm)
acc["ml"].append(loss_usd(s["K"], lo["K"], s) - ce)
if not acc["cm"]:
print(f"{f:<10} {len(gg):>4} nessuna struttura con credito positivo al mark")
continue
r = dict(n=len(gg), due=due, neg=neg, s=float(np.median(ss)), l=float(np.median(ll)),
ds=float(np.median(ds)), dl=float(np.median(dl)), cred=float(np.median(cred)),
cost=float(np.median(cost)), fee=float(np.median(fee)), ml=float(np.median(ml)))
res[fam] = r
print(f"{fam:<10} {r['n']:>5} {due:>6} {r['ds']:>8.3f} {r['dl']:>8.3f} "
f"{r['s']*100:>10.1f}% {r['l']*100:>10.1f}% {r['cred']:>9.2f} "
f"{r['cost']*100:>10.1f}% {r['fee']*100:>8.1f}% {r['ml']:>9.2f}")
print("\n `2lati` = strutture in cui ENTRAMBE le gambe hanno bid E ask. Una riga presente non")
print(" e' un dato presente: una gamba con un solo lato non e' negoziabile a un prezzo noto.")
print(" `d corta`/`d lunga` = delta REALIZZATI (non i target): se la griglia degli strike e'")
print(" grossolana la struttura che compreresti non e' quella che hai chiesto.")
print(" `costo/cred` = quanto dell'incasso a mid resta sul tavolo attraversando lo spread su")
print(" ENTRAMBE le gambe. Riferimento del progetto su BTC/ETH inverse: ~10% del credito.")
print(" `fee/cred` = listino taker Deribit, 2 gambe x apertura+chiusura, col cap 12.5%.")
print(" `credito$` e `maxloss$` sono per UN LOTTO MINIMO.")
m = {k: float(np.nanmedian(v)) if v else float("nan") for k, v in acc.items()}
m["fv"] = float(np.median([e / c for e, c in zip(acc["ce"], acc["cm"])]))
m["n"] = len(acc["cm"])
res[f] = m
print(f"{f:<10} {m['n']:>4} {m['ds']:>8.3f} {m['dl']:>7.3f} {m['ss']*100:>10.1f}% "
f"{m['sl']*100:>8.1f}% {m['cm']:>11.2f} {m['ce']:>11.2f} {m['fv']:>8.3f} "
f"{m['fee']*100:>8.1f}% {m['ml']:>9.2f}")
print("\n ⚠️ `spr%` puo' essere NaN quando la gamba ha un lato solo: e' negoziabile per")
print(" aprire (il lato che serve c'e') ma non ha un mid, quindi non ha uno spread definito.")
print(" `fee/cred` = 2 gambe x (apertura + chiusura) col cap 12.5%. VRP01 tiene FINO A")
print(" SCADENZA (nessuna gestione infra-settimana, il profit-take e' REFUTED il 30/07),")
print(" quindi il costo realistico e' ~la META' di questa colonna + la delivery fee.")
print(f"\n --- controllo: gli STESSI strike scelti fra TUTTI gli strike (non solo quotati) ---")
print(f" {'famiglia':<10} {'ideale d corta':>15} {'eseg. d corta':>14} {'ideale d ala':>13} "
f"{'eseg. d ala':>12} {'scad ideali':>12} {'scad eseg.':>11}")
for f in FAMS:
gi, ge = scegli(rows, f, False), scegli(rows, f, True)
if not gi:
continue
di = float(np.median([g["short"]["delta"] for g in gi]))
li = float(np.median([g["long"]["delta"] for g in gi]))
de = float(np.median([g["short"]["delta"] for g in ge])) if ge else float("nan")
le = float(np.median([g["long"]["delta"] for g in ge])) if ge else float("nan")
print(f" {f:<10} {di:>15.3f} {de:>14.3f} {li:>13.3f} {le:>12.3f} "
f"{len(gi):>12} {len(ge):>11}")
print(" Se la colonna `eseg.` si allontana dal target -0.28/-0.10, la struttura che si")
print(" comprerebbe NON e' quella richiesta: la griglia degli strike quotati la deforma.")
return res
def profondita(rows: list[dict], fams: list[str], b: Budget) -> None:
print("\n" + "=" * 104)
print("2b. PROFONDITA' IN CIMA AL BOOK (public/get_order_book depth=5), sulle gambe scelte")
print("3b. PROFONDITA' IN CIMA AL BOOK (public/get_order_book depth=5) sulle gambe scelte")
print("=" * 104)
print(f"{'famiglia':<10} {'gamba':<6} {'n':>3} {'lotti al best':>14} {'$ premio al best':>17} "
f"{'ask/tick lunga':>15} {'max|delta venue-BS|':>21}")
for fam in fams:
gg = gambe(rows, fam)[:4] # max 4 scadenze/famiglia: budget di rete
for lato, key in (("corta", "short"), ("lunga", "long")):
lots, prem, dd, tk = [], [], [], []
f"{'prezzo/tick':>12} {'max|d venue-BS|':>17}")
for f in fams:
gg = scegli(rows, f, eseguibile=True)[:4] # max 4 scadenze: budget di rete
for lato, key, side in (("corta", "short", "bids"), ("ala", "long", "asks")):
lots, prem, tk, dd = [], [], [], []
for g in gg:
r = g[key]
ob = get("get_order_book", {"instrument_name": r["name"], "depth": 5}, b)
if not ob:
if not ob or not (ob.get(side) or []):
continue
side = ob.get("bids") if key == "short" else ob.get("asks")
if not side:
continue
px, sz = float(side[0][0]), float(side[0][1])
px, sz = float(ob[side][0][0]), float(ob[side][0][1])
lots.append(sz / r["minamt"] if r["minamt"] else float("nan"))
prem.append(prem_usd(px, r) * (sz / max(r["minamt"], 1e-12)))
prem.append(usd(px, r) * (sz / max(r["minamt"], 1e-12)))
if r["tick"]:
tk.append(px / r["tick"])
gv = (ob.get("greeks") or {}).get("delta")
if gv is not None and np.isfinite(r["delta_bs"]):
dd.append(abs(float(gv) - r["delta_bs"]))
if gv is not None and np.isfinite(r["delta"]):
dd.append(abs(float(gv) - r["delta"]))
if not lots:
print(f"{fam:<10} {lato:<6} {'0':>3} book vuoto su tutte le scadenze provate")
print(f"{f:<10} {lato:<6} {'0':>3} book vuoto sul lato che serve")
continue
print(f"{fam:<10} {lato:<6} {len(lots):>3} {np.median(lots):>14.1f} "
f"{np.median(prem):>17.2f} "
f"{(np.median(tk) if tk else float('nan')):>15.1f} "
f"{(max(dd) if dd else float('nan')):>21.4f}")
print(f"{f:<10} {lato:<6} {len(lots):>3} {np.median(lots):>14.1f} "
f"{np.median(prem):>17.2f} {(np.median(tk) if tk else float('nan')):>12.1f} "
f"{(max(dd) if dd else float('nan')):>17.4f}")
print("\n `lotti al best` = size in cima al book / lotto minimo: quante strutture minime")
print(" entrano senza muovere il prezzo. `ask/tick` sulla gamba LUNGA e' il controllo")
print(" d'artefatto del 30/07: un'ala a 1-2 tick e' un prezzo di griglia, non un prezzo.")
print(" `max|delta venue-BS|` valida il MIO calcolo del delta contro le greche del venue: se")
print(" non e' piccolo, tutta la selezione degli strike qui sopra e' sbagliata.")
print(" entrano senza muovere il prezzo. `prezzo/tick` e' il controllo d'artefatto del")
print(" 30/07: un prezzo a 1-2 tick e' una griglia, non un prezzo.")
print(" `max|d venue-BS|` valida il MIO delta contro le greche del venue: se non e' piccolo,")
print(" tutta la selezione degli strike qui sopra e' sbagliata.")
# ---------------------------------------------------------------- 3. collaterale
# ---------------------------------------------------------------- §4 collaterale e capacita'
def collaterale(rows: list[dict], res: dict) -> None:
print("\n" + "=" * 104)
print("3. IL COLLATERALE — quanto conto serve per UNA struttura minima (conto reale $635)")
print(f"4. COLLATERALE E CAPACITA' — conto reale ${CAPITAL:.0f}")
print("=" * 104)
print(f"{'famiglia':<10} {'IM corta+ala $':>15} {'max-loss $':>11} {'IM/conto':>9} "
f"{'strutture @635 (IM)':>20} {'(max-loss)':>12}")
for fam in res:
gg = gambe(rows, fam)
ims, mls = [], []
print(f"{'famiglia':<10} {'IM corta+ala$':>14} {'max-loss$':>10} {'n @IM':>7} "
f"{'n @maxloss':>11} {'n a budget 20%':>15} {'credito lordo$':>15}")
for f, m in res.items():
gg = scegli(rows, f, eseguibile=True)
ims = []
for g in gg:
s, lo = g["short"], g["long"]
if s["mid"] is None or lo["ask"] is None:
if lo["ask"] is None:
continue
qty = s["csize"] * s["minamt"]
im = im_short_put_usd(s["S"], s["K"], prem_usd(s["mark"], s), qty)
ims.append(im + prem_usd(lo["ask"], lo)) # l'ala si PAGA: e' cassa, non margine
mls.append(loss_usd(s["K"], lo["K"], s))
ims.append(im_short_put(s["S"], s["K"], usd(s["mark"], s), s) + usd(lo["ask"], lo))
if not ims:
continue
im, ml = float(np.median(ims)), float(np.median(mls))
print(f"{fam:<10} {im:>15.2f} {ml:>11.2f} {im/CAPITAL:>8.1%} "
f"{CAPITAL/im:>20.1f} {CAPITAL/ml:>12.1f}")
im, ml = float(np.median(ims)), m["ml"]
n_budget = math.floor(RISK_BUDGET * CAPITAL / ml) if ml > 0 else 0
print(f"{f:<10} {im:>14.2f} {ml:>10.2f} {CAPITAL/im:>7.1f} {CAPITAL/ml:>11.1f} "
f"{n_budget:>15} {n_budget*m['ce']:>15.2f}")
print("\n `IM corta+ala` = margine iniziale della sola put venduta (formula PUBBLICATA dal")
print(" venue, FONTE SECONDARIA) + il premio dell'ala, che si paga in contanti. E' il")
print(" fabbisogno se il venue NON netta le gambe.")
print(" `max-loss` = perdita massima strutturale = il fabbisogno se il venue LE NETTA.")
print(" ⚠️ La differenza fra i due numeri e' l'unica cosa importante di questa tabella e NON")
print(" E' LEGGIBILE dall'API pubblica: si chiude con `private/get_margins` (lettura, ma")
print(" autenticata -> fuori dal perimetro dichiarato di questo file).")
print(" venue, FONTE SECONDARIA) + il premio dell'ala, che si paga in contanti = il")
print(" fabbisogno se il venue NON netta le gambe. `max-loss` = il fabbisogno se LE NETTA.")
print(" ⚠️ Quale dei due valga NON e' leggibile dall'API pubblica: si chiude con")
print(" `private/get_margins` (lettura autenticata, fuori dal perimetro di questo file).")
print(" Ma la conclusione NON dipende da quale sia: il collaterale non e' il vincolo in")
print(" nessuna delle due letture.")
print(f" `n a budget 20%` = strutture che stanno in {RISK_BUDGET:.0%} del conto a max-loss;")
print(" `credito lordo` = il loro credito ESEGUIBILE sommato, per un ciclo. E' un incasso")
print(" LORDO PRIMA DI QUALUNQUE PERDITA, non un rendimento atteso: la struttura perde fino")
print(" a ~7x il credito quando va male (misura del progetto sul canonico BTC/ETH).")
def costo_raccolta(tab: dict) -> None:
def costo_raccolta(rows: list[dict], tab: dict) -> None:
print("\n" + "=" * 104)
print("4. COSTO DI RACCOLTA — cosa costerebbe aggiungere una famiglia al giro esistente")
print("5. COSTO DI RACCOLTA — cosa costerebbe aggiungere una famiglia al giro esistente")
print("=" * 104)
print(" `collect_chain.py` oggi: ~650 chiamate in ~160s a 4 rps (BTC+ETH inverse), al :25.")
print(f"{'famiglia':<10} {'chiamate/giro':>14} {'+s a 4 rps':>11} {'+% sul giro':>12}")
print(f"{'famiglia':<10} {'a OI>=100':>10} {'a 2-lati':>9} {'+s a 4rps (2-lati)':>19} "
f"{'+% sul giro':>12}")
for f in LINEAR:
t = tab.get(f)
if t:
n = t["nliq"] + 2 # + get_instruments + get_book_summary
print(f"{f:<10} {n:>14.0f} {n/4.0:>11.1f} {n/650*100:>11.0f}%")
sub = [r for r in rows if r["fam"] == f]
two = sum(1 for r in sub if r["bid"] is not None and r["ask"] is not None)
print(f"{f:<10} {tab[f]['nliq']:>10} {two:>9} {(two+2)/4.0:>19.1f} "
f"{(two+2)/650*100:>11.0f}%")
print("\n ⚠️ Il vincolo non e' la CPU ma il rate limit Deribit PER-IP, gia' costato un guasto")
print(" il 29/07 (fallback silenzioso del feed 5m di SKH01). Ogni famiglia aggiunta allunga")
print(" la finestra in cui il giro occupa l'IP.")
@@ -471,7 +566,7 @@ def main() -> int:
print("=" * 104)
print("Sola lettura pubblica, nessun ordine. UNO SNAPSHOT: qui non esiste un backtest.")
b = Budget()
b, rete = Budget(), not a.cache
if a.cache and CACHE.exists():
raw = json.loads(CACHE.read_text())
print(f"\n[cache] {CACHE}")
@@ -481,8 +576,7 @@ def main() -> int:
raw = fetch_all(b)
CACHE.parent.mkdir(parents=True, exist_ok=True)
CACHE.write_text(json.dumps(raw))
print(f"\n[rete] {b.calls} chiamate, {b.err} errori, {b.r429} risposte 429, "
f"{time.time()-t0:.0f}s")
print(f"\n[rete] {b.calls} chiamate, {b.err} errori, {b.r429} 429, {time.time()-t0:.0f}s")
rows = build(raw)
print(f"[dato] {len(rows)} strumenti con specifiche E quote — snapshot "
@@ -491,38 +585,38 @@ def main() -> int:
print("NESSUN DATO: il venue non ha risposto. Verdetto: non misurabile.")
return 1
unita(rows, b, rete)
tab = famiglie(rows)
replica(tab)
res = liquidita(rows)
liquidita(rows, tab)
res = struttura(rows)
vive = [f for f in res if res[f]["due"] >= 2]
if a.cache:
print("\n2b. PROFONDITA': non girata (--cache non usa la rete).")
elif not vive:
print("\n2b. PROFONDITA': non girata — nessuna famiglia con >=2 strutture a due lati.")
else:
vive = [f for f in res if res[f]["n"] >= 2]
if rete and vive:
guardia_finestra()
profondita(rows, vive, b)
else:
print("\n3b. PROFONDITA': non girata (--cache, oppure nessuna famiglia con >=2 strutture).")
collaterale(rows, res)
costo_raccolta(tab)
costo_raccolta(rows, tab)
print("\n" + "=" * 104)
print("5. COSA QUESTO FILE NON PUO' DIRE (dichiarato prima di qualunque verdetto)")
print("6. COSA QUESTO FILE NON PUO' DIRE (dichiarato prima di qualunque verdetto)")
print("=" * 104)
print(" * Non c'e' STORIA: il collettore raccoglie BTC/ETH inverse, l'archivio ereditato pure.")
print(" Zero giorni di catena su SOL/XRP/HYPE/AVAX/*_USDC -> nessun backtest, nessun")
print(" hold-out, nessun deflated-Sharpe. Il massimo verdetto ottenibile e' LEAD.")
print(" * Non c'e' STORIA: il collettore raccoglie BTC/ETH inverse, l'archivio ereditato")
print(" pure. Zero giorni di catena su queste famiglie -> nessun backtest, nessun hold-out,")
print(" nessun deflated-Sharpe. Il verdetto massimo ottenibile e' LEAD.")
print(" * Non c'e' IV-RANK: il gate>0.30 e' l'unico alpha misurato di VRP01 e richiede la")
print(" distribuzione storica della vol implicita del sottostante. Senza, la struttura non")
print(" e' VRP01: e' vendere vol a caso. (Su BTC/ETH quel gate e' passato 0/19 settimane.)")
print(" * Non c'e' STRESS nel campione: la regola 'niente short-vol da modello in deploy' e'")
print(" del 19/06 e la condizione dichiarata per rivalutarla e' un crash CATTURATO.")
print(" * Il margine e' da FORMULA PUBBLICATA, non dall'API: il netting delle gambe non e'")
print(" * Il margine e' da FORMULA PUBBLICATA, non dall'API, e il netting delle gambe non e'")
print(" leggibile pubblicamente.")
print(" * E' UN ISTANTE: uno spread relativo mediano misurato a un'ora del sabato non e' la")
print(" sua distribuzione. Servirebbe almeno un ciclo settimanale per sapere se e' tipico.")
print(f"[rete, totale] {b.calls} chiamate, {b.err} errori, {b.r429} risposte 429")
print(" * E' UN ISTANTE, per giunta di SABATO pomeriggio: uno spread relativo mediano a")
print(" un'ora del fine settimana non e' la sua distribuzione. Un book alt puo' essere")
print(" molto piu' quotato in settimana. Servirebbe almeno un ciclo settimanale.")
print(f"\n[rete, totale] {b.calls} chiamate, {b.err} errori, {b.r429} risposte 429")
return 0