Reportes de partido para cualquier liga/temporada en curso

- runner: resolver team IDs desde el preprocessed cuando el dataset del
modelo no cubre la temporada (p.ej. La Liga 26-27, donde juega Racing).
- pre_match: si falta historial de modelado (temporada en curso) con NN
habilitado, degradar la cancha de predicción a placeholder en vez de
romper el previo entero — el previo táctico igual se genera.
- ejes previo: normas separadas por localía (local vs visitante).

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

src/racing_reports/ejes_data.py

@@ -206,13 +206,28 @@ def _eje_z(scales: dict, eje_col: str, value: float) -> float:
 
 
 def pre_prediction(league: str, season: str, home: str, away: str) -> dict:
-    """Para cada equipo: por eje, su norma y la predicción del partido (crece/decrece)."""
+    """Para cada equipo: por eje, su norma y la predicción del partido (crece/decrece).
+
+    Usa normas separadas por localía: el LOCAL ataca con su norma de local contra la
+    concesión de VISITANTE del rival, y viceversa. Cae a la norma combinada si falta el
+    split (artefactos viejos o equipo sin partidos en esa condición).
+    """
     sc = _scales(league, season)
     pred = _predictor(league, season)
+    gen_all, con_all = sc["team_eje_norm_gen"], sc["team_eje_norm_con"]
+    gen_home = sc.get("team_eje_norm_gen_home", {})
+    gen_away = sc.get("team_eje_norm_gen_away", {})
+    con_home = sc.get("team_eje_norm_con_home", {})
+    con_away = sc.get("team_eje_norm_con_away", {})
     out = []
-    for team, rival in [(home, away), (away, home)]:
-        gen = sc["team_eje_norm_gen"].get(team)
-        con = sc["team_eje_norm_con"].get(rival)
+    # (equipo, rival, equipo_es_local)
+    for team, rival, team_home in [(home, away, True), (away, home, False)]:
+        if team_home:  # team de local → rival defiende de visitante
+            gen = gen_home.get(team) or gen_all.get(team)
+            con = con_away.get(rival) or con_all.get(rival)
+        else:          # team de visitante → rival defiende de local
+            gen = gen_away.get(team) or gen_all.get(team)
+            con = con_home.get(rival) or con_all.get(rival)
         if gen is None or con is None:
             raise ValueError(f"Sin perfil de ejes para {team if gen is None else rival} "
                              f"en {league} {season}")
@@ -232,7 +247,8 @@ def pre_prediction(league: str, season: str, home: str, away: str) -> dict:
                 pred_z=round(_eje_z(sc, ec, p), 2),
                 delta_sigma=round((p - norma) / sigma, 2),
             ))
-        out.append(dict(team=team, rival=rival, rows=rows))
+        out.append(dict(team=team, rival=rival,
+                        venue="local" if team_home else "visitante", rows=rows))
     return {"league": league, "season": season, "teams": out}
 
 

src/racing_reports/reports/ejes.py

@@ -69,7 +69,9 @@ def _fig_pre(pred: dict):
         ax.set_yticks(list(ys))
         ax.set_yticklabels([r["label"] for r in rows], color=FG, fontsize=10)
         ax.invert_yaxis()
-        ax.set_title(f"{tinfo['team']}  (vs {tinfo['rival']})", color=FG, fontsize=12)
+        venue = tinfo.get("venue")
+        vtag = f" — de {venue}" if venue else ""
+        ax.set_title(f"{tinfo['team']}{vtag}  (vs {tinfo['rival']})", color=FG, fontsize=12)
         ax.set_xlabel("z vs liga (medias de partido)", color=MUT, fontsize=9)
     fig.suptitle("Ejes de ataque esperados — punto amarillo = su norma, flecha = predicción del partido",
                  color=FG, fontsize=11, y=1.0)
@@ -93,18 +95,21 @@ def generate_pre(out_path: Path, league: str, season: str,
             f"<td class='{_cls(r['delta_sigma'])}'>{r['delta_sigma']:+.2f}σ</td></tr>"
             for r in sorted(tinfo["rows"], key=lambda x: -abs(x["delta_sigma"]))
         )
+        venue = tinfo.get("venue")
+        vtag = f" <span style='color:{MUT};font-weight:400'>(de {venue})</span>" if venue else ""
         tables.append(
-            f"<div><h2>{tinfo['team']}</h2>"
+            f"<div><h2>{tinfo['team']}{vtag}</h2>"
             f"<table><tr><th>eje</th><th>su norma (z)</th><th>predicción (z)</th>"
             f"<th>Δ esperado</th></tr>{rows}</table></div>"
         )
     body = (
         f"<img src='{png_to_data_uri(png)}' alt='ejes previstos'>"
         f"<div class='grid'>{''.join(tables)}</div>"
-        "<p class='note'>Predicción = generación propia × concesión del rival (regresión por eje, "
-        "leave-one-match-out). Δ en σ partido-a-partido: ±1σ = variación normal entre partidos. "
-        "El rival moldea sobre todo la elaboración y la rotura de líneas / profundidad; el robo alto "
-        "es más oportunista (menos predecible).</p>"
+        "<p class='note'>Predicción = generación propia (de local/visitante según corresponda) × "
+        "concesión del rival en esa misma condición (regresión por eje, leave-one-match-out). "
+        "Por eso el reporte cambia según quién juega de local. Δ en σ partido-a-partido: ±1σ = "
+        "variación normal entre partidos. El rival moldea sobre todo la elaboración y la rotura de "
+        "líneas / profundidad; el robo alto es más oportunista (menos predecible).</p>"
     )
     html = _html_shell(
         f"Ejes de ataque — previo: {home_name} vs {away_name}",

src/racing_reports/reports/pre_match.py

@@ -21,6 +21,24 @@ from racing_reports.reports.catalogs import PRE_MATCH_FIGURES, PRE_MATCH_TABLES
 from racing_reports.reports.common import save_figure, save_table
 
 
+def _placeholder_fig(title: str, message: str):
+    """Figura vacía con un mensaje (reemplaza a la cancha de predicción del modelo
+    cuando ésta no está disponible)."""
+    fig, ax = plt.subplots(figsize=(10.0, 6.4))
+    fig.patch.set_facecolor("#f9f8f4")
+    ax.set_facecolor("#f9f8f4")
+    ax.set_xticks([])
+    ax.set_yticks([])
+    for spine in ax.spines.values():
+        spine.set_visible(False)
+    ax.text(0.5, 0.62, title, ha="center", va="center", fontsize=14,
+            fontweight="bold", color="#1f2933", transform=ax.transAxes)
+    ax.text(0.5, 0.42, message, ha="center", va="center", fontsize=11,
+            color="#52606d", transform=ax.transAxes)
+    fig.tight_layout()
+    return fig
+
+
 @contextmanager
 def _disable_nn_predictions(pro_module) -> Iterator[None]:
     originals = {
@@ -36,25 +54,7 @@ def _disable_nn_predictions(pro_module) -> Iterator[None]:
         return None
 
     def _stub_plot(_prediction, title: str):
-        fig, ax = plt.subplots(figsize=(10.0, 6.4))
-        fig.patch.set_facecolor("#f9f8f4")
-        ax.set_facecolor("#f9f8f4")
-        ax.set_xticks([])
-        ax.set_yticks([])
-        for spine in ax.spines.values():
-            spine.set_visible(False)
-        ax.text(
-            0.5, 0.62, title,
-            ha="center", va="center", fontsize=14, fontweight="bold",
-            color="#1f2933", transform=ax.transAxes,
-        )
-        ax.text(
-            0.5, 0.42, "Predicciones del modelo no disponibles en el MVP.",
-            ha="center", va="center", fontsize=11, color="#52606d",
-            transform=ax.transAxes,
-        )
-        fig.tight_layout()
-        return fig
+        return _placeholder_fig(title, "Predicciones del modelo no disponibles en el MVP.")
 
     pro_module._load_modeling_dataset = _stub_dataset
     pro_module._predict_single_team_future = _stub_predict
@@ -66,6 +66,37 @@ def _disable_nn_predictions(pro_module) -> Iterator[None]:
             setattr(pro_module, name, fn)
 
 
+@contextmanager
+def _guard_missing_model_history(pro_module) -> Iterator[None]:
+    """Con NN habilitado, la predicción del modelo necesita historial de modelado
+    de la liga-temporada. La temporada EN CURSO (p.ej. La Liga 26-27) todavía no
+    está en el dataset del modelo → ``_predict_single_team_future`` tira ValueError.
+    En ese caso devolvemos None y dibujamos un placeholder, así el previo táctico
+    (zonas, presión, win/loss, local/visitante) igual se genera para cualquier liga."""
+    orig_predict = pro_module._predict_single_team_future
+    orig_plot = pro_module.plot_model_prediction_pitch
+
+    def _safe_predict(**kwargs):
+        try:
+            return orig_predict(**kwargs)
+        except Exception:  # noqa: BLE001 — la predicción es un extra, nunca rompe el previo
+            return None
+
+    def _safe_plot(prediction, title: str):
+        if prediction is None:
+            return _placeholder_fig(
+                title, "Sin historial de modelado para esta temporada todavía.")
+        return orig_plot(prediction, title)
+
+    pro_module._predict_single_team_future = _safe_predict
+    pro_module.plot_model_prediction_pitch = _safe_plot
+    try:
+        yield
+    finally:
+        pro_module._predict_single_team_future = orig_predict
+        pro_module.plot_model_prediction_pitch = orig_plot
+
+
 @contextmanager
 def _capture_figures(base_module, out_dir: Path, figures_out: list[FigureArtifact]) -> Iterator[None]:
     """Intercepta cada llamada a ``base._fig_to_base64`` para persistir a disco.
@@ -179,6 +210,10 @@ def generate(
     with ExitStack() as stack:
         if not settings.enable_nn_predictions:
             stack.enter_context(_disable_nn_predictions(pro))
+        else:
+            # NN on: si falta historial de modelado (temporada en curso), degradá a
+            # placeholder en vez de romper el previo entero.
+            stack.enter_context(_guard_missing_model_history(pro))
         stack.enter_context(_capture_figures(base, out_path.parent, figures))
         stack.enter_context(_capture_tables(pro, base, out_path.parent, tables))
         result_path = pro.generate_professional_head_to_head_report(

src/racing_reports/runner.py

@@ -6,6 +6,7 @@ from dataclasses import asdict
 from pathlib import Path
 from typing import Any
 
+import pandas as pd
 import yaml
 
 from racing_reports import vendor_env
@@ -56,6 +57,19 @@ class ReportRunner:
                 pass
         return ids
 
+    @staticmethod
+    def _team_ids_from_csv(csv_path: Path) -> dict[str, str]:
+        # Mapa nombre→id leído del preprocessed. Cubre la temporada EN CURSO (que el
+        # dataset del modelo todavía no tiene: p.ej. La Liga 26-27), así el
+        # head-to-head funciona para cualquier liga/temporada que esté en Azure.
+        try:
+            df = pd.read_csv(csv_path, usecols=["TeamName", "teamId"],
+                             dtype={"teamId": str}, low_memory=False)
+            df = df.dropna(subset=["TeamName", "teamId"]).drop_duplicates("TeamName")
+            return dict(zip(df["TeamName"].astype(str), df["teamId"].astype(str)))
+        except Exception:
+            return {}
+
     def _resolve_id(self, name: str, team_ids: dict[str, str]) -> str:
         if name in team_ids:
             return team_ids[name]
@@ -123,6 +137,11 @@ class ReportRunner:
                 pre_csv = self.datastore.sync_preprocessed(
                     request.league, request.season
                 )
+                # Completar los IDs con los del preprocessed (cubre la temporada en
+                # curso, que el dataset del modelo aún no tiene). Se pisa lo bundleado
+                # solo si falta; los nombres del preprocessed son los de Opta.
+                for name, tid in self._team_ids_from_csv(pre_csv).items():
+                    team_ids.setdefault(name, tid)
                 gen_zones = vendor_env.patch_helper_paths(
                     preprocessed_csv=pre_csv, matches_csv=paths["matches_csv"],
                     league=request.league, season=request.season,