Upload 5 files

README.md

@@ -1,10 +1,27 @@
-# Analizador de Partidas PGN (Doctor Linux)
-
-- Repara PGN y analiza la primera partida válida (no se altera tu texto original).
-- Si existe `models/blunder/model.joblib` + `features.txt`, muestra curva de **prob. de blunder**.
-- Gráfico de Ventaja aprox. y reporte básico.
-
-## Local
-```bash
-pip install -r requirements.txt
-python app.py
+# AI Chess Analyzer — estilo DecodeChess (Doctor Linux)
+
+Analizador de partidas PGN con motor **Stockfish** y explicaciones en lenguaje natural, inspirado en DecodeChess.
+
+## Características
+- Repara PGN “sucios” y toma la **primera partida válida**.
+- Evalúa jugada por jugada con Stockfish (tiempo por jugada configurable).
+- Clasifica cada jugada: **Best / Good / Inaccuracy / Mistake / Blunder**.
+- Agrega comentarios a cada jugada (explicación natural) → **PGN anotado descargable**.
+- Exporta **CSV** con métricas por jugada.
+- (Opcional) Si subes un modelo en `models/blunder/` (`model.joblib` + `features.txt`) muestra probabilidad de blunder.
+
+## Despliegue en Hugging Face Spaces
+1. Crea un Space tipo **Gradio**.
+2. Sube estos archivos al root del repo:
+   - `app.py`
+   - `requirements.txt`
+   - `apt.txt`  *(para instalar `stockfish`)*
+3. Habilita hardware CPU normal (no requiere GPU).
+4. Ejecuta el Space; el motor se lanzará desde `apt`.
+
+## Local
+```bash
+python -m venv .venv && source .venv/bin/activate  # en Windows: .venv\Scripts\activate
+pip install -r requirements.txt
+python app.py
+```

app.py

@@ -1,278 +1,342 @@
-import os
-import gradio as gr
-import chess
-import chess.pgn
-import matplotlib
-matplotlib.use("Agg")
-import matplotlib.pyplot as plt
-import re
-import joblib
-import numpy as np
-import pandas as pd
-from io import StringIO
-
-# ====== Intento cargar modelo de blunders si existe ======
-BLUNDER_MODEL_PATH = "models/blunder/model.joblib"
-BLUNDER_FEATURES_PATH = "models/blunder/features.txt"
-blunder_model = None
-blunder_features = None
-if os.path.exists(BLUNDER_MODEL_PATH) and os.path.exists(BLUNDER_FEATURES_PATH):
-    try:
-        blunder_model = joblib.load(BLUNDER_MODEL_PATH)
-        with open(BLUNDER_FEATURES_PATH, "r", encoding="utf-8") as f:
-            blunder_features = [ln.strip() for ln in f if ln.strip()]
-        print("✅ Modelo de blunders cargado.")
-    except Exception as e:
-        print("⚠️ No se pudo cargar el modelo de blunders:", e)
-        blunder_model = None
-        blunder_features = None
-
-# -------------------------------
-# Reparador de PGN
-# -------------------------------
-class ReparadorPGN:
-    @staticmethod
-    def reparar_pgn(pgn_text: str) -> str:
-        if not isinstance(pgn_text, str):
-            return pgn_text
-        lineas = pgn_text.splitlines()
-        out = []
-        for linea in lineas:
-            original = linea
-            s = linea.strip()
-            if s.startswith("[") and "]" in s:
-                s = re.sub(r'\[([A-Za-z0-9_]+)\s+"([^"]*)["“”]?\]?$', r'[\1 "\2"]', s)
-                s = re.sub(r'\[Ulnite', '[White', s)
-                s = s.replace('[Result "I-0"]',  '[Result "1-0"]')
-                s = s.replace('[Result "O-I"]',  '[Result "0-1"]')
-                s = s.replace('[Result "I/2-I/2"]', '[Result "1/2-1/2"]')
-                out.append(s); continue
-            t = s
-            correcciones = {
-                r'\bnf([1-8a-h])': r'Nf\1',
-                r'\bnc([1-8a-h])': r'Nc\1',
-                r'\bng([1-8a-h])': r'Ng\1',
-                r'\bhc([1-8])\b': 'Nc\\1',
-                r'\bhf([1-8])\b': 'Nf\\1',
-                r'\bnn1\b': 'Nf1',
-                r'\bhe2\b': 'Ne2',
-                r'\bnh7\b': 'Nh7',
-                r'\bhc5\b': 'Nc5',
-                r'\bqu2\b': 'Qd2',
-                r'\bre1\b': 'Re1',
-                r'\brn\b': 'Rf1',
-                r'\bbe4:?': 'Be4',
-                r'\bo-o-o\b': 'O-O-O',
-                r'\bo-o\b': 'O-O',
-            }
-            for pat, rep in correcciones.items():
-                t = re.sub(pat, rep, t, flags=re.IGNORECASE)
-            out.append(t if t else original)
-        texto = "\n".join(out)
-        texto = texto.replace('Result "* *"', 'Result "*"')
-        return texto
-
-# -------------------------------
-# Analizador simple
-# -------------------------------
-class AnalizadorAjedrez:
-    def __init__(self):
-        self.datos_jugadas = []  # lista de dicts por ply
-        self._last_meta = {}     # meta de partida analizada
-
-    def analizar_primera_partida_valida(self, pgn_text: str):
-        if not pgn_text or not pgn_text.strip():
-            return "Anónimo", "Anónimo", "*", "PGN vacío.", None
-        candidatos = []
-        candidatos.append(("original", pgn_text))
-        reparado = ReparadorPGN.reparar_pgn(pgn_text)
-        candidatos.append(("reparado", reparado))
-        candidatos.append(("minimo", self._crear_pgn_minimo(pgn_text)))
-        for etiqueta, intento in candidatos:
-            try:
-                partidas = list(self._iterar_partidas(intento))
-                for game in partidas:
-                    if game is None: continue
-                    plies = sum(1 for _ in game.mainline_moves())
-                    if plies == 0: continue
-                    blancas = game.headers.get("White", "Anónimo") or "Anónimo"
-                    negras = game.headers.get("Black", "Anónimo") or "Anónimo"
-                    resultado = game.headers.get("Result", "*") or "*"
-                    self._analizar_jugadas(game, blancas, negras)
-                    info = f"Análisis exitoso ({etiqueta}). Plies: {plies}"
-                    return blancas, negras, resultado, info, intento
-            except Exception:
-                continue
-        return "Anónimo", "Anónimo", "*", "No se pudo analizar ninguna partida válida en el PGN.", None
-
-    def _iterar_partidas(self, pgn_text: str):
-        f = StringIO(pgn_text)
-        while True:
-            game = chess.pgn.read_game(f)
-            if game is None: break
-            yield game
-
-    def _analizar_jugadas(self, game, white, black):
-        board = game.board()
-        self.datos_jugadas = []
-        self._last_meta = {"white": white, "black": black}
-        jugada_num = 0
-        for mv in game.mainline_moves():
-            jugada_num += 1
-            board.push(mv)
-            self.datos_jugadas.append(self._evaluar_posicion(board, jugada_num, white, black))
-
-    def _crear_pgn_minimo(self, pgn_text: str) -> str:
-        pares = re.findall(r'\b(\d+)\.\s*([^\s]+)\s+([^\s]+)', pgn_text)
-        movimientos = []
-        if pares:
-            for _, m1, m2 in pares[:50]:
-                movimientos.append((m1, m2))
-        else:
-            san = re.findall(r'\b([NBRQK]?[a-h]?[1-8]?x?[a-h][1-8](?:=[NBRQK])?[+#]?)\b', pgn_text)
-            if san:
-                it = iter(san[:100]); tmp = []
-                for m in it:
-                    n1 = m; n2 = next(it, None)
-                    if n2 is None: tmp.append((n1, "")); break
-                    tmp.append((n1, n2))
-                movimientos = tmp
-        header = (
-            '[Event "Partida Reparada"]\n'
-            '[White "Blancas"]\n'
-            '[Black "Negras"]\n'
-            '[Result "*"]\n\n'
-        )
-        cuerpo = []
-        for i, par in enumerate(movimientos, 1):
-            b, n = par
-            cuerpo.append(f"{i}. {b} {n}".strip())
-        return header + " ".join(cuerpo).strip() + ("\n" if cuerpo else "")
-
-    def _evaluar_posicion(self, board: chess.Board, jugada_num: int, white: str, black: str):
-        valores = {'p': 1, 'n': 3, 'b': 3, 'r': 5, 'q': 9, 'k': 0}
-        pieces = board.piece_map().values()
-        mat_w = sum(valores.get(p.symbol().lower(), 0) for p in pieces if p.color == chess.WHITE)
-        mat_b = sum(valores.get(p.symbol().lower(), 0) for p in pieces if p.color == chess.BLACK)
-        ventaja = mat_w - mat_b
-        movilidad = board.legal_moves.count()
-        return {
-            "jugada": jugada_num,
-            "evaluacion": ventaja + movilidad * 0.1,
-            "material_w": mat_w,
-            "material_b": mat_b,
-            "material_rel": ventaja,
-            "mobility": movilidad,
-            "stm": 1 if board.turn == chess.WHITE else 0,
-            "phase": self._fase_por_material(mat_w + mat_b),
-            "white": white,
-            "black": black,
-            "elo_white": -1,
-            "elo_black": -1,
-            "elo_gap": 0,
-            # campos binarios aproximados (sin SAN aquí)
-            "is_capture": 0,
-            "is_check_move": 0,
-            "is_castling": 0,
-            "is_promotion": 0,
-            "in_check": int(board.is_check()),
-            "ply": jugada_num - 1,
-        }
-
-    @staticmethod
-    def _fase_por_material(total):
-        if total > 5000: return 0
-        if total > 2000: return 1
-        return 2
-
-    def _df_features_for_model(self):
-        if not self.datos_jugadas:
-            return None
-        return pd.DataFrame(self.datos_jugadas)
-
-    def generar_grafico(self, blancas: str, negras: str):
-        if not self.datos_jugadas:
-            fig, ax = plt.subplots(figsize=(10, 6))
-            ax.text(0.5, 0.5, "PGN no analizable", ha="center", va="center", fontsize=14, transform=ax.transAxes,
-                    bbox=dict(boxstyle="round,pad=0.3", facecolor="lightcoral", alpha=0.7))
-            ax.set_axis_off()
-            return fig
-
-        jugadas = [d["jugada"] for d in self.datos_jugadas]
-        evals = [d["evaluacion"] for d in self.datos_jugadas]
-        material = [d["material_rel"] for d in self.datos_jugadas]
-
-        fig, ax = plt.subplots(figsize=(12, 6))
-        ax.plot(jugadas, evals, linewidth=2, label="Ventaja aprox.")
-        ax.fill_between(jugadas, evals, alpha=0.20)
-        ax.axhline(0, linestyle="--")
-        ax.set_title(f"Análisis: {blancas} vs {negras}")
-        ax.set_xlabel("Jugada"); ax.set_ylabel("Valor")
-        ax.grid(True, alpha=0.3)
-
-        # Si hay modelo, dibujamos curva de probabilidad de blunder
-        if blunder_model is not None and blunder_features is not None:
-            df = self._df_features_for_model()
-            missing = [c for c in blunder_features if c not in df.columns]
-            for m in missing:
-                df[m] = 0
-            X = df[blunder_features].astype(float).values
-            try:
-                prob = blunder_model.predict_proba(X)[:, 1]
-                ax.plot(jugadas, prob, linewidth=2, label="Prob. blunder (modelo)")
-            except Exception as e:
-                print("⚠️ No se pudo inferir prob. de blunder:", e)
-
-        ax.legend(loc="best")
-        fig.tight_layout()
-        return fig
-
-    def generar_reporte(self, blancas: str, negras: str, resultado: str, info_extra: str):
-        if not self.datos_jugadas:
-            return "## PGN no analizable\nCarga otro PGN o revisa el formato."
-        jugadas = [d["jugada"] for d in self.datos_jugadas]
-        evals = [d["evaluacion"] for d in self.datos_jugadas]
-        material = [d["material_rel"] for d in self.datos_jugadas]
-        tiene_modelo = (blunder_model is not None and blunder_features is not None)
-        nota = "Modelo de blunders activo." if tiene_modelo else "Modelo de blunders no disponible."
-        return f"""
-## Reporte de partida
-**Blancas:** {blancas}  
-**Negras:** {negras}  
-**Resultado:** {resultado}  
-
-**Plies analizados:** {len(jugadas)}  
-**Ventaja final aprox.:** {evals[-1]:.2f}  
-**Diferencia de material final (W-B):** {material[-1]}  
-
-{info_extra or ""}
-
-_{nota}_
-"""
-
-# ====== UI ======
-analizador = AnalizadorAjedrez()
-
-def ui_analizar(pgn_text: str):
-    blancas, negras, resultado, info, _ = analizador.analizar_primera_partida_valida(pgn_text)
-    fig = analizador.generar_grafico(blancas, negras)
-    reporte = analizador.generar_reporte(blancas, negras, resultado, info)
-    pgn_reparado = ReparadorPGN.reparar_pgn(pgn_text)
-    return fig, reporte, pgn_reparado
-
-with gr.Blocks(title="Analizador PGN (ML-ready) — Doctor Linux") as demo:
-    gr.Markdown("# Analizador de Partidas PGN\nCarga un PGN (el input no se modifica).")
-    with gr.Row():
-        pgn_in = gr.Textbox(label="PGN original", lines=18, placeholder="Pega aquí un PGN. Puede contener múltiples partidas.")
-    with gr.Row():
-        btn = gr.Button("Analizar")
-    with gr.Row():
-        graf = gr.Plot(label="Gráfico")
-    with gr.Row():
-        rep = gr.Markdown(label="Reporte")
-    with gr.Row():
-        reparado_out = gr.Textbox(label="PGN reparado (para revisión; tu texto original no se toca)", lines=12)
-    btn.click(fn=ui_analizar, inputs=[pgn_in], outputs=[graf, rep, reparado_out])
-
-if __name__ == "__main__":
-    demo.launch()
+import os
+import io
+import re
+import math
+import traceback
+from io import StringIO
+import gradio as gr
+import chess, chess.pgn, chess.engine
+import numpy as np
+import pandas as pd
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+APP_TITLE = "AI Chess Analyzer — estilo DecodeChess (Doctor Linux)"
+ENGINE_PATHS = ["stockfish", "/usr/bin/stockfish", "/usr/games/stockfish"]
+
+# -------------------------------
+# Carga opcional de modelo ML (blunders)
+# -------------------------------
+blunder_model = None
+blunder_features = None
+try:
+    from joblib import load as joblib_load
+    f_model = "models/blunder/model.joblib"
+    f_feats = "models/blunder/features.txt"
+    if os.path.exists(f_model) and os.path.exists(f_feats):
+        blunder_model = joblib_load(f_model)
+        with open(f_feats, "r", encoding="utf-8") as f:
+            blunder_features = [ln.strip() for ln in f if ln.strip()]
+        print("✅ Modelo de blunders cargado.")
+except Exception as e:
+    print("⚠️ No se pudo cargar el modelo de blunders:", e)
+
+# -------------------------------
+# Reparador PGN
+# -------------------------------
+class ReparadorPGN:
+    @staticmethod
+    def reparar_pgn(pgn_text: str) -> str:
+        if not isinstance(pgn_text, str):
+            return pgn_text
+        lineas = pgn_text.splitlines()
+        out = []
+        for linea in lineas:
+            original = linea
+            s = linea.strip()
+            if s.startswith("[") and "]" in s:
+                s = re.sub(r'\[([A-Za-z0-9_]+)\s+"([^"]*)["“”]?\]?$', r'[\1 "\2"]', s)
+                s = re.sub(r'\[Ulnite', '[White', s)
+                s = s.replace('[Result "I-0"]',  '[Result "1-0"]')
+                s = s.replace('[Result "O-I"]',  '[Result "0-1"]')
+                s = s.replace('[Result "I/2-I/2"]', '[Result "1/2-1/2"]')
+                out.append(s); continue
+            t = s
+            correcciones = {
+                r'\bnf([1-8a-h])': r'Nf\1',
+                r'\bnc([1-8a-h])': r'Nc\1',
+                r'\bng([1-8a-h])': r'Ng\1',
+                r'\bhc([1-8])\b': 'Nc\\1',
+                r'\bhf([1-8])\b': 'Nf\\1',
+                r'\bnn1\b': 'Nf1',
+                r'\bhe2\b': 'Ne2',
+                r'\bnh7\b': 'Nh7',
+                r'\bhc5\b': 'Nc5',
+                r'\bqu2\b': 'Qd2',
+                r'\bre1\b': 'Re1',
+                r'\brn\b': 'Rf1',
+                r'\bbe4:?': 'Be4',
+                r'\bo-o-o\b': 'O-O-O',
+                r'\bo-o\b': 'O-O',
+            }
+            for pat, rep in correcciones.items():
+                t = re.sub(pat, rep, t, flags=re.IGNORECASE)
+            out.append(t if t else original)
+        texto = "\n".join(out)
+        texto = texto.replace('Result "* *"', 'Result "*"')
+        return texto
+
+# -------------------------------
+# Motor de ajedrez
+# -------------------------------
+def load_engine():
+    last_err = None
+    for p in ENGINE_PATHS:
+        try:
+            eng = chess.engine.SimpleEngine.popen_uci(p)
+            return eng
+        except Exception as e:
+            last_err = e
+    raise RuntimeError(f"No pude iniciar Stockfish. ¿Está instalado? Último error: {last_err}")
+
+def score_to_cp(score: chess.engine.PovScore) -> float:
+    # Devuelve evaluación en centipawns desde el punto de vista del bando que juega
+    if score.is_mate():
+        # usar un valor grande con signo para graficar
+        mate = score.white().mate()
+        if mate is None:
+            return 0.0
+        return 100000.0 if mate > 0 else -100000.0
+    return float(score.white().score(mate_score=100000))
+
+def classify_drop(delta_cp: float, mate_change: int|None) -> str:
+    # delta_cp = eval_after - eval_before (POV del bando que juega antes de mover)
+    # Si delta es muy negativo => caída de evaluación => peor jugada
+    if mate_change is not None and mate_change < 0:
+        return "Blunder (perdió/permitió mate)"
+    drop = -delta_cp
+    if drop < 20:   return "Best/Excellent"
+    if drop < 60:   return "Good"
+    if drop < 120:  return "Inaccuracy"
+    if drop < 300:  return "Mistake"
+    return "Blunder"
+
+def natural_explanation(delta_cp, best_san, played_san, b_before: chess.Board, b_after: chess.Board, info_before, info_after) -> str:
+    tips = []
+    if info_before.get("score") and info_after.get("score"):
+        sb = info_before["score"]; sa = info_after["score"]
+        if sb.is_mate() and not sa.is_mate():
+            tips.append("Se perdió una secuencia de mate forzado.")
+        if not sb.is_mate() and sa.is_mate():
+            tips.append("Se permitió una secuencia de mate forzado.")
+    if -delta_cp >= 300:
+        tips.append("La evaluación cayó fuertemente; revisa táctica inmediata (piezas colgando, mates).")
+    elif -delta_cp >= 120:
+        tips.append("Cede ventaja significativa; había opciones más fuertes.")
+    elif -delta_cp >= 60:
+        tips.append("Había una alternativa mejor según el motor.")
+    if b_after.is_check():
+        tips.append("La jugada conduce a jaques del rival o deja al rey expuesto.")
+    center = [chess.D4, chess.E4, chess.D5, chess.E5]
+    if any(b_after.piece_at(sq) and b_after.piece_at(sq).piece_type==chess.PAWN for sq in center):
+        tips.append("Buen control del centro con peones.")
+    if best_san and played_san and best_san != played_san:
+        tips.append(f"Recomendación del motor: {best_san} en lugar de {played_san}.")
+    if not tips:
+        tips.append("Jugada razonable.")
+    return " ".join(tips)
+
+def analyze_game_with_engine(game: chess.pgn.Game, engine, time_limit=0.3, depth=None):
+    board = game.board()
+    ann_rows = []
+    eval_cp_series = []
+    annotated_pgn = io.StringIO()
+
+    # Exporter para re-serializar con comentarios
+    exporter = chess.pgn.StringExporter(headers=True, variations=False, comments=True)
+
+    node = game
+    move_index = 0
+    while node.variations:
+        move = node.variation(0).move
+        turn_white = board.turn  # bando que mueve antes de la jugada
+        # eval antes
+        info_before = engine.analyse(board, chess.engine.Limit(time=time_limit, depth=depth))
+        eval_before = score_to_cp(info_before["score"].pov(chess.WHITE))
+        # mejor jugada sugerida
+        best_move = info_before.get("pv", [move])[0]
+        best_san = board.san(best_move) if best_move else None
+
+        # jugar jugada real
+        played_san = board.san(move)
+        board.push(move)
+
+        # eval después
+        info_after = engine.analyse(board, chess.engine.Limit(time=time_limit, depth=depth))
+        eval_after = score_to_cp(info_after["score"].pov(chess.WHITE))
+
+        # delta desde la perspectiva del bando que jugaba
+        delta_cp = (eval_after if turn_white else -eval_after) - (eval_before if turn_white else -eval_before)
+        mate_change = None
+        if info_before["score"].is_mate() or info_after["score"].is_mate():
+            # si empeora la distancia a mate desde POV del bando que jugaba, marcamos negativo
+            m_before = info_before["score"].white().mate()
+            m_after  = info_after["score"].white().mate()
+            if m_before is not None and m_after is not None:
+                mate_change = abs(m_before) - abs(m_after)
+
+        category = classify_drop(delta_cp, mate_change)
+        explanation = natural_explanation(delta_cp, best_san, played_san, node.board(), board, info_before, info_after)
+
+        eval_cp_series.append(eval_after if board.turn else -eval_after)
+
+        # guardar fila
+        move_index += 1
+        ann_rows.append({
+            "ply": move_index,
+            "turn": "White" if turn_white else "Black",
+            "played": played_san,
+            "best": best_san,
+            "delta_cp": round(delta_cp, 1),
+            "eval_after_cp": round(eval_after, 1),
+            "category": category,
+            "explanation": explanation
+        })
+
+        # comentario en el nodo siguiente
+        node = node.variation(0)
+        if node.comment:
+            node.comment += " "
+        else:
+            node.comment = ""
+        node.comment += f"[{category}] Δ={round(delta_cp,1)} | Mejor: {best_san}. {explanation}"
+
+    annotated_text = game.accept(exporter)
+    return ann_rows, eval_cp_series, annotated_text
+
+# -------------------------------
+# Gráfica
+# -------------------------------
+def plot_eval(pgn_headers, eval_series):
+    fig, ax = plt.subplots(figsize=(12, 5))
+    if not eval_series:
+        ax.text(0.5,0.5,"Sin evaluación (¿PGN vacío?)", ha="center", va="center", transform=ax.transAxes)
+        ax.set_axis_off()
+        return fig
+    xs = list(range(1, len(eval_series)+1))
+    ax.plot(xs, eval_series, linewidth=2)
+    ax.axhline(0, linestyle="--")
+    ax.set_xlabel("Ply")
+    ax.set_ylabel("Evaluación (cp, + = Blancas)")
+    title = f"{pgn_headers.get('White','?')} vs {pgn_headers.get('Black','?')} — {pgn_headers.get('Result','*')}"
+    ax.set_title(title)
+    ax.grid(True, alpha=0.3)
+    fig.tight_layout()
+    return fig
+
+# -------------------------------
+# Pipeline principal
+# -------------------------------
+def process(pgn_text, time_per_move, depth_limit):
+    if not pgn_text or not pgn_text.strip():
+        return None, "Pega un PGN.", None, None, None
+
+    repaired = ReparadorPGN.reparar_pgn(pgn_text)
+
+    # Leer primera partida válida
+    f = StringIO(repaired)
+    game = chess.pgn.read_game(f)
+    while game is not None and sum(1 for _ in game.mainline_moves()) == 0:
+        game = chess.pgn.read_game(f)
+
+    if game is None:
+        return None, "No se encontró una partida válida.", repaired, None, None
+
+    # Motor
+    try:
+        engine = load_engine()
+    except Exception as e:
+        err = f"No pude iniciar Stockfish: {e}"
+        return None, err, repaired, None, None
+
+    try:
+        rows, evals, annotated_pgn = analyze_game_with_engine(game, engine, time_limit=time_per_move, depth=None if depth_limit<=0 else depth_limit)
+    except Exception as e:
+        engine.quit()
+        tb = traceback.format_exc(limit=2)
+        return None, f"Falló el análisis: {e}\n{tb}", repaired, None, None
+
+    engine.quit()
+
+    # Si hay modelo ML, añadimos prob. blunder
+    if blunder_model is not None and blunder_features is not None and rows:
+        df = pd.DataFrame(rows)
+        # construir features simples por ahora
+        df_feat = df.copy()
+        for col in blunder_features:
+            if col not in df_feat.columns:
+                df_feat[col] = 0.0
+        try:
+            proba = blunder_model.predict_proba(df_feat[blunder_features].astype(float).values)[:,1]
+            df["blunder_proba"] = np.round(proba, 3)
+            rows = df.to_dict(orient="records")
+        except Exception as e:
+            print("⚠️ No se pudo inferir prob. blunder:", e)
+
+    # Render tabla markdown resumen top errores
+    worst = sorted(rows, key=lambda r: r["delta_cp"])[:10]  # más caída (delta más negativo)
+    md_lines = ["### Resumen (top caídas de evaluación)",
+                "| Ply | Turno | Jugada | Mejor | Δcp | Categoría |",
+                "|---:|:---:|:---|:---|---:|:---|"]
+    for r in worst:
+        md_lines.append(f"| {r['ply']} | {r['turn']} | {r['played']} | {r.get('best','')} | {r['delta_cp']} | {r['category']} |")
+    md_report = "\n".join(md_lines)
+
+    fig = plot_eval(game.headers, evals)
+
+    # CSV para descargar
+    import csv
+    csv_buf = io.StringIO()
+    cw = csv.DictWriter(csv_buf, fieldnames=list(rows[0].keys()))
+    cw.writeheader()
+    cw.writerows(rows)
+    csv_bytes = csv_buf.getvalue()
+
+    return fig, md_report, repaired, annotated_pgn, csv_bytes
+
+# -------------------------------
+# UI Gradio
+# -------------------------------
+with gr.Blocks(title=APP_TITLE) as demo:
+    gr.Markdown(f"# {APP_TITLE}\nCarga un PGN. Se analiza la **primera** partida válida.\n- Motor: Stockfish (apt)\n- Clasificación: Best/Good/Inaccuracy/Mistake/Blunder\n- Comentarios automáticos estilo DecodeChess (explicación en lenguaje natural)\n- Descarga PGN anotado + CSV por jugada")
+
+    with gr.Row():
+        pgn_in = gr.Textbox(lines=18, label="PGN (pegar aquí)", placeholder="Pega aquí el PGN...")
+
+    with gr.Row():
+        time_per = gr.Slider(0.05, 1.0, value=0.25, step=0.05, label="Tiempo por jugada (s)")
+        depth = gr.Slider(0, 30, value=0, step=1, label="Límite de profundidad (0 = solo tiempo)")
+
+    run_btn = gr.Button("Analizar")
+
+    with gr.Row():
+        plot_out = gr.Plot(label="Gráfico de evaluación")
+    with gr.Row():
+        md_out = gr.Markdown(label="Resumen")
+    with gr.Row():
+        repaired_out = gr.Textbox(lines=10, label="PGN reparado (no sobrescribe tu original)")
+
+    with gr.Row():
+        ann_pgn = gr.Textbox(lines=12, label="PGN anotado (descargable)")
+    with gr.Row():
+        dl_pgn = gr.File(label="Descargar PGN anotado")
+        dl_csv = gr.File(label="Descargar CSV jugadas")
+
+    def _run_and_pack(pgn_text, time_per_move, depth_limit):
+        fig, md, repaired, pgn_annot, csv_bytes = process(pgn_text, time_per_move, depth_limit)
+        files = []
+        if pgn_annot:
+            fn = "annotated.pgn"
+            open(fn, "w", encoding="utf-8").write(pgn_annot)
+            files.append(fn)
+        if csv_bytes:
+            fn2 = "moves.csv"
+            open(fn2, "w", encoding="utf-8").write(csv_bytes)
+            files.append(fn2)
+        return fig, md, repaired, pgn_annot, files[0] if files else None, files[1] if len(files)>1 else None
+
+    run_btn.click(_run_and_pack, inputs=[pgn_in, time_per, depth], outputs=[plot_out, md_out, repaired_out, ann_pgn, dl_pgn, dl_csv])
+
+if __name__ == "__main__":
+    demo.launch()

apt.txt

@@ -0,0 +1 @@
+stockfish

requirements.txt

@@ -1,9 +1,9 @@
-gradio>=4.44.0
-python-chess>=1.999
-matplotlib>=3.8
-numpy>=1.26
-pandas>=2.2
-scikit-learn>=1.3
-tqdm>=4.66
-joblib>=1.4
-pyarrow>=16.0
+gradio>=4.44.0
+python-chess>=1.999
+matplotlib>=3.8
+numpy>=1.26
+pandas>=2.2
+joblib>=1.4
+scikit-learn>=1.3
+tqdm>=4.66
+pyarrow>=16.0

runtime.txt

@@ -0,0 +1 @@
+python-3.11