Upload 2 files

app.py

@@ -6,31 +6,53 @@ import numpy as np
 import io
 import re
 from io import BytesIO
+import tempfile
+import os
+
+# Configurar matplotlib
+plt.switch_backend('Agg')
 
 class AnalizadorAjedrez:
     def __init__(self):
         self.datos_jugadas = []
-        plt.style.use('default')
         
+    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):
-        """Analiza una partida completa desde PGN"""
         try:
-            pgn = io.StringIO(pgn_string)
+            # 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 "Error", "Error", "Error", "No se pudo leer el PGN"
+                return "Anónimo", "Anónimo", "*", "No se pudo leer el PGN (formato inválido)"
             
-            # Metadatos
             blancas = game.headers.get("White", "Anónimo")
-            negras = game.headers.get("Black", "Anónimo")
+            negras = game.headers.get("Black", "Anónimo") 
             resultado = game.headers.get("Result", "*")
             
-            # Analizar cada jugada
+            # Analizar jugadas
             tablero = game.board()
             self.datos_jugadas = []
-            
             jugada_num = 0
+            
             for move in game.mainline_moves():
                 tablero.push(move)
                 jugada_num += 1
@@ -40,17 +62,16 @@ class AnalizadorAjedrez:
             return blancas, negras, resultado, ""
             
         except Exception as e:
-            return "Error", "Error", "Error", f"Error procesando PGN: {str(e)}"
+            return "Error", "Error", "*", f"Error: {str(e)}"
 
     def _evaluar_posicion(self, tablero, jugada_num):
-        """Evalúa una posición específica del tablero"""
-        # Valor material (puntos estándar)
+        """Evaluación simple de la posición"""
         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():
+        for pieza in tablero.piece_map().values():
             valor = valores.get(pieza.symbol().lower(), 0)
             if pieza.color == chess.WHITE:
                 material_blancas += valor
@@ -60,15 +81,9 @@ class AnalizadorAjedrez:
         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
+        movilidad = len(list(tablero.legal_moves))
         
-        ventaja_movilidad = movilidad_blancas - movilidad_negras
-        
-        # Evaluación compuesta
-        evaluacion = ventaja_material + (ventaja_movilidad * 0.1)
+        evaluacion = ventaja_material + (movilidad * 0.1)
         
         return {
             'jugada': jugada_num,
@@ -76,236 +91,172 @@ class AnalizadorAjedrez:
             'material_blancas': material_blancas,
             'material_negras': material_negras,
             'ventaja_material': ventaja_material,
-            'movilidad_blancas': movilidad_blancas,
-            'movilidad_negras': movilidad_negras,
+            'movilidad': movilidad,
             'es_blancas': jugada_num % 2 == 1
         }
 
-    def generar_graficos_gradio(self, blancas, negras):
-        """Genera todos los gráficos para Gradio"""
+    def generar_grafico_completo(self, blancas, negras):
+        """Genera gráficos completos"""
         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)
+            ax.text(0.5, 0.5, 'No hay datos para analizar', 
+                   ha='center', va='center', fontsize=16)
             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]
+        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]
         
-        # Crear fondo coloreado para ventaja
-        ax1.axhspan(0.1, max(evaluaciones) if max(evaluaciones) > 0 else 0.1, 
-                   alpha=0.2, color='blue', label='Ventaja Blancas')
-        ax1.axhspan(min(evaluaciones) if min(evaluaciones) < 0 else -0.1, -0.1, 
-                   alpha=0.2, color='red', label='Ventaja Negras')
+        fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 10))
         
-        ax1.plot(jugadas, evaluaciones, 'b-', linewidth=2.5, alpha=0.8, marker='o', markersize=3)
-        ax1.axhline(y=0, color='black', linestyle='-', alpha=0.5, linewidth=1)
-        ax1.set_title('📊 EVALUACIÓN DE POSICIÓN', fontweight='bold', fontsize=14)
-        ax1.set_xlabel('Número de Jugada')
+        # Gráfico 1: Evaluación general
+        ax1.plot(jugadas, evaluaciones, 'b-', linewidth=2, label='Evaluación')
+        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.grid(True, alpha=0.3)
         ax1.legend()
-
-        # 📈 2. ANÁLISIS DE MATERIAL
-        material_data = [d['ventaja_material'] for d in self.datos_jugadas]
-        ax2.bar(jugadas, material_data, alpha=0.7, 
-               color=['blue' if x >= 0 else 'red' for x in material_data])
-        ax2.axhline(y=0, color='black', linestyle='-', alpha=0.5, linewidth=1)
-        ax2.set_title('📈 VENTAJA MATERIAL', fontweight='bold', fontsize=14)
-        ax2.set_xlabel('Jugada')
-        ax2.set_ylabel('Ventaja Material')
+        ax1.grid(True, alpha=0.3)
+        
+        # Gráfico 2: Ventaja material
+        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_ylabel('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.fill_between(jugadas, movilidad_b, alpha=0.3, color='blue')
-        ax3.fill_between(jugadas, movilidad_n, alpha=0.3, color='red')
-        ax3.plot(jugadas, movilidad_b, 'b-', label=f'{blancas}', linewidth=2.5)
-        ax3.plot(jugadas, movilidad_n, 'r-', label=f'{negras}', linewidth=2.5)
-        ax3.set_title('🎯 MOVILIDAD DE PIEZAS', fontweight='bold', fontsize=14)
+        # 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)
-
-        # 📋 4. ESTADÍSTICAS FINALES
+        
+        # Gráfico 4: Resumen final
         ultimo = self.datos_jugadas[-1]
         categorias = ['Material', 'Movilidad']
-        valores_b = [ultimo['material_blancas'], ultimo['movilidad_blancas']]
-        valores_n = [ultimo['material_negras'], ultimo['movilidad_negras']]
+        blancas_stats = [ultimo['material_blancas'], ultimo['movilidad']]
+        negras_stats = [ultimo['material_negras'], ultimo['movilidad']]
         
         x = np.arange(len(categorias))
-        bar_width = 0.35
-        
-        ax4.bar(x - bar_width/2, valores_b, bar_width, label=blancas, 
-               color='blue', alpha=0.7, edgecolor='black')
-        ax4.bar(x + bar_width/2, valores_n, bar_width, label=negras, 
-               color='red', alpha=0.7, edgecolor='black')
-        
-        # Añadir valores encima de las barras
-        for i, v in enumerate(valores_b):
-            ax4.text(i - bar_width/2, v + 0.5, str(v), ha='center', va='bottom', fontweight='bold')
-        for i, v in enumerate(valores_n):
-            ax4.text(i + bar_width/2, v + 0.5, str(v), ha='center', va='bottom', fontweight='bold')
-            
-        ax4.set_title('📋 COMPARACIÓN FINAL', fontweight='bold', fontsize=14)
+        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()
-        ax4.grid(True, alpha=0.3, axis='y')
-
+        
         plt.tight_layout()
         return fig
 
-    def generar_reporte_textual(self):
-        """Genera un análisis textual de la partida"""
+    def generar_reporte_detallado(self, blancas, negras, resultado):
         if not self.datos_jugadas:
-            return "No hay datos para generar reporte"
-            
-        reporte = "🎯 ANÁLISIS DETALLADO DE LA PARTIDA\n"
-        reporte += "=" * 50 + "\n\n"
+            return "No se pudo generar el reporte"
         
-        # Estadísticas básicas
         total_jugadas = len(self.datos_jugadas)
         eval_final = self.datos_jugadas[-1]['evaluacion']
-        
-        reporte += f"📊 **Estadísticas Básicas:**\n"
-        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])
         
-        reporte += f"\n🎯 **Análisis de Movilidad:**\n"
-        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"
+        # 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
         
-        # Punto de mayor ventaja
-        max_ventaja_b = max([d['evaluacion'] for d in self.datos_jugadas])
-        min_ventaja_b = min([d['evaluacion'] for d in self.datos_jugadas])
+        precision = max(0, 100 - (cambios_bruscos * 5))
         
-        reporte += f"\n📈 **Momentos Clave:**\n"
-        reporte += f"   • Mayor ventaja de Blancas: +{max_ventaja_b:.1f}\n"
-        reporte += f"   • Mayor ventaja de Negras: +{abs(min_ventaja_b):.1f}\n"
+        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:
+"""
         
-        # Duración de la partida
-        if total_jugadas < 30:
-            reporte += f"   • Partida rápida ({total_jugadas} jugadas)\n"
-        elif total_jugadas < 60:
-            reporte += f"   • Partida de duración media ({total_jugadas} jugadas)\n"
+        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 += f"   • Partida larga ({total_jugadas} jugadas)\n"
+            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 limpiar_y_corregir_pgn(pgn_text):
-    """Limpia y corrige errores comunes en PGN automáticamente"""
-    correcciones = {
-        'N75': 'Nf3', 'N76': 'Nf6', 'N15': 'Nf5', 'N16': 'Nf6',
-        'Re6': 'Nc6', 'Re3': 'Ne3', 'Re4': 'Ne4',
-        'Rel': 'Re1', 'Ral': 'Ra1', 'Rbl': 'Rb1', 'Rcl': 'Rc1', 'Rdl': 'Rd1',
-        'Nba': 'Nb8', 'Nbc': 'Nbc6', 'Nbd': 'Nbd7',
-        'Of8': 'Qf8', 'Oc7': 'Qc7', 'Od8': 'Qd8',
-        'B6': 'Bf6', 'B7': 'Bb7', 'B5': 'Bb5',
-        'ae': 'a6', 'af': 'a5'
-    }
-    
-    # Aplicar correcciones
-    for error, correccion in correcciones.items():
-        pgn_text = pgn_text.replace(error, correccion)
-    
-    # Corregir números de jugada mal formados
-    pgn_text = re.sub(r'(\d+)\.([A-Z])', r'\1. \2', pgn_text)
-    
-    # Asegurar espacios después de puntos
-    pgn_text = re.sub(r'(\d+)\.(\S)', r'\1. \2', pgn_text)
-    
-    return pgn_text
-
-def analizar_y_mostrar(pgn_text):
-    """Función que Gradio usará para la interfaz"""
+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, pega una partida PGN válida"
+            return None, "❌ Por favor, ingresa un PGN o sube un archivo"
             
-        # Limpiar y corregir PGN automáticamente
-        pgn_limpio = limpiar_y_corregir_pgn(pgn_text)
-        
         analizador = AnalizadorAjedrez()
-        blancas, negras, resultado, error = analizador.analizar_partida(pgn_limpio)
-        
-        if "Error" in blancas:
-            # Intentar análisis con PGN original como fallback
-            try:
-                analizador = AnalizadorAjedrez()
-                blancas, negras, resultado, error = analizador.analizar_partida(pgn_text)
-                if "Error" in blancas:
-                    return None, f"❌ No se pudo analizar el PGN.\n\n💡 **Sugerencias:**\n• Verifica que la notación sea correcta\n• Asegúrate de que los movimientos sigan formato estándar\n• Revisa que no haya caracteres especiales extraños\n\nError técnico: {error}"
-            except:
-                return None, f"❌ Error crítico en el PGN.\n\n📝 **Formato esperado:**\n```\n[Event \"Nombre\"]\n[White \"JugadorB\"]\n[Black \"JugadorN\"]\n\n1. e4 e5 2. Nf3 Nc6 3. Bb5 a6\n```"
+        blancas, negras, resultado, error = analizador.analizar_partida(pgn_text)
         
-        # Generar gráficos
-        fig = analizador.generar_graficos_gradio(blancas, negras)
+        if error:
+            return None, f"❌ Error al procesar: {error}"
         
-        # Convertir figura a imagen para Gradio
+        # Generar gráfico
+        fig = analizador.generar_grafico_completo(blancas, negras)
         buf = BytesIO()
-        fig.savefig(buf, format='png', dpi=120, bbox_inches='tight', facecolor='white')
+        fig.savefig(buf, format='png', dpi=100, bbox_inches='tight')
         buf.seek(0)
         plt.close(fig)
         
-        # Generar reporte textual
-        reporte = analizador.generar_reporte_textual()
-        reporte_header = f"**♟️ PARTIDA ANALIZADA:**\n"
-        reporte_header += f"**Blancas:** {blancas}\n"
-        reporte_header += f"**Negras:** {negras}\n" 
-        reporte_header += f"**Resultado:** {resultado}\n\n"
+        # Generar reporte
+        reporte = analizador.generar_reporte_detallado(blancas, negras, resultado)
         
-        full_reporte = reporte_header + reporte
-        
-        return buf, full_reporte
+        return buf, reporte
         
     except Exception as e:
-        return None, f"❌ Error inesperado: {str(e)}\n\nPor favor, verifica el formato de tu PGN."
+        return None, f"❌ Error inesperado: {str(e)}"
 
-# Interfaz de Gradio mejorada
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="slate")) as demo:
+# Interfaz de Gradio con uploader
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
-    # ♟️ Analizador Avanzado de Partidas de Ajedrez
-    
-    **Pega cualquier partida en formato PGN y obtén un análisis completo con gráficos y estadísticas detalladas.**
-    
-    *El sistema corrige automáticamente errores comunes de notación.*
+    # ♟️ 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("### 📝 Ingresa tu partida")
+            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=18,
+                lines=15,
                 placeholder="""[Event \"Mi Torneo\"]
-[White \"Jugador Blanco\"]
+[White \"Jugador Blanco\"] 
 [Black \"Jugador Negro\"]
 [Result \"1-0\"]
 
@@ -313,88 +264,59 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="slate"))
 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""",
-                info="Puedes pegar PGNs con pequeños errores, el sistema los corregirá automáticamente."
+29. fxe5 fxe5 30. Bg5 Qd7 31. e6 Qe7 32. Bf6 Qf8 33. e7 1-0"""
             )
             
-            with gr.Row():
-                btn_analizar = gr.Button("🧠 Analizar Partida", variant="primary", size="lg")
-                btn_limpiar = gr.Button("🗑️ Limpiar", variant="secondary")
+            btn_analizar = gr.Button("🧠 Analizar Partida", variant="primary", size="lg")
+            btn_limpiar = gr.Button("🗑️ Limpiar Todo", variant="secondary")
             
-            gr.Markdown("### 💡 Ejemplos rápidos:")
-            with gr.Row():
-                gr.Examples(
-                    examples=[[
-"""[Event "Partida Rápida"]
-[White "Aman"]
-[Black "Boris"]
-[Result "1-0"]
-
-1. e4 e5 2. Nf3 Nc6 3. Bc4 Nf6 4. Ng5 d5 5. exd5 Nxd5 6. Nxf7 Kxf7 7. Qf3+ Ke6 
-8. Nc3 Ne7 9. d4 c6 10. Bg5 h6 11. Bxe7 Bxe7 12. O-O-O Rf8 13. Qe4 Rxf2 14. d5+ Kd6 
-15. Nxd5 cxd5 16. Rxd5+ Kc6 17. Qc4+ Kb6 18. Rb5+ Ka6 19. Qc6+ 1-0"""]],
-                    inputs=pgn_input,
-                    label="Ataque Legal"
-                )
-                
         with gr.Column(scale=1):
             gr.Markdown("### 📊 Resultados del Análisis")
             image_output = gr.Image(
-                label="Análisis Gráfico de la Partida", 
+                label="Análisis Gráfico", 
                 type="filepath",
                 height=400
             )
-            text_output = gr.Markdown(
-                label="Reporte de Análisis Detallado"
+            report_output = gr.Markdown(
+                label="Reporte Detallado",
+                value="### 📋 Reporte de Análisis\n\n*Los resultados aparecerán aquí después del análisis...*"
             )
     
-    # Funcionalidades adicionales
-    gr.Markdown("---")
-    with gr.Accordion("📚 Guía de Formato PGN", open=False):
-        gr.Markdown("""
-        **Formato PGN Correcto:**
-        ```
-        [Event "Nombre del Torneo"]
-        [Site "Ciudad, País"]
-        [Date "2024.01.01"]
-        [Round "1"]
-        [White "Apellido, Nombre"]
-        [Black "Apellido, Nombre"]
-        [Result "1-0"]
-        [WhiteElo "2500"]
-        [BlackElo "2400"]
-
-        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
-        ...
-        33. e7 1-0
-        ```
+    # Ejemplos
+    gr.Markdown("### 💡 Partidas de Ejemplo")
+    with gr.Row():
+        gr.Examples(
+            examples=[[
+"""[Event "Ejemplo Clásico"]
+[White "Fischer"]
+[Black "Spassky"] 
+[Result "1-0"]
 
-        **Notación de Piezas:**
-        - Rey: **K** (King)
-        - Reina: **Q** (Queen) 
-        - Torre: **R** (Rook)
-        - Alfil: **B** (Bishop)
-        - Caballo: **N** (Knight)
-        - Peón: (sin letra, ej: e4, d5)
-        """)
+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 de eventos
+    # Conectores
     btn_analizar.click(
-        fn=analizar_y_mostrar,
-        inputs=pgn_input,
-        outputs=[image_output, text_output]
+        fn=procesar_pgn,
+        inputs=[pgn_input, uploader],
+        outputs=[image_output, report_output]
     )
     
     btn_limpiar.click(
-        fn=lambda: [None, "### 📊 Reporte de Análisis\n\n*Los resultados aparecerán aquí después del análisis...*"],
+        fn=limpiar_todo,
         inputs=[],
-        outputs=[image_output, text_output]
+        outputs=[uploader, pgn_input, report_output]
     )
 
 if __name__ == "__main__":
-    demo.launch(
-        share=True,
-        show_error=True
-    )
+    demo.launch(share=True)