Update app.py

app.py

@@ -1,470 +1,348 @@
-# --- INSTALACIÓN DE DEPENDENCIAS ADICIONALES ---
-import os
-import sys
-import subprocess
-
-os.system("pip install --upgrade gradio")
-
 import gradio as gr
-import pandas as pd
-import numpy as np
-import plotly.graph_objects as go
-import plotly.express as px
 from gradio_client import Client, handle_file
+import pandas as pd
+import json
 import tempfile
 import os
-import asyncio
-import json
 from datetime import datetime
-import logging
-
-# Configurar logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-class BiotechAnalysisAgent:
-    def __init__(self):
-        self.biotech_client = Client("C2MV/BiotechU4")
-        self.analysis_client = Client("C2MV/Project-HF-2025")
-        self.results_cache = {}
-        
-    async def process_biotech_data(self, file_path, models, component, use_de, maxfev, exp_names, theme):
-        """Procesa los datos biotecnológicos usando el primer endpoint"""
-        try:
-            logger.info(f"Procesando archivo: {file_path}")
-            
-            result = self.biotech_client.predict(
-                file=handle_file(file_path),
-                models=models,
-                component=component,
-                use_de=use_de,
-                maxfev=maxfev,
-                exp_names=exp_names,
-                theme=theme,
-                api_name="/run_analysis_wrapper"
-            )
-            
-            # Extraer resultados
-            plot_data, table_data, status = result
-            
-            # Guardar en caché
-            self.results_cache['biotech_results'] = {
-                'plot': plot_data,
-                'table': table_data,
-                'status': status,
-                'timestamp': datetime.now()
-            }
-            
-            return plot_data, table_data, status
-            
-        except Exception as e:
-            logger.error(f"Error en análisis biotecnológico: {str(e)}")
-            return None, None, f"Error: {str(e)}"
-    
-    async def generate_csv_from_results(self, table_data):
-        """Convierte los resultados de la tabla en un archivo CSV temporal"""
-        try:
-            if not table_data or 'data' not in table_data:
-                return None, "No hay datos para convertir"
-            
-            # Crear DataFrame
-            df = pd.DataFrame(
-                data=table_data['data'],
-                columns=table_data.get('headers', [])
-            )
-            
-            # Guardar como CSV temporal
-            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.csv', mode='w')
-            df.to_csv(temp_file.name, index=False)
-            temp_file.close()
-            
-            return temp_file.name, "CSV generado exitosamente"
-            
-        except Exception as e:
-            logger.error(f"Error generando CSV: {str(e)}")
-            return None, f"Error generando CSV: {str(e)}"
-    
-    async def generate_analysis_report(self, csv_file_path, model, detail, language, additional_specs):
-        """Genera el reporte de análisis usando el segundo endpoint"""
-        try:
-            if not csv_file_path or not os.path.exists(csv_file_path):
-                return "Error: No se encontró el archivo CSV", ""
-            
-            logger.info(f"Generando reporte con archivo: {csv_file_path}")
-            
-            result = self.analysis_client.predict(
-                files=[handle_file(csv_file_path)],
-                model=model,
-                detail=detail,
-                language=language,
-                additional_specs=additional_specs,
-                api_name="/process_and_store"
-            )
-            
-            analysis_markdown, implementation_code = result
-            
-            # Limpiar archivo temporal
-            try:
-                os.unlink(csv_file_path)
-            except:
-                pass
-            
-            return analysis_markdown, implementation_code
-            
-        except Exception as e:
-            logger.error(f"Error generando reporte: {str(e)}")
-            return f"Error generando reporte: {str(e)}", ""
-    
-    async def export_report(self, format_type, language):
-        """Exporta el reporte en el formato especificado"""
-        try:
-            result = self.analysis_client.predict(
-                format=format_type,
-                language=language,
-                api_name="/handle_export"
-            )
-            
-            status, file_path = result
-            return status, file_path
-            
-        except Exception as e:
-            logger.error(f"Error exportando: {str(e)}")
-            return f"Error exportando: {str(e)}", None
 
-# Inicializar el agente
-agent = BiotechAnalysisAgent()
+# Configuración de clientes
+biotech_client = Client("C2MV/BiotechU4")
+analysis_client = Client("C2MV/Project-HF-2025")
 
-def create_sample_plot():
-    """Crea un gráfico de ejemplo"""
-    x = np.linspace(0, 10, 100)
-    y = np.sin(x)
-    
-    fig = go.Figure()
-    fig.add_trace(go.Scatter(x=x, y=y, mode='lines', name='Ejemplo'))
-    fig.update_layout(
-        title="Gráfico de Ejemplo - Carga tus datos para ver resultados reales",
-        xaxis_title="Tiempo",
-        yaxis_title="Valor",
-        template="plotly_white"
-    )
-    return fig
+# Tema personalizado
+theme = gr.themes.Soft(
+    primary_hue="blue",
+    secondary_hue="indigo",
+    neutral_hue="slate",
+    spacing_size="md",
+    radius_size="lg",
+)
 
-async def process_complete_analysis(
-    file, models, component, use_de, maxfev, exp_names, 
-    claude_model, detail_level, language, additional_specs, theme
-):
-    """Función principal que ejecuta todo el pipeline"""
-    
-    if file is None:
-        return (
-            create_sample_plot(),
-            pd.DataFrame({"Status": ["Por favor, carga un archivo para comenzar"]}),
-            "⚠️ Esperando archivo...",
-            "📄 Carga un archivo Excel (.xlsx) para generar el análisis completo",
-            "",
-            None
-        )
-    
+def process_biotech_data(file, models, component, use_de, maxfev, exp_names):
+    """Procesa los datos en el primer endpoint de BiotechU4"""
     try:
-        # Paso 1: Análisis biotecnológico
-        yield (
-            create_sample_plot(),
-            pd.DataFrame({"Status": ["Procesando análisis biotecnológico..."]}),
-            "🔄 Paso 1/3: Analizando datos biotecnológicos...",
-            "Procesando archivo con modelos seleccionados...",
-            "",
-            None
-        )
-        
-        plot_data, table_data, status = await agent.process_biotech_data(
-            file.name, models, component, use_de, maxfev, exp_names, theme
-        )
-        
-        if table_data is None:
-            yield (
-                create_sample_plot(),
-                pd.DataFrame({"Error": [status]}),
-                f"❌ Error en análisis: {status}",
-                "Error en el procesamiento de datos",
-                "",
-                None
-            )
-            return
-        
-        # Convertir datos de tabla para mostrar
-        if table_data and 'data' in table_data:
-            results_df = pd.DataFrame(
-                data=table_data['data'],
-                columns=table_data.get('headers', [])
-            )
-        else:
-            results_df = pd.DataFrame({"Status": ["Datos procesados pero tabla vacía"]})
-        
-        # Paso 2: Generar CSV
-        yield (
-            create_sample_plot(),
-            results_df,
-            "🔄 Paso 2/3: Generando archivo CSV temporal...",
-            "Convirtiendo resultados para análisis con IA...",
-            "",
-            None
-        )
-        
-        csv_path, csv_status = await agent.generate_csv_from_results(table_data)
-        
-        if csv_path is None:
-            yield (
-                create_sample_plot(),
-                results_df,
-                f"❌ Error generando CSV: {csv_status}",
-                "Error en la conversión de datos",
-                "",
-                None
-            )
-            return
-        
-        # Paso 3: Análisis con IA
-        yield (
-            create_sample_plot(),
-            results_df,
-            "🔄 Paso 3/3: Generando análisis con IA (Claude)...",
-            "Analizando resultados y generando reporte inteligente...",
-            "",
-            None
+        result = biotech_client.predict(
+            file=handle_file(file.name),
+            models=models,
+            component=component,
+            use_de=use_de,
+            maxfev=maxfev,
+            exp_names=exp_names,
+            theme=False,
+            api_name="/run_analysis_wrapper"
         )
-        
-        analysis_report, implementation_code = await agent.generate_analysis_report(
-            csv_path, claude_model, detail_level, language, additional_specs
+        return result
+    except Exception as e:
+        return None, None, f"Error en el análisis: {str(e)}"
+
+def download_results_as_csv(df_data):
+    """Descarga los resultados como CSV desde BiotechU4"""
+    try:
+        result = biotech_client.predict(
+            df=df_data,
+            api_name="/download_results_excel"
         )
-        
-        # Paso 4: Exportar reporte
-        export_status, export_file = await agent.export_report("PDF", language)
-        
-        # Resultado final
-        yield (
-            create_sample_plot(),
-            results_df,
-            "✅ Análisis completado exitosamente",
-            analysis_report,
-            implementation_code,
-            export_file
+        return result
+    except Exception as e:
+        return None
+
+def generate_claude_report(csv_file, model, detail_level, language, additional_specs):
+    """Genera el informe usando Claude"""
+    try:
+        result = analysis_client.predict(
+            files=[handle_file(csv_file)],
+            model=model,
+            detail=detail_level,
+            language=language,
+            additional_specs=additional_specs,
+            api_name="/process_and_store"
         )
-        
+        return result
     except Exception as e:
-        logger.error(f"Error en análisis completo: {str(e)}")
-        yield (
-            create_sample_plot(),
-            pd.DataFrame({"Error": [str(e)]}),
-            f"❌ Error general: {str(e)}",
-            "Error en el procesamiento completo",
-            "",
-            None
+        return f"Error en el análisis: {str(e)}", ""
+
+def export_report(format_type, language, analysis, code):
+    """Exporta el informe en el formato seleccionado"""
+    try:
+        # Primero procesamos y almacenamos
+        result = analysis_client.predict(
+            format=format_type,
+            language=language,
+            api_name="/handle_export"
         )
+        return result[1], result[0]
+    except Exception as e:
+        return None, f"Error al exportar: {str(e)}"
+
+def process_complete_pipeline(
+    file, 
+    models, 
+    component, 
+    use_de, 
+    maxfev, 
+    exp_names,
+    claude_model,
+    detail_level,
+    language,
+    additional_specs,
+    export_format
+):
+    """Pipeline completo de procesamiento"""
+    progress_updates = []
+    
+    # Paso 1: Procesar con BiotechU4
+    progress_updates.append("🔄 Procesando datos biotecnológicos...")
+    plot, df_data, status = process_biotech_data(
+        file, models, component, use_de, maxfev, exp_names
+    )
+    
+    if "Error" in status:
+        return None, None, None, status, None, None
+    
+    progress_updates.append("✅ Análisis biotecnológico completado")
+    
+    # Paso 2: Descargar resultados como CSV
+    progress_updates.append("📥 Descargando resultados...")
+    csv_file = download_results_as_csv(df_data)
+    
+    if not csv_file:
+        return plot, df_data, None, "Error al descargar resultados", None, status
+    
+    # Paso 3: Generar análisis con Claude
+    progress_updates.append(f"🤖 Generando análisis con {claude_model}...")
+    analysis, code = generate_claude_report(
+        csv_file, claude_model, detail_level, language, additional_specs
+    )
+    
+    progress_updates.append("✅ Análisis con Claude completado")
+    
+    # Paso 4: Exportar informe
+    progress_updates.append(f"📄 Exportando informe en formato {export_format}...")
+    report_file, export_status = export_report(export_format, language, analysis, code)
+    
+    final_status = "\n".join(progress_updates) + f"\n\n{export_status}"
+    
+    return plot, df_data, analysis, code, report_file, final_status
 
-# Crear la interfaz
-def create_interface():
-    with gr.Blocks(
-        theme=gr.themes.Soft(
-            primary_hue="blue",
-            secondary_hue="cyan",
-            neutral_hue="slate"
-        ),
-        title="🧬 BioTech Analysis Suite - Análisis Inteligente de Datos Biotecnológicos",
-        css="""
-        .main-header {
-            text-align: center;
-            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-            color: white;
-            padding: 2rem;
-            border-radius: 10px;
-            margin-bottom: 2rem;
-        }
-        .step-indicator {
-            background: #f8f9fa;
-            padding: 1rem;
-            border-radius: 8px;
-            border-left: 4px solid #007bff;
-        }
-        .results-container {
-            background: #ffffff;
-            border-radius: 10px;
-            padding: 1.5rem;
-            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
-        }
+# Interfaz de Gradio
+with gr.Blocks(theme=theme, title="🧬 BioTech Analysis & Report Generator") as demo:
+    gr.Markdown(
         """
-    ) as interface:
+        # 🧬 BioTech Analysis & Report Generator
         
-        gr.HTML("""
-            <div class="main-header">
-                <h1>🧬 BioTech Analysis Suite</h1>
-                <p>Análisis Inteligente de Datos Biotecnológicos con IA</p>
-                <p>Carga tu archivo Excel → Análisis automático → Reporte con Claude AI</p>
-            </div>
-        """)
+        ### Pipeline completo de análisis biotecnológico con IA
         
-        with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("## 📁 Configuración de Análisis")
+        Este sistema combina análisis avanzado de datos biotecnológicos con generación de informes mediante Claude 3.5.
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("## 📊 Configuración del Análisis")
+            
+            # Inputs para BiotechU4
+            file_input = gr.File(
+                label="📁 Archivo de datos (CSV/Excel)",
+                file_types=[".csv", ".xlsx", ".xls"],
+                elem_classes="file-input"
+            )
+            
+            with gr.Group():
+                gr.Markdown("### 🔬 Parámetros de Análisis")
                 
-                file_input = gr.File(
-                    label="📁 Sube tu archivo Excel (.xlsx)",
-                    file_types=[".xlsx", ".xls"],
-                    type="filepath"
+                models_input = gr.CheckboxGroup(
+                    choices=['logistic', 'gompertz', 'moser', 'baranyi', 'monod', 
+                            'contois', 'andrews', 'tessier', 'richards', 'stannard', 'huang'],
+                    value=['logistic', 'gompertz', 'moser', 'baranyi'],
+                    label="📊 Modelos a probar",
+                    elem_classes="models-input"
                 )
                 
-                with gr.Accordion("⚙️ Configuración del Modelo", open=True):
-                    models = gr.CheckboxGroup(
-                        choices=["logistic", "gompertz", "moser", "baranyi", "monod", "contois", "andrews", "tessier", "richards", "stannard", "huang"],
-                        value=["logistic", "gompertz", "moser", "baranyi"],
-                        label="📊 Modelos a Probar"
-                    )
-                    
-                    component = gr.Dropdown(
-                        choices=["all", "biomass", "substrate", "product"],
-                        value="all",
-                        label="📈 Componente a visualizar"
-                    )
-                    
-                with gr.Accordion("🔧 Configuración Avanzada", open=False):
-                    use_de = gr.Checkbox(
-                        label="Usar Evolución Diferencial",
+                component_input = gr.Dropdown(
+                    choices=['all', 'biomass', 'substrate', 'product'],
+                    value='all',
+                    label="📈 Componente a visualizar"
+                )
+                
+                exp_names_input = gr.Textbox(
+                    label="🏷️ Nombres de experimentos",
+                    placeholder="Experimento 1, Experimento 2...",
+                    value="Análisis Biotecnológico"
+                )
+                
+                with gr.Row():
+                    use_de_input = gr.Checkbox(
+                        label="🧮 Usar Evolución Diferencial",
                         value=False
                     )
                     
-                    maxfev = gr.Number(
-                        label="Iteraciones máximas",
+                    maxfev_input = gr.Number(
+                        label="🔄 Iteraciones máximas",
                         value=50000,
-                        precision=0
-                    )
-                    
-                    exp_names = gr.Textbox(
-                        label="🏷️ Nombres de Experimentos",
-                        value="Experimento_BioTech"
-                    )
-                
-                with gr.Accordion("🤖 Configuración de IA", open=True):
-                    claude_model = gr.Dropdown(
-                        choices=[
-                            "claude-3-5-sonnet-20241022",
-                            "claude-3-5-haiku-20241022", 
-                            "claude-3-7-sonnet-20250219"
-                        ],
-                        value="claude-3-5-sonnet-20241022",
-                        label="🤖 Modelo Claude"
-                    )
-                    
-                    detail_level = gr.Radio(
-                        choices=["detailed", "summarized"],
-                        value="detailed",
-                        label="📋 Nivel de detalle del análisis"
-                    )
-                    
-                    language = gr.Dropdown(
-                        choices=["es", "en", "fr", "de", "pt"],
-                        value="es",
-                        label="🌐 Idioma del reporte"
-                    )
-                    
-                    additional_specs = gr.Textbox(
-                        label="📝 Especificaciones adicionales",
-                        placeholder="Ej: Enfócate en la eficiencia de crecimiento y optimización de parámetros...",
-                        lines=3
+                        minimum=1000,
+                        maximum=100000,
+                        step=1000
                     )
+            
+            with gr.Group():
+                gr.Markdown("### 🤖 Configuración de Claude")
                 
-                theme = gr.Checkbox(
-                    label="🌙 Modo Oscuro",
-                    value=False
+                claude_model_input = gr.Dropdown(
+                    choices=[
+                        'claude-3-7-sonnet-20250219',
+                        'claude-3-5-sonnet-20241022',
+                        'claude-3-5-haiku-20241022',
+                        'claude-sonnet-4-20250514',
+                        'claude-opus-4-20250514'
+                    ],
+                    value='claude-3-7-sonnet-20250219',
+                    label="🤖 Modelo de Claude"
                 )
                 
-                process_btn = gr.Button(
-                    "🚀 Iniciar Análisis Completo",
-                    variant="primary",
-                    size="lg"
+                detail_level_input = gr.Radio(
+                    choices=['detailed', 'summarized'],
+                    value='detailed',
+                    label="📋 Nivel de detalle del análisis"
                 )
-            
-            with gr.Column(scale=2):
-                gr.Markdown("## 📊 Resultados del Análisis")
                 
-                status_box = gr.Textbox(
-                    label="📋 Estado del Proceso",
-                    value="⚠️ Esperando archivo...",
-                    interactive=False
+                language_input = gr.Dropdown(
+                    choices=['en', 'es', 'fr', 'de', 'pt'],
+                    value='es',
+                    label="🌐 Idioma del informe"
                 )
                 
-                with gr.Tabs():
-                    with gr.TabItem("📈 Visualización"):
-                        plot_output = gr.Plot(
-                            label="Gráfico de Resultados",
-                            value=create_sample_plot()
-                        )
-                    
-                    with gr.TabItem("📊 Datos"):
-                        table_output = gr.Dataframe(
-                            label="Tabla de Resultados",
-                            value=pd.DataFrame({"Status": ["Carga un archivo para ver resultados"]})
-                        )
-                    
-                    with gr.TabItem("🤖 Análisis IA"):
-                        analysis_output = gr.Markdown(
-                            label="Reporte de Análisis",
-                            value="📄 El análisis con IA aparecerá aquí una vez procesados los datos..."
-                        )
-                    
-                    with gr.TabItem("💻 Código"):
-                        code_output = gr.Code(
-                            label="Código de Implementación",
-                            language="python",
-                            value="# El código generado aparecerá aquí..."
-                        )
+                additional_specs_input = gr.Textbox(
+                    label="📝 Especificaciones adicionales",
+                    placeholder="Añade contexto o requisitos específicos para el análisis...",
+                    lines=3
+                )
                 
-                download_file = gr.File(
-                    label="📥 Descargar Reporte PDF",
-                    visible=True
+                export_format_input = gr.Radio(
+                    choices=['PDF', 'DOCX'],
+                    value='PDF',
+                    label="📄 Formato de exportación"
                 )
+            
+            process_btn = gr.Button(
+                "🚀 Ejecutar Pipeline Completo",
+                variant="primary",
+                size="lg"
+            )
         
-        # Conectar la función principal
-        process_btn.click(
-            fn=process_complete_analysis,
-            inputs=[
-                file_input, models, component, use_de, maxfev, exp_names,
-                claude_model, detail_level, language, additional_specs, theme
-            ],
-            outputs=[
-                plot_output, table_output, status_box,
-                analysis_output, code_output, download_file
-            ]
-        )
-        
-        gr.Markdown("""
-            ---
-            ### 📋 Instrucciones de Uso:
-            1. **Carga tu archivo**: Sube un archivo Excel (.xlsx) con tus datos biotecnológicos
-            2. **Configura modelos**: Selecciona los modelos de crecimiento a probar
-            3. **Configura IA**: Elige el modelo Claude y nivel de detalle para el análisis
-            4. **Ejecuta**: Haz clic en "Iniciar Análisis Completo"
-            5. **Revisa resultados**: Explora las pestañas de visualización, datos, análisis IA y código
-            6. **Descarga**: Obtén tu reporte PDF completo
+        with gr.Column(scale=2):
+            gr.Markdown("## 📈 Resultados")
+            
+            with gr.Tabs():
+                with gr.TabItem("📊 Visualización"):
+                    plot_output = gr.Plot(label="Gráfico interactivo")
+                
+                with gr.TabItem("📋 Tabla de Resultados"):
+                    table_output = gr.Dataframe(
+                        label="Resultados del ajuste",
+                        interactive=False
+                    )
+                
+                with gr.TabItem("📝 Análisis de Claude"):
+                    analysis_output = gr.Markdown(label="Análisis comparativo")
+                
+                with gr.TabItem("💻 Código"):
+                    code_output = gr.Code(
+                        label="Código de implementación",
+                        language="python"
+                    )
             
-            ### 🔬 Modelos Disponibles:
-            - **Logistic, Gompertz, Moser, Baranyi**: Modelos clásicos de crecimiento
-            - **Monod, Contois, Andrews**: Modelos de cinética enzimática
-            - **Tessier, Richards, Stannard, Huang**: Modelos especializados
+            with gr.Row():
+                status_output = gr.Textbox(
+                    label="📊 Estado del proceso",
+                    lines=6,
+                    interactive=False
+                )
             
-            ### 🤖 Análisis con IA:
-            - Interpretación automática de resultados
-            - Recomendaciones de optimización
-            - Código de implementación generado
-            - Reportes en múltiples idiomas
-        """)
+            with gr.Row():
+                report_output = gr.File(
+                    label="📥 Descargar informe",
+                    interactive=False
+                )
+    
+    # Conectar la función principal
+    process_btn.click(
+        fn=process_complete_pipeline,
+        inputs=[
+            file_input,
+            models_input,
+            component_input,
+            use_de_input,
+            maxfev_input,
+            exp_names_input,
+            claude_model_input,
+            detail_level_input,
+            language_input,
+            additional_specs_input,
+            export_format_input
+        ],
+        outputs=[
+            plot_output,
+            table_output,
+            analysis_output,
+            code_output,
+            report_output,
+            status_output
+        ]
+    )
     
-    return interface
+    # Ejemplos
+    gr.Examples(
+        examples=[
+            [
+                "example_data.csv",
+                ['logistic', 'gompertz'],
+                'all',
+                False,
+                50000,
+                "Crecimiento bacteriano",
+                'claude-3-7-sonnet-20250219',
+                'detailed',
+                'es',
+                "Analizar el crecimiento bacteriano en diferentes condiciones de temperatura",
+                'PDF'
+            ]
+        ],
+        inputs=[
+            file_input,
+            models_input,
+            component_input,
+            use_de_input,
+            maxfev_input,
+            exp_names_input,
+            claude_model_input,
+            detail_level_input,
+            language_input,
+            additional_specs_input,
+            export_format_input
+        ]
+    )
+    
+    gr.Markdown(
+        """
+        ---
+        ### 📚 Instrucciones de uso:
+        
+        1. **Sube tu archivo de datos** en formato CSV o Excel
+        2. **Selecciona los modelos** que deseas probar para el ajuste
+        3. **Configura los parámetros** de análisis según tus necesidades
+        4. **Elige el modelo de Claude** para generar el informe
+        5. **Especifica el idioma y formato** de exportación deseado
+        6. **Haz clic en "Ejecutar Pipeline Completo"** y espera los resultados
+        
+        El sistema procesará tus datos, realizará el ajuste de modelos, generará un análisis 
+        detallado con IA y producirá un informe profesional descargable.
+        """
+    )
 
-# Lanzar la aplicación
 if __name__ == "__main__":
-    interface = create_interface()
-    interface.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
+    demo.launch(
         share=True,
-        show_error=True
+        show_error=True,
+        favicon_path="🧬"
     )