Upload 2 files

app.py

@@ -7,15 +7,192 @@ import io
 import base64
 from io import BytesIO
 
-# (Aquí va toda la clase AnalizadorAjedrez que te pasé antes)
+class AnalizadorAjedrez:
+    def __init__(self):
+        self.datos_jugadas = []
+        plt.style.use('default')
+        
+    def analizar_partida(self, pgn_string):
+        """Analiza una partida completa desde PGN"""
+        try:
+            pgn = io.StringIO(pgn_string)
+            game = chess.pgn.read_game(pgn)
+            
+            if game is None:
+                return "Error", "Error", "Error", "No se pudo leer el PGN"
+            
+            # Metadatos
+            blancas = game.headers.get("White", "Anónimo")
+            negras = game.headers.get("Black", "Anónimo")
+            resultado = game.headers.get("Result", "*")
+            
+            # Analizar cada jugada
+            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)
+                
+            return blancas, negras, resultado, ""
+            
+        except Exception as e:
+            return "Error", "Error", "Error", f"Error procesando PGN: {str(e)}"
+
+    def _evaluar_posicion(self, tablero, jugada_num):
+        """Evalúa una posición específica del tablero"""
+        # Valor material (puntos estándar)
+        valores = {'p': 1, 'n': 3, 'b': 3, 'r': 5, 'q': 9, 'k': 0}
+        
+        material_blancas = 0
+        material_negras = 0
+        
+        for square, pieza in tablero.piece_map().items():
+            valor = valores.get(pieza.symbol().lower(), 0)
+            if pieza.color == chess.WHITE:
+                material_blancas += valor
+            else:
+                material_negras += valor
+        
+        ventaja_material = material_blancas - material_negras
+        
+        # Movilidad
+        movilidad_blancas = len(list(tablero.legal_moves))
+        tablero.turn = not tablero.turn
+        movilidad_negras = len(list(tablero.legal_moves))
+        tablero.turn = not tablero.turn
+        
+        ventaja_movilidad = movilidad_blancas - movilidad_negras
+        
+        # Evaluación compuesta
+        evaluacion = ventaja_material + (ventaja_movilidad * 0.1)
+        
+        return {
+            'jugada': jugada_num,
+            'evaluacion': evaluacion,
+            'material_blancas': material_blancas,
+            'material_negras': material_negras,
+            'ventaja_material': ventaja_material,
+            'movilidad_blancas': movilidad_blancas,
+            'movilidad_negras': movilidad_negras,
+            'es_blancas': jugada_num % 2 == 1
+        }
+
+    def generar_graficos_gradio(self, blancas, negras):
+        """Genera todos los gráficos para Gradio"""
+        if not self.datos_jugadas:
+            # Crear gráfico vacío si no hay datos
+            fig, ax = plt.subplots(figsize=(10, 6))
+            ax.text(0.5, 0.5, 'No hay datos para mostrar', 
+                   horizontalalignment='center', verticalalignment='center',
+                   transform=ax.transAxes, fontsize=16)
+            ax.set_xlim(0, 1)
+            ax.set_ylim(0, 1)
+            return fig
+        
+        fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 12))
+        
+        # 📊 1. GRÁFICO DE EVALUACIÓN DE POSICIÓN
+        jugadas = [d['jugada'] for d in self.datos_jugadas]
+        evaluaciones = [d['evaluacion'] for d in self.datos_jugadas]
+        
+        ax1.plot(jugadas, evaluaciones, 'b-', linewidth=2, alpha=0.7)
+        ax1.fill_between(jugadas, evaluaciones, alpha=0.3)
+        ax1.axhline(y=0, color='black', linestyle='-', alpha=0.5)
+        ax1.set_title('📊 EVALUACIÓN DE POSICIÓN', fontweight='bold')
+        ax1.set_xlabel('Número de Jugada')
+        ax1.set_ylabel('Ventaja para Blancas')
+        ax1.grid(True, alpha=0.3)
+
+        # 📈 2. ANÁLISIS DE MATERIAL
+        material_data = [d['ventaja_material'] for d in self.datos_jugadas]
+        ax2.plot(jugadas, material_data, 'r-', linewidth=2, alpha=0.7)
+        ax2.axhline(y=0, color='black', linestyle='-', alpha=0.5)
+        ax2.set_title('📈 VENTAJA MATERIAL', fontweight='bold')
+        ax2.set_xlabel('Jugada')
+        ax2.set_ylabel('Ventaja Material')
+        ax2.grid(True, alpha=0.3)
+
+        # 🎯 3. MOVILIDAD
+        movilidad_b = [d['movilidad_blancas'] for d in self.datos_jugadas]
+        movilidad_n = [d['movilidad_negras'] for d in self.datos_jugadas]
+        
+        ax3.plot(jugadas, movilidad_b, 'b-', label=f'{blancas}', linewidth=2)
+        ax3.plot(jugadas, movilidad_n, 'r-', label=f'{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)
+
+        # 📋 4. ESTADÍSTICAS FINALES
+        ultimo = self.datos_jugadas[-1]
+        categorias = ['Material', 'Movilidad']
+        valores_b = [ultimo['material_blancas'], ultimo['movilidad_blancas']]
+        valores_n = [ultimo['material_negras'], ultimo['movilidad_negras']]
+        
+        x = np.arange(len(categorias))
+        ax4.bar(x - 0.2, valores_b, 0.4, label=blancas, color='blue', alpha=0.7)
+        ax4.bar(x + 0.2, valores_n, 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_textual(self):
+        """Genera un análisis textual de la partida"""
+        if not self.datos_jugadas:
+            return "No hay datos para generar reporte"
+            
+        reporte = "🎯 ANÁLISIS DETALLADO DE LA PARTIDA\n"
+        reporte += "=" * 40 + "\n"
+        
+        # Estadísticas básicas
+        total_jugadas = len(self.datos_jugadas)
+        eval_final = self.datos_jugadas[-1]['evaluacion']
+        
+        reporte += f"• Total de jugadas: {total_jugadas}\n"
+        reporte += f"• Evaluación final: {eval_final:.2f}\n"
+        
+        # Balance de material final
+        mat_final = self.datos_jugadas[-1]['ventaja_material']
+        if mat_final > 2:
+            reporte += f"• Ventaja material final: +{mat_final} para Blancas\n"
+        elif mat_final < -2:
+            reporte += f"• Ventaja material final: +{abs(mat_final)} para Negras\n"
+        else:
+            reporte += "• Material equilibrado al final\n"
+            
+        # Jugador con mejor movilidad promedio
+        mov_avg_b = np.mean([d['movilidad_blancas'] for d in self.datos_jugadas])
+        mov_avg_n = np.mean([d['movilidad_negras'] for d in self.datos_jugadas])
+        
+        if mov_avg_b > mov_avg_n:
+            reporte += f"• Mejor movilidad promedio: Blancas ({mov_avg_b:.1f} vs {mov_avg_n:.1f})\n"
+        else:
+            reporte += f"• Mejor movilidad promedio: Negras ({mov_avg_n:.1f} vs {mov_avg_b:.1f})\n"
+            
+        return reporte
 
 def analizar_y_mostrar(pgn_text):
     """Función que Gradio usará para la interfaz"""
     try:
+        if not pgn_text.strip():
+            return None, "❌ Por favor, pega una partida PGN válida"
+            
         analizador = AnalizadorAjedrez()
-        blancas, negras, resultado = analizador.analizar_partida(pgn_text)
+        blancas, negras, resultado, error = analizador.analizar_partida(pgn_text)
         
-        # Generar gráficos y convertirlos a base64 para mostrar en Gradio
+        if error:
+            return None, f"❌ {error}"
+        
+        # Generar gráficos
         fig = analizador.generar_graficos_gradio(blancas, negras)
         
         # Convertir figura a imagen para Gradio
@@ -26,27 +203,61 @@ def analizar_y_mostrar(pgn_text):
         
         # Generar reporte textual
         reporte = analizador.generar_reporte_textual()
+        reporte = f"Partida: {blancas} vs {negras}\nResultado: {resultado}\n\n" + reporte
         
         return buf, reporte
         
     except Exception as e:
-        return None, f"❌ Error: {str(e)}"
+        return None, f"❌ Error inesperado: {str(e)}"
 
 # Interfaz de Gradio
-demo = gr.Interface(
-    fn=analizar_y_mostrar,
-    inputs=gr.Textbox(
-        label="Pega tu partida PGN aquí", 
-        lines=10,
-        placeholder="[Event 'Mi Partida']\n[White 'Yo']\n[Black 'Rival']\n\n1. e4 e5 2. Nf3 Nc6 ..."
-    ),
-    outputs=[
-        gr.Image(label="Análisis Gráfico de la Partida"),
-        gr.Textbox(label="Reporte de Análisis")
-    ],
-    title="♟️ Analizador de Partidas de Ajedrez",
-    description="Pega cualquier partida en formato PGN y obtén un análisis completo con gráficos y estadísticas."
-)
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# ♟️ Analizador de Partidas de Ajedrez")
+    gr.Markdown("Pega cualquier partida en formato PGN y obtén un análisis completo con gráficos y estadísticas.")
+    
+    with gr.Row():
+        with gr.Column():
+            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\"]
+
+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"""
+            )
+            btn_analizar = gr.Button("Analizar Partida", variant="primary")
+            
+        with gr.Column():
+            image_output = gr.Image(label="Análisis Gráfico de la Partida", type="filepath")
+            text_output = gr.Textbox(label="Reporte de Análisis", lines=8)
+    
+    # Ejemplos de PGN
+    gr.Markdown("### 📋 Ejemplo de formato PGN:")
+    gr.Examples(
+        examples=[[
+"""[Event "Ejemplo"]
+[Site "?"]
+[Date "2023.??.??"]
+[Round "?"]
+[White "Carlsen"]
+[Black "Caruana"]
+[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
+    )
+    
+    btn_analizar.click(
+        fn=analizar_y_mostrar,
+        inputs=pgn_input,
+        outputs=[image_output, text_output]
+    )
 
 if __name__ == "__main__":
     demo.launch()

requirements.txt

@@ -1,5 +1,5 @@
 chess
 matplotlib
 numpy
-seaborn
-gradio
+gradio
+pillow