merge lavoro/goldrake-u4 (revisione 27/09)

src/live/journal.py

@@ -248,12 +248,26 @@ def movimenti_capitale(con, fino_ts: str, rows=None) -> dict:
                   + (f" il {d['dichiarato_il']}" if d.get("dichiarato_il") else "")
                   + (f": {d['nota']}" if d["nota"] else "")
                   + (f" (banda ±${d['banda']:,.2f})" if d["banda"] else ""))
-        gia = next((e for e in eventi if e["ts_dopo"] == cur["ts_utc"]), None)
-        if gia is not None:                          # rilevato E dichiarato: l'importo e' quello dichiarato
-            gia.update(delta=d["delta"], pct=d["delta"] / float(prev["equity"]) if prev["equity"] else None,
+        # (#27) l'aggancio "dichiarato+rilevato" vale SOLO contro un evento rilevato: se si
+        # cercasse un qualunque evento sullo stesso ts_dopo, il secondo dichiarato nello stesso
+        # intervallo troverebbe il primo (gia' "dichiarato") e lo SOVRASCRIVEREBBE, perdendo
+        # il primo importo invece di somarli.
+        rilevato = next((e for e in eventi
+                         if e["ts_dopo"] == cur["ts_utc"] and e["fonte"] == "rilevato"), None)
+        if rilevato is not None:                      # rilevato E dichiarato: l'importo e' quello dichiarato
+            rilevato.update(delta=d["delta"], pct=d["delta"] / float(prev["equity"]) if prev["equity"] else None,
                        classe="movimento", fonte="dichiarato+rilevato",
                        dopo=float(prev["equity"]) + d["delta"], dichiarazione=nota_d)
             continue
+        gia = next((e for e in eventi if e["ts_dopo"] == cur["ts_utc"]
+                    and e["fonte"] in ("dichiarato", "dichiarato+rilevato")), None)
+        if gia is not None:                           # un altro dichiarato nello stesso intervallo: si SOMMA
+            nuovo_delta = gia["delta"] + d["delta"]
+            gia.update(delta=nuovo_delta,
+                       pct=(nuovo_delta / float(gia["prima"]) if gia["prima"] else None),
+                       dopo=float(gia["prima"]) + nuovo_delta,
+                       dichiarazione=(gia["dichiarazione"] + "; " + nota_d))
+            continue
         eventi.append(dict(ts_prima=prev["ts_utc"], ts_dopo=cur["ts_utc"],
                            prima=float(prev["equity"]), dopo=float(prev["equity"]) + d["delta"],
                            delta=d["delta"],
@@ -376,16 +390,23 @@ def pnl_giorno(con, giorno: date) -> dict:
         twr_da_arming=(r_twr["twr"] if cum is not None else None), twr_motivo=r_twr["motivo"])
 
 
+MINUTO_GIRO = 47  # deve restare d'accordo con la crontab e scripts/cron_book.sh (#35 C9)
+
+
 def salute(con, giorno: date) -> dict:
     """Giri attesi: 24 per un giorno CHIUSO, le ore trascorse per quello in corso.
 
     Un giorno in corso confrontato con 24 produce un allarme a ogni esecuzione — e un
     allarme che scatta sempre e' un allarme che non verra' letto il giorno che e' vero.
+
+    Il giro dell'ora CORRENTE scatta al minuto `MINUTO_GIRO` (il cron e' `47 * * * *`): prima
+    di quel minuto non e' ancora avvenuto, e contarlo comunque (#35 C9) segnalava un giro
+    "mancante" che semplicemente non era ancora il suo turno.
     """
     lb = stato_libro(con, giorno)
     adesso = datetime.now(timezone.utc)
     in_corso = giorno == adesso.date()
-    atteso = (adesso.hour + 1) if in_corso else 24
+    atteso = (adesso.hour + (1 if adesso.minute >= MINUTO_GIRO + 1 else 0)) if in_corso else 24
     fatti = lb.get("giri", 0)
     return dict(giri_book=fatti, feed_skh_min=lb.get("feed_skh_min"), atteso_giri=atteso,
                 giorno_in_corso=in_corso, giri_mancanti=max(0, atteso - fatti))
@@ -591,16 +612,19 @@ def lettura(con, voce: dict) -> list[dict]:
         # il cumulato di TRADING: i movimenti di capitale certi escono, o un versamento
         # diventa "concentrazione di P&L" (e' successo: 25/08, +$1.399 letti come profitto)
         mv_ev = [e for e in (p.get("movimenti_arming") or []) if e["classe"] == "movimento"]
-        g7s = (date.fromisoformat(voce["giorno"]) - timedelta(days=7)).isoformat()
         tot = e1 - e0 - sum(e["delta"] for e in mv_ev)
-        picco = max(r["equity"] for r in eq)
-        g7 = [r for r in eq if r["ts_utc"][:10] >= g7s]
-        mv7 = sum(e["delta"] for e in mv_ev if e["ts_dopo"][:10] >= g7s)
+        # (#35 C15) "ultimi 7 giorni" deve essere VERO: la baseline e' l'ULTIMA lettura al o
+        # prima del giorno-7 a fine giornata — non la PRIMA lettura di quel giorno. Filtrare per
+        # data (>= giorno-7) include anche le ore del giorno-7 gia' trascorse, cioe' 8 giorni di
+        # calendario, non 7.
+        g7_cutoff = (date.fromisoformat(voce["giorno"]) - timedelta(days=7)).isoformat() + "T23:59:59+00:00"
+        base7 = next((r for r in reversed(eq) if r["ts_utc"] <= g7_cutoff), None)
+        mv7 = sum(e["delta"] for e in mv_ev if e["ts_dopo"] > g7_cutoff)
         # Soglia di rilevanza: su un cumulato di pochi dollari la "concentrazione" e' aritmetica
         # vera e informazione zero. Una regola che si accende su $2 insegna a saltare la sezione.
         rilevante = abs(tot) >= max(5.0, 0.01 * e1)
-        if rilevante and g7:
-            quota = (e1 - g7[0]["equity"] - mv7) / tot
+        if rilevante and base7 is not None:
+            quota = (e1 - base7["equity"] - mv7) / tot
             if quota > 0.60:
                 coda = ("Un risultato concentrato in una finestra non e' un tasso di rendimento: "
                         "e' un evento.")
@@ -609,10 +633,22 @@ def lettura(con, voce: dict) -> list[dict]:
                             "senza questi 7 giorni il libro sarebbe sotto. " + coda)
                 dire("concentrazione", f"**Il {100*quota:.0f}% di tutto il P&L cumulato "
                      f"(${tot:+,.2f}) viene dagli ultimi 7 giorni.** " + coda, "nota")
-        if picco > 0:
-            dd = (e1 - picco) / picco
+        # (#35 C7) il DD si calcola sulla serie AL NETTO dei movimenti CERTI (gli stessi che il
+        # TWR scorpora): sulla serie grezza un prelievo si legge come drawdown di trading e un
+        # versamento alza il picco, mascherando un DD vero appena prima del versamento.
+        mv_ord = sorted(mv_ev, key=lambda e: e["ts_dopo"])
+        cum_mov, i_mov, eq_netto = 0.0, 0, []
+        for r in eq:
+            while i_mov < len(mv_ord) and r["ts_utc"] >= mv_ord[i_mov]["ts_dopo"]:
+                cum_mov += mv_ord[i_mov]["delta"]
+                i_mov += 1
+            eq_netto.append(r["equity"] - cum_mov)
+        picco_netto = max(eq_netto)
+        if picco_netto > 0:
+            dd = (eq_netto[-1] - picco_netto) / picco_netto
             if dd < -0.005:
-                dire("drawdown", f"Equity **{100*dd:.2f}%** sotto il picco (${picco:,.2f}). "
+                dire("drawdown", f"Equity **{100*dd:.2f}%** sotto il picco (${picco_netto:,.2f}, "
+                                 "al netto dei movimenti di capitale certi). "
                                  "⚠️ e' un DD su letture ORARIE, non sul minimo intra-giorno.", "nota")
 
     # --- volatilita' implicita contro realizzata ---------------------------------------------

src/live/tradesdb.py

@@ -262,31 +262,43 @@ def reconcile(fills_log: list[Fill], righe_jsonl: list[dict], tol_px: float = 0.
 
 
 def fifo_roundtrips(fills: list[Fill]) -> tuple[list[dict], dict]:
-    """Round-trip chiusi per FIFO + lotti residui. Le fee si allocano PRO-QUOTA sulla qty."""
+    """Round-trip chiusi per FIFO + lotti residui. Le fee si allocano PRO-QUOTA sulla qty.
+
+    Lotti CON SEGNO (#32 C2): ogni lotto e' long (+1) o short (-1). Un fill chiude PRIMA i
+    lotti di segno OPPOSTO (FIFO), e l'eccedenza — se resta qty dopo aver chiuso tutto il
+    lato opposto — apre (o accoda) un lotto nel segno del fill stesso. Prima di questa
+    riparazione un SELL senza lotti long da chiudere spariva in silenzio (nessun lotto,
+    nessun round-trip): l'inversione long -> short in un solo fill e' lo stesso meccanismo,
+    solo che il lato opposto si esaurisce a meta' fill invece che all'inizio.
+    """
     from collections import deque, defaultdict
-    lotti: dict[str, deque] = defaultdict(deque)
+    lotti: dict[str, deque] = defaultdict(deque)   # ciascun lotto: [qty, price, ts, fee_u, segno]
     rts: list[dict] = []
     for f in sorted(fills, key=lambda x: (x.ts_utc, x.asset)):
         fee_u = f.fee / f.qty if f.qty else 0.0
-        if f.side == "buy":
-            lotti[f.asset].append([f.qty, f.price, f.ts_utc, fee_u])
-        else:
-            resto = f.qty
-            while resto > 1e-12 and lotti[f.asset]:
-                lq, lp, lts, lfee_u = lotti[f.asset][0]
-                usa = min(resto, lq)
-                lordo = usa * (f.price - lp)
-                quota_fee = usa * (lfee_u + fee_u)
-                ore = (datetime.fromisoformat(f.ts_utc) - datetime.fromisoformat(lts)).total_seconds() / 3600
-                rts.append(dict(asset=f.asset, qty=usa, ts_in=lts, px_in=lp, ts_out=f.ts_utc,
-                                px_out=f.price, ore_tenuta=ore, pnl_lordo=lordo,
-                                fee_quota=quota_fee, pnl_netto=lordo - quota_fee))
-                lq -= usa; resto -= usa
-                if lq <= 1e-12:
-                    lotti[f.asset].popleft()
-                else:
-                    lotti[f.asset][0][0] = lq
-    aperti = {a: [dict(qty=q, price=p, ts=t) for q, p, t, _ in dq] for a, dq in lotti.items() if dq}
+        segno_fill = 1 if f.side == "buy" else -1
+        dq = lotti[f.asset]
+        resto = f.qty
+        while resto > 1e-12 and dq and dq[0][4] == -segno_fill:
+            lq, lp, lts, lfee_u, lseg = dq[0]
+            usa = min(resto, lq)
+            # long chiuso da una vendita: (exit - entry); short chiuso da un acquisto: (entry - exit)
+            lordo = usa * (f.price - lp) if lseg == 1 else usa * (lp - f.price)
+            quota_fee = usa * (lfee_u + fee_u)
+            ore = (datetime.fromisoformat(f.ts_utc) - datetime.fromisoformat(lts)).total_seconds() / 3600
+            rts.append(dict(asset=f.asset, qty=usa, ts_in=lts, px_in=lp, ts_out=f.ts_utc,
+                            px_out=f.price, ore_tenuta=ore, pnl_lordo=lordo,
+                            fee_quota=quota_fee, pnl_netto=lordo - quota_fee,
+                            direzione=("long" if lseg == 1 else "short")))
+            lq -= usa; resto -= usa
+            if lq <= 1e-12:
+                dq.popleft()
+            else:
+                dq[0][0] = lq
+        if resto > 1e-12:                          # l'eccedenza apre/accoda nel segno del fill
+            dq.append([resto, f.price, f.ts_utc, fee_u, segno_fill])
+    aperti = {a: [dict(qty=q, price=p, ts=t, direzione=("long" if s == 1 else "short"))
+                  for q, p, t, _, s in dq] for a, dq in lotti.items() if dq}
     return rts, aperti
 
 
@@ -332,8 +344,12 @@ def upsert_equity(con: sqlite3.Connection, punti: list[tuple[str, float, str]])
 
 
 def rebuild_roundtrips(con: sqlite3.Connection) -> int:
-    """Ricalcola da zero: i round-trip sono DERIVATI, mai inseriti a mano."""
-    righe = con.execute("SELECT * FROM fills ORDER BY ts_utc, asset").fetchall()
+    """Ricalcola da zero: i round-trip sono DERIVATI, mai inseriti a mano.
+
+    `qty > 0` (#32 C10): un fill "NON VERIFICATO" da `place_order error` puo' arrivare a
+    qty 0 — non e' un trade, resta nel DB marcato (`verified=0`) ma fuori dal FIFO.
+    """
+    righe = con.execute("SELECT * FROM fills WHERE qty > 0 ORDER BY ts_utc, asset").fetchall()
     fills = [Fill(ts_utc=r["ts_utc"], asset=r["asset"], side=r["side"], qty=r["qty"],
                   price=r["price"], fee=r["fee"]) for r in righe]
     rts, _ = fifo_roundtrips(fills)
@@ -358,7 +374,8 @@ def get_meta(con: sqlite3.Connection, k: str, default=None):
 
 
 def stato_aperto(con: sqlite3.Connection) -> dict:
-    righe = con.execute("SELECT * FROM fills ORDER BY ts_utc, asset").fetchall()
+    # qty > 0 (#32 C10): stessa esclusione di rebuild_roundtrips, un fill a qty 0 non e' posizione.
+    righe = con.execute("SELECT * FROM fills WHERE qty > 0 ORDER BY ts_utc, asset").fetchall()
     fills = [Fill(ts_utc=r["ts_utc"], asset=r["asset"], side=r["side"], qty=r["qty"],
                   price=r["price"], fee=r["fee"]) for r in righe]
     _, aperti = fifo_roundtrips(fills)
@@ -366,7 +383,10 @@ def stato_aperto(con: sqlite3.Connection) -> dict:
     for a, lotti in aperti.items():
         q = sum(x["qty"] for x in lotti)
         costo = sum(x["qty"] * x["price"] for x in lotti)
-        out[a] = dict(qty=q, prezzo_medio=costo / q if q else 0.0, dal=min(x["ts"] for x in lotti))
+        # un asset ha un solo segno di lotti aperti alla volta (fifo_roundtrips chiude prima
+        # il lato opposto): la direzione del primo lotto vale per tutti (#32 C2).
+        out[a] = dict(qty=q, prezzo_medio=costo / q if q else 0.0, dal=min(x["ts"] for x in lotti),
+                      direzione=lotti[0]["direzione"])
     return out