Upload 2 files

app.py

@@ -6,317 +6,174 @@ import numpy as np
 import io
 import re
 from io import BytesIO
-import tempfile
-import os
 
-# Configurar matplotlib
 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 corregir_pgn_automatico(self, pgn_text):
-        """Corrección AGGRESIVA de errores comunes"""
-        correcciones = {
-            # Piezas mal escritas
-            'nf3': 'Nf3', 'nc3': 'Nc3', 'ng5': 'Ng5', 'hc6': 'Nc6', 'hf6': 'Nf6',
-            'he7': 'Ne7', 'fxd5': 'Nxd5', 'fxf7': 'Nxf7', 
-            'kxf7': 'Kxf7', 'ke6': 'Ke6', 'kd6': 'Kd6', 'kc6': 'Kc6', 'kb6': 'Kb6', 'ka6': 'Ka6',
-            'of3': 'Qf3', 'oc6': 'Qc6', 'oc4': 'Qc4',
-            'hf8': 'Rf8', 'fxf2': 'Rxf2', 'fxd5': 'Rxd5', 'fb5': 'Rb5',
-            # Notación de enroque
-            'o-o-o': 'O-O-O', 'o-o': 'O-O',
-        }
-        
-        for error, correccion in correcciones.items():
-            pgn_text = re.sub(r'\b' + error + r'\b', correccion, pgn_text, flags=re.IGNORECASE)
-        
-        return pgn_text
-
+    
     def analizar_partida(self, pgn_string):
-        try:
-            # Corrección automática
-            pgn_corregido = self.corregir_pgn_automatico(pgn_string)
-            pgn = io.StringIO(pgn_corregido)
-            game = chess.pgn.read_game(pgn)
-            
-            if game is None:
-                return "Anónimo", "Anónimo", "*", "No se pudo leer el PGN (formato inválido)"
-            
-            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 = []
-            jugada_num = 0
-            
-            for move in game.mainline_moves():
-                tablero.push(move)
-                jugada_num += 1
-                analisis = self._evaluar_posicion(tablero, jugada_num)
-                self.datos_jugadas.append(analisis)
+        """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)
                 
-            return blancas, negras, resultado, ""
-            
-        except Exception as e:
-            return "Error", "Error", "*", f"Error: {str(e)}"
+                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 de la posición"""
+        """Evaluación simple pero robusta"""
         valores = {'p': 1, 'n': 3, 'b': 3, 'r': 5, 'q': 9, 'k': 0}
         
-        material_blancas = 0
-        material_negras = 0
-        
-        for pieza in tablero.piece_map().values():
-            valor = valores.get(pieza.symbol().lower(), 0)
-            if pieza.color == chess.WHITE:
-                material_blancas += valor
-            else:
-                material_negras += valor
+        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
         movilidad = len(list(tablero.legal_moves))
         
-        evaluacion = ventaja_material + (movilidad * 0.1)
-        
         return {
             'jugada': jugada_num,
-            'evaluacion': evaluacion,
+            'evaluacion': ventaja_material + (movilidad * 0.1),
             'material_blancas': material_blancas,
             'material_negras': material_negras,
             'ventaja_material': ventaja_material,
-            'movilidad': movilidad,
-            'es_blancas': jugada_num % 2 == 1
+            'movilidad': movilidad
         }
 
-    def generar_grafico_completo(self, blancas, negras):
-        """Genera gráficos completos"""
+    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, 'No hay datos para analizar', 
-                   ha='center', va='center', fontsize=16)
+            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]
-        material = [d['ventaja_material'] for d in self.datos_jugadas]
-        movilidad_b = [d['movilidad'] if d['es_blancas'] else 0 for d in self.datos_jugadas]
-        movilidad_n = [d['movilidad'] if not d['es_blancas'] else 0 for d in self.datos_jugadas]
         
-        fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 10))
+        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8))
         
-        # Gráfico 1: Evaluación general
-        ax1.plot(jugadas, evaluaciones, 'b-', linewidth=2, label='Evaluación')
+        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('📊 Evaluación de la Partida', fontweight='bold')
-        ax1.set_ylabel('Ventaja para Blancas')
-        ax1.legend()
+        ax1.set_title(f'📊 Análisis: {blancas} vs {negras}', fontweight='bold')
+        ax1.set_ylabel('Ventaja')
         ax1.grid(True, alpha=0.3)
         
-        # Gráfico 2: Ventaja material
+        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.axhline(y=0, color='black', linestyle='--')
-        ax2.set_title('⚖️ Ventaja Material', fontweight='bold')
+        ax2.set_xlabel('Jugada')
         ax2.set_ylabel('Material')
         ax2.grid(True, alpha=0.3)
         
-        # Gráfico 3: Movilidad
-        ax3.plot(jugadas, movilidad_b, 'blue', label=blancas, linewidth=2)
-        ax3.plot(jugadas, movilidad_n, 'red', label=negras, linewidth=2)
-        ax3.set_title('🎯 Movilidad de Piezas', fontweight='bold')
-        ax3.set_xlabel('Jugada')
-        ax3.set_ylabel('Movimientos Legales')
-        ax3.legend()
-        ax3.grid(True, alpha=0.3)
-        
-        # Gráfico 4: Resumen final
-        ultimo = self.datos_jugadas[-1]
-        categorias = ['Material', 'Movilidad']
-        blancas_stats = [ultimo['material_blancas'], ultimo['movilidad']]
-        negras_stats = [ultimo['material_negras'], ultimo['movilidad']]
-        
-        x = np.arange(len(categorias))
-        ax4.bar(x - 0.2, blancas_stats, 0.4, label=blancas, color='blue', alpha=0.7)
-        ax4.bar(x + 0.2, negras_stats, 0.4, label=negras, color='red', alpha=0.7)
-        ax4.set_title('📋 Comparación Final', fontweight='bold')
-        ax4.set_xticks(x)
-        ax4.set_xticklabels(categorias)
-        ax4.legend()
-        
         plt.tight_layout()
         return fig
 
-    def generar_reporte_detallado(self, blancas, negras, resultado):
+    def generar_reporte(self, blancas, negras, resultado):
         if not self.datos_jugadas:
-            return "No se pudo generar el reporte"
-        
-        total_jugadas = len(self.datos_jugadas)
-        eval_final = self.datos_jugadas[-1]['evaluacion']
-        mat_final = self.datos_jugadas[-1]['ventaja_material']
-        
-        # Calcular precision aproximada
-        cambios_bruscos = 0
-        for i in range(1, len(self.datos_jugadas)):
-            cambio = abs(self.datos_jugadas[i]['evaluacion'] - self.datos_jugadas[i-1]['evaluacion'])
-            if cambio > 3:  # Cambio brusco
-                cambios_bruscos += 1
-        
-        precision = max(0, 100 - (cambios_bruscos * 5))
-        
-        reporte = f"""
-## ♟️ ANÁLISIS DE PARTIDA
-
-**Jugadores:** {blancas} vs {negras}  
-**Resultado:** {resultado}  
-**Total de jugadas:** {total_jugadas}
-
-### 📊 Métricas Finales:
-- **Evaluación final:** {eval_final:+.2f}
-- **Ventaja material:** {mat_final:+d}
-- **Precisión estimada:** {precision:.0f}%
-
-### 🎯 Resumen:
-"""
-        
-        if eval_final > 3:
-            reporte += "• ✅ **Victoria clara de las Blancas**\n"
-            reporte += "• Las Blancas mantuvieron ventaja consistente\n"
-        elif eval_final < -3:
-            reporte += "• ✅ **Victoria clara de las Negras**\n" 
-            reporte += "• Las Negras dominaron la partida\n"
-        else:
-            reporte += "• ⚖️ **Partida equilibrada**\n"
-            reporte += "• Ambos bandos jugaron a un nivel similar\n"
-            
-        if cambios_bruscos > 5:
-            reporte += "• ⚠️ **Varios cambios bruscos** - Posibles errores tácticos\n"
-            
-        reporte += f"\n*Análisis generado automáticamente*"
-        
-        return reporte
-
-def procesar_pgn(pgn_text, archivo_pgn=None):
-    """Procesa PGN desde texto o archivo"""
-    try:
-        # Si se subió un archivo, leer su contenido
-        if archivo_pgn is not None:
-            with open(archivo_pgn.name, 'r', encoding='utf-8') as f:
-                pgn_text = f.read()
-        
-        if not pgn_text.strip():
-            return None, "❌ Por favor, ingresa un PGN o sube un archivo"
-            
-        analizador = AnalizadorAjedrez()
-        blancas, negras, resultado, error = analizador.analizar_partida(pgn_text)
-        
-        if error:
-            return None, f"❌ Error al procesar: {error}"
-        
-        # Generar gráfico
-        fig = analizador.generar_grafico_completo(blancas, negras)
-        buf = BytesIO()
-        fig.savefig(buf, format='png', dpi=100, bbox_inches='tight')
-        buf.seek(0)
-        plt.close(fig)
-        
-        # Generar reporte
-        reporte = analizador.generar_reporte_detallado(blancas, negras, resultado)
-        
-        return buf, reporte
-        
-    except Exception as e:
-        return None, f"❌ Error inesperado: {str(e)}"
+            return """## ❌ PGN NO ANALIZABLE
 
-# Interfaz de Gradio con uploader
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""
-    # ♟️ Analizador de Partidas de Ajedrez
-    **Carga archivos PGN o pega el texto directamente - Análisis completo con gráficos profesionales**
-    """)
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### 📁 Subir archivo PGN")
-            uploader = gr.File(
-                label="Selecciona tu archivo .pgn",
-                file_types=[".pgn"],
-                type="filepath",
-                height=100
-            )
-            
-            gr.Markdown("### 📝 O pegar PGN como texto")
-            pgn_input = gr.Textbox(
-                label="Pega tu partida PGN aquí",
-                lines=15,
-                placeholder="""[Event \"Mi Torneo\"]
-[White \"Jugador Blanco\"] 
-[Black \"Jugador Negro\"]
-[Result \"1-0\"]
+**El archivo PGN está corrupto o tiene formato inválido.**
 
-1. e4 e5 2. Nf3 Nc6 3. Bb5 a6 4. Ba4 Nf6 5. O-O Be7 6. Re1 b5 7. Bb3 d6 8. c3 O-O
-9. h3 Nb8 10. d4 Nbd7 11. Nbd2 Bb7 12. Bc2 Re8 13. Nf1 Bf8 14. Ng3 g6 15. a4 c5
-16. d5 c4 17. Bg5 h6 18. Be3 Nc5 19. Qd2 h5 20. Bh6 Nh7 21. g3 Bd7 22. Rf1 Qc7
-23. Ne2 Rec8 24. Ng5 Nxg5 25. Bxg5 Bg7 26. f4 exf4 27. gxf4 f6 28. Bf3 Be5
-29. fxe5 fxe5 30. Bg5 Qd7 31. e6 Qe7 32. Bf6 Qf8 33. e7 1-0"""
-            )
-            
-            btn_analizar = gr.Button("🧠 Analizar Partida", variant="primary", size="lg")
-            btn_limpiar = gr.Button("🗑️ Limpiar Todo", variant="secondary")
-            
-        with gr.Column(scale=1):
-            gr.Markdown("### 📊 Resultados del Análisis")
-            image_output = gr.Image(
-                label="Análisis Gráfico", 
-                type="filepath",
-                height=400
-            )
-            report_output = gr.Markdown(
-                label="Reporte Detallado",
-                value="### 📋 Reporte de Análisis\n\n*Los resultados aparecerán aquí después del análisis...*"
-            )
-    
-    # Ejemplos
-    gr.Markdown("### 💡 Partidas de Ejemplo")
-    with gr.Row():
-        gr.Examples(
-            examples=[[
-"""[Event "Ejemplo Clásico"]
-[White "Fischer"]
-[Black "Spassky"] 
-[Result "1-0"]
-
-1. e4 e5 2. Nf3 Nc6 3. Bb5 a6 4. Ba4 Nf6 5. O-O Be7 6. Re1 b5 7. Bb3 d6 8. c3 O-O 
-9. h3 Nb8 10. d4 Nbd7 11. Nbd2 Bb7 12. Bc2 Re8 13. Nf1 Bf8 14. Ng3 g6 15. a4 c5 
-16. d5 c4 17. Bg5 h6 18. Be3 Nc5 19. Qd2 h5 20. Bh6 Nh7 21. g3 Bd7 22. Rf1 Qc7 
-23. Ne2 Rec8 24. Ng5 Nxg5 25. Bxg5 Bg7 26. f4 exf4 27. gxf4 f6 28. Bf3 Be5 
-29. fxe5 fxe5 30. Bg5 Qd7 31. e6 Qe7 32. Bf6 Qf8 33. e7 1-0"""]],
-            inputs=pgn_input,
-            label="Partida de Ejemplo"
-        )
-    
-    # Funcionalidades
-    def limpiar_todo():
-        return None, None, "### 📋 Reporte de Análisis\n\n*Los resultados aparecerán aquí después del análisis...*"
-    
-    # Conectores
-    btn_analizar.click(
-        fn=procesar_pgn,
-        inputs=[pgn_input, uploader],
-        outputs=[image_output, report_output]
-    )
-    
-    btn_limpiar.click(
-        fn=limpiar_todo,
-        inputs=[],
-        outputs=[uploader, pgn_input, report_output]
-    )
+### 🔧 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"]**
 
-if __name__ == "__main__":
-    demo.launch(share=True)
+### 📝 Formato PGN correcto: