225 lines
8.4 KiB
Python
225 lines
8.4 KiB
Python
"""
|
||
CLV Report — the single most important edge metric.
|
||
===================================================
|
||
Closing Line Value = did we bet at better odds than the market's closing line?
|
||
Consistently positive CLV is the only reliable proof of a real betting edge;
|
||
negative CLV means no edge, regardless of short-term wins/losses.
|
||
|
||
This codebase stores the BET-TIME odds for ~92% of runs (prediction_runs.
|
||
odds_snapshot.source = 'live_match' with the live odds blob, and the pick's
|
||
odds in payload main_pick.odds). For the closing line we use, in order:
|
||
1. odds_snapshot.closing_odds (captured by capture_closing_odds.py, forward)
|
||
2. odd_selections current value (the static near-final capture — a proxy)
|
||
|
||
CLV per bet = bet_odds / closing_odds - 1 (positive = beat the close = good).
|
||
|
||
Read-only. SELECT only.
|
||
Usage:
|
||
python scripts/clv_report.py
|
||
python scripts/clv_report.py --staked-only
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import argparse
|
||
import json
|
||
import os
|
||
import sys
|
||
from collections import defaultdict
|
||
from typing import Any, Dict, Optional, Tuple
|
||
|
||
if sys.stdout and hasattr(sys.stdout, "reconfigure"):
|
||
try:
|
||
sys.stdout.reconfigure(encoding="utf-8")
|
||
except Exception:
|
||
pass
|
||
|
||
SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
|
||
AI_ENGINE_DIR = os.path.dirname(SCRIPT_DIR)
|
||
sys.path.insert(0, AI_ENGINE_DIR)
|
||
|
||
from data.db import get_clean_dsn # noqa: E402
|
||
import psycopg2 # noqa: E402
|
||
from psycopg2.extras import RealDictCursor # noqa: E402
|
||
|
||
# market code -> (Turkish odds-category name, pick-normalizer -> selection key)
|
||
OU_CATS = {"OU05": "0,5 Alt/Üst", "OU15": "1,5 Alt/Üst", "OU25": "2,5 Alt/Üst",
|
||
"OU35": "3,5 Alt/Üst", "OU45": "4,5 Alt/Üst"}
|
||
|
||
|
||
def _f(x: Any, d: Optional[float] = None) -> Optional[float]:
|
||
try:
|
||
return float(x) if x is not None else d
|
||
except (TypeError, ValueError):
|
||
return d
|
||
|
||
|
||
def _parse(j: Any) -> Dict[str, Any]:
|
||
if isinstance(j, str):
|
||
try:
|
||
return json.loads(j)
|
||
except Exception:
|
||
return {}
|
||
return j or {}
|
||
|
||
|
||
def map_pick(market: str, pick: str) -> Optional[Tuple[str, str]]:
|
||
"""Return (category_name, selection_key) for the live-odds JSON / odd_selections."""
|
||
m = (market or "").upper()
|
||
p = (pick or "").strip()
|
||
pl = p.casefold()
|
||
if m in ("MS", "ML", "1X2"):
|
||
return ("Maç Sonucu", p if p in ("1", "X", "2") else None) if p in ("1", "X", "2") else None
|
||
if m == "HT":
|
||
return ("1. Yarı Sonucu", p) if p in ("1", "X", "2") else None
|
||
if m in OU_CATS:
|
||
if "üst" in pl or "ust" in pl or "over" in pl:
|
||
return (OU_CATS[m], "Üst")
|
||
if "alt" in pl or "under" in pl:
|
||
return (OU_CATS[m], "Alt")
|
||
return None
|
||
if m == "DC":
|
||
key = p.upper().replace(" ", "").replace("/", "-")
|
||
norm = {"1X": "1-X", "X1": "1-X", "X2": "X-2", "2X": "X-2",
|
||
"12": "1-2", "21": "1-2", "1-X": "1-X", "X-2": "X-2", "1-2": "1-2"}.get(key)
|
||
return ("Çifte Şans", norm) if norm else None
|
||
if m == "BTTS":
|
||
if "var" in pl or "yes" in pl:
|
||
return ("Karşılıklı Gol", "Var")
|
||
if "yok" in pl or "no" in pl:
|
||
return ("Karşılıklı Gol", "Yok")
|
||
return None
|
||
if m == "OE":
|
||
if "tek" in pl or "odd" in pl:
|
||
return ("Tek/Çift", "Tek")
|
||
if "çift" in pl or "cift" in pl or "even" in pl:
|
||
return ("Tek/Çift", "Çift")
|
||
return None
|
||
return None
|
||
|
||
|
||
def closing_from_blob(blob: Any, cat: str, sel: str) -> Optional[float]:
|
||
blob = _parse(blob)
|
||
cat_map = blob.get(cat) if isinstance(blob, dict) else None
|
||
if isinstance(cat_map, dict):
|
||
return _f(cat_map.get(sel))
|
||
return None
|
||
|
||
|
||
def main() -> int:
|
||
ap = argparse.ArgumentParser(description=__doc__)
|
||
ap.add_argument("--staked-only", action="store_true",
|
||
help="Only playable/staked bets (default: all picks with a mappable market)")
|
||
args = ap.parse_args()
|
||
|
||
rows_out = []
|
||
with psycopg2.connect(get_clean_dsn()) as conn:
|
||
with conn.cursor(cursor_factory=RealDictCursor) as cur:
|
||
cur.execute("""
|
||
SELECT match_id, engine_version, odds_snapshot, payload_summary,
|
||
eventual_outcome, unit_profit
|
||
FROM prediction_runs
|
||
WHERE odds_snapshot->>'source' = 'live_match'
|
||
ORDER BY generated_at ASC
|
||
""")
|
||
runs = cur.fetchall()
|
||
|
||
for r in runs:
|
||
snap = _parse(r["odds_snapshot"])
|
||
ps = _parse(r["payload_summary"])
|
||
mp = ps.get("main_pick") or {}
|
||
market = mp.get("market")
|
||
pick = mp.get("pick")
|
||
bet_odds = _f(mp.get("odds"))
|
||
playable = bool(mp.get("playable"))
|
||
if args.staked_only and not playable:
|
||
continue
|
||
if not market or not pick or not bet_odds or bet_odds <= 1.0:
|
||
continue
|
||
mapped = map_pick(market, pick)
|
||
if not mapped or not mapped[1]:
|
||
continue
|
||
cat, sel = mapped
|
||
|
||
# closing line: prefer captured closing_odds, else static odd_selections
|
||
closing = closing_from_blob(snap.get("closing_odds"), cat, sel)
|
||
src = "captured"
|
||
if closing is None:
|
||
cur.execute("""
|
||
SELECT os.odd_value FROM odd_categories oc
|
||
JOIN odd_selections os ON os.odd_category_db_id = oc.db_id
|
||
WHERE oc.match_id = %s AND oc.name = %s AND os.name = %s
|
||
LIMIT 1
|
||
""", (r["match_id"], cat, sel))
|
||
row = cur.fetchone()
|
||
closing = _f(row["odd_value"]) if row else None
|
||
src = "static_proxy"
|
||
if closing is None or closing <= 1.0:
|
||
continue
|
||
|
||
clv = bet_odds / closing - 1.0
|
||
rows_out.append({
|
||
"market": market, "playable": playable,
|
||
"bet_odds": bet_odds, "closing": closing, "clv": clv,
|
||
"src": src, "profit": _f(r["unit_profit"], 0.0) or 0.0,
|
||
"settled": r["eventual_outcome"] is not None
|
||
and not str(r["eventual_outcome"]).startswith("NO_BET"),
|
||
})
|
||
|
||
if not rows_out:
|
||
print("No mappable runs with both bet-time and closing odds found.")
|
||
return 0
|
||
|
||
def agg(rs):
|
||
n = len(rs)
|
||
clvs = [x["clv"] for x in rs]
|
||
pos = sum(1 for c in clvs if c > 0)
|
||
return {
|
||
"n": n,
|
||
"mean_clv_pct": round(100.0 * sum(clvs) / n, 2),
|
||
"pct_positive": round(100.0 * pos / n, 1),
|
||
"captured": sum(1 for x in rs if x["src"] == "captured"),
|
||
}
|
||
|
||
print("=" * 70)
|
||
print("CLV REPORT — did we beat the closing line? (the edge compass)")
|
||
print("=" * 70)
|
||
o = agg(rows_out)
|
||
print(f"runs analyzed: {o['n']} (closing source: {o['captured']} captured, "
|
||
f"{o['n'] - o['captured']} static-proxy)")
|
||
print(f"\nOVERALL mean CLV: {o['mean_clv_pct']}% "
|
||
f"bets beating close: {o['pct_positive']}%")
|
||
print(" (positive mean CLV = real edge; ~0 or negative = no edge)\n")
|
||
|
||
staked = [x for x in rows_out if x["playable"]]
|
||
if staked:
|
||
s = agg(staked)
|
||
print(f"STAKED only: n={s['n']} mean CLV={s['mean_clv_pct']}% "
|
||
f"beating close={s['pct_positive']}%\n")
|
||
|
||
print("BY MARKET")
|
||
by_m = defaultdict(list)
|
||
for x in rows_out:
|
||
by_m[x["market"]].append(x)
|
||
for m, rs in sorted(by_m.items(), key=lambda kv: -len(kv[1])):
|
||
a = agg(rs)
|
||
print(f" {m:<8} n={a['n']:>4} mean CLV={a['mean_clv_pct']:>7}% "
|
||
f"beating close={a['pct_positive']:>5}%")
|
||
|
||
# CLV vs outcome sanity: do positive-CLV bets actually win more / lose less?
|
||
print("\nCLV vs realized P/L (settled staked)")
|
||
ss = [x for x in rows_out if x["playable"] and x["settled"]]
|
||
if ss:
|
||
posc = [x for x in ss if x["clv"] > 0]
|
||
negc = [x for x in ss if x["clv"] <= 0]
|
||
for label, grp in (("CLV>0", posc), ("CLV<=0", negc)):
|
||
if grp:
|
||
pr = sum(x["profit"] for x in grp)
|
||
print(f" {label:<7} n={len(grp):>3} profit={pr:>7.2f}u "
|
||
f"ROI(flat1u)={round(100*pr/len(grp),1)}%")
|
||
print("=" * 70)
|
||
return 0
|
||
|
||
|
||
if __name__ == "__main__":
|
||
raise SystemExit(main())
|