Update app.py

app.py

@@ -1,374 +1,430 @@
-# -*- coding: utf-8 -*-
-"""
-Aplicación Gradio para Análisis de Partidos de Fútbol
-Basada en datos de la Premier League
-"""
-
-import gradio as gr
-import pandas as pd
-import numpy as np
-import anthropic
-import os
-import tempfile
-from io import StringIO
-
-# Variables globales para almacenar resultados
-analisis_partido_resultado = ""
-analisis_partido_volatilidad = ""
-df = None
-
-def cargar_datos(archivo_csv):
-    """Carga el archivo CSV con los datos de partidos"""
-    global df
-    try:
-        if archivo_csv is None:
-            return "⚠️ Por favor, carga un archivo CSV primero.", None, None
-        
-        df = pd.read_csv(archivo_csv.name)
-        
-        # Obtener lista de equipos únicos
-        equipos_local = df['HomeTeam'].unique().tolist()
-        equipos_visitante = df['AwayTeam'].unique().tolist()
-        equipos = sorted(list(set(equipos_local + equipos_visitante)))
-        
-        info = f"""✅ **Archivo cargado exitosamente**
-        
-📊 **Información del dataset:**
-- Total de partidos: {len(df)}
-- Total de equipos: {len(equipos)}
-- Columnas disponibles: {len(df.columns)}
-
-📋 **Primeras filas del dataset:**
-"""
-        preview = df.head(10).to_string()
-        
-        return info + "\n" + preview, gr.update(choices=equipos, value=None), gr.update(choices=equipos, value=None)
-    
-    except Exception as e:
-        return f"❌ Error al cargar el archivo: {str(e)}", None, None
-
-
-def interpretar_volatilidad(media, moda):
-    """Compara la media con la moda para determinar la consistencia"""
-    diferencia = abs(media - moda)
-    
-    if diferencia < 0.5:
-        return "Alta Consistencia"
-    elif media > moda:
-        return "Volatilidad Positiva (Picos altos)"
-    else:
-        return "Volatilidad Negativa (Bajones marcados)"
-
-
-def analizar_partido(equipo_a, equipo_b):
-    """Análisis cruzado de rendimiento entre dos equipos"""
-    global analisis_partido_resultado, df
-    
-    if df is None or df.empty:
-        return "⚠️ No hay datos disponibles. Por favor, carga un archivo CSV primero."
-    
-    if not equipo_a or not equipo_b:
-        return "⚠️ Por favor, selecciona ambos equipos."
-    
-    # Definir las métricas de interés
-    metrics = {
-        'Goles': ('FTHG', 'FTAG'),
-        'Goles MT': ('HTHG', 'HTAG'),
-        'Tiros': ('HS', 'AS'),
-        'Tiros a Puerta': ('HST', 'AST'),
-        'Corners': ('HC', 'AC')
-    }
-    
-    # Filtrar datos
-    df_home_a = df[df['HomeTeam'] == equipo_a]
-    df_away_b = df[df['AwayTeam'] == equipo_b]
-    
-    # Validación
-    if df_home_a.empty or df_away_b.empty:
-        return f"❌ Error: No hay suficientes datos para {equipo_a} o {equipo_b}"
-    
-    def get_stats(series):
-        if series.empty: 
-            return (0, 0, 0)
-        mode_val = series.mode().iloc[0] if not series.mode().empty else 0
-        return series.mean(), series.median(), mode_val
-    
-    results = []
-    output_text = f"\n## 📊 ANÁLISIS CRUZADO: {equipo_a} (Local) vs {equipo_b} (Visitante)\n\n"
-    
-    for nombre, (col_home, col_away) in metrics.items():
-        # Cruce 1: Ataque Local A vs Defensa Visitante B
-        mean_atq_a, _, _ = get_stats(df_home_a[col_home])
-        mean_def_b, _, _ = get_stats(df_away_b[col_home])
-        
-        # Cruce 2: Ataque Visitante B vs Defensa Local A
-        mean_atq_b, _, _ = get_stats(df_away_b[col_away])
-        mean_def_a, _, _ = get_stats(df_home_a[col_away])
-        
-        results.append({
-            'Categoría': nombre,
-            f'Atq {equipo_a} (L)': round(mean_atq_a, 2),
-            f'Def {equipo_b} (V)': round(mean_def_b, 2),
-            f'Atq {equipo_b} (V)': round(mean_atq_b, 2),
-            f'Def {equipo_a} (L)': round(mean_def_a, 2)
-        })
-    
-    tabla = pd.DataFrame(results)
-    analisis_partido_resultado = tabla.to_string(index=False)
-    output_text += tabla.to_markdown(index=False)
-    
-    return output_text
-
-
-def analizar_partido_volatilidad_func(equipo_local, equipo_visitante):
-    """Análisis de volatilidad y consistencia"""
-    global analisis_partido_volatilidad, df
-    
-    if df is None or df.empty:
-        return "⚠️ No hay datos disponibles. Por favor, carga un archivo CSV primero."
-    
-    if not equipo_local or not equipo_visitante:
-        return "⚠️ Por favor, selecciona ambos equipos."
-    
-    # Categorías a analizar
-    metricas = {
-        'Goles Final': ('FTHG', 'FTAG'),
-        'Goles Medio Tiempo': ('HTHG', 'HTAG'),
-        'Tiros Totales': ('HS', 'AS'),
-        'Tiros a Puerta': ('HST', 'AST'),
-        'Corners': ('HC', 'AC')
-    }
-    
-    df_local = df[df['HomeTeam'] == equipo_local]
-    df_visitante = df[df['AwayTeam'] == equipo_visitante]
-    
-    if df_local.empty or df_visitante.empty:
-        return "❌ Uno de los equipos no se encuentra en el dataset."
-    
-    resultados = []
-    
-    for nombre, (col_L, col_V) in metricas.items():
-        # CRUCE 1: ATAQUE LOCAL VS DEFENSA VISITANTE
-        m_atq_l = df_local[col_L].mean()
-        mod_atq_l = df_local[col_L].mode().iloc[0] if not df_local[col_L].empty else 0
-        
-        m_def_v = df_visitante[col_L].mean()
-        mod_def_v = df_visitante[col_L].mode().iloc[0] if not df_visitante[col_L].empty else 0
-        
-        # CRUCE 2: ATAQUE VISITANTE VS DEFENSA LOCAL
-        m_atq_v = df_visitante[col_V].mean()
-        mod_atq_v = df_visitante[col_V].mode().iloc[0] if not df_visitante[col_V].empty else 0
-        
-        m_def_l = df_local[col_V].mean()
-        mod_def_l = df_local[col_V].mode().iloc[0] if not df_local[col_V].empty else 0
-        
-        # Agregar resultados
-        resultados.append({
-            'Métrica': f"{nombre} - Atq {equipo_local}",
-            'Media': round(m_atq_l, 2),
-            'Moda': mod_atq_l,
-            'Volatilidad': interpretar_volatilidad(m_atq_l, mod_atq_l)
-        })
-        resultados.append({
-            'Métrica': f"{nombre} - Def {equipo_visitante}",
-            'Media': round(m_def_v, 2),
-            'Moda': mod_def_v,
-            'Volatilidad': interpretar_volatilidad(m_def_v, mod_def_v)
-        })
-        resultados.append({
-            'Métrica': f"{nombre} - Atq {equipo_visitante}",
-            'Media': round(m_atq_v, 2),
-            'Moda': mod_atq_v,
-            'Volatilidad': interpretar_volatilidad(m_atq_v, mod_atq_v)
-        })
-        resultados.append({
-            'Métrica': f"{nombre} - Def {equipo_local}",
-            'Media': round(m_def_l, 2),
-            'Moda': mod_def_l,
-            'Volatilidad': interpretar_volatilidad(m_def_l, mod_def_l)
-        })
-    
-    df_final = pd.DataFrame(resultados)
-    analisis_partido_volatilidad = df_final.to_string(index=False)
-    
-    output_text = f"\n## 📈 ANÁLISIS DE VOLATILIDAD: {equipo_local} vs {equipo_visitante}\n\n"
-    output_text += df_final.to_markdown(index=False)
-    
-    return output_text
-
-
-def generar_analisis_completo(equipo_local, equipo_visitante, api_key):
-    """Genera análisis completo usando Claude AI"""
-    global analisis_partido_resultado, analisis_partido_volatilidad
-    
-    if not api_key:
-        return "⚠️ Por favor, ingresa tu API Key de Anthropic."
-    
-    # Ejecutar ambos análisis
-    resultado_rendimiento = analizar_partido(equipo_local, equipo_visitante)
-    resultado_volatilidad = analizar_partido_volatilidad_func(equipo_local, equipo_visitante)
-    
-    if "Error" in resultado_rendimiento or "Error" in resultado_volatilidad:
-        return resultado_rendimiento + "\n\n" + resultado_volatilidad
-    
-    # Generar análisis con Claude
-    SYSTEM_PROMPT = """
-    Actúa como un experto analista estadístico de fútbol y apostador profesional.
-
-    REGLAS DE PROCESAMIENTO:
-    1. Cruce de Variables: Calcula la proyección (Media Local + Media Visitante) / 2 para Goles, Corners y Tiros.
-    2. Evaluación de Riesgo: Cruza la 'Media' con la 'Moda' y la 'Volatilidad'.
-       - Si Media > Moda y Volatilidad es "Picos Altos", advierte sobre la inconsistencia.
-       - Si Media ≈ Moda y hay "Alta Consistencia", aumenta la confianza del pronóstico.
-    3. Formato: Genera un informe con Resumen Estadístico, Porcentajes de Probabilidad y Sugerencias de Apuesta.
-    """
-    
-    USER_PROMPT = f"""
-    Analiza el siguiente partido utilizando estas dos fuentes de datos:
-
-    1. DATOS DE RENDIMIENTO (Ataque vs Defensa):
-    {analisis_partido_resultado}
-
-    2. DATOS DE VOLATILIDAD Y CONSISTENCIA:
-    {analisis_partido_volatilidad}
-
-    Proporciona el análisis siguiendo el tono profesional y la estructura de valor solicitada.
-    """
-    
-    try:
-        client = anthropic.Anthropic(api_key=api_key)
-        response = client.messages.create(
-            model="claude-haiku-4-5",
-            max_tokens=2500,
-            temperature=0,
-            system=SYSTEM_PROMPT,
-            messages=[{"role": "user", "content": USER_PROMPT}]
-        )
-        
-        analisis_ia = response.content[0].text
-        
-        # Combinar todos los resultados
-        output_completo = f"""# ⚽ ANÁLISIS COMPLETO DEL PARTIDO
-
-{resultado_rendimiento}
-
----
-
-{resultado_volatilidad}
-
----
-
-## 🤖 ANÁLISIS PROFESIONAL CON IA
-
-{analisis_ia}
-"""
-        
-        return output_completo
-        
-    except Exception as e:
-        return f"❌ Error en la API de Anthropic: {str(e)}\n\nAsegúrate de que tu API Key sea válida."
-
-
-# Crear la interfaz de Gradio
-with gr.Blocks(theme=gr.themes.Soft(), title="⚽ Análisis de Partidos - Premier League") as demo:
-    
-    gr.Markdown("""
-    # ⚽ Sistema de Análisis de Partidos de Fútbol
-    ### Análisis estadístico profesional para apuestas deportivas
-    
-    Esta aplicación analiza partidos de fútbol usando datos históricos de la Premier League.
-    Proporciona análisis de rendimiento, volatilidad y predicciones profesionales con IA.
-    """)
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### 📁 Paso 1: Cargar Datos")
-            archivo_input = gr.File(
-                label="Cargar archivo CSV",
-                file_types=[".csv"],
-                type="filepath"
-            )
-            btn_cargar = gr.Button("📊 Cargar y Procesar Datos", variant="primary")
-            info_datos = gr.Textbox(
-                label="Información del Dataset",
-                lines=15,
-                interactive=False
-            )
-    
-    gr.Markdown("---")
-    
-    with gr.Row():
-        with gr.Column():
-            gr.Markdown("### 🏟️ Paso 2: Seleccionar Equipos")
-            equipo_local = gr.Dropdown(
-                label="Equipo Local",
-                choices=[],
-                interactive=True
-            )
-            equipo_visitante = gr.Dropdown(
-                label="Equipo Visitante",
-                choices=[],
-                interactive=True
-            )
-        
-        with gr.Column():
-            gr.Markdown("### 🔑 Paso 3: API Key (Opcional)")
-            api_key = gr.Textbox(
-                label="Anthropic API Key",
-                placeholder="sk-ant-...",
-                type="password",
-                info="Solo necesaria para análisis con IA"
-            )
-    
-    gr.Markdown("---")
-    
-    with gr.Row():
-        btn_rendimiento = gr.Button("📊 Análisis de Rendimiento", size="lg")
-        btn_volatilidad = gr.Button("📈 Análisis de Volatilidad", size="lg")
-        btn_completo = gr.Button("🤖 Análisis Completo con IA", variant="primary", size="lg")
-    
-    gr.Markdown("---")
-    
-    output_analisis = gr.Markdown(label="Resultados del Análisis")
-    
-    # Eventos
-    btn_cargar.click(
-        fn=cargar_datos,
-        inputs=[archivo_input],
-        outputs=[info_datos, equipo_local, equipo_visitante]
-    )
-    
-    btn_rendimiento.click(
-        fn=analizar_partido,
-        inputs=[equipo_local, equipo_visitante],
-        outputs=[output_analisis]
-    )
-    
-    btn_volatilidad.click(
-        fn=analizar_partido_volatilidad_func,
-        inputs=[equipo_local, equipo_visitante],
-        outputs=[output_analisis]
-    )
-    
-    btn_completo.click(
-        fn=generar_analisis_completo,
-        inputs=[equipo_local, equipo_visitante, api_key],
-        outputs=[output_analisis]
-    )
-    
-    gr.Markdown("""
-    ---
-    ### 📖 Instrucciones de Uso:
-    1. **Cargar datos**: Sube un archivo CSV con datos de partidos (formato Football-Data.co.uk)
-    2. **Seleccionar equipos**: Elige el equipo local y visitante
-    3. **Elegir análisis**:
-       - **Rendimiento**: Compara ataque vs defensa
-       - **Volatilidad**: Analiza consistencia estadística
-       - **Completo con IA**: Genera reporte profesional (requiere API Key)
-    
-    💡 **Tip**: Puedes descargar datos gratuitos desde [Football-Data.co.uk](https://www.football-data.co.uk/englandm.php)
-    """)
-
-# Lanzar la aplicación
-if __name__ == "__main__":
+# -*- coding: utf-8 -*-
+"""bet-inglaterra con Gradio
+
+Análisis estadístico de partidos de fútbol con interfaz Gradio
+"""
+
+# Instalaciones necesarias
+# !pip install selenium webdriver-manager pandas anthropic gradio
+
+import os
+import shutil
+import pandas as pd
+import numpy as np
+import gradio as gr
+import anthropic
+
+# Variables globales para almacenar resultados
+analisis_partido_resultado = ""
+analisis_partido_volatilidad = ""
+df = pd.DataFrame()
+
+# =============================================================================
+# FUNCIONES ORIGINALES (SIN CAMBIOS)
+# =============================================================================
+
+def limpiar_carpeta():
+    """Limpia la carpeta de trabajo"""
+    folder = '/content'
+    mensajes = []
+    for filename in os.listdir(folder):
+        file_path = os.path.join(folder, filename)
+        try:
+            if filename != 'sample_data' and not filename.startswith('.'):
+                if os.path.isfile(file_path) or os.path.islink(file_path):
+                    os.unlink(file_path)
+                elif os.path.isdir(file_path):
+                    shutil.rmtree(file_path)
+            mensajes.append(f"Eliminado: {filename}")
+        except Exception as e:
+            mensajes.append(f'No se pudo borrar {file_path}. Razón: {e}')
+    return "\n".join(mensajes)
+
+def descargar_datos():
+    """Descarga los datos de football-data.co.uk"""
+    import urllib.request
+    url = "https://www.football-data.co.uk/mmz4281/2526/E0.csv"
+    try:
+        urllib.request.urlretrieve(url, 'E0.csv')
+        return "✓ Datos descargados exitosamente"
+    except Exception as e:
+        return f"Error al descargar: {e}"
+
+def cargar_datos():
+    """Carga los datos del CSV"""
+    global df
+    try:
+        df = pd.read_csv('E0.csv')
+        return f"✓ Datos cargados: {df.shape[0]} partidos, {df.shape[1]} columnas"
+    except FileNotFoundError:
+        return "Error: No se encontró el archivo 'E0.csv'. Descarga los datos primero."
+    except Exception as e:
+        return f"Error al cargar datos: {e}"
+
+def renombrar_columnas():
+    """Renombra y filtra columnas del dataset"""
+    global df
+    
+    column_mapping = {
+        'Div': 'League_Division',
+        'Date': 'Match_Date',
+        'Time': 'Kick_Off_Time',
+        'HomeTeam': 'Home_Team',
+        'AwayTeam': 'Away_Team',
+        'FTHG': 'Full_Time_Home_Goals',
+        'HG': 'Full_Time_Home_Goals',
+        'FTAG': 'Full_Time_Away_Goals',
+        'AG': 'Full_Time_Away_Goals',
+        'FTR': 'Full_Time_Result',
+        'Res': 'Full_Time_Result',
+        'HTHG': 'Half_Time_Home_Goals',
+        'HTAG': 'Half_Time_Away_Goals',
+        'HTR': 'Half_Time_Result',
+        'Attendance': 'Crowd_Attendance',
+        'Referee': 'Match_Referee',
+        'HS': 'Home_Shots',
+        'AS': 'Away_Shots',
+        'HST': 'Home_Shots_On_Target',
+        'AST': 'Away_Shots_On_Target',
+        'HHW': 'Home_Hit_Woodwork',
+        'AHW': 'Away_Hit_Woodwork',
+        'HC': 'Home_Corners',
+        'AC': 'Away_Corners',
+        'HF': 'Home_Fouls',
+        'AF': 'Away_Fouls',
+        'HFKC': 'Home_Free_Kicks_Conceded',
+        'AFKC': 'Away_Free_Kicks_Conceded',
+        'HO': 'Home_Offsides',
+        'AO': 'Away_Offsides',
+        'HY': 'Home_Yellow_Cards',
+        'AY': 'Away_Yellow_Cards',
+        'HR': 'Home_Red_Cards',
+        'AR': 'Away_Red_Cards',
+        'HBP': 'Home_Booking_Points',
+        'ABP': 'Away_Booking_Points'
+    }
+    
+    columns_to_keep = [col for col in df.columns if col in column_mapping.keys()]
+    df_filtered = df[columns_to_keep]
+    df_renamed = df_filtered.rename(columns=column_mapping)
+    df_renamed.to_csv('football_data_renamed.csv', index=False)
+    
+    return f"✓ Columnas renombradas: {len(columns_to_keep)} columnas conservadas"
+
+def generar_estadisticas():
+    """Genera estadísticas por equipo"""
+    global df
+    
+    numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+    
+    def get_mode(x):
+        m = x.mode()
+        if not m.empty:
+            return m.iloc[0]
+        return np.nan
+    
+    home_stats = df.groupby('HomeTeam')[numeric_cols].agg(['mean', 'median', get_mode])
+    home_stats.columns = [f'Home_{col}_{stat}' for col, stat in home_stats.columns]
+    home_stats.index.name = 'Team'
+    
+    away_stats = df.groupby('AwayTeam')[numeric_cols].agg(['mean', 'median', get_mode])
+    away_stats.columns = [f'Away_{col}_{stat}' for col, stat in away_stats.columns]
+    away_stats.index.name = 'Team'
+    
+    final_stats = pd.concat([home_stats, away_stats], axis=1)
+    final_stats.columns = [col.replace('get_mode', 'mode') for col in final_stats.columns]
+    final_stats.to_csv('estadisticas_equipos.csv')
+    
+    return f"✓ Estadísticas generadas: {len(final_stats)} equipos procesados"
+
+def analizar_partido(equipo_a, equipo_b):
+    """Análisis cruzado de un partido"""
+    global analisis_partido_resultado, df
+    
+    if df.empty:
+        return "No hay datos disponibles. Carga los datos primero."
+    
+    metrics = {
+        'Goles': ('FTHG', 'FTAG'),
+        'Goles MT': ('HTHG', 'HTAG'),
+        'Tiros': ('HS', 'AS'),
+        'Tiros a Puerta': ('HST', 'AST'),
+        'Corners': ('HC', 'AC')
+    }
+    
+    df_home_a = df[df['HomeTeam'] == equipo_a]
+    df_away_b = df[df['AwayTeam'] == equipo_b]
+    
+    if df_home_a.empty or df_away_b.empty:
+        return f"Error: No hay suficientes datos para {equipo_a} o {equipo_b}"
+    
+    def get_stats(series):
+        if series.empty: return (0, 0, 0)
+        mode_val = series.mode().iloc[0] if not series.mode().empty else 0
+        return series.mean(), series.median(), mode_val
+    
+    results = []
+    for nombre, (col_home, col_away) in metrics.items():
+        mean_atq_a, _, _ = get_stats(df_home_a[col_home])
+        mean_def_b, _, _ = get_stats(df_away_b[col_home])
+        mean_atq_b, _, _ = get_stats(df_away_b[col_away])
+        mean_def_a, _, _ = get_stats(df_home_a[col_away])
+        
+        results.append({
+            'Categoría': nombre,
+            f'Atq {equipo_a} (L)': round(mean_atq_a, 2),
+            f'Def {equipo_b} (V)': round(mean_def_b, 2),
+            f'Atq {equipo_b} (V)': round(mean_atq_b, 2),
+            f'Def {equipo_a} (L)': round(mean_def_a, 2)
+        })
+    
+    tabla = pd.DataFrame(results)
+    analisis_partido_resultado = tabla.to_string(index=False)
+    return analisis_partido_resultado
+
+def interpretar_volatilidad(media, moda):
+    """Compara la media con la moda para determinar la consistencia"""
+    diferencia = abs(media - moda)
+    
+    if diferencia < 0.5:
+        return "Alta Consistencia"
+    elif media > moda:
+        return "Volatilidad Positiva (Picos altos)"
+    else:
+        return "Volatilidad Negativa (Bajones marcados)"
+
+def analizar_partido_volatilidad_func(equipo_local, equipo_visitante):
+    """Análisis de volatilidad del partido"""
+    global analisis_partido_volatilidad, df
+    
+    if df.empty:
+        return "No hay datos disponibles. Carga los datos primero."
+    
+    metricas = {
+        'Goles Final': ('FTHG', 'FTAG'),
+        'Goles Medio Tiempo': ('HTHG', 'HTAG'),
+        'Tiros Totales': ('HS', 'AS'),
+        'Tiros a Puerta': ('HST', 'AST'),
+        'Corners': ('HC', 'AC')
+    }
+    
+    df_local = df[df['HomeTeam'] == equipo_local]
+    df_visitante = df[df['AwayTeam'] == equipo_visitante]
+    
+    if df_local.empty or df_visitante.empty:
+        return "Uno de los equipos no se encuentra en el dataset."
+    
+    resultados = []
+    
+    for nombre, (col_L, col_V) in metricas.items():
+        m_atq_l = df_local[col_L].mean()
+        mod_atq_l = df_local[col_L].mode().iloc[0] if not df_local[col_L].empty else 0
+        
+        m_def_v = df_visitante[col_L].mean()
+        mod_def_v = df_visitante[col_L].mode().iloc[0] if not df_visitante[col_L].empty else 0
+        
+        m_atq_v = df_visitante[col_V].mean()
+        mod_atq_v = df_visitante[col_V].mode().iloc[0] if not df_visitante[col_V].empty else 0
+        
+        m_def_l = df_local[col_V].mean()
+        mod_def_l = df_local[col_V].mode().iloc[0] if not df_local[col_V].empty else 0
+        
+        resultados.append({'Métrica': f"{nombre} - Atq {equipo_local}", 'Media': round(m_atq_l, 2), 'Moda': mod_atq_l, 'Volatilidad': interpretar_volatilidad(m_atq_l, mod_atq_l)})
+        resultados.append({'Métrica': f"{nombre} - Def {equipo_visitante}", 'Media': round(m_def_v, 2), 'Moda': mod_def_v, 'Volatilidad': interpretar_volatilidad(m_def_v, mod_def_v)})
+        resultados.append({'Métrica': f"{nombre} - Atq {equipo_visitante}", 'Media': round(m_atq_v, 2), 'Moda': mod_atq_v, 'Volatilidad': interpretar_volatilidad(m_atq_v, mod_atq_v)})
+        resultados.append({'Métrica': f"{nombre} - Def {equipo_local}", 'Media': round(m_def_l, 2), 'Moda': mod_def_l, 'Volatilidad': interpretar_volatilidad(m_def_l, mod_def_l)})
+    
+    df_final = pd.DataFrame(resultados)
+    analisis_partido_volatilidad = df_final.to_string(index=False)
+    return analisis_partido_volatilidad
+
+def generar_analisis_profesional(api_key, datos_rendimiento, datos_volatilidad):
+    """Genera análisis profesional usando Claude API"""
+    SYSTEM_PROMPT = """
+    Actúa como un experto analista estadístico de fútbol y apostador profesional.
+
+    REGLAS DE PROCESAMIENTO:
+    1. Cruce de Variables: Calcula la proyección (Media Local + Media Visitante) / 2 para Goles, Corners y Tiros.
+    2. Evaluación de Riesgo: Cruza la 'Media' con la 'Moda' y la 'Volatilidad'.
+       - Si Media > Moda y Volatilidad es "Picos Altos", advierte sobre la inconsistencia.
+       - Si Media ≈ Moda y hay "Alta Consistencia", aumenta la confianza del pronóstico.
+    3. Formato: Genera un informe con Resumen Estadístico, Porcentajes de Probabilidad y Sugerencias de Apuesta.
+    """
+    
+    USER_PROMPT = f"""
+    Analiza el siguiente partido utilizando estas dos fuentes de datos:
+
+    1. DATOS DE RENDIMIENTO (Ataque vs Defensa):
+    {datos_rendimiento}
+
+    2. DATOS DE VOLATILIDAD Y CONSISTENCIA:
+    {datos_volatilidad}
+
+    Proporciona el análisis siguiendo el tono profesional y la estructura de valor solicitada.
+    """
+    
+    try:
+        client = anthropic.Anthropic(api_key=api_key)
+        response = client.messages.create(
+            model="claude-haiku-4-5-20251001",
+            max_tokens=2500,
+            temperature=0,
+            system=SYSTEM_PROMPT,
+            messages=[{"role": "user", "content": USER_PROMPT}]
+        )
+        return response.content[0].text
+    except Exception as e:
+        return f"Error en la API: {e}"
+
+# =============================================================================
+# FUNCIONES PARA GRADIO
+# =============================================================================
+
+def obtener_equipos():
+    """Obtiene la lista de equipos disponibles"""
+    global df
+    if df.empty:
+        return []
+    equipos = sorted(list(set(df['HomeTeam'].unique().tolist() + df['AwayTeam'].unique().tolist())))
+    return equipos
+
+def inicializar_datos():
+    """Función para inicializar todos los datos"""
+    resultado = []
+    resultado.append(descargar_datos())
+    resultado.append(cargar_datos())
+    resultado.append(renombrar_columnas())
+    resultado.append(generar_estadisticas())
+    return "\n".join(resultado)
+
+def analisis_completo(equipo_local, equipo_visitante, api_key):
+    """Realiza el análisis completo del partido"""
+    global analisis_partido_resultado, analisis_partido_volatilidad
+    
+    # Análisis de rendimiento
+    rendimiento = analizar_partido(equipo_local, equipo_visitante)
+    
+    # Análisis de volatilidad
+    volatilidad = analizar_partido_volatilidad_func(equipo_local, equipo_visitante)
+    
+    # Análisis con IA
+    if api_key:
+        analisis_ia = generar_analisis_profesional(api_key, rendimiento, volatilidad)
+    else:
+        analisis_ia = "Proporciona tu API Key de Anthropic para obtener el análisis profesional con IA."
+    
+    return rendimiento, volatilidad, analisis_ia
+
+# =============================================================================
+# INTERFAZ GRADIO
+# =============================================================================
+
+with gr.Blocks(title="Análisis de Partidos de Fútbol", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # ⚽ Análisis Estadístico de Partidos - Premier League
+    ### Sistema de análisis avanzado para apuestas deportivas
+    """)
+    
+    with gr.Tab("1️⃣ Configuración"):
+        gr.Markdown("### Paso 1: Inicializar datos")
+        btn_inicializar = gr.Button("🔄 Descargar y Procesar Datos", variant="primary")
+        output_inicializacion = gr.Textbox(label="Estado", lines=5)
+        
+        btn_inicializar.click(
+            fn=inicializar_datos,
+            outputs=output_inicializacion
+        )
+    
+    with gr.Tab("2️⃣ Análisis de Partido"):
+        gr.Markdown("### Selecciona los equipos y obtén el análisis completo")
+        
+        with gr.Row():
+            with gr.Column():
+                equipo_local = gr.Dropdown(
+                    label="Equipo Local",
+                    choices=obtener_equipos(),
+                    interactive=True
+                )
+                btn_actualizar = gr.Button("🔄 Actualizar lista de equipos")
+                
+            with gr.Column():
+                equipo_visitante = gr.Dropdown(
+                    label="Equipo Visitante",
+                    choices=obtener_equipos(),
+                    interactive=True
+                )
+        
+        api_key_input = gr.Textbox(
+            label="API Key de Anthropic (opcional)",
+            type="password",
+            placeholder="sk-ant-..."
+        )
+        
+        btn_analizar = gr.Button("📊 Analizar Partido", variant="primary", size="lg")
+        
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### 📈 Análisis de Rendimiento")
+                output_rendimiento = gr.Textbox(label="Ataque vs Defensa", lines=10)
+            
+            with gr.Column():
+                gr.Markdown("### 📉 Análisis de Volatilidad")
+                output_volatilidad = gr.Textbox(label="Consistencia y Riesgo", lines=10)
+        
+        gr.Markdown("### 🤖 Análisis Profesional con IA")
+        output_ia = gr.Textbox(label="Recomendaciones", lines=15)
+        
+        # Eventos
+        btn_actualizar.click(
+            fn=obtener_equipos,
+            outputs=[equipo_local, equipo_visitante]
+        )
+        
+        btn_analizar.click(
+            fn=analisis_completo,
+            inputs=[equipo_local, equipo_visitante, api_key_input],
+            outputs=[output_rendimiento, output_volatilidad, output_ia]
+        )
+    
+    with gr.Tab("ℹ️ Información"):
+        gr.Markdown("""
+        ## Cómo usar esta aplicación
+        
+        ### Paso 1: Configuración
+        1. Ve a la pestaña "Configuración"
+        2. Haz clic en "Descargar y Procesar Datos"
+        3. Espera a que se complete el procesamiento
+        
+        ### Paso 2: Análisis
+        1. Ve a la pestaña "Análisis de Partido"
+        2. Actualiza la lista de equipos si es necesario
+        3. Selecciona el equipo local y visitante
+        4. (Opcional) Ingresa tu API Key de Anthropic para análisis con IA
+        5. Haz clic en "Analizar Partido"
+        
+        ### Interpretación de Resultados
+        
+        **Análisis de Rendimiento:**
+        - Muestra el promedio de goles, tiros, corners, etc.
+        - Compara el ataque de cada equipo vs la defensa del rival
+        
+        **Análisis de Volatilidad:**
+        - Alta Consistencia: El equipo es predecible
+        - Volatilidad Positiva: Tiene picos de buen rendimiento
+        - Volatilidad Negativa: Tiene caídas en rendimiento
+        
+        **Análisis con IA:**
+        - Combina ambos análisis
+        - Proporciona recomendaciones de apuesta
+        - Calcula probabilidades
+        
+        ### Obtener API Key de Anthropic
+        1. Visita https://console.anthropic.com/
+        2. Crea una cuenta o inicia sesión
+        3. Ve a "API Keys"
+        4. Genera una nueva clave
+        """)
+
+# Lanzar la aplicación
+if __name__ == "__main__":
     demo.launch(share=True)