Web: selector de liga/temporada (data completa) + post-partido funcional

- routes_meta dataset-driven: ligas/temporadas/equipos/partidos salen del dataset
bundleado, intersecados con lo que tiene preprocessed en Azure ("data completa",
auto-configurable). datastore.available_league_seasons() lista Azure.
- web_meta.py: provee teams/matches/resolve por liga-temporada desde el bundle
(subset ahora incluye is_home para armar home/away).
- home.html: dropdowns de liga/temporada que recargan equipos y partidos; card de
post-partido funcional (elegís un partido JUGADO -> genera). Solo se ofrecen
partidos reales => no se puede generar uno inexistente.
- post_match habilitado en el endpoint /run (gateado por NN + match_id requerido);
post_match.generate devuelve ReportBundle para verse en la UI moderna.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

src/racing_reports/api/routes_meta.py

@@ -1,35 +1,74 @@
-"""Endpoints meta: ligas, equipos, partidos, salud."""
+"""Endpoints meta: ligas, temporadas, equipos, partidos, salud.
+
+Las ligas/temporadas salen del dataset de modelado bundleado (web_meta) y, si se
+puede listar Azure, se filtran a las que tienen el preprocessed subido ("data
+completa"). Así los selectores andan offline para todas las ligas del modelo y
+sólo se ofrecen las que realmente pueden generar el reporte completo.
+"""
 
 from __future__ import annotations
 
-import json
+import time
 from datetime import date
+from pathlib import Path
 
 from fastapi import APIRouter, Depends, HTTPException
 
-from racing_reports import data_cache, vendor_env
+from racing_reports import data_cache, web_meta
 from racing_reports.api.deps import require_auth
 from racing_reports.api.schemas import HealthResponse, MatchCandidate
 from racing_reports.config import DEFAULT_SETTINGS
 from racing_reports.datastore import DataStore
-from racing_reports.match_index import MatchIndex
 from racing_reports.utils import git_commit
-from pathlib import Path
 
 router = APIRouter(prefix="/api")
 
-# Las ligas y temporadas hoy son single: SSD 25-26. Multi-liga es para más
-# adelante; igual exponemos los endpoints para que el frontend no asuma.
-SUPPORTED_LEAGUES = ["Spanish Segunda Division"]
-SUPPORTED_SEASONS = {"Spanish Segunda Division": ["25-26"]}
+_AVAIL_TTL_SECONDS = 1800
+_avail_cache: dict[str, object] = {"ts": 0.0, "value": None}
+
+
+def _league_seasons() -> dict[str, list[str]]:
+    """{liga: [temporadas]} ofrecidas: dataset ∩ (disponible en Azure si se sabe)."""
+    in_dataset = web_meta.league_seasons() if web_meta.has_dataset() else {}
+    if not in_dataset:
+        return {}
+    now = time.time()
+    if now - float(_avail_cache["ts"]) > _AVAIL_TTL_SECONDS:
+        try:
+            _avail_cache["value"] = DataStore().available_league_seasons()
+        except Exception:
+            _avail_cache["value"] = None
+        _avail_cache["ts"] = now
+    avail = _avail_cache["value"]
+    if not avail:
+        # No se pudo listar Azure (dev / sin credenciales): ofrecer todo el dataset.
+        return in_dataset
+    out: dict[str, list[str]] = {}
+    for league, seasons in in_dataset.items():
+        a = avail.get(league)
+        if not a:
+            continue
+        keep = [s for s in seasons if s in a]
+        if keep:
+            out[league] = keep
+    # Si la intersección quedó vacía (p.ej. naming distinto), no dejar al usuario
+    # sin nada: caer al dataset completo.
+    return out or in_dataset
+
+
+def _default_league_season() -> tuple[str, str]:
+    ls = _league_seasons()
+    if not ls:
+        return ("Spanish Segunda Division", "25-26")
+    league = "Spanish Segunda Division" if "Spanish Segunda Division" in ls else next(iter(ls))
+    return (league, ls[league][0])
 
 
 @router.get("/health", response_model=HealthResponse)
 def health() -> HealthResponse:
-    # Check si el preprocessed default ya está en RAM (indica corrida "caliente")
+    league, season = _default_league_season()
     ds = DataStore()
-    pre_path = ds.preprocessed_path(SUPPORTED_LEAGUES[0], SUPPORTED_SEASONS[SUPPORTED_LEAGUES[0]][0])
-    cached = data_cache.is_cached(pre_path)
+    cached = data_cache.is_cached(ds.preprocessed_path(league, season))
     return HealthResponse(
         ok=True,
         nn_enabled=DEFAULT_SETTINGS.enable_nn_predictions,
@@ -40,33 +79,28 @@ def health() -> HealthResponse:
 
 @router.get("/leagues", dependencies=[Depends(require_auth)])
 def leagues() -> list[str]:
-    return list(SUPPORTED_LEAGUES)
+    return list(_league_seasons().keys())
 
 
 @router.get("/seasons", dependencies=[Depends(require_auth)])
 def seasons(league: str) -> list[str]:
-    if league not in SUPPORTED_SEASONS:
+    ls = _league_seasons()
+    if league not in ls:
         raise HTTPException(status_code=404, detail=f"Liga desconocida: {league}")
-    return list(SUPPORTED_SEASONS[league])
+    return list(ls[league])
 
 
 @router.get("/teams", dependencies=[Depends(require_auth)])
 def teams(league: str, season: str) -> list[str]:
-    try:
-        ids = json.loads(vendor_env.team_ids_path().read_text(encoding="utf-8"))
-    except FileNotFoundError as exc:
-        raise HTTPException(status_code=503, detail="team_ids no disponible") from exc
-    return sorted(ids.keys())
+    names = web_meta.teams(league, season)
+    if not names:
+        raise HTTPException(status_code=404, detail=f"Sin equipos para {league} {season}")
+    return names
 
 
 @router.get("/matches", dependencies=[Depends(require_auth)])
 def matches(league: str, season: str, played_only: bool = False) -> list[dict]:
-    idx = MatchIndex(DataStore())
-    df = idx.build(league, season)
-    if played_only:
-        today = date.today().isoformat()
-        df = df[df["date"] <= today]
-    return df.sort_values("date", ascending=False).to_dict("records")
+    return web_meta.matches(league, season, played_only=played_only)
 
 
 @router.get(
@@ -75,24 +109,14 @@ def matches(league: str, season: str, played_only: bool = False) -> list[dict]:
     dependencies=[Depends(require_auth)],
 )
 def resolve(league: str, season: str, team_a: str, team_b: str) -> list[MatchCandidate]:
-    idx = MatchIndex(DataStore())
-    df = idx.build(league, season)
-    a, b = team_a.strip().casefold(), team_b.strip().casefold()
-    pair = df[
-        ((df["home_team"].str.casefold() == a) & (df["away_team"].str.casefold() == b))
-        | ((df["home_team"].str.casefold() == b) & (df["away_team"].str.casefold() == a))
-    ].copy()
-    today = date.today().isoformat()
-    out = []
-    for _, m in pair.iterrows():
-        status = "played" if str(m["date"]) and str(m["date"]) <= today else "future"
-        out.append(
-            MatchCandidate(
-                match_id=str(m["match_id"]),
-                date=str(m["date"] or ""),
-                home_team=str(m["home_team"]),
-                away_team=str(m["away_team"]),
-                status=status,
-            )
+    pairs = web_meta.resolve_pair(league, season, team_a, team_b)
+    return [
+        MatchCandidate(
+            match_id=m["match_id"],
+            date=m["date"],
+            home_team=m["home_team"],
+            away_team=m["away_team"],
+            status=m["status"],
         )
-    return out
+        for m in pairs
+    ]

src/racing_reports/api/routes_reports.py

@@ -14,7 +14,7 @@ from racing_reports.runner import ReportRunner
 
 router = APIRouter(prefix="/api/reports")
 
-SUPPORTED_REPORTS = {"pre_match", "block_zscore"}  # post_match deshabilitado en MVP
+SUPPORTED_REPORTS = {"pre_match", "block_zscore", "post_match"}  # post_match requiere NN
 
 
 @router.get(
@@ -60,6 +60,11 @@ def run(report_type: str, payload: RunRequest) -> RunResponse:
         raise HTTPException(status_code=404, detail=f"Reporte desconocido: {report_type}")
     if not payload.team_a or not payload.team_b:
         raise HTTPException(status_code=400, detail="team_a y team_b son requeridos.")
+    if report_type == "post_match" and not payload.match_id:
+        raise HTTPException(
+            status_code=400,
+            detail="Para el post-partido elegí un partido jugado (match_id requerido).",
+        )
 
     settings_blob = {}
     if report_type == "block_zscore":

src/racing_reports/datastore.py

@@ -109,6 +109,31 @@ class DataStore:
         )
         return service.get_file_system_client(self.settings.azure_filesystem)
 
+    def available_league_seasons(self) -> dict[str, list[str]] | None:
+        """{liga: [temporadas]} que tienen el preprocessed subido en Azure.
+
+        Devuelve None si no se puede listar (sin credenciales / dev local / error):
+        el caller debe interpretar None como "desconocido, no filtrar".
+        """
+        if self.local_data_dir is not None:
+            return None
+        name = self.settings.preprocessed_name
+        root = self.settings.azure_preprocessed_root.strip("/")
+        try:
+            fs = self._filesystem_client()
+            found: dict[str, set[str]] = {}
+            for p in fs.get_paths(path=root, recursive=True):
+                path_name = getattr(p, "name", "") or ""
+                rel = path_name[len(root):].lstrip("/") if path_name.startswith(root) else path_name
+                parts = rel.split("/")
+                if len(parts) >= 3 and parts[-1] == name:
+                    found.setdefault(parts[-3], set()).add(parts[-2])
+            if not found:
+                return None
+            return {lg: sorted(ss, reverse=True) for lg, ss in sorted(found.items())}
+        except Exception:
+            return None
+
     def _sync_named_csv(self, league: str, season: str, name: str, force: bool) -> Path:
         local = self._csv_path(league, season, name)
         if local.exists() and not force:

src/racing_reports/reports/post_match.py

@@ -12,6 +12,7 @@ from pathlib import Path
 import pandas as pd
 
 from racing_reports import vendor_env
+from racing_reports.reports.bundle import ReportBundle
 
 
 class MatchNotPlayedError(RuntimeError):
@@ -31,7 +32,7 @@ def generate(
     title: str,
     season: str | None = None,
     match_date: str | None = None,
-) -> Path:
+) -> ReportBundle:
     gen = vendor_env.patch_helper_paths(
         preprocessed_csv=preprocessed_csv, matches_csv=matches_csv
     )
@@ -82,4 +83,19 @@ def generate(
     section = pm.build_match_section(match_cfg, df_model, df_match, zone_df, league)
     out_path.parent.mkdir(parents=True, exist_ok=True)
     pm.build_html([section], out_path, match_cfg["title"])
-    return out_path
+    return ReportBundle(
+        report_type="post_match",
+        html_path=out_path,
+        figures=[],
+        tables=[],
+        warnings=["Las 7 figuras del post-partido están embebidas: abrí 'Ver HTML completo'."],
+        meta={
+            "league": league,
+            "season": season or "",
+            "match_id": str(match_id),
+            "home_name": home_name,
+            "away_name": away_name,
+            "home_goals": home_goals,
+            "away_goals": away_goals,
+        },
+    )

src/racing_reports/web/app.py

@@ -95,17 +95,19 @@ def login(request: Request, password: str = Form(...)):
 
 # ── home (SPA nuevo) ──────────────────────────────────────────────────────
 @app.get("/", response_class=HTMLResponse)
-def home(request: Request, league: str = DEFAULT_LEAGUE, season: str = DEFAULT_SEASON):
+def home(request: Request, league: str | None = None, season: str | None = None):
     if not _password_ok(request):
         return RedirectResponse(url="/login", status_code=303)
+    from racing_reports.api.routes_meta import _default_league_season
+
+    def_league, def_season = _default_league_season()
     return templates.TemplateResponse(
         request,
         "home.html",
         {
             "request": request,
-            "league": league,
-            "season": season,
-            "teams": _team_list(),
+            "league": league or def_league,
+            "season": season or def_season,
             "nn_enabled": DEFAULT_SETTINGS.enable_nn_predictions,
         },
     )

src/racing_reports/web/templates/home.html

@@ -21,7 +21,6 @@
 <style>
   body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; }
   [x-cloak] { display: none !important; }
-  /* contenido de tablas preview embebido vía x-html */
   .table-preview table { width:100%; border-collapse: collapse; font-size: 12px; }
   .table-preview th, .table-preview td { padding: 6px 8px; border-bottom: 1px solid rgba(255,255,255,.08); text-align: left; }
   .table-preview th { color: #9fb4ab; font-weight: 600; text-transform: uppercase; font-size: 10px; letter-spacing: .04em; }
@@ -31,16 +30,26 @@
 
 <!-- Header -->
 <header class="bg-gradient-to-r from-racing-700 to-ink-900 border-b border-racing-700/50">
-  <div class="max-w-6xl mx-auto px-4 py-5 flex items-center justify-between">
+  <div class="max-w-6xl mx-auto px-4 py-5 flex items-center justify-between flex-wrap gap-3">
     <div>
       <h1 class="text-2xl font-bold">⚽ Reportes Racing</h1>
-      <p class="text-sm text-racing-200">Pre-partido y bloques · data en Azure, reportes on-demand</p>
+      <p class="text-sm text-racing-200">Previo, bloques y post-partido · data en Azure, reportes on-demand</p>
     </div>
     <div class="flex gap-3 items-center text-sm">
-      <span class="text-gray-400">Liga:</span>
-      <span class="font-medium" x-text="league"></span>
-      <span class="text-gray-400 ml-2">Temporada:</span>
-      <span class="font-medium" x-text="season"></span>
+      <div>
+        <label class="block text-[10px] uppercase tracking-wide text-gray-400">Liga</label>
+        <select x-model="league" @change="onLeagueChange()"
+                class="bg-ink-800 border border-ink-600 rounded-lg px-3 py-1.5 min-w-[180px]">
+          <template x-for="lg in leagues" :key="lg"><option :value="lg" x-text="lg"></option></template>
+        </select>
+      </div>
+      <div>
+        <label class="block text-[10px] uppercase tracking-wide text-gray-400">Temporada</label>
+        <select x-model="season" @change="onSeasonChange()"
+                class="bg-ink-800 border border-ink-600 rounded-lg px-3 py-1.5">
+          <template x-for="s in seasons" :key="s"><option :value="s" x-text="s"></option></template>
+        </select>
+      </div>
     </div>
   </div>
 </header>
@@ -49,18 +58,18 @@
 
   <!-- Setup -->
   <section class="bg-ink-700 border border-ink-600 rounded-2xl p-5">
-    <h2 class="text-lg font-semibold text-racing-500 mb-4">1. Partido / Equipos</h2>
+    <h2 class="text-lg font-semibold text-racing-500 mb-4">1. Equipos (previo / bloques)</h2>
     <div class="grid sm:grid-cols-2 gap-4">
       <div>
         <label class="block text-xs uppercase tracking-wide text-gray-400 mb-1">Equipo A</label>
         <select x-model="teamA" class="w-full bg-ink-800 border border-ink-600 rounded-lg px-3 py-2">
-          {% for t in teams %}<option value="{{ t }}">{{ t }}</option>{% endfor %}
+          <template x-for="t in teams" :key="t"><option :value="t" x-text="t"></option></template>
         </select>
       </div>
       <div>
         <label class="block text-xs uppercase tracking-wide text-gray-400 mb-1">Equipo B</label>
         <select x-model="teamB" class="w-full bg-ink-800 border border-ink-600 rounded-lg px-3 py-2">
-          {% for t in teams %}<option value="{{ t }}">{{ t }}</option>{% endfor %}
+          <template x-for="t in teams" :key="t"><option :value="t" x-text="t"></option></template>
         </select>
       </div>
     </div>
@@ -76,7 +85,8 @@
       <div class="flex items-start justify-between mb-3 gap-4">
         <div>
           <h3 class="font-semibold">Reporte previo (head-to-head)</h3>
-          <p class="text-xs text-gray-400 mt-1">15 figuras: zonas, presión, win/loss, local/visitante. Predicciones NN deshabilitadas en MVP.</p>
+          <p class="text-xs text-gray-400 mt-1">Zonas, presión, win/loss, local/visitante. Predicción del modelo de ataque
+            <span x-show="nnEnabled" class="text-racing-200">activada</span><span x-show="!nnEnabled">deshabilitada (falta RR_ENABLE_NN_PREDICTIONS=1)</span>.</p>
         </div>
       </div>
       <div class="flex flex-wrap gap-2">
@@ -90,15 +100,14 @@
           <span x-show="reports.pre_match.catalogOpen">Ocultar catálogo</span>
         </button>
       </div>
-      <div x-show="reports.pre_match.catalogOpen" class="mt-4 grid sm:grid-cols-3 gap-2"
-           x-transition.duration.150ms>
+      <div x-show="reports.pre_match.catalogOpen" class="mt-4 grid sm:grid-cols-3 gap-2" x-transition.duration.150ms>
         <template x-for="fig in reports.pre_match.catalog?.figures || []" :key="fig.name">
           <button @click="runOne('pre_match', fig.name)"
-                  :disabled="fig.requires_nn"
-                  :class="fig.requires_nn ? 'opacity-40 cursor-not-allowed' : 'hover:border-racing-500'"
+                  :disabled="fig.requires_nn && !nnEnabled"
+                  :class="(fig.requires_nn && !nnEnabled) ? 'opacity-40 cursor-not-allowed' : 'hover:border-racing-500'"
                   class="text-left bg-ink-800 border border-ink-600 rounded-lg px-3 py-2 text-xs">
             <div class="font-medium" x-text="fig.title"></div>
-            <div class="text-gray-400 mt-1" x-text="fig.section + (fig.requires_nn ? ' · NN (no disponible)' : '')"></div>
+            <div class="text-gray-400 mt-1" x-text="fig.section + (fig.requires_nn && !nnEnabled ? ' · NN (no disponible)' : '')"></div>
           </button>
         </template>
       </div>
@@ -144,10 +153,43 @@
       </div>
     </article>
 
-    <!-- Post-match card (deshabilitado en MVP) -->
-    <article class="bg-ink-700 border border-ink-600 rounded-2xl p-5 opacity-60">
-      <h3 class="font-semibold">Reporte post-partido</h3>
-      <p class="text-xs text-gray-400 mt-1">Próximamente. Requiere artifacts del modelo NN que todavía no están en la web.</p>
+    <!-- Post-match card -->
+    <article class="bg-ink-700 border border-ink-600 rounded-2xl p-5" :class="nnEnabled ? '' : 'opacity-60'">
+      <div class="flex items-start justify-between mb-3 gap-4">
+        <div>
+          <h3 class="font-semibold">Reporte post-partido</h3>
+          <p class="text-xs text-gray-400 mt-1">Elegí un partido <strong>ya jugado</strong>: predicción pre-partido (point-in-time) vs lo que ocurrió, por zona.</p>
+        </div>
+      </div>
+
+      <template x-if="!nnEnabled">
+        <p class="text-xs text-yellow-200 bg-yellow-950/30 border border-yellow-700/40 rounded-lg p-3">
+          Deshabilitado: falta la variable <code>RR_ENABLE_NN_PREDICTIONS=1</code> en el Space.
+        </p>
+      </template>
+
+      <template x-if="nnEnabled">
+        <div>
+          <label class="block text-xs uppercase tracking-wide text-gray-400 mb-1">Partido jugado</label>
+          <select x-model="selectedMatchId"
+                  class="w-full bg-ink-800 border border-ink-600 rounded-lg px-3 py-2 mb-3">
+            <option value="">— Elegí un partido —</option>
+            <template x-for="m in playedMatches" :key="m.match_id">
+              <option :value="m.match_id" x-text="`${m.date} · ${m.home_team} vs ${m.away_team}`"></option>
+            </template>
+          </select>
+          <div class="flex items-center gap-3">
+            <button @click="runPostMatch()"
+                    :disabled="!selectedMatchId"
+                    :class="!selectedMatchId ? 'opacity-40 cursor-not-allowed' : 'hover:bg-racing-600'"
+                    class="bg-racing-500 text-racing-900 font-semibold px-4 py-2 rounded-lg text-sm">
+              Generar post-partido
+            </button>
+            <span class="text-xs text-gray-400" x-show="!playedMatches.length">No hay partidos jugados para esta liga/temporada.</span>
+            <span class="text-xs text-gray-400" x-show="playedMatches.length" x-text="`${playedMatches.length} partidos jugados disponibles`"></span>
+          </div>
+        </div>
+      </template>
     </article>
   </section>
 
@@ -155,7 +197,6 @@
   <section x-show="currentJob" class="space-y-4" x-transition.duration.200ms>
     <h2 class="text-lg font-semibold text-racing-500">3. Resultados</h2>
 
-    <!-- Progreso -->
     <div x-show="jobStatus && jobStatus.status !== 'done' && jobStatus.status !== 'error'"
          class="bg-ink-700 border border-ink-600 rounded-2xl p-5">
       <div class="flex items-center gap-3">
@@ -166,21 +207,16 @@
         </div>
       </div>
       <p class="text-xs text-gray-500 mt-3" x-show="!preprocessedCached">
-        Primera corrida después de un cold start: tarda ~3-5 min (baja el preprocessed ~2.5 GB y lo deja en RAM).
-      </p>
-      <p class="text-xs text-gray-500 mt-3" x-show="preprocessedCached">
-        Datos ya en RAM. Cada reporte tarda ~5-15 s.
+        Primera corrida después de un cold start: tarda ~3-5 min (baja el preprocessed y lo deja en RAM).
       </p>
+      <p class="text-xs text-gray-500 mt-3" x-show="preprocessedCached">Datos ya en RAM. Cada reporte tarda ~5-15 s.</p>
     </div>
 
-    <!-- Error -->
-    <div x-show="jobStatus?.status === 'error'"
-         class="bg-red-950/40 border border-red-700/40 rounded-2xl p-5">
+    <div x-show="jobStatus?.status === 'error'" class="bg-red-950/40 border border-red-700/40 rounded-2xl p-5">
       <div class="font-medium text-red-300">Falló la generación</div>
       <pre class="text-xs text-red-200 mt-2 whitespace-pre-wrap" x-text="jobStatus?.error"></pre>
     </div>
 
-    <!-- Done -->
     <template x-if="jobStatus?.status === 'done'">
       <div class="space-y-4">
         <template x-for="(bundle, reportType) in jobStatus.bundles" :key="reportType">
@@ -202,16 +238,12 @@
               </div>
             </div>
 
-            <!-- Warnings -->
             <template x-if="bundle.warnings && bundle.warnings.length">
               <div class="bg-yellow-950/30 border border-yellow-700/40 rounded-lg p-3 mb-4 text-xs text-yellow-200">
-                <template x-for="w in bundle.warnings" :key="w">
-                  <div x-text="w"></div>
-                </template>
+                <template x-for="w in bundle.warnings" :key="w"><div x-text="w"></div></template>
               </div>
             </template>
 
-            <!-- Filtro visual: mostrar sólo la seleccionada si vino de runOne -->
             <div class="grid sm:grid-cols-2 gap-4">
               <template x-for="fig in visibleFigures(reportType, bundle.figures)" :key="fig.name">
                 <figure class="bg-ink-800 border border-ink-600 rounded-xl p-3">
@@ -230,7 +262,6 @@
               </template>
             </div>
 
-            <!-- Tablas -->
             <template x-if="bundle.tables.length">
               <div class="mt-6 space-y-3">
                 <template x-for="table in bundle.tables" :key="table.name">
@@ -240,9 +271,7 @@
                         <span class="font-medium" x-text="table.title"></span>
                         <span class="text-xs text-gray-400 ml-2" x-text="table.section"></span>
                       </div>
-                      <a :href="table.csv_url" download
-                         @click.stop
-                         class="text-racing-500 hover:underline text-xs">Descargar CSV</a>
+                      <a :href="table.csv_url" download @click.stop class="text-racing-500 hover:underline text-xs">Descargar CSV</a>
                     </summary>
                     <div class="px-4 pb-4 overflow-x-auto table-preview" x-html="table.preview_html"></div>
                   </details>
@@ -266,8 +295,13 @@
     return {
       league: {{ league|tojson }},
       season: {{ season|tojson }},
-      teamA: 'Racing de Santander',
-      teamB: 'Huesca',
+      leagues: [],
+      seasons: [],
+      teams: [],
+      playedMatches: [],
+      selectedMatchId: '',
+      teamA: '',
+      teamB: '',
       dateFrom: '',
       dateTo: '',
       nnEnabled: {{ ('true' if nn_enabled else 'false') }},
@@ -278,27 +312,63 @@
       },
       currentJob: null,
       jobStatus: null,
-      onlyFigure: null,         // si la corrida fue 'runOne', filtra UI
+      onlyFigure: null,
       pollTimer: null,
 
-      init() { this._refreshHealth(); },
+      async init() {
+        await this.loadLeagues();
+        await this.loadSeasons(false);
+        await this.loadTeamsAndMatches();
+        this._refreshHealth();
+      },
+
+      async _getJSON(url) {
+        const r = await fetch(url);
+        if (!r.ok) throw new Error((await r.json().catch(()=>({detail:r.statusText}))).detail);
+        return r.json();
+      },
+
+      async loadLeagues() {
+        try {
+          this.leagues = await this._getJSON('/api/leagues');
+          if (this.leagues.length && !this.leagues.includes(this.league)) this.league = this.leagues[0];
+        } catch (e) { this.leagues = this.league ? [this.league] : []; }
+      },
+
+      async loadSeasons(reset = true) {
+        try {
+          this.seasons = await this._getJSON(`/api/seasons?league=${encodeURIComponent(this.league)}`);
+          if (this.seasons.length && (reset || !this.seasons.includes(this.season))) this.season = this.seasons[0];
+        } catch (e) { this.seasons = this.season ? [this.season] : []; }
+      },
+
+      async loadTeamsAndMatches() {
+        const q = `league=${encodeURIComponent(this.league)}&season=${encodeURIComponent(this.season)}`;
+        try {
+          this.teams = await this._getJSON(`/api/teams?${q}`);
+          if (this.teams.length) {
+            if (!this.teams.includes(this.teamA)) this.teamA = this.teams[0];
+            if (!this.teams.includes(this.teamB)) this.teamB = this.teams[Math.min(1, this.teams.length - 1)];
+          }
+        } catch (e) { this.teams = []; }
+        try {
+          this.playedMatches = await this._getJSON(`/api/matches?${q}&played_only=true`);
+        } catch (e) { this.playedMatches = []; }
+        this.selectedMatchId = '';
+      },
+
+      async onLeagueChange() { await this.loadSeasons(true); await this.loadTeamsAndMatches(); },
+      async onSeasonChange() { await this.loadTeamsAndMatches(); },
 
       async _refreshHealth() {
         try {
           const r = await fetch('/api/health');
-          if (r.ok) {
-            const d = await r.json();
-            this.preprocessedCached = !!d.preprocessed_cached;
-          }
+          if (r.ok) { const d = await r.json(); this.preprocessedCached = !!d.preprocessed_cached; }
         } catch (_e) {}
       },
 
       reportTitle(id) {
-        return ({
-          pre_match: 'Reporte previo (head-to-head)',
-          block_zscore: 'Bloques (z-score)',
-          post_match: 'Reporte post-partido',
-        })[id] || id;
+        return ({ pre_match: 'Reporte previo (head-to-head)', block_zscore: 'Bloques (z-score)', post_match: 'Reporte post-partido' })[id] || id;
       },
 
       visibleFigures(reportType, figs) {
@@ -310,51 +380,50 @@
         const r = this.reports[reportId];
         r.catalogOpen = !r.catalogOpen;
         if (r.catalogOpen && !r.catalog) {
-          try {
-            const resp = await fetch(`/api/reports/${reportId}/catalog`);
-            r.catalog = await resp.json();
-          } catch (e) {
-            alert('Error cargando catálogo: ' + e);
-            r.catalogOpen = false;
-          }
+          try { r.catalog = await this._getJSON(`/api/reports/${reportId}/catalog`); }
+          catch (e) { alert('Error cargando catálogo: ' + e); r.catalogOpen = false; }
         }
       },
 
-      async runFull(reportId)        { await this._run(reportId, null); },
+      async runFull(reportId)         { await this._run(reportId, null); },
       async runOne(reportId, figName) { await this._run(reportId, figName); },
 
       async _run(reportId, figName) {
         if (!this.teamA || !this.teamB) { alert('Elegí equipo A y equipo B.'); return; }
         if (this.teamA === this.teamB) { alert('Equipo A y B deben ser distintos.'); return; }
-        const body = {
-          league: this.league,
-          season: this.season,
-          team_a: this.teamA,
-          team_b: this.teamB,
-          filters: {
-            date_from: this.dateFrom || null,
-            date_to: this.dateTo || null,
-          },
+        await this._post(reportId, {
+          league: this.league, season: this.season,
+          team_a: this.teamA, team_b: this.teamB,
+          filters: { date_from: this.dateFrom || null, date_to: this.dateTo || null },
           only: figName ? [figName] : [],
-        };
+        }, figName, figName ? `${this.reportTitle(reportId)} · ${figName}` : this.reportTitle(reportId));
+      },
+
+      async runPostMatch() {
+        if (!this.selectedMatchId) { alert('Elegí un partido jugado.'); return; }
+        const m = this.playedMatches.find(x => x.match_id === this.selectedMatchId);
+        if (!m) { alert('Ese partido no existe para esta liga/temporada.'); return; }
+        await this._post('post_match', {
+          league: this.league, season: this.season,
+          team_a: m.home_team, team_b: m.away_team,
+          match_id: m.match_id, filters: {}, only: [],
+        }, null, `Post-partido · ${m.home_team} vs ${m.away_team}`);
+      },
+
+      async _post(reportId, body, figName, title) {
         let resp;
         try {
           resp = await fetch(`/api/reports/${reportId}/run`, {
-            method: 'POST',
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify(body),
+            method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body),
           });
-        } catch (e) {
-          alert('Error de red: ' + e); return;
-        }
+        } catch (e) { alert('Error de red: ' + e); return; }
         if (!resp.ok) {
           const err = await resp.json().catch(() => ({ detail: resp.statusText }));
-          alert('Error: ' + err.detail);
-          return;
+          alert('Error: ' + err.detail); return;
         }
         const { job_id } = await resp.json();
         this.onlyFigure = figName;
-        this._startPolling(job_id, figName ? `${this.reportTitle(reportId)} · ${figName}` : this.reportTitle(reportId));
+        this._startPolling(job_id, title);
       },
 
       _startPolling(jobId, title) {
@@ -363,9 +432,7 @@
         if (this.pollTimer) clearInterval(this.pollTimer);
         this.pollTimer = setInterval(() => this._poll(), 2000);
         this._poll();
-        setTimeout(() => {
-          document.querySelector('section > h2')?.scrollIntoView({ behavior: 'smooth', block: 'start' });
-        }, 100);
+        setTimeout(() => { document.querySelector('section > h2')?.scrollIntoView({ behavior: 'smooth', block: 'start' }); }, 100);
       },
 
       async _poll() {
@@ -375,11 +442,9 @@
           if (!r.ok) return;
           this.jobStatus = await r.json();
           if (['done', 'error'].includes(this.jobStatus.status)) {
-            clearInterval(this.pollTimer);
-            this.pollTimer = null;
-            this._refreshHealth();  // cache RAM probablemente cambió
+            clearInterval(this.pollTimer); this.pollTimer = null; this._refreshHealth();
           }
-        } catch (_e) { /* siguiente tick */ }
+        } catch (_e) {}
       },
     };
   }

src/racing_reports/web_meta.py

@@ -0,0 +1,95 @@
+"""Metadata para la web (ligas, temporadas, equipos, partidos) derivada del
+dataset de modelado bundleado — sin depender de Azure para *seleccionar*.
+
+El dataset (`vendor/data/modeling/attack_prediction_dataset.parquet`) trae, por
+partido y equipo: league, season, fecha, team_name, opponent_name, is_home,
+matchId. Con eso armamos los selectores y la lista de partidos jugados para
+cualquiera de las ligas que el modelo soporta, offline.
+
+La GENERACIÓN de reportes sigue necesitando el preprocessed (Azure); por eso
+`available_league_seasons()` puede intersecar con lo que realmente está subido.
+"""
+
+from __future__ import annotations
+
+import threading
+from datetime import date
+from functools import lru_cache
+
+import pandas as pd
+
+from racing_reports import vendor_env
+
+_LOCK = threading.Lock()
+_CACHE: dict[str, object] = {}
+
+_DATASET_PATH = vendor_env.DATA_DIR / "modeling" / "attack_prediction_dataset.parquet"
+_COLS = ["matchId", "league", "season", "fecha", "team_name", "opponent_name", "is_home"]
+
+
+def _load() -> pd.DataFrame:
+    """Carga (cacheada) las columnas meta del dataset de modelado."""
+    with _LOCK:
+        df = _CACHE.get("df")
+        if df is None:
+            cols = [c for c in _COLS if c]
+            df = pd.read_parquet(_DATASET_PATH, columns=cols)
+            df["fecha"] = pd.to_datetime(df["fecha"], errors="coerce")
+            df["league"] = df["league"].astype(str)
+            df["season"] = df["season"].astype(str)
+            _CACHE["df"] = df
+        return df
+
+
+def has_dataset() -> bool:
+    return _DATASET_PATH.exists()
+
+
+def league_seasons() -> dict[str, list[str]]:
+    """{liga: [temporadas]} presentes en el dataset (orden temporada desc)."""
+    df = _load()
+    out: dict[str, list[str]] = {}
+    for league, sub in df.groupby("league"):
+        out[str(league)] = sorted(sub["season"].unique().tolist(), reverse=True)
+    return dict(sorted(out.items()))
+
+
+def teams(league: str, season: str) -> list[str]:
+    """Equipos de esa liga/temporada (nombres ordenados)."""
+    df = _load()
+    sub = df[(df["league"] == league) & (df["season"] == str(season))]
+    names = set(sub["team_name"].dropna().astype(str)) | set(sub["opponent_name"].dropna().astype(str))
+    return sorted(names)
+
+
+def matches(league: str, season: str, played_only: bool = False) -> list[dict]:
+    """Lista de partidos (home/away/fecha/estado) de esa liga/temporada."""
+    df = _load()
+    sub = df[(df["league"] == league) & (df["season"] == str(season)) & (df["is_home"] == True)]  # noqa: E712
+    sub = sub.drop_duplicates("matchId")
+    today = pd.Timestamp(date.today())
+    rows: list[dict] = []
+    for _, r in sub.sort_values("fecha", ascending=False).iterrows():
+        d = r["fecha"]
+        played = pd.notna(d) and d <= today
+        if played_only and not played:
+            continue
+        rows.append({
+            "match_id": str(r["matchId"]),
+            "date": d.strftime("%Y-%m-%d") if pd.notna(d) else "",
+            "home_team": str(r["team_name"]),
+            "away_team": str(r["opponent_name"]),
+            "status": "played" if played else "future",
+        })
+    return rows
+
+
+def resolve_pair(league: str, season: str, team_a: str, team_b: str) -> list[dict]:
+    """Partidos entre A y B (en cualquier orden) en esa liga/temporada."""
+    a, b = team_a.strip().casefold(), team_b.strip().casefold()
+    out = []
+    for m in matches(league, season):
+        h, w = m["home_team"].casefold(), m["away_team"].casefold()
+        if {h, w} == {a, b}:
+            out.append(m)
+    return out

tests/test_web_app.py

@@ -11,16 +11,31 @@ from racing_reports.web import app as web_app
 
 
 def test_home_is_spa_with_teams_and_report_cards():
-    """El nuevo home es un SPA que consume /api/. Verificamos que el HTML
-    contiene los selects de equipos y las cards de los reportes."""
+    """El nuevo home es un SPA que consume /api/. Equipos/ligas/partidos se cargan
+    client-side; verificamos los selectores y las cards de reportes."""
     client = TestClient(web_app.app)
     resp = client.get("/")
     assert resp.status_code == 200
-    assert "Racing de Santander" in resp.text  # desde vendor/data/team_ids_ssd.json
+    assert 'x-model="league"' in resp.text       # selector de liga
+    assert 'x-model="season"' in resp.text       # selector de temporada
     assert "Reporte previo" in resp.text
     assert "Bloques" in resp.text
-    assert "post-partido" in resp.text  # card deshabilitada
-    assert "/api/reports/" in resp.text  # alpine consume la API
+    assert "post-partido" in resp.text            # card de post-partido
+    assert "runPostMatch" in resp.text            # flujo de post-partido funcional
+    assert "/api/leagues" in resp.text            # alpine consume la API meta
+    assert "/api/reports/" in resp.text
+
+
+def test_meta_endpoints_are_dataset_driven():
+    """leagues/seasons/teams/matches salen del dataset bundleado (offline)."""
+    from racing_reports.api import routes_meta as rm
+    ls = rm._league_seasons()
+    assert ls, "debe haber al menos una liga/temporada"
+    league = next(iter(ls))
+    season = ls[league][0]
+    assert rm.teams(league, season), "debe listar equipos"
+    # matches puede estar vacío para temporadas sin jugados, pero no debe romper
+    assert isinstance(rm.matches(league, season, played_only=True), list)
 
 
 def test_legacy_home_still_works():

vendor/data/modeling/attack_prediction_dataset.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:885726cff0233d7ab8a2c6fea06d4d66c7707bf60c1b40b7a6560874e6904164
-size 10009594
+oid sha256:05b43be8a91cea8400eef47d55ea5dffb69809cfe73c8d26937c9f7955139d06
+size 10011206