Post-partido: resolver partidos recientes ausentes del dataset del modelo

El resolve usaba el dataset del modelo (cortado en marzo) y no encontraba partidos
posteriores aunque estén en el catálogo (p.ej. Racing vs Almería del 12/04, Racing
local). Ahora:
- web_meta.matches(): para ligas del modelo suma los partidos del catálogo (cubre
hasta la última fecha); esos van sin matchId.
- runner + MatchIndex.find_by_teams(): cuando no hay matchId, se resuelve del
preprocessed en vivo por local/visitante(+fecha).
- Se mantiene el ORDEN (primer equipo local, segundo visitante) que se había roto.

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

src/racing_reports/api/routes_reports.py

@@ -63,10 +63,10 @@ def run(report_type: str, payload: RunRequest) -> RunResponse:
     # pre/post necesitan los dos equipos (local + visitante); los de equipo permiten 1.
     if report_type in ("pre_match", "post_match") and not payload.team_b:
         raise HTTPException(status_code=400, detail="Para previo/post-partido elegí local y visitante.")
-    if report_type == "post_match" and not payload.match_id:
+    if report_type == "post_match" and not payload.match_id and not payload.match_date:
         raise HTTPException(
             status_code=400,
-            detail="Para el post-partido elegí un partido jugado (match_id requerido).",
+            detail="Para el post-partido elegí un partido jugado.",
         )
 
     def _venue(v: str | None) -> str:
@@ -101,6 +101,7 @@ def run(report_type: str, payload: RunRequest) -> RunResponse:
         away_team=payload.team_b,
         report_types=[report_type],
         match_id=payload.match_id,
+        match_date=payload.match_date,
         settings=settings_blob,
     )
 

src/racing_reports/api/schemas.py

@@ -79,6 +79,7 @@ class RunRequest(BaseModel):
     team_a: str = ""
     team_b: str = ""
     match_id: str = ""
+    match_date: str = ""
     filters: FilterPayload = Field(default_factory=FilterPayload)
     only: list[str] = Field(default_factory=list)  # nombres de figuras/tablas específicas
 

src/racing_reports/match_index.py

@@ -90,5 +90,21 @@ class MatchIndex:
         row = hit.iloc[0]
         return MatchInfo(**row.to_dict())
 
+    def find_by_teams(self, league: str, season: str, home: str, away: str,
+                      date: str | None = None) -> MatchInfo | None:
+        """Resuelve el partido por local/visitante (y fecha si se da) desde el
+        preprocessed en vivo. Para partidos recientes sin matchId en el dataset."""
+        idx = self.build(league, season)
+        h, a = str(home).casefold(), str(away).casefold()
+        hit = idx[(idx["home_team"].astype(str).str.casefold() == h)
+                  & (idx["away_team"].astype(str).str.casefold() == a)]
+        if date and not hit.empty:
+            exact = hit[hit["date"].astype(str) == str(date)[:10]]
+            if not exact.empty:
+                hit = exact
+        if hit.empty:
+            return None
+        return MatchInfo(**hit.iloc[0].to_dict())
+
     def preprocessed_path(self, league: str, season: str) -> Path:
         return self.datastore.require_preprocessed(league, season)

src/racing_reports/models.py

@@ -15,6 +15,7 @@ class ReportRequest:
     away_team: str
     report_types: list[str]
     match_id: str = ""
+    match_date: str = ""  # fecha del partido (para resolver el matchId si no vino)
     settings: dict[str, dict[str, Any]] = field(default_factory=dict)
 
 

src/racing_reports/runner.py

@@ -74,10 +74,10 @@ class ReportRunner:
         away_name = request.away_team
         match_date = None
 
-        if "post_match" in report_types or request.match_id:
-            # Resolvemos home/away/fecha desde el dataset bundleado (web_meta),
-            # NO del preprocessed: éste todavía no se descargó (prepare_vendor corre
-            # después) y además así el local/visitante es el real del partido.
+        resolved_match_id = request.match_id
+        if request.match_id:
+            # Con matchId: resolvemos home/away/fecha desde el dataset bundleado (web_meta),
+            # NO del preprocessed (éste todavía no se descargó; prepare_vendor corre después).
             from racing_reports import web_meta
 
             match = web_meta.find_match(
@@ -86,6 +86,13 @@ class ReportRunner:
             home_name = match["home_team"]
             away_name = match["away_team"]
             match_date = match["date"]
+        elif "post_match" in report_types:
+            # Partido reciente sin matchId en el dataset: usamos lo que mandó el front
+            # (local/visitante/fecha). El matchId real se resuelve más abajo desde el
+            # preprocessed, una vez descargado.
+            home_name = request.home_team
+            away_name = request.away_team
+            match_date = request.match_date or None
 
         paths = self.datastore.prepare_vendor(
             report_types, request.league, request.season
@@ -148,6 +155,19 @@ class ReportRunner:
                     venue_b=flt.get("venue_b", flt.get("venue", "both")),
                 )
             elif report_type == "post_match":
+                # Si el partido no traía matchId (reciente, no está en el dataset),
+                # lo resolvemos del preprocessed ya descargado por local/visitante/fecha.
+                if not resolved_match_id:
+                    info = self.match_index.find_by_teams(
+                        request.league, request.season, home_name, away_name, match_date
+                    )
+                    if info is None:
+                        raise ValueError(
+                            f"No se encontró {home_name} vs {away_name}"
+                            + (f" ({match_date})" if match_date else "")
+                            + f" en el preprocessed de {request.league} {request.season}."
+                        )
+                    resolved_match_id = info.match_id
                 title = (
                     f"{home_name} vs {away_name}"
                     + (f" — {match_date}" if match_date else "")
@@ -160,7 +180,7 @@ class ReportRunner:
                     matches_csv=paths["matches_csv"],
                     league=request.league,
                     season=request.season,
-                    match_id=request.match_id,
+                    match_id=resolved_match_id,
                     home_name=home_name,
                     away_name=away_name,
                     team_ids=team_ids,

src/racing_reports/web/templates/home.html

@@ -740,15 +740,10 @@
               cands=await this._getJSON(`/api/matches/resolve?${q}`); }
         catch(e){ this.postMatchChecking=false; this._pmErr('Error verificando: '+e); return; }
         this.postMatchChecking=false;
-        // Acepta el partido en cualquier orden (no importa a quién elegiste como local):
-        // usamos la orientación REAL del partido (quién fue local de verdad).
-        const pair=new Set([this.teamA, this.teamB]);
-        const m=cands.find(c=>c.status==='played' && c.home_team && c.away_team
-                           && new Set([c.home_team, c.away_team]).size===2
-                           && [c.home_team, c.away_team].every(t=>pair.has(t)));
-        if (!m){ this._pmErr(`No existe ${this.teamA} vs ${this.teamB} jugado en ${this.league} ${this.season}. (Datos hasta ${this.dataMaxDate||'la última actualización'}.)`); 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} (${m.date})`);
+        const m=cands.find(c=>c.home_team===this.teamA && c.away_team===this.teamB && c.status==='played');
+        if (!m){ this._pmErr(`No existe ${this.teamA} (local) vs ${this.teamB} (visitante) jugado en ${this.league} ${this.season}. (Datos hasta ${this.dataMaxDate||'la última actualización'}.)`); return; }
+        await this._post('post_match', { league:this.league, season:this.season, team_a:this.teamA, team_b:this.teamB, match_id:m.match_id, match_date:m.date, filters:{}, only:[] },
+                         null, `Post-partido · ${this.teamA} vs ${this.teamB} (${m.date})`);
       },
       _pmErr(m){ this.postMatchMsg=m; this.postMatchMsgError=true; },
 

src/racing_reports/web_meta.py

@@ -120,16 +120,23 @@ def _dataset_matches(league: str, season: str) -> list[dict]:
 def matches(league: str, season: str, played_only: bool = False) -> list[dict]:
     """Lista de partidos. Para ligas del modelo, con matchId real (post-partido);
     para el resto, del catálogo (sin matchId)."""
+    today = date.today().isoformat()
+    c = _catalog()
+    sub = c[(c["league"] == league) & (c["season"] == str(season))].drop_duplicates(["date", "home_team", "away_team"])
+    cat_rows = [{"match_id": "", "date": str(r["date"])[:10], "home_team": str(r["home_team"]),
+                 "away_team": str(r["away_team"]),
+                 "status": "played" if str(r["date"])[:10] <= today else "future"}
+                for _, r in sub.iterrows()]
     if league in _model_leagues():
+        # Dataset del modelo: trae matchId, pero puede estar cortado. Se completa con
+        # el catálogo (cubre hasta la última fecha) — esos van sin matchId y el runner
+        # lo resuelve del preprocessed al generar.
         rows = _dataset_matches(league, season)
+        have = {(m["date"], m["home_team"], m["away_team"]) for m in rows}
+        rows += [m for m in cat_rows if (m["date"], m["home_team"], m["away_team"]) not in have]
+        rows.sort(key=lambda m: m["date"], reverse=True)
     else:
-        c = _catalog()
-        sub = c[(c["league"] == league) & (c["season"] == str(season))].drop_duplicates(["date", "home_team", "away_team"])
-        today = date.today().isoformat()
-        rows = [{"match_id": "", "date": str(r["date"]), "home_team": str(r["home_team"]),
-                 "away_team": str(r["away_team"]),
-                 "status": "played" if str(r["date"]) <= today else "future"}
-                for _, r in sub.sort_values("date", ascending=False).iterrows()]
+        rows = sorted(cat_rows, key=lambda m: m["date"], reverse=True)
     if played_only:
         rows = [m for m in rows if m["status"] == "played"]
     return rows