wraith-tdf-predictor 0.7.0__py3-none-any.whl

tdf_predictor/__init__.py

@@ -0,0 +1,5 @@
+"""Tour de France race outcome prediction."""
+
+from importlib.metadata import version
+
+__version__ = version("wraith-tdf-predictor")

tdf_predictor/db.py

@@ -0,0 +1,85 @@
+"""Load data/raw/*.json into data/races.db (SQLite).
+
+Run: uv run python -m tdf_predictor.db
+"""
+
+# ponytail: stdlib sqlite3 file DB; swap for Turso when multi-host
+# access is actually needed
+
+import json
+import sqlite3
+import sys
+from pathlib import Path
+
+from tdf_predictor.ingest import DATA_DIR, RAW_DIR
+
+DB_PATH = DATA_DIR / "races.db"
+
+SCHEMA = """
+CREATE TABLE IF NOT EXISTS races (
+    race TEXT NOT NULL,
+    year INTEGER NOT NULL,
+    kind TEXT NOT NULL,
+    date TEXT,
+    source TEXT,
+    PRIMARY KEY (race, year)
+);
+CREATE TABLE IF NOT EXISTS results (
+    race TEXT NOT NULL,
+    year INTEGER NOT NULL,
+    rider TEXT NOT NULL,
+    rider_url TEXT,
+    team TEXT,
+    rank INTEGER,
+    status TEXT,
+    age INTEGER,
+    nationality TEXT,
+    time TEXT,
+    pcs_points REAL,
+    uci_points REAL,
+    PRIMARY KEY (race, year, rider)
+);
+CREATE INDEX IF NOT EXISTS idx_results_rider ON results (rider_url);
+"""
+
+
+def load(db_path: Path = DB_PATH, raw_dir: Path = RAW_DIR) -> int:
+    con = sqlite3.connect(db_path)
+    con.executescript(SCHEMA)
+    n = 0
+    for f in sorted(raw_dir.glob("*.json")):
+        if f.name.startswith("_"):
+            continue
+        d = json.loads(f.read_text())
+        con.execute(
+            "INSERT OR REPLACE INTO races VALUES (?,?,?,?,?)",
+            (d["race"], d["year"], d["kind"], d["date"], d["source"]),
+        )
+        con.executemany(
+            "INSERT OR REPLACE INTO results VALUES (?,?,?,?,?,?,?,?,?,?,?,?)",
+            [
+                (
+                    d["race"],
+                    d["year"],
+                    r["rider_name"],
+                    r["rider_url"],
+                    r["team_name"],
+                    r["rank"],
+                    r["status"],
+                    r["age"],
+                    r["nationality"],
+                    r["time"],
+                    r["pcs_points"],
+                    r["uci_points"],
+                )
+                for r in d["results"]
+            ],
+        )
+        n += len(d["results"])
+    con.commit()
+    con.close()
+    return n
+
+
+if __name__ == "__main__":
+    print(f"loaded {load()} result rows into {DB_PATH}", file=sys.stderr)

tdf_predictor/fantasy.py

@@ -0,0 +1,439 @@
+"""Tissot fantasy team picker: 8 riders, <=120 stars, max points.
+
+Proxy for fantasy points: PCS points over TDF stages + final GC.
+Predict a rider's TDF points from pre-Tour season form (ridge
+regression), synthesize past-year star costs by quantile-mapping form
+onto the 2026 cost distribution, pick the team by exact knapsack DP,
+and backtest leave-one-year-out against the hindsight-optimal team.
+Run: uv run python -m tdf_predictor.fantasy
+"""
+
+import csv
+import json
+import math
+import sys
+import unicodedata
+from collections import defaultdict
+
+from tdf_predictor import tissot
+from tdf_predictor.ingest import DATA_DIR, RAW_DIR
+
+STAGE_DIR = RAW_DIR / "stages"
+RIDERS_CSV = DATA_DIR / "riders.csv"
+BUDGET = 120
+TEAM_SIZE = 8
+BACKTEST_YEARS = range(2021, 2026)
+
+# Tissot squad caps (rules art 4.1.2.5 / "Building your team")
+CATEGORY_CAPS = {
+    "Leaders": 3,
+    "All-rounders": 5,
+    "Sprinters": 3,
+    "Climbers": 3,
+}
+
+
+# NFKD drops these instead of transliterating them
+_TRANS = str.maketrans(
+    {
+        "ß": "ss",
+        "ł": "l",
+        "Ł": "L",
+        "ø": "o",
+        "Ø": "O",
+        "đ": "d",
+        "Đ": "D",
+        "æ": "ae",
+        "Æ": "AE",
+    }
+)
+
+
+def name_key(name: str) -> frozenset:
+    """Order/accent/case-insensitive name key.
+
+    'Tadej POGAČAR' and 'Pogačar Tadej' -> same key.
+    """
+    s = unicodedata.normalize("NFKD", name.translate(_TRANS))
+    s = s.encode("ascii", "ignore").decode()
+    for ch in "'’":
+        s = s.replace(ch, "")
+    for ch in "-.":
+        s = s.replace(ch, " ")
+    return frozenset(s.upper().split())
+
+
+def match_rider(key: frozenset, by_key: dict) -> str | None:
+    """Exact key match, else unique-subset match.
+
+    Tissot uses full legal names ('Jonas VINGEGAARD HANSEN'); PCS
+    doesn't ('Vingegaard Jonas') — PCS key ⊆ Tissot key counts.
+    """
+    if key in by_key:
+        return by_key[key]
+    cands = {u for k, u in by_key.items() if k <= key}
+    return cands.pop() if len(cands) == 1 else None
+
+
+def load_stage_points() -> dict:
+    """(year, rider_url) -> summed Tissot stage points (finish + KOM +
+    jersey bonuses; see tdf_predictor.tissot)."""
+    pts = defaultdict(float)
+    for f in sorted(STAGE_DIR.glob("*.json")):
+        d = json.loads(f.read_text())
+        for url, p in tissot.stage_points(d).items():
+            pts[(d["year"], url)] += p
+    return dict(pts)
+
+
+def proxy_points(rows: list[dict], stage_pts: dict) -> dict:
+    """(year, rider_url) -> summed Tissot stage points, for riders who
+    appear in a TDF GC (i.e. started and finished). GC standing is
+    already scored per stage via the yellow-jersey bonus, so there is no
+    separate final-GC term."""
+    out = {}
+    for r in rows:
+        if r["race"] != "tour-de-france":
+            continue
+        key = (r["year"], r["rider_url"])
+        out[key] = stage_pts.get(key, 0.0)
+    return out
+
+
+def season_form(rows: list[dict], year: int) -> dict:
+    """rider_url -> feature vector from results before July of year.
+
+    Last feature is freshness: previous-year pre-July race count minus
+    this year's — positive means racing less than usual, fresher legs.
+    """
+    cutoff = f"{year}-07-01"
+    prev_cutoff = f"{year - 1}-07-01"
+    cur = defaultdict(list)
+    prev, prev_n = defaultdict(float), defaultdict(int)
+    for r in rows:
+        if r["year"] == year and r["date"] < cutoff:
+            cur[r["rider_url"]].append(r)
+        elif r["year"] == year - 1:
+            prev[r["rider_url"]] += r["pcs_points"] or 0
+            if r["date"] < prev_cutoff:
+                prev_n[r["rider_url"]] += 1
+    feats = {}
+    for u, rs in cur.items():
+        ranks = [x["rank"] for x in rs]
+        pcs = [x["pcs_points"] or 0 for x in rs]
+        gc = sum(p for x, p in zip(rs, pcs) if x["kind"] == "gc")
+        feats[u] = [
+            len(rs),
+            sum(pcs),
+            gc,
+            sum(pcs) - gc,
+            min(ranks),
+            sum(k <= 10 for k in ranks) / len(ranks),
+            prev[u],
+            prev_n[u] - len(rs),
+        ]
+    return feats
+
+
+def tour_teams(year: int) -> dict:
+    """rider_url -> team name from that year's first TDF stage file
+    (startlist proxy)."""
+    for f in sorted(STAGE_DIR.glob(f"tdf-{year}-stage*.json")):
+        d = json.loads(f.read_text())
+        return {r["rider_url"]: r["team_name"] for r in d["results"]}
+    return {}
+
+
+def build_features(rows, actual, year, teams=None) -> dict:
+    """Season form + team strength: teammates' previous-Tour proxy
+    points — cohesion/tactics proxy, strong squads control races."""
+    feats = season_form(rows, year)
+    teams = teams or tour_teams(year)
+    tot = defaultdict(float)
+    for u, t in teams.items():
+        tot[t] += actual.get((year - 1, u), 0.0)
+    out = {}
+    for u, f in feats.items():
+        mates = 0.0
+        if u in teams:
+            mates = tot[teams[u]] - actual.get((year - 1, u), 0.0)
+        out[u] = f + [mates]
+    return out
+
+
+def _solve(a: list[list[float]], b: list[float]) -> list[float]:
+    """Gaussian elimination with partial pivoting."""
+    n = len(a)
+    m = [row[:] + [bv] for row, bv in zip(a, b)]
+    for i in range(n):
+        p = max(range(i, n), key=lambda r: abs(m[r][i]))
+        m[i], m[p] = m[p], m[i]
+        for r in range(i + 1, n):
+            f = m[r][i] / m[i][i]
+            for c in range(i, n + 1):
+                m[r][c] -= f * m[i][c]
+    x = [0.0] * n
+    for i in range(n - 1, -1, -1):
+        s = sum(m[i][c] * x[c] for c in range(i + 1, n))
+        x[i] = (m[i][n] - s) / m[i][i]
+    return x
+
+
+def fit_ridge(X, y, lam: float = 1.0):
+    """Closed-form ridge on log1p(points); returns weight vector."""
+    # ponytail: pure-python normal equations; features stay <10 wide
+    rows = [list(r) + [1.0] for r in X]
+    n = len(rows[0])
+    yl = [math.log1p(v) for v in y]
+    a = [
+        [
+            sum(r[i] * r[j] for r in rows) + (lam if i == j else 0.0)
+            for j in range(n)
+        ]
+        for i in range(n)
+    ]
+    b = [sum(r[i] * v for r, v in zip(rows, yl)) for i in range(n)]
+    return _solve(a, b)
+
+
+def predict_points(w, X) -> list[float]:
+    return [
+        max(math.expm1(sum(a * b for a, b in zip(list(r) + [1.0], w))), 0.0)
+        for r in X
+    ]
+
+
+def synth_costs(pred: list[float], cost_pool: list[int]) -> list[int]:
+    """Map predicted-points ranks onto the 2026 star distribution."""
+    pool = sorted(cost_pool, reverse=True)
+    order = sorted(range(len(pred)), key=lambda i: -pred[i])
+    costs = [0] * len(pred)
+    for rank, i in enumerate(order):
+        q = rank / max(len(pred) - 1, 1)
+        costs[i] = pool[round(q * (len(pool) - 1))]
+    return costs
+
+
+def _cat_exact(idxs, costs, points, budget, cap):
+    """Per-category knapsack: dp[k][b] = max points for exactly k riders
+    of this category at total cost exactly b. Returns (dp, take)."""
+    neg = float("-inf")
+    dp = [[neg] * (budget + 1) for _ in range(cap + 1)]
+    dp[0][0] = 0.0
+    take = {}
+    for pos, i in enumerate(idxs):
+        c, p = costs[i], points[i]
+        for k in range(min(cap, pos + 1), 0, -1):
+            for b in range(budget, c - 1, -1):
+                cand = dp[k - 1][b - c] + p
+                if cand > dp[k][b]:
+                    dp[k][b] = cand
+                    take[(pos, k, b)] = True
+    return dp, take
+
+
+def pick_team(
+    costs: list[int],
+    points: list[float],
+    categories: list[str] | None = None,
+    budget: int = BUDGET,
+    size: int = TEAM_SIZE,
+    caps: dict[str, int] | None = None,
+) -> list[int]:
+    """Exact 0/1 knapsack with cardinality: indices of the best team.
+
+    With `categories` (one per rider), also enforces the Tissot squad
+    caps in `caps` (default CATEGORY_CAPS): solved as per-category
+    knapsacks combined over the budget so no category exceeds its cap.
+    """
+    if categories is None:
+        neg = float("-inf")
+        dp = [[neg] * (budget + 1) for _ in range(size + 1)]
+        dp[0][0] = 0.0
+        take = {}
+        for i, (c, p) in enumerate(zip(costs, points)):
+            for n in range(min(i + 1, size), 0, -1):
+                for b in range(budget, c - 1, -1):
+                    cand = dp[n - 1][b - c] + p
+                    if cand > dp[n][b]:
+                        dp[n][b] = cand
+                        take[(i, n, b)] = True
+        b = max(range(budget + 1), key=lambda x: dp[size][x])
+        if dp[size][b] == neg:
+            raise ValueError("no feasible team")
+        team, n = [], size
+        for i in range(len(costs) - 1, -1, -1):
+            if take.get((i, n, b)):
+                team.append(i)
+                b -= costs[i]
+                n -= 1
+        return sorted(team)
+
+    caps = caps or CATEGORY_CAPS
+    neg = float("-inf")
+    groups: dict[str, list[int]] = defaultdict(list)
+    for i, cat in enumerate(categories):
+        groups[cat].append(i)
+    tables = {
+        cat: _cat_exact(idxs, costs, points, budget, caps.get(cat, size))
+        for cat, idxs in groups.items()
+    }
+
+    # combine categories over the budget; bp[ci][(k,b)] = (pk,pb,kc,bc)
+    cat_list = list(tables)
+    comb = [[neg] * (budget + 1) for _ in range(size + 1)]
+    comb[0][0] = 0.0
+    bp = []
+    for cat in cat_list:
+        dp, _ = tables[cat]
+        cap = caps.get(cat, size)
+        new = [[neg] * (budget + 1) for _ in range(size + 1)]
+        choice = {}
+        for k in range(size + 1):
+            for b in range(budget + 1):
+                if comb[k][b] == neg:
+                    continue
+                base = comb[k][b]
+                for kc in range(min(cap, size - k) + 1):
+                    for bc in range(budget - b + 1):
+                        v = dp[kc][bc]
+                        if v == neg:
+                            continue
+                        if base + v > new[k + kc][b + bc]:
+                            new[k + kc][b + bc] = base + v
+                            choice[(k + kc, b + bc)] = (k, b, kc, bc)
+        comb, _ = new, bp.append(choice)
+
+    b = max(range(budget + 1), key=lambda x: comb[size][x])
+    if comb[size][b] == neg:
+        raise ValueError("no feasible team")
+    team, k = [], size
+    for ci in range(len(cat_list) - 1, -1, -1):
+        pk, pb, kc, bc = bp[ci][(k, b)]
+        idxs = groups[cat_list[ci]]
+        _, take = tables[cat_list[ci]]
+        kk, bb = kc, bc
+        for pos in range(len(idxs) - 1, -1, -1):
+            if kk and take.get((pos, kk, bb)):
+                team.append(idxs[pos])
+                bb -= costs[idxs[pos]]
+                kk -= 1
+        k, b = pk, pb
+    return sorted(team)
+
+
+def _soft_cap(p: float, cap: float) -> float:
+    """Compress predictions above cap instead of clipping, so
+    co-favourites keep their ordering (there can be only one)."""
+    return p if p <= cap else cap + math.log1p(p - cap)
+
+
+def _train_predict(rows, actual, train_years, target_year, teams=None):
+    Xtr, ytr = [], []
+    for yr in train_years:
+        feats = build_features(rows, actual, yr)
+        for u, f in feats.items():
+            if (yr, u) in actual:
+                Xtr.append(f)
+                ytr.append(actual[(yr, u)])
+    feats = build_features(rows, actual, target_year, teams)
+    urls = sorted(feats)
+    Xte = [feats[u] for u in urls]
+    preds = predict_points(fit_ridge(Xtr, ytr), Xte)
+    cap = max(ytr)  # expm1 extrapolation can explode off-scale
+    return {u: _soft_cap(p, cap) for u, p in zip(urls, preds)}
+
+
+def load_tissot_roster() -> list[dict]:
+    with RIDERS_CSV.open() as f:
+        return [
+            {
+                "name": r["name"],
+                "team": r["team"],
+                "category": r["category"],
+                "stars": int(r["stars"]),
+            }
+            for r in csv.DictReader(f)
+            if r["stars"].isdigit()
+        ]
+
+
+def backtest() -> None:  # pragma: no cover
+    from tdf_predictor.model import load_rows
+
+    rows = load_rows()
+    actual = proxy_points(rows, load_stage_points())
+    cost_pool = [r["stars"] for r in load_tissot_roster()]
+    print("year  ridge  optimal  share  random")
+    for yr in BACKTEST_YEARS:
+        train = [y for y in BACKTEST_YEARS if y != yr]
+        preds = _train_predict(rows, actual, train, yr)
+        starters = sorted(u for (y, u) in actual if y == yr and u in preds)
+        pred = [preds[u] for u in starters]
+        real = [actual[(yr, u)] for u in starters]
+        costs = synth_costs(pred, cost_pool)
+        team = pick_team(costs, pred)
+        got = sum(real[i] for i in team)
+        best = sum(real[i] for i in pick_team(costs, real))
+        rnd = sum(real) / len(real) * TEAM_SIZE
+        print(f"{yr}  {got:5.0f}  {best:7.0f}  {got / best:5.0%}  {rnd:6.0f}")
+
+
+def roster_predictions() -> list[dict]:  # pragma: no cover
+    """Tissot roster with predicted 2026 TDF proxy points attached."""
+    from tdf_predictor.model import load_rows
+
+    rows = load_rows()
+    actual = proxy_points(rows, load_stage_points())
+    by_key = {}
+    for r in rows:
+        by_key.setdefault(name_key(r["rider"]), r["rider_url"])
+
+    roster = load_tissot_roster()
+    for r in roster:
+        r["url"] = match_rider(name_key(r["name"]), by_key)
+    teams = {r["url"]: r["team"] for r in roster if r["url"]}
+    preds = _train_predict(
+        rows, actual, list(BACKTEST_YEARS), 2026, teams=teams
+    )
+    # expanding-window backcast (2023-25): 0.5*ridge + 0.5*prior-TDF
+    # actual beat pure ridge every year (66/63/61% vs 65/60/45% of
+    # the hindsight-optimal team)
+    prior_year = max(BACKTEST_YEARS)
+    for r in roster:
+        base = preds.get(r["url"], 0.0) if r["url"] else 0.0
+        prior = actual.get((prior_year, r["url"]), 0.0)
+        r["pred"] = 0.5 * base + 0.5 * prior
+    return roster
+
+
+def pick_2026() -> None:  # pragma: no cover
+    roster = roster_predictions()
+    points = [r["pred"] for r in roster]
+    unmatched = [r["name"] for r in roster if not r["url"]]
+    costs = [r["stars"] for r in roster]
+    cats = [r["category"] for r in roster]
+    team = pick_team(costs, points, cats)
+
+    print(
+        f"\n=== 2026 Tissot team ({TEAM_SIZE} riders, "
+        f"{sum(costs[i] for i in team)}/{BUDGET} stars) ==="
+    )
+    for i in sorted(team, key=lambda i: -points[i]):
+        r = roster[i]
+        print(
+            f"{points[i]:6.0f}  {r['stars']:>2}★  "
+            f"{r['name']:<26.26} {r['category']:<12} {r['team']}"
+        )
+    print(f"expected proxy points: {sum(points[i] for i in team):.0f}")
+    if unmatched:
+        print(
+            f"({len(unmatched)} roster riders with no PCS match, "
+            f"treated as 0 pts)",
+            file=sys.stderr,
+        )
+
+
+if __name__ == "__main__":
+    backtest()
+    pick_2026()