Delete app.py

app.py

@@ -1,342 +0,0 @@
-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()