replace hardcoded demo with live World Cup model

README.md

@@ -9,20 +9,23 @@ python_version: "3.12"
 app_file: app.py
 pinned: false
 license: mit
-short_description: How much football chaos is coming?
+short_description: Live, explainable World Cup drama analytics
 ---
 
 # DramaMeter 2026
 
-Football is never just football. DramaMeter gives a match a 0–100 chaos score, names the flashpoints, rates a dodgy VAR moment, and turns the final whistle into a short fan-ready recap.
+A live football analytics product for the 2026 World Cup. Pick a current, upcoming or recent fixture and get a pre-match forecast, a live drama index, the match events behind it and a post-ready take.
 
-## What it does
+## What makes it real
 
-- **Match Forecast** — rivalry, team edge, tournament VAR heat and knockout stakes become one explainable Drama Score.
-- **VAR Moment** — paste a controversial incident and get a controversy rating, likely fan reaction and a historical echo.
-- **Full-time Recap** — turn a result and key moment into a sharp post-match report.
+- Loads the current 2026 World Cup schedule, scores and match statistics from ESPN Match Center's public JSON feed.
+- Retrains a gradient-boosted tree ensemble on every completed tournament match at startup.
+- Builds rolling pre-match features without using future match statistics.
+- Reports held-out MAE and improvement over a naive mean baseline instead of hiding model quality.
+- Replaces the forecast with an observed live index once a match starts.
+- Shows fetch time, data source, model inputs and feature importance in the UI.
 
-England vs Argentina is loaded by default. You can type any two teams.
+The observed target is an editorial proxy derived from fouls, cards, goals, score closeness, late goals, stage and extra time. It is not a claim about social-media sentiment and it is not betting advice.
 
 ## Run locally
 
@@ -33,10 +36,13 @@ pip install -r requirements.txt
 python app.py
 ```
 
-Run the tests with `python -m pytest`.
+Run tests with `python -m pytest`.
 
-## How the score works
+## Architecture
 
-The MVP uses a small, deterministic scoring model. Known rivalries have hand-tuned history and intensity ratings. Unknown matchups fall back to team profiles and a stable matchup value. The stage and VAR heat controls are always visible, so the score never pretends to come from a hidden live feed.
+- `feed.py` — live data client, 30–45 second cache and fixture selection
+- `drama.py` — rolling features, observed target and gradient-boosted model training
+- `app.py` — responsive Gradio product UI and data-driven match report
+- `tests/` — deterministic model and feed-contract tests
 
-This is a fan toy, not a betting model, a referee assessment, or a live data product.
+Data availability depends on ESPN's public Match Center endpoints. Cached data is used if a refresh fails after at least one successful request.

app.py

@@ -1,129 +1,270 @@
+from __future__ import annotations
+
+from datetime import datetime
 from html import escape
 
 import gradio as gr
 import spaces
 
-from drama import TEAMS, analyze_moment, match_forecast, post_match
+from drama import card_counts, competitors, h2h, observed_index, stat, train_and_score
+from feed import FeedError, MATCH_PAGE, find_event, fixture_choices, summary, tournament
 
 
-# The existing Space is pinned to ZeroGPU and refuses CPU-only apps without a marker.
 @spaces.GPU(duration=1)
 def zero_gpu_marker():
     return True
 
 
 CSS = """
-:root { --ink: #11110f; --paper: #f4f0e6; --lime: #c7ff2f; --red: #ff473d; }
-.gradio-container { background: var(--paper) !important; color: var(--ink); max-width: 1120px !important; }
-.hero { border: 4px solid var(--ink); background: var(--lime); padding: 28px; box-shadow: 8px 8px 0 var(--ink); margin: 18px 0 26px; }
-.hero h1 { font-size: clamp(2.7rem, 8vw, 6.6rem); line-height: .82; letter-spacing: -.07em; margin: 0; text-transform: uppercase; }
-.hero p { font-weight: 800; font-size: 1.05rem; margin: 18px 0 0; text-transform: uppercase; letter-spacing: .04em; }
-.score-card { border: 4px solid var(--ink); background: var(--ink); color: white; padding: 26px; box-shadow: 8px 8px 0 var(--red); min-height: 250px; }
-.score-card .fixture { color: var(--lime); font-weight: 900; text-transform: uppercase; letter-spacing: .08em; }
-.score-card .score { font-size: clamp(5rem, 13vw, 9rem); font-weight: 950; line-height: .8; letter-spacing: -.08em; margin: 24px 0 14px; }
-.score-card .score span { color: #8a8a84; font-size: .28em; letter-spacing: 0; }
-.score-card .verdict { background: var(--red); color: var(--ink); display: inline-block; font-weight: 950; padding: 8px 12px; transform: rotate(-1deg); }
-.moment-card { border: 4px solid var(--ink); padding: 24px; background: white; box-shadow: 8px 8px 0 var(--lime); }
-.moment-card strong { display: block; font-size: 4rem; line-height: 1; }
-.disclaimer { border-top: 2px solid var(--ink); margin-top: 30px; padding-top: 12px; font-size: .85rem; font-weight: 700; }
-button.primary { background: var(--red) !important; color: var(--ink) !important; border: 3px solid var(--ink) !important; box-shadow: 5px 5px 0 var(--ink) !important; font-weight: 950 !important; text-transform: uppercase; }
-button.primary:hover { transform: translate(2px, 2px); box-shadow: 3px 3px 0 var(--ink) !important; }
-.tab-nav button { font-weight: 900 !important; text-transform: uppercase; }
+:root, .dark {
+  --body-background-fill: #090b0d !important;
+  --body-text-color: #f5f3ed !important;
+  --block-background-fill: #12161a !important;
+  --block-border-color: #2b3238 !important;
+  --input-background-fill: #0d1013 !important;
+  --input-border-color: #384149 !important;
+  --input-placeholder-color: #7f898f !important;
+  --button-secondary-background-fill: #171c20 !important;
+  --button-secondary-text-color: #f5f3ed !important;
+}
+html, body, .gradio-container { background: #090b0d !important; color: #f5f3ed !important; }
+.gradio-container { max-width: 1180px !important; padding: 0 22px 60px !important; }
+.gradio-container label, .gradio-container .label-wrap span, .gradio-container .prose,
+.gradio-container p, .gradio-container h1, .gradio-container h2, .gradio-container h3 { color: #f5f3ed !important; }
+.topbar { display: flex; align-items: center; justify-content: space-between; gap: 24px; padding: 34px 0 26px; border-bottom: 1px solid #2b3238; }
+.brand { font: 900 clamp(2rem, 5vw, 4.4rem)/.85 Arial Black, sans-serif; letter-spacing: -.075em; text-transform: uppercase; }
+.brand span { color: #c7ff2f; }
+.tagline { max-width: 340px; color: #aab3b8; font-size: .9rem; line-height: 1.45; text-align: right; }
+.live-dot { display: inline-block; width: 8px; height: 8px; border-radius: 50%; background: #ff503f; margin-right: 8px; box-shadow: 0 0 0 5px #ff503f22; }
+.control-row { margin: 24px 0 18px; }
+#fixture { flex: 1; }
+#refresh { max-width: 180px; align-self: end; }
+button#refresh { min-height: 48px; background: #c7ff2f !important; color: #090b0d !important; border: 0 !important; font-weight: 900 !important; }
+.match-shell { border: 1px solid #30373d; background: #101418; overflow: hidden; }
+.match-head { display: flex; justify-content: space-between; align-items: center; gap: 16px; padding: 15px 20px; border-bottom: 1px solid #30373d; color: #aab3b8; font-size: .76rem; font-weight: 800; letter-spacing: .08em; text-transform: uppercase; }
+.status-live { color: #ff6557; }
+.scoreboard { display: grid; grid-template-columns: 1fr minmax(170px, .6fr) 1fr; align-items: center; gap: 24px; padding: 34px 28px 30px; }
+.team { display: flex; align-items: center; gap: 16px; min-width: 0; }
+.team.away { flex-direction: row-reverse; text-align: right; }
+.team img { width: 66px; height: 66px; object-fit: contain; }
+.team-name { font-size: clamp(1.1rem, 2.5vw, 1.85rem); font-weight: 900; }
+.team-form { color: #8c979d; font-size: .78rem; margin-top: 5px; }
+.score { text-align: center; font: 900 clamp(3rem, 8vw, 6.2rem)/.8 Arial Black, sans-serif; letter-spacing: -.08em; white-space: nowrap; }
+.clock { color: #c7ff2f; font-size: .78rem; font-weight: 900; letter-spacing: .08em; margin-top: 14px; }
+.index-band { display: grid; grid-template-columns: 230px 1fr; gap: 28px; padding: 26px 28px; background: #c7ff2f; color: #090b0d; }
+.index-band, .index-band * { color: #090b0d !important; }
+.index-number { font: 900 5rem/.8 Arial Black, sans-serif; letter-spacing: -.08em; }
+.index-label { font-weight: 900; font-size: .78rem; letter-spacing: .08em; margin-top: 14px; }
+.meter-track { height: 13px; background: #090b0d33; margin: 14px 0 12px; }
+.meter-fill { height: 100%; background: #090b0d; }
+.index-copy { font-weight: 750; line-height: 1.45; max-width: 630px; }
+.stat-grid { display: grid; grid-template-columns: repeat(6, 1fr); border-top: 1px solid #30373d; border-bottom: 1px solid #30373d; }
+.stat { padding: 19px 16px; border-right: 1px solid #30373d; }
+.stat:last-child { border-right: 0; }
+.stat b { display: block; font-size: 1.45rem; }
+.stat span { color: #879198; font-size: .7rem; font-weight: 800; letter-spacing: .06em; text-transform: uppercase; }
+.detail-grid { display: grid; grid-template-columns: 1fr 1fr; }
+.detail { padding: 26px 28px 30px; }
+.detail + .detail { border-left: 1px solid #30373d; }
+.detail h3 { margin: 0 0 18px; font-size: .78rem; letter-spacing: .08em; text-transform: uppercase; }
+.signal { display: flex; justify-content: space-between; gap: 20px; padding: 11px 0; border-bottom: 1px solid #262d32; color: #aeb7bc; }
+.signal b { color: #f5f3ed; }
+.event { display: grid; grid-template-columns: 58px 1fr; gap: 12px; padding: 10px 0; border-bottom: 1px solid #262d32; }
+.event time { color: #c7ff2f; font-weight: 900; }
+.event p { color: #c8ced1 !important; margin: 0; font-size: .86rem; line-height: 1.4; }
+.source-line { padding: 16px 28px; color: #778187; font-size: .72rem; border-top: 1px solid #30373d; }
+.source-line a { color: #c7ff2f !important; }
+.model-card { color: #bdc5c9; line-height: 1.55; }
+.model-grid { display: grid; grid-template-columns: repeat(4, 1fr); gap: 1px; background: #30373d; border: 1px solid #30373d; margin: 16px 0 20px; }
+.model-metric { background: #101418; padding: 18px; }
+.model-metric b { display: block; color: #f5f3ed; font-size: 1.55rem; }
+.model-metric span { font-size: .72rem; text-transform: uppercase; letter-spacing: .05em; }
+.error-card { border: 1px solid #ff6557; padding: 24px; color: #ffb0a9; background: #281411; }
+.footer-note { color: #6f797f; font-size: .72rem; padding: 18px 0; }
+@media (max-width: 760px) {
+  .topbar { align-items: flex-start; padding-top: 24px; }
+  .tagline { display: none; }
+  .scoreboard { grid-template-columns: 1fr 120px 1fr; padding: 26px 16px; gap: 8px; }
+  .team, .team.away { flex-direction: column; text-align: center; gap: 8px; }
+  .team img { width: 48px; height: 48px; }
+  .team-form { display: none; }
+  .index-band { grid-template-columns: 1fr; gap: 18px; }
+  .stat-grid { grid-template-columns: repeat(3, 1fr); }
+  .stat:nth-child(3) { border-right: 0; }
+  .detail-grid { grid-template-columns: 1fr; }
+  .detail + .detail { border-left: 0; border-top: 1px solid #30373d; }
+  .model-grid { grid-template-columns: repeat(2, 1fr); }
+}
 """
 
 
-def forecast(team_a, team_b, stage, var_heat):
-    result = match_forecast(team_a, team_b, stage, var_heat)
-    a, b = result["teams"]
-    card = f"""
-    <div class="score-card">
-      <div class="fixture">{escape(a)} vs {escape(b)}</div>
-      <div class="score">{result['score']}<span>/100</span></div>
-      <div class="verdict">{result['verdict']}</div>
-    </div>
+def logo(team: dict) -> str:
+    return escape(team.get("team", {}).get("logo", ""), quote=True)
+
+
+def timeline(summary_data: dict) -> str:
+    wanted = {"goal", "goal---header", "penalty---scored", "yellow-card", "red-card", "own-goal"}
+    events = [item for item in summary_data.get("keyEvents", []) if item.get("type", {}).get("type") in wanted]
+    rows = []
+    for item in events[-8:]:
+        minute = escape(item.get("clock", {}).get("displayValue", "—"))
+        text = escape(item.get("shortText") or item.get("text") or item.get("type", {}).get("text", "Match event"))
+        rows.append(f'<div class="event"><time>{minute}</time><p>{text}</p></div>')
+    return "".join(rows) or '<div class="signal"><span>No key events yet</span><b>Pre-match</b></div>'
+
+
+def match_html(event: dict, summary_data: dict, model: dict, meta: dict) -> tuple[str, str, str]:
+    home, away = competitors(event)
+    state = event["status"]["type"]["state"]
+    actual = observed_index(event) if state != "pre" else None
+    index = actual if actual is not None else model["forecast"]
+    index_kind = "LIVE DRAMA INDEX" if state == "in" else "FINAL DRAMA INDEX" if state == "post" else "PRE-MATCH FORECAST"
+    status = event["status"]["type"]["description"]
+    kickoff = datetime.fromisoformat(event["date"].replace("Z", "+00:00")).strftime("%b %d · %H:%M UTC")
+    clock = kickoff if state == "pre" else event["status"].get("displayClock", "FT")
+    scoreline = "VS" if state == "pre" else f"{home.get('score', '–')}–{away.get('score', '–')}"
+    yellow, red = card_counts(event)
+    fouls = round(stat(home, "foulsCommitted") + stat(away, "foulsCommitted"))
+    shots = round(stat(home, "totalShots") + stat(away, "totalShots"))
+    on_target = round(stat(home, "shotsOnTarget") + stat(away, "shotsOnTarget"))
+    h2h_data = h2h(summary_data)
+    venue = summary_data.get("gameInfo", {}).get("venue", {})
+    officials = summary_data.get("gameInfo", {}).get("officials", [])
+    referee = officials[0].get("displayName", "Not listed") if officials else "Not listed"
+    stage = model["features"]["stage"]
+    stale = " · cached fallback" if meta.get("stale") else ""
+
+    if state == "pre":
+        lead = f"The model expects {stage.lower()} pressure, based on both teams’ tournament form before kickoff."
+    else:
+        lead = f"{fouls} fouls, {yellow + red} cards and {shots} shots are driving the live index. Pre-match model: {model['forecast']}/100."
+
+    top_signals = "".join(
+        f'<div class="signal"><span>{escape(name.title())}</span><b>{weight:.1f}%</b></div>'
+        for name, weight in model["importances"][:5]
+    )
+    dashboard = f"""
+    <section class="match-shell">
+      <div class="match-head">
+        <span class="{'status-live' if state == 'in' else ''}">{escape(status)} · {escape(clock)}</span>
+        <span>{escape(stage)} · {escape(venue.get('fullName', 'Venue TBC'))}</span>
+      </div>
+      <div class="scoreboard">
+        <div class="team">
+          <img src="{logo(home)}" alt="{escape(home['team']['displayName'])} badge">
+          <div><div class="team-name">{escape(home['team']['displayName'])}</div><div class="team-form">FORM {escape(home.get('form') or '—')}</div></div>
+        </div>
+        <div class="score">{escape(scoreline)}<div class="clock">{escape(clock)}</div></div>
+        <div class="team away">
+          <img src="{logo(away)}" alt="{escape(away['team']['displayName'])} badge">
+          <div><div class="team-name">{escape(away['team']['displayName'])}</div><div class="team-form">FORM {escape(away.get('form') or '—')}</div></div>
+        </div>
+      </div>
+      <div class="index-band">
+        <div><div class="index-number">{index}</div><div class="index-label">{index_kind}</div></div>
+        <div class="index-copy"><div class="meter-track"><div class="meter-fill" style="width:{index}%"></div></div>{escape(lead)}</div>
+      </div>
+      <div class="stat-grid">
+        <div class="stat"><b>{model['forecast']}</b><span>Model forecast</span></div>
+        <div class="stat"><b>{model['confidence']}%</b><span>Confidence</span></div>
+        <div class="stat"><b>{fouls or '—'}</b><span>Fouls</span></div>
+        <div class="stat"><b>{yellow + red or '—'}</b><span>Cards</span></div>
+        <div class="stat"><b>{shots or '—'}</b><span>Shots</span></div>
+        <div class="stat"><b>{on_target or '—'}</b><span>On target</span></div>
+      </div>
+      <div class="detail-grid">
+        <div class="detail"><h3>What the model sees</h3>{top_signals}</div>
+        <div class="detail"><h3>Match timeline</h3>{timeline(summary_data)}</div>
+      </div>
+      <div class="stat-grid">
+        <div class="stat"><b>{h2h_data['games']}</b><span>Recent H2H</span></div>
+        <div class="stat"><b>{h2h_data['world_cups']}</b><span>World Cup H2H</span></div>
+        <div class="stat"><b>{h2h_data['shootouts']}</b><span>H2H shootouts</span></div>
+        <div class="stat"><b>{escape(referee)}</b><span>Referee</span></div>
+        <div class="stat"><b>{model['features']['home_ppg']}</b><span>Home PPG</span></div>
+        <div class="stat"><b>{model['features']['away_ppg']}</b><span>Away PPG</span></div>
+      </div>
+      <div class="source-line">Live match data from <a href="{MATCH_PAGE.format(event['id'])}" target="_blank">ESPN Match Center</a> · fetched {escape(meta['fetched_at'])}{stale} · refresh cache 30–45 seconds</div>
+    </section>
     """
-    factors = " · ".join(f"**{name}:** {value}" for name, value in result["factors"].items())
-    stories = "\n".join(f"{i}. {line}" for i, line in enumerate(result["narratives"], 1))
-    breakdown = f"### Why it could kick off\n\n{stories}\n\n---\n{factors}"
-    share = f"{a} vs {b}: {result['score']}/100 on the DramaMeter. {result['verdict']}. Who loses their head first? #DramaMeter2026"
-    return card, breakdown, share
-
-
-def controversy(text, minute, tension):
-    result = analyze_moment(text, minute, tension)
-    card = f"""
-    <div class="moment-card">
-      <span>CONTROVERSY RATING</span>
-      <strong>{result['score']}/100</strong>
-      <p>{escape(result['reaction'])}</p>
+    model_card = f"""
+    <div class="model-card">
+      <p>This is a live, explainable model — not an LLM guess. A gradient-boosted tree ensemble is retrained from scratch on completed 2026 World Cup matches using only information available before each kickoff.</p>
+      <div class="model-grid">
+        <div class="model-metric"><b>{model['samples']}</b><span>Training matches</span></div>
+        <div class="model-metric"><b>{model['mae']}</b><span>Held-out MAE</span></div>
+        <div class="model-metric"><b>{model['baseline_lift']}%</b><span>MAE lift vs baseline</span></div>
+        <div class="model-metric"><b>{model['features']['prior_games']}</b><span>Team games seen</span></div>
+      </div>
+      <p><b>Target:</b> an observed match-drama proxy derived from fouls, cards, goals, score closeness, late goals, knockout stage and extra time. <b>Forecast inputs:</b> rolling team PPG, goals, fouls, cards, shots, stage and tournament experience. The target is an editorial index, not social-media ground truth or betting advice.</p>
     </div>
     """
-    notes = f"### Historical echo\n\n{result['echo']}\n\n### The moment\n\n{escape(result['moment'])}"
-    return card, notes
+    if state == "pre":
+        share = f"{home['team']['displayName']} vs {away['team']['displayName']}: {model['forecast']}/100 pre-match DramaMeter forecast. Trained on {model['samples']} World Cup matches. #DramaMeter2026"
+    else:
+        phase = "live" if state == "in" else "final"
+        share = f"{home['team']['displayName']} {home['score']}–{away['score']} {away['team']['displayName']}: {phase} DramaMeter {index}/100. {fouls} fouls, {yellow + red} cards, {shots} shots. #DramaMeter2026"
+    return dashboard, share, model_card
+
 
+def render(event_id: str, force: bool = False):
+    try:
+        events, feed_meta = tournament(force)
+        event = find_event(events, event_id)
+        summary_data, summary_meta = summary(event_id, force)
+        model = train_and_score(events, event)
+        meta = {
+            "fetched_at": max(feed_meta["fetched_at"], summary_meta["fetched_at"]),
+            "stale": feed_meta["stale"] or summary_meta["stale"],
+        }
+        return match_html(event, summary_data, model, meta)
+    except FeedError as exc:
+        return f'<div class="error-card"><b>Live feed error</b><br>{escape(str(exc))}</div>', "", ""
 
-def recap(home, away, home_goals, away_goals, key_moment, fan_heat):
-    result = post_match(home, away, home_goals, away_goals, key_moment, fan_heat)
-    return result["report"], result["share"]
 
+def load_dashboard():
+    try:
+        events, _ = tournament()
+        choices, default = fixture_choices(events)
+        dashboard, share, model_card = render(default)
+        return gr.update(choices=choices, value=default), dashboard, share, model_card
+    except FeedError as exc:
+        error = f'<div class="error-card"><b>Live feed error</b><br>{escape(str(exc))}</div>'
+        return gr.update(choices=[], value=None), error, "", ""
+
+
+def refresh_dashboard(event_id: str):
+    try:
+        events, _ = tournament(force=True)
+        choices, default = fixture_choices(events)
+        selected = event_id if any(value == event_id for _, value in choices) else default
+        dashboard, share, model_card = render(selected, force=True)
+        return gr.update(choices=choices, value=selected), dashboard, share, model_card
+    except FeedError as exc:
+        error = f'<div class="error-card"><b>Live feed error</b><br>{escape(str(exc))}</div>'
+        return gr.update(), error, "", ""
 
-team_choices = sorted(TEAMS)
 
 with gr.Blocks(title="DramaMeter 2026") as demo:
     gr.HTML("""
-    <section class="hero">
-      <h1>Drama<br>Meter '26</h1>
-      <p>How much football chaos is coming?</p>
-    </section>
+    <header class="topbar">
+      <div class="brand">DramaMeter <span>2026</span></div>
+      <div class="tagline"><span class="live-dot"></span>Live World Cup match data. A model you can inspect. A score you can argue with.</div>
+    </header>
     """)
+    with gr.Row(elem_classes="control-row"):
+        fixture = gr.Dropdown([], label="Match radar", info="Live, upcoming and latest World Cup fixtures", elem_id="fixture")
+        refresh = gr.Button("Refresh live data", elem_id="refresh")
+    dashboard = gr.HTML('<div class="match-shell"><div class="source-line">Loading the live tournament feed…</div></div>')
+    share = gr.Textbox(label="Post-ready take", buttons=["copy"], interactive=False)
+    with gr.Accordion("Model & data card", open=False):
+        model_card = gr.HTML()
+    gr.HTML('<div class="footer-note">Independent fan analytics project. Match data is attributed to ESPN Match Center. No betting advice.</div>')
 
-    with gr.Tabs():
-        with gr.Tab("Match Forecast"):
-            with gr.Row():
-                with gr.Column(scale=4):
-                    team_a = gr.Dropdown(team_choices, value="England", allow_custom_value=True, label="Team one")
-                    team_b = gr.Dropdown(team_choices, value="Argentina", allow_custom_value=True, label="Team two")
-                    stage = gr.Radio(list(("Group stage", "Round of 16", "Quarter-final", "Semi-final", "Final")), value="Quarter-final", label="Stage")
-                    var_heat = gr.Slider(0, 100, value=72, step=1, label="Tournament VAR heat", info="Your read on how angry the tournament feels")
-                    forecast_btn = gr.Button("Calculate the drama", variant="primary")
-                with gr.Column(scale=5):
-                    forecast_card = gr.HTML()
-                    forecast_notes = gr.Markdown()
-                    forecast_share = gr.Textbox(label="Copy this post", buttons=["copy"], interactive=False)
-
-            forecast_btn.click(forecast, [team_a, team_b, stage, var_heat], [forecast_card, forecast_notes, forecast_share])
-            demo.load(forecast, [team_a, team_b, stage, var_heat], [forecast_card, forecast_notes, forecast_share])
-
-        with gr.Tab("VAR Moment"):
-            with gr.Row():
-                with gr.Column():
-                    moment = gr.Textbox(lines=5, label="What happened?", placeholder="88th minute. The ball hits a defender's arm in the box. VAR says no penalty.")
-                    minute = gr.Slider(1, 120, value=88, step=1, label="Minute")
-                    tension = gr.Slider(0, 100, value=78, step=1, label="Match tension")
-                    moment_btn = gr.Button("Rate the controversy", variant="primary")
-                with gr.Column():
-                    moment_card = gr.HTML()
-                    moment_notes = gr.Markdown()
-            moment_btn.click(controversy, [moment, minute, tension], [moment_card, moment_notes])
-
-        with gr.Tab("Full-time Recap"):
-            with gr.Row():
-                with gr.Column():
-                    home = gr.Dropdown(team_choices, value="England", allow_custom_value=True, label="Home team")
-                    away = gr.Dropdown(team_choices, value="Argentina", allow_custom_value=True, label="Away team")
-                    with gr.Row():
-                        home_goals = gr.Number(value=1, minimum=0, precision=0, label="Home goals")
-                        away_goals = gr.Number(value=2, minimum=0, precision=0, label="Away goals")
-                    key_moment = gr.Textbox(lines=4, label="The moment everyone is arguing about")
-                    fan_heat = gr.Slider(0, 100, value=85, step=1, label="Fan heat")
-                    recap_btn = gr.Button("Write the recap", variant="primary")
-                with gr.Column():
-                    report = gr.Markdown()
-                    recap_share = gr.Textbox(label="Copy this post", lines=3, buttons=["copy"], interactive=False)
-            recap_btn.click(recap, [home, away, home_goals, away_goals, key_moment, fan_heat], [report, recap_share])
-
-    gr.HTML("<div class='disclaimer'>Fan-made entertainment. No live data. No betting advice. Referees may disagree.</div>")
+    fixture.change(render, fixture, [dashboard, share, model_card], show_progress="minimal")
+    refresh.click(refresh_dashboard, fixture, [fixture, dashboard, share, model_card], show_progress="minimal")
+    demo.load(load_dashboard, outputs=[fixture, dashboard, share, model_card], show_progress="minimal")
 
 
 if __name__ == "__main__":
-    demo.launch(css=CSS)
+    demo.launch(theme=gr.themes.Base(), css=CSS)

drama.py

@@ -1,137 +1,223 @@
 from __future__ import annotations
 
-import hashlib
-import re
-
-
-TEAMS = {
-    "Argentina": 91,
-    "Brazil": 88,
-    "England": 84,
-    "France": 80,
-    "Germany": 82,
-    "Italy": 86,
-    "Mexico": 78,
-    "Netherlands": 87,
-    "Portugal": 83,
-    "Spain": 74,
-    "Uruguay": 89,
+from collections import defaultdict
+
+import numpy as np
+from sklearn.ensemble import HistGradientBoostingRegressor
+from sklearn.inspection import permutation_importance
+from sklearn.metrics import mean_absolute_error, r2_score
+
+
+FEATURES = (
+    "stage pressure",
+    "combined points per game",
+    "form gap",
+    "goals scored per game",
+    "goals allowed per game",
+    "fouls per game",
+    "cards per game",
+    "shots per game",
+    "tournament experience",
+)
+
+STAGES = {
+    "group-stage": 0.15,
+    "round-of-32": 0.3,
+    "round-of-16": 0.48,
+    "quarterfinals": 0.68,
+    "semifinals": 0.86,
+    "3rd-place-match": 0.5,
+    "final": 1.0,
 }
 
-RIVALRIES = {
-    frozenset(("Argentina", "Brazil")): (98, "South American royalty with no quiet tackles"),
-    frozenset(("Argentina", "England")): (97, "1986, 1998 and decades of unfinished business"),
-    frozenset(("Argentina", "Netherlands")): (94, "knockout grudges, touchline heat and penalty scars"),
-    frozenset(("England", "Germany")): (91, "ghost goals, shootouts and national nerves"),
-    frozenset(("Argentina", "Uruguay")): (90, "the oldest international rivalry still bites"),
-    frozenset(("Brazil", "Uruguay")): (89, "Maracanazo history hangs over every meeting"),
-    frozenset(("Italy", "Germany")): (84, "heavyweight knockout history and zero easy minutes"),
-    frozenset(("Portugal", "Spain")): (82, "neighbours, stars and an Iberian point to prove"),
-    frozenset(("England", "Scotland")): (88, "the oldest fixture in football needs no warm-up"),
+STAGE_NAMES = {
+    "group-stage": "Group stage",
+    "round-of-32": "Round of 32",
+    "round-of-16": "Round of 16",
+    "quarterfinals": "Quarter-final",
+    "semifinals": "Semi-final",
+    "3rd-place-match": "Third-place match",
+    "final": "Final",
 }
 
-STAGE_BONUS = {
-    "Group stage": 0,
-    "Round of 16": 3,
-    "Quarter-final": 6,
-    "Semi-final": 9,
-    "Final": 12,
-}
-
-
-def clamp(value: float, low: int = 0, high: int = 100) -> int:
-    return max(low, min(high, round(value)))
-
-
-def clean_team(name: str) -> str:
-    name = re.sub(r"\s+", " ", (name or "").strip())
-    return name[:40] or "Unknown XI"
-
-
-def stable_number(*parts: str, low: int = 58, span: int = 24) -> int:
-    key = "|".join(part.casefold() for part in parts).encode()
-    return low + int(hashlib.sha256(key).hexdigest()[:8], 16) % span
 
-
-def match_forecast(team_a: str, team_b: str, stage: str, var_heat: float) -> dict:
-    a, b = clean_team(team_a), clean_team(team_b)
-    pair = frozenset((a, b))
-    known = RIVALRIES.get(pair)
-    rivalry = known[0] if known else stable_number(*sorted(pair), low=54, span=28)
-    history = known[1] if known else "no famous grudge — yet"
-    edge_a = TEAMS.get(a, stable_number(a, low=66, span=18))
-    edge_b = TEAMS.get(b, stable_number(b, low=66, span=18))
-    intensity = round((edge_a + edge_b) / 2)
-    score = clamp(rivalry * 0.48 + intensity * 0.27 + float(var_heat) * 0.2 + STAGE_BONUS[stage])
-
-    if score >= 90:
-        verdict = "ABSOLUTE CINEMA"
-    elif score >= 78:
-        verdict = "GET THE POPCORN"
-    elif score >= 64:
-        verdict = "ONE BAD WHISTLE AWAY"
-    else:
-        verdict = "COULD STILL KICK OFF"
-
-    narratives = [
-        f"First flashpoint: one early yellow and {history} comes straight back.",
-        f"VAR watch: at {round(var_heat)}% heat, every slow-motion replay becomes a national debate.",
-        f"Pressure point: a {stage.lower()} leaves no room for a calm reaction after a late call.",
+def clamp(value: float) -> int:
+    return max(0, min(100, round(value)))
+
+
+def competitors(event: dict) -> tuple[dict, dict]:
+    teams = event["competitions"][0]["competitors"]
+    ordered = sorted(teams, key=lambda item: item["homeAway"] != "home")
+    return ordered[0], ordered[1]
+
+
+def stat(team: dict, name: str) -> float:
+    for item in team.get("statistics", []):
+        if item.get("name") == name:
+            try:
+                return float(str(item.get("displayValue", 0)).replace("%", ""))
+            except ValueError:
+                return 0.0
+    return 0.0
+
+
+def card_counts(event: dict) -> tuple[int, int]:
+    yellow = red = 0
+    for detail in event["competitions"][0].get("details", []):
+        kind = detail.get("type", {}).get("text", "").lower()
+        yellow += "yellow card" in kind
+        red += "red card" in kind
+    return yellow, red
+
+
+def team_cards(event: dict, team_id: str) -> int:
+    total = 0
+    for detail in event["competitions"][0].get("details", []):
+        if str(detail.get("team", {}).get("id")) != str(team_id):
+            continue
+        kind = detail.get("type", {}).get("text", "").lower()
+        total += 1 if "yellow card" in kind else 2 if "red card" in kind else 0
+    return total
+
+
+def observed_index(event: dict) -> int:
+    home, away = competitors(event)
+    yellow, red = card_counts(event)
+    fouls = stat(home, "foulsCommitted") + stat(away, "foulsCommitted")
+    goals = int(float(home.get("score", 0))) + int(float(away.get("score", 0)))
+    score_gap = abs(int(float(home.get("score", 0))) - int(float(away.get("score", 0))))
+    details = event["competitions"][0].get("details", [])
+    late_goal = any(
+        "goal" in detail.get("type", {}).get("text", "").lower()
+        and float(detail.get("clock", {}).get("value", 0)) >= 75 * 60
+        for detail in details
+    )
+    status = event["status"]["type"].get("description", "").lower()
+    knockout = STAGES.get(event.get("season", {}).get("slug", ""), 0.15)
+    raw = 10 + fouls * 0.78 + yellow * 4.8 + red * 12 + min(goals, 6) * 3.2
+    raw += (10 if score_gap <= 1 else 0) + (9 if late_goal else 0) + knockout * 12
+    raw += 10 if "extra time" in status or "penalties" in status else 0
+    return clamp(raw)
+
+
+def _empty_form() -> dict:
+    return {"games": 0, "points": 0, "gf": 0, "ga": 0, "fouls": 0.0, "cards": 0, "shots": 0.0}
+
+
+def _rate(form: dict, key: str, fallback: float) -> float:
+    return form[key] / form["games"] if form["games"] else fallback
+
+
+def _features(event: dict, forms: dict[str, dict]) -> tuple[list[float], dict]:
+    home, away = competitors(event)
+    a = forms[home["team"]["id"]]
+    b = forms[away["team"]["id"]]
+    ppg_a, ppg_b = _rate(a, "points", 1.5), _rate(b, "points", 1.5)
+    values = [
+        STAGES.get(event.get("season", {}).get("slug", ""), 0.15),
+        (ppg_a + ppg_b) / 6,
+        abs(ppg_a - ppg_b) / 3,
+        (_rate(a, "gf", 1.25) + _rate(b, "gf", 1.25)) / 6,
+        (_rate(a, "ga", 1.25) + _rate(b, "ga", 1.25)) / 6,
+        (_rate(a, "fouls", 11.5) + _rate(b, "fouls", 11.5)) / 35,
+        (_rate(a, "cards", 1.8) + _rate(b, "cards", 1.8)) / 8,
+        (_rate(a, "shots", 10) + _rate(b, "shots", 10)) / 35,
+        min((a["games"] + b["games"]) / 10, 1),
     ]
-    factors = {
-        "Rivalry heat": rivalry,
-        "Team edge": intensity,
-        "VAR heat": round(float(var_heat)),
-        "Stage pressure": STAGE_BONUS[stage],
+    raw = {
+        "stage": STAGE_NAMES.get(event.get("season", {}).get("slug", ""), "Tournament match"),
+        "home_ppg": round(ppg_a, 2),
+        "away_ppg": round(ppg_b, 2),
+        "combined_fouls_pg": round(_rate(a, "fouls", 11.5) + _rate(b, "fouls", 11.5), 1),
+        "combined_cards_pg": round(_rate(a, "cards", 1.8) + _rate(b, "cards", 1.8), 1),
+        "combined_shots_pg": round(_rate(a, "shots", 10) + _rate(b, "shots", 10), 1),
+        "prior_games": a["games"] + b["games"],
+    }
+    return values, raw
+
+
+def _update(forms: dict[str, dict], event: dict) -> None:
+    home, away = competitors(event)
+    home_score, away_score = int(float(home["score"])), int(float(away["score"]))
+    for team, scored, allowed in (
+        (home, home_score, away_score),
+        (away, away_score, home_score),
+    ):
+        form = forms[team["team"]["id"]]
+        form["games"] += 1
+        form["points"] += 3 if scored > allowed else 1 if scored == allowed else 0
+        form["gf"] += scored
+        form["ga"] += allowed
+        form["fouls"] += stat(team, "foulsCommitted")
+        form["cards"] += team_cards(event, team["team"]["id"])
+        form["shots"] += stat(team, "totalShots")
+
+
+def train_and_score(events: list[dict], target: dict) -> dict:
+    ordered = sorted(events, key=lambda item: item["date"])
+    forms: dict[str, dict] = defaultdict(_empty_form)
+    x: list[list[float]] = []
+    y: list[int] = []
+    target_x = target_raw = None
+
+    for event in ordered:
+        features, raw = _features(event, forms)
+        if str(event["id"]) == str(target["id"]):
+            target_x, target_raw = features, raw
+            continue
+        if event["date"] > target["date"]:
+            continue
+        if event["status"]["type"].get("completed"):
+            x.append(features)
+            y.append(observed_index(event))
+            _update(forms, event)
+
+    if target_x is None:
+        target_x, target_raw = _features(target, forms)
+
+    x_data, y_data = np.asarray(x), np.asarray(y)
+    split = max(30, int(len(x_data) * 0.8))
+    eval_model = HistGradientBoostingRegressor(
+        max_iter=120, max_leaf_nodes=8, l2_regularization=2, random_state=26
+    )
+    eval_model.fit(x_data[:split], y_data[:split])
+    held_out = eval_model.predict(x_data[split:])
+    mae = mean_absolute_error(y_data[split:], held_out)
+    r2 = r2_score(y_data[split:], held_out)
+    baseline_mae = mean_absolute_error(y_data[split:], np.full(len(y_data[split:]), y_data[:split].mean()))
+    baseline_lift = (baseline_mae - mae) / baseline_mae * 100
+
+    model = HistGradientBoostingRegressor(
+        max_iter=160, max_leaf_nodes=8, l2_regularization=2, random_state=26
+    )
+    model.fit(x_data, y_data)
+    forecast = clamp(model.predict(np.asarray([target_x]))[0])
+    permuted = permutation_importance(model, x_data, y_data, n_repeats=8, random_state=26)
+    weights = np.maximum(permuted.importances_mean, 0)
+    weights = weights / weights.sum() if weights.sum() else np.ones(len(FEATURES)) / len(FEATURES)
+    importances = sorted(zip(FEATURES, weights), key=lambda item: item[1], reverse=True)
+    confidence = clamp(88 - mae * 1.6 + min(target_raw["prior_games"], 10))
+    return {
+        "forecast": forecast,
+        "confidence": confidence,
+        "samples": len(x),
+        "mae": round(float(mae), 1),
+        "r2": round(float(r2), 2),
+        "baseline_lift": round(float(baseline_lift), 1),
+        "features": target_raw,
+        "importances": [(name, round(float(weight) * 100, 1)) for name, weight in importances],
     }
-    return {"teams": (a, b), "score": score, "verdict": verdict, "narratives": narratives, "factors": factors}
-
-
-MOMENT_RULES = {
-    "handball": (24, "Hand of God, 1986 — one touch can live for generations"),
-    "penalty": (19, "Robben vs Mexico, 2014 — the penalty argument never really ended"),
-    "red card": (17, "Beckham vs Argentina, 1998 — one red card can own the whole story"),
-    "offside": (15, "tight tournament offside calls — one freeze-frame splits the room"),
-    "goal line": (25, "Lampard vs Germany, 2010 — the goal everybody saw except the officials"),
-    "var": (13, "modern VAR delays — the wait often makes the anger worse"),
-    "dive": (16, "big-stage simulation rows — replay rarely ends the argument"),
-    "foul": (9, "classic knockout flashpoints — the second tackle changes the mood"),
-}
 
 
-def analyze_moment(text: str, minute: float, match_tension: float) -> dict:
-    moment = re.sub(r"\s+", " ", (text or "").strip())
-    haystack = moment.casefold()
-    hits = [(word, rule) for word, rule in MOMENT_RULES.items() if word in haystack]
-    bump = max((rule[0] for _, rule in hits), default=6)
-    late = 16 if minute >= 85 else 10 if minute >= 70 else 4 if minute >= 45 else 0
-    score = clamp(22 + bump + float(match_tension) * 0.42 + late)
-    echo = hits[0][1][1] if hits else "any disputed winner — the clip matters more than the full match"
-
-    if score >= 88:
-        reaction = "Timeline meltdown. Everyone has a screenshot and nobody agrees."
-    elif score >= 72:
-        reaction = "Heavy outrage. Expect referee clips, conspiracy posts and rival fans piling in."
-    elif score >= 55:
-        reaction = "Proper argument territory. The replay will be posted all night."
-    else:
-        reaction = "Some noise, but the next goal probably kills the story."
-
-    return {"score": score, "reaction": reaction, "echo": echo, "moment": moment or "No moment entered"}
-
-
-def post_match(home: str, away: str, home_goals: float, away_goals: float, key_moment: str, fan_heat: float) -> dict:
-    a, b = clean_team(home), clean_team(away)
-    ga, gb = max(0, int(home_goals)), max(0, int(away_goals))
-    moment = re.sub(r"\s+", " ", (key_moment or "").strip())
-    if ga == gb:
-        lead = f"{a} and {b} finished {ga}-{gb}, but nobody left with the same version of the match."
-    else:
-        winner = a if ga > gb else b
-        lead = f"{winner} took it {ga}-{gb}. The score is clean; the night was not."
-
-    mood = "furious" if fan_heat >= 80 else "boiling" if fan_heat >= 60 else "split" if fan_heat >= 40 else "surprisingly calm"
-    detail = moment or "The biggest argument arrived after the final whistle"
-    report = f"{lead}\n\n{detail.rstrip('.')} became the clip everyone replayed. Fan mood: {mood}. Tomorrow the result stays; the argument gets louder."
-    share = f"FT: {a} {ga}-{gb} {b}. {detail.rstrip('.')}. Drama never needs extra time. #DramaMeter2026"
-    return {"report": report, "share": share, "mood": mood}
+def h2h(summary: dict) -> dict:
+    groups = summary.get("headToHeadGames", [])
+    games = groups[0].get("events", []) if groups else []
+    world_cups = [game for game in games if "World Cup" in game.get("leagueName", "")]
+    shootouts = [game for game in games if int(game.get("homeShootoutScore", 0)) or int(game.get("awayShootoutScore", 0))]
+    latest = games[0] if games else None
+    return {
+        "games": len(games),
+        "world_cups": len(world_cups),
+        "shootouts": len(shootouts),
+        "latest": f"{latest['competitionName']} · {latest['score']}" if latest else "No H2H record returned",
+    }

feed.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import time
+from datetime import datetime, timezone
+
+import requests
+
+
+SCOREBOARD = "https://site.api.espn.com/apis/site/v2/sports/soccer/fifa.world/scoreboard?dates=2026&limit=200"
+SUMMARY = "https://site.api.espn.com/apis/site/v2/sports/soccer/fifa.world/summary?event={}"
+MATCH_PAGE = "https://www.espn.com/soccer/match/_/gameId/{}"
+
+_session = requests.Session()
+_session.headers["User-Agent"] = "DramaMeter2026/2.0 (+https://github.com/yava-code/DramaMeter-2026)"
+_cache: dict[str, tuple[float, dict, str]] = {}
+
+
+class FeedError(RuntimeError):
+    pass
+
+
+def _get(url: str, ttl: int, force: bool = False) -> tuple[dict, str, bool]:
+    now = time.monotonic()
+    cached = _cache.get(url)
+    if cached and not force and now - cached[0] < ttl:
+        return cached[1], cached[2], False
+
+    try:
+        response = _session.get(url, timeout=12)
+        response.raise_for_status()
+        fetched_at = datetime.now(timezone.utc).isoformat(timespec="seconds")
+        data = response.json()
+        _cache[url] = (now, data, fetched_at)
+        return data, fetched_at, False
+    except (requests.RequestException, ValueError) as exc:
+        if cached:
+            return cached[1], cached[2], True
+        raise FeedError("The live football feed is unavailable. Try refresh in a moment.") from exc
+
+
+def tournament(force: bool = False) -> tuple[list[dict], dict]:
+    data, fetched_at, stale = _get(SCOREBOARD, 45, force)
+    return data.get("events", []), {"fetched_at": fetched_at, "stale": stale}
+
+
+def summary(event_id: str, force: bool = False) -> tuple[dict, dict]:
+    data, fetched_at, stale = _get(SUMMARY.format(event_id), 30, force)
+    return data, {"fetched_at": fetched_at, "stale": stale}
+
+
+def find_event(events: list[dict], event_id: str) -> dict:
+    for event in events:
+        if str(event.get("id")) == str(event_id):
+            return event
+    raise FeedError("That fixture is no longer in the tournament feed.")
+
+
+def fixture_choices(events: list[dict]) -> tuple[list[tuple[str, str]], str | None]:
+    live = [event for event in events if event["status"]["type"]["state"] == "in"]
+    upcoming = [event for event in events if event["status"]["type"]["state"] == "pre"]
+    finished = [event for event in events if event["status"]["type"]["state"] == "post"][-10:]
+    visible = live + upcoming + list(reversed(finished))
+    choices = [(fixture_label(event), str(event["id"])) for event in visible]
+    latest = finished[-1] if finished else None
+    recent = latest and (
+        datetime.now(timezone.utc) - datetime.fromisoformat(latest["date"].replace("Z", "+00:00"))
+    ).total_seconds() < 8 * 60 * 60
+    preferred = live or ([latest] if recent else []) or upcoming or list(reversed(finished))
+    default = str(preferred[0]["id"]) if preferred else None
+    return choices, default
+
+
+def fixture_label(event: dict) -> str:
+    teams = sorted(event["competitions"][0]["competitors"], key=lambda item: item["homeAway"] != "home")
+    home, away = teams
+    home_name, away_name = home["team"]["displayName"], away["team"]["displayName"]
+    state = event["status"]["type"]["state"]
+    if state == "in":
+        return f"LIVE {event['status']['displayClock']} · {home_name} {home['score']}–{away['score']} {away_name}"
+    if state == "post":
+        return f"FT · {home_name} {home['score']}–{away['score']} {away_name}"
+    kickoff = datetime.fromisoformat(event["date"].replace("Z", "+00:00"))
+    return f"{kickoff:%b %d · %H:%M UTC} · {home_name} vs {away_name}"

requirements.txt

@@ -1,3 +1,5 @@
 gradio==6.20.0
 pytest==8.4.1
+requests==2.34.2
+scikit-learn==1.9.0
 spaces==0.51.0

tests/test_drama.py

@@ -1,30 +1,83 @@
-from drama import analyze_moment, match_forecast, post_match
+from copy import deepcopy
 
+from drama import observed_index, train_and_score
+from feed import fixture_choices
 
-def test_england_argentina_is_box_office():
-    result = match_forecast("England", "Argentina", "Quarter-final", 72)
 
-    assert result["score"] >= 85
-    assert result["verdict"] in {"ABSOLUTE CINEMA", "GET THE POPCORN"}
+def event(event_id, date, home_id, away_id, home_score, away_score, state="post", stage="group-stage", cards=1):
+    details = [
+        {"type": {"text": "Yellow Card"}, "clock": {"value": 1800}}
+        for _ in range(cards)
+    ]
+    details.append({"type": {"text": "Goal"}, "clock": {"value": 5100}})
+    return {
+        "id": str(event_id),
+        "date": date,
+        "season": {"slug": stage},
+        "status": {
+            "displayClock": "90'",
+            "type": {"state": state, "completed": state == "post", "description": "Full Time"},
+        },
+        "competitions": [{
+            "details": details,
+            "competitors": [
+                {
+                    "homeAway": "home",
+                    "score": str(home_score),
+                    "team": {"id": str(home_id), "displayName": f"Team {home_id}"},
+                    "statistics": [
+                        {"name": "foulsCommitted", "displayValue": "12"},
+                        {"name": "totalShots", "displayValue": "11"},
+                    ],
+                },
+                {
+                    "homeAway": "away",
+                    "score": str(away_score),
+                    "team": {"id": str(away_id), "displayName": f"Team {away_id}"},
+                    "statistics": [
+                        {"name": "foulsCommitted", "displayValue": "10"},
+                        {"name": "totalShots", "displayValue": "9"},
+                    ],
+                },
+            ],
+        }],
+    }
 
 
-def test_forecast_is_stable_for_unknown_teams():
-    first = match_forecast("Japan", "Canada", "Group stage", 50)
-    second = match_forecast("Japan", "Canada", "Group stage", 50)
+def tournament_sample(count=40):
+    games = []
+    for i in range(count):
+        games.append(event(i, f"2026-06-{i % 28 + 1:02d}T12:00Z", i % 8, (i + 1) % 8, i % 4, (i + 2) % 3, cards=i % 5))
+    return games
 
-    assert first == second
-    assert 0 <= first["score"] <= 100
 
+def test_cards_raise_observed_index():
+    calm = event(1, "2026-06-01T12:00Z", 1, 2, 1, 0, cards=0)
+    heated = deepcopy(calm)
+    heated["competitions"][0]["details"] += [
+        {"type": {"text": "Yellow Card"}, "clock": {"value": 4000}}
+        for _ in range(5)
+    ]
 
-def test_late_handball_beats_early_foul():
-    late = analyze_moment("VAR checks a handball and possible penalty", 91, 80)
-    early = analyze_moment("A foul in midfield", 12, 40)
+    assert observed_index(heated) > observed_index(calm)
 
-    assert late["score"] > early["score"]
 
+def test_model_trains_on_completed_tournament_matches():
+    games = tournament_sample()
+    target = event(99, "2026-07-15T19:00Z", 1, 4, 0, 0, state="pre", stage="semifinals")
+    result = train_and_score(games + [target], target)
 
-def test_post_match_handles_draw():
-    result = post_match("Spain", "Portugal", 2, 2, "A late penalty was overturned", 70)
+    assert result["samples"] == 40
+    assert 0 <= result["forecast"] <= 100
+    assert len(result["importances"]) == 9
 
-    assert "finished 2-2" in result["report"]
-    assert "#DramaMeter2026" in result["share"]
+
+def test_fixture_choices_put_live_match_first():
+    finished = event(1, "2026-07-14T19:00Z", 1, 2, 2, 1)
+    live = event(2, "2026-07-15T19:00Z", 3, 4, 1, 1, state="in")
+    upcoming = event(3, "2026-07-16T19:00Z", 5, 6, 0, 0, state="pre")
+
+    choices, default = fixture_choices([finished, upcoming, live])
+
+    assert default == "2"
+    assert choices[0][1] == "2"