Upload 3 files

README.md

@@ -1,13 +1,10 @@
----
-title: Ml
-emoji: 😻
-colorFrom: green
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
-license: gpl
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 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

app.py

@@ -1,179 +1,278 @@
-import gradio as gr
-import chess
-import chess.pgn
-import matplotlib.pyplot as plt
-import numpy as np
-import io
-import re
-from io import BytesIO
-
-plt.switch_backend('Agg')
-
-class ReparadorPGN:
-    @staticmethod
-    def reparar_pgn(pgn_text):
-        """Repara PGNs extremadamente corruptos"""
-        lineas = pgn_text.split('\n')
-        lineas_reparadas = []
-        
-        for linea in lineas:
-            linea = linea.strip()
-            
-            # Reparar headers corruptos
-            if linea.startswith('['):
-                # Corregir comillas y paréntesis
-                linea = re.sub(r"\[(.*?)[')](.*?)[')]", r"[\1 '\2']", linea)
-                # Corregir nombres de headers
-                linea = re.sub(r'\[Ulnite', '[White', linea)
-                linea = re.sub(r'\[Result "I-0"\]', '[Result "1-0"]', linea)
-                linea = re.sub(r'\[Result "O-I"\]', '[Result "0-1"]', linea)
-                linea = re.sub(r'\[Result "I/2-I/2"\]', '[Result "1/2-1/2"]', linea)
-            
-            # Reparar notación de movimientos
-            else:
-                # Corregir piezas mal escritas
-                correcciones = {
-                    r'\bnf3\b': 'Nf3', r'\bnc3\b': 'Nc3', r'\bng5\b': 'Ng5',
-                    r'\bhc6\b': 'Nc6', r'\bhf6\b': 'Nf6', r'\bhba\b': 'Nb8',
-                    r'\bhbe7\b': 'Nbd7', 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:\b': 'Be4',
-                    r'\bo-o-o\b': 'O-O-O', r'\bo-o\b': 'O-O'
-                }
-                
-                for error, correccion in correcciones.items():
-                    linea = re.sub(error, correccion, linea, flags=re.IGNORECASE)
-            
-            lineas_reparadas.append(linea)
-        
-        return '\n'.join(lineas_reparadas)
-
-class AnalizadorAjedrez:
-    def __init__(self):
-        self.datos_jugadas = []
-    
-    def analizar_partida(self, pgn_string):
-        """Analiza partida con múltiples intentos y reparación"""
-        intentos = [
-            pgn_string,  # Intento 1: Original
-            ReparadorPGN.reparar_pgn(pgn_string),  # Intento 2: Reparado
-            self._crear_pgn_minimo(pgn_string)  # Intento 3: PGN mínimo
-        ]
-        
-        for i, pgn_intento in enumerate(intentos):
-            try:
-                pgn = io.StringIO(pgn_intento)
-                game = chess.pgn.read_game(pgn)
-                
-                if game and len(list(game.mainline_moves())) > 0:
-                    blancas = game.headers.get("White", "Anónimo")
-                    negras = game.headers.get("Black", "Anónimo")
-                    resultado = game.headers.get("Result", "*")
-                    
-                    # Analizar jugadas
-                    tablero = game.board()
-                    self.datos_jugadas = []
-                    
-                    for jugada_num, move in enumerate(game.mainline_moves(), 1):
-                        tablero.push(move)
-                        analisis = self._evaluar_posicion(tablero, jugada_num)
-                        self.datos_jugadas.append(analisis)
-                    
-                    print(f"✅ Análisis exitoso (Intento {i+1})")
-                    return blancas, negras, resultado, ""
-                    
-            except Exception as e:
-                continue
-        
-        return "Anónimo", "Anónimo", "*", "No se pudo analizar el PGN (formato muy corrupto)"
-
-    def _crear_pgn_minimo(self, pgn_text):
-        """Crea un PGN mínimo desde los movimientos"""
-        # Extraer solo movimientos numéricos
-        movimientos = re.findall(r'\d+\.\s*(\S+)\s+(\S+)', pgn_text)
-        if not movimientos:
-            movimientos = re.findall(r'\b([NBRQK]?[a-h]?[1-8]?x?[a-h][1-8]\+?\+?#?)\b', pgn_text, re.IGNORECASE)
-        
-        pgn_minimo = """[Event "Partida Reparada"]
-[White "Blancas"]
-[Black "Negras"] 
-[Result "*"]
-
-"""
-        for i, (blanca, negra) in enumerate(movimientos[:50], 1):  # Máximo 50 jugadas
-            pgn_minimo += f"{i}. {blanca} {negra} "
-        
-        return pgn_minimo.strip()
-
-    def _evaluar_posicion(self, tablero, jugada_num):
-        """Evaluación simple pero robusta"""
-        valores = {'p': 1, 'n': 3, 'b': 3, 'r': 5, 'q': 9, 'k': 0}
-        
-        material_blancas = sum(valores.get(p.symbol().lower(), 0) 
-                              for p in tablero.piece_map().values() 
-                              if p.color == chess.WHITE)
-        material_negras = sum(valores.get(p.symbol().lower(), 0) 
-                             for p in tablero.piece_map().values() 
-                             if p.color == chess.BLACK)
-        
-        ventaja_material = material_blancas - material_negras
-        movilidad = len(list(tablero.legal_moves))
-        
-        return {
-            'jugada': jugada_num,
-            'evaluacion': ventaja_material + (movilidad * 0.1),
-            'material_blancas': material_blancas,
-            'material_negras': material_negras,
-            'ventaja_material': ventaja_material,
-            'movilidad': movilidad
-        }
-
-    def generar_grafico(self, blancas, negras):
-        """Genera gráfico incluso con datos mínimos"""
-        if not self.datos_jugadas:
-            # Gráfico de error informativo
-            fig, ax = plt.subplots(figsize=(10, 6))
-            ax.text(0.5, 0.5, '⚠️ PGN no analizable\n\nEl archivo PGN está corrupto\no tiene formato inválido', 
-                   ha='center', va='center', fontsize=14, transform=ax.transAxes,
-                   bbox=dict(boxstyle="round,pad=0.3", facecolor="lightcoral", alpha=0.7))
-            ax.set_xlim(0, 1)
-            ax.set_ylim(0, 1)
-            ax.set_xticks([])
-            ax.set_yticks([])
-            return fig
-        
-        # Gráfico normal con datos
-        jugadas = [d['jugada'] for d in self.datos_jugadas]
-        evaluaciones = [d['evaluacion'] for d in self.datos_jugadas]
-        
-        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8))
-        
-        ax1.plot(jugadas, evaluaciones, 'b-', linewidth=2)
-        ax1.fill_between(jugadas, evaluaciones, alpha=0.3)
-        ax1.axhline(y=0, color='black', linestyle='--')
-        ax1.set_title(f'📊 Análisis: {blancas} vs {negras}', fontweight='bold')
-        ax1.set_ylabel('Ventaja')
-        ax1.grid(True, alpha=0.3)
-        
-        material = [d['ventaja_material'] for d in self.datos_jugadas]
-        ax2.bar(jugadas, material, alpha=0.7, color=['green' if x >= 0 else 'red' for x in material])
-        ax2.set_xlabel('Jugada')
-        ax2.set_ylabel('Material')
-        ax2.grid(True, alpha=0.3)
-        
-        plt.tight_layout()
-        return fig
-
-    def generar_reporte(self, blancas, negras, resultado):
-        if not self.datos_jugadas:
-            reporte = """## ❌ PGN NO ANALIZABLE
-
-**El archivo PGN está corrupto o tiene formato inválido.**
-
-### 🔧 Posibles soluciones:
-1. **Verifica que el PGN sea de una partida real**
-2. **Comprueba que la notación de movimientos sea correcta**
-3. **Intenta con otro archivo PGN**
-4. **Los headers deben usar comillas: [Event "Nombre"]**
-
-### 📝 Formato PGN correcto:
+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()

requirements.txt

@@ -1,5 +1,9 @@
-chess==1.10.0
-matplotlib==3.7.1
-numpy==1.24.3
-gradio==4.19.1
-pillow==10.0.0
+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