Update app.py

app.py

@@ -1,5 +1,4 @@
 import gradio as gr
-from openai import OpenAI
 import PyPDF2
 import pandas as pd
 import numpy as np
@@ -18,227 +17,218 @@ from docx import Document
 from docx.shared import Inches, Pt, RGBColor
 from docx.enum.text import WD_ALIGN_PARAGRAPH
 from reportlab.lib import colors
-from reportlab.lib.pagesizes import letter
-from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, PageBreak
+from reportlab.lib.pagesizes import letter, A4
+from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer, PageBreak
 from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
 from reportlab.lib.units import inch
+from reportlab.pdfbase import pdfmetrics
+from reportlab.pdfbase.ttfonts import TTFont
 import matplotlib.pyplot as plt
 from datetime import datetime
+from openai import OpenAI  # Replaced Anthropic with OpenAI for Qwen
 
-# --- Configuración para la API de Qwen ---
-
-# Configuración de Gradio
+# Configuración para HuggingFace
 os.environ['GRADIO_ANALYTICS_ENABLED'] = 'False'
 
-# Inicializar cliente OpenAI para apuntar a la API de Nebius (Qwen)
-try:
-    if "NEBIUS_API_KEY" not in os.environ:
-        print("⚠️ ADVERTENCIA: La variable de entorno NEBIUS_API_KEY no está configurada. El analizador no funcionará.")
-        client = None
-    else:
-        client = OpenAI(
-            base_url="https://api.studio.nebius.com/v1/",
-            api_key=os.environ.get("NEBIUS_API_KEY")
-        )
-except Exception as e:
-    print(f"Error al inicializar el cliente OpenAI para Nebius: {e}")
-    client = None
-
-# --- Sistema de Traducción Completo ---
+# Inicializar cliente Qwen
+client = OpenAI(
+    base_url="https://api.studio.nebius.com/v1/",
+    api_key=os.environ.get("NEBIUS_API_KEY")
+)
 
+# Sistema de traducción - Actualizado con nuevas entradas
 TRANSLATIONS = {
-'en': {
-'title': '🧬 Comparative Analyzer of Biotechnological Models',
-'subtitle': 'Specialized in comparative analysis of mathematical model fitting results',
-'upload_files': '📁 Upload fitting results (CSV/Excel)',
-'select_model': '🤖 Qwen Model',
-'select_language': '🌐 Language',
-'select_theme': '🎨 Theme',
-'detail_level': '📋 Analysis detail level',
-'detailed': 'Detailed',
-'summarized': 'Summarized',
-'analyze_button': '🚀 Analyze and Compare Models',
-'export_format': '📄 Export format',
-'export_button': '💾 Export Report',
-'comparative_analysis': '📊 Comparative Analysis',
-'implementation_code': '💻 Implementation Code',
-'data_format': '📋 Expected data format',
-'examples': '📚 Analysis examples',
-'light': 'Light',
-'dark': 'Dark',
-'best_for': 'Best for',
-'loading': 'Loading...',
-'error_no_api': 'Please configure NEBIUS_API_KEY in the environment variables or Space secrets',
-'error_no_files': 'Please upload fitting result files to analyze',
-'report_exported': 'Report exported successfully as',
-'specialized_in': '🎯 Specialized in:',
-'metrics_analyzed': '📊 Analyzed metrics:',
-'what_analyzes': '🔍 What it specifically analyzes:',
-'tips': '💡 Tips for better results:',
-'additional_specs': '📝 Additional specifications for analysis',
-'additional_specs_placeholder': 'Add any specific requirements or focus areas for the analysis...'
-},
-'es': {
-'title': '🧬 Analizador Comparativo de Modelos Biotecnológicos',
-'subtitle': 'Especializado en análisis comparativo de resultados de ajuste de modelos matemáticos',
-'upload_files': '📁 Subir resultados de ajuste (CSV/Excel)',
-'select_model': '🤖 Modelo Qwen',
-'select_language': '🌐 Idioma',
-'select_theme': '🎨 Tema',
-'detail_level': '📋 Nivel de detalle del análisis',
-'detailed': 'Detallado',
-'summarized': 'Resumido',
-'analyze_button': '🚀 Analizar y Comparar Modelos',
-'export_format': '📄 Formato de exportación',
-'export_button': '💾 Exportar Reporte',
-'comparative_analysis': '📊 Análisis Comparativo',
-'implementation_code': '💻 Código de Implementación',
-'data_format': '📋 Formato de datos esperado',
-'examples': '📚 Ejemplos de análisis',
-'light': 'Claro',
-'dark': 'Oscuro',
-'best_for': 'Mejor para',
-'loading': 'Cargando...',
-'error_no_api': 'Por favor configura NEBIUS_API_KEY en las variables de entorno o secretos del Space',
-'error_no_files': 'Por favor sube archivos con resultados de ajuste para analizar',
-'report_exported': 'Reporte exportado exitosamente como',
-'specialized_in': '🎯 Especializado en:',
-'metrics_analyzed': '📊 Métricas analizadas:',
-'what_analyzes': '🔍 Qué analiza específicamente:',
-'tips': '💡 Tips para mejores resultados:',
-'additional_specs': '📝 Especificaciones adicionales para el análisis',
-'additional_specs_placeholder': 'Agregue cualquier requerimiento específico o áreas de enfoque para el análisis...'
-},
-'fr': {
-'title': '🧬 Analyseur Comparatif de Modèles Biotechnologiques',
-'subtitle': 'Spécialisé dans l\'analyse comparative des résultats d\'ajustement',
-'upload_files': '📁 Télécharger les résultats (CSV/Excel)',
-'select_model': '🤖 Modèle Qwen',
-'select_language': '🌐 Langue',
-'select_theme': '🎨 Thème',
-'detail_level': '📋 Niveau de détail',
-'detailed': 'Détaillé',
-'summarized': 'Résumé',
-'analyze_button': '🚀 Analyser et Comparer',
-'export_format': '📄 Format d\'export',
-'export_button': '💾 Exporter le Rapport',
-'comparative_analysis': '📊 Analyse Comparative',
-'implementation_code': '💻 Code d\'Implémentation',
-'data_format': '📋 Format de données attendu',
-'examples': '📚 Exemples d\'analyse',
-'light': 'Clair',
-'dark': 'Sombre',
-'best_for': 'Meilleur pour',
-'loading': 'Chargement...',
-'error_no_api': 'Veuillez configurer NEBIUS_API_KEY',
-'error_no_files': 'Veuillez télécharger des fichiers à analyser',
-'report_exported': 'Rapport exporté avec succès comme',
-'specialized_in': '🎯 Spécialisé dans:',
-'metrics_analyzed': '📊 Métriques analysées:',
-'what_analyzes': '🔍 Ce qu\'il analyse spécifiquement:',
-'tips': '💡 Conseils pour de meilleurs résultats:',
-'additional_specs': '📝 Spécifications supplémentaires pour l\'analyse',
-'additional_specs_placeholder': 'Ajoutez des exigences spécifiques ou des domaines d\'intérêt pour l\'analyse...'
-},
-'de': {
-'title': '🧬 Vergleichender Analysator für Biotechnologische Modelle',
-'subtitle': 'Spezialisiert auf vergleichende Analyse von Modellanpassungsergebnissen',
-'upload_files': '📁 Ergebnisse hochladen (CSV/Excel)',
-'select_model': '🤖 Qwen Modell',
-'select_language': '🌐 Sprache',
-'select_theme': '🎨 Thema',
-'detail_level': '📋 Detailgrad der Analyse',
-'detailed': 'Detailliert',
-'summarized': 'Zusammengefasst',
-'analyze_button': '🚀 Analysieren und Vergleichen',
-'export_format': '📄 Exportformat',
-'export_button': '💾 Bericht Exportieren',
-'comparative_analysis': '📊 Vergleichende Analyse',
-'implementation_code': '💻 Implementierungscode',
-'data_format': '📋 Erwartetes Datenformat',
-'examples': '📚 Analysebeispiele',
-'light': 'Hell',
-'dark': 'Dunkel',
-'best_for': 'Am besten für',
-'loading': 'Laden...',
-'error_no_api': 'Bitte konfigurieren Sie NEBIUS_API_KEY',
-'error_no_files': 'Bitte laden Sie Dateien zur Analyse hoch',
-'report_exported': 'Bericht erfolgreich exportiert als',
-'specialized_in': '🎯 Spezialisiert auf:',
-'metrics_analyzed': '📊 Analysierte Metriken:',
-'what_analyzes': '🔍 Was spezifisch analysiert wird:',
-'tips': '💡 Tipps für bessere Ergebnisse:',
-'additional_specs': '📝 Zusätzliche Spezifikationen für die Analyse',
-'additional_specs_placeholder': 'Fügen Sie spezifische Anforderungen oder Schwerpunktbereiche für die Analyse hinzu...'
-},
-'pt': {
-'title': '🧬 Analisador Comparativo de Modelos Biotecnológicos',
-'subtitle': 'Especializado em análise comparativa de resultados de ajuste',
-'upload_files': '📁 Carregar resultados (CSV/Excel)',
-'select_model': '🤖 Modelo Qwen',
-'select_language': '🌐 Idioma',
-'select_theme': '🎨 Tema',
-'detail_level': '📋 Nível de detalhe',
-'detailed': 'Detalhado',
-'summarized': 'Resumido',
-'analyze_button': '🚀 Analisar e Comparar',
-'export_format': '📄 Formato de exportação',
-'export_button': '💾 Exportar Relatório',
-'comparative_analysis': '📊 Análise Comparativa',
-'implementation_code': '💻 Código de Implementação',
-'data_format': '📋 Formato de dados esperado',
-'examples': '📚 Exemplos de análise',
-'light': 'Claro',
-'dark': 'Escuro',
-'best_for': 'Melhor para',
-'loading': 'Carregando...',
-'error_no_api': 'Por favor configure NEBIUS_API_KEY',
-'error_no_files': 'Por favor carregue arquivos para analisar',
-'report_exported': 'Relatório exportado com sucesso como',
-'specialized_in': '🎯 Especializado em:',
-'metrics_analyzed': '📊 Métricas analisadas:',
-'what_analyzes': '🔍 O que analisa especificamente:',
-'tips': '💡 Dicas para melhores resultados:',
-'additional_specs': '📝 Especificações adicionais para a análise',
-'additional_specs_placeholder': 'Adicione requisitos específicos ou áreas de foco para a análise...'
-}
+    'en': {
+        'title': '🧬 Comparative Analyzer of Biotechnological Models',
+        'subtitle': 'Specialized in comparative analysis of mathematical model fitting results',
+        'upload_files': '📁 Upload fitting results (CSV/Excel)',
+        'select_model': '🤖 Qwen Model',
+        'select_language': '🌐 Language',
+        'select_theme': '🎨 Theme',
+        'detail_level': '📋 Analysis detail level',
+        'detailed': 'Detailed',
+        'summarized': 'Summarized',
+        'analyze_button': '🚀 Analyze and Compare Models',
+        'export_format': '📄 Export format',
+        'export_button': '💾 Export Report',
+        'comparative_analysis': '📊 Comparative Analysis',
+        'implementation_code': '💻 Implementation Code',
+        'data_format': '📋 Expected data format',
+        'examples': '📚 Analysis examples',
+        'light': 'Light',
+        'dark': 'Dark',
+        'best_for': 'Best for',
+        'loading': 'Loading...',
+        'error_no_api': 'Please configure NEBIUS_API_KEY in HuggingFace Space secrets',
+        'error_no_files': 'Please upload fitting result files to analyze',
+        'report_exported': 'Report exported successfully as',
+        'specialized_in': '🎯 Specialized in:',
+        'metrics_analyzed': '📊 Analyzed metrics:',
+        'what_analyzes': '🔍 What it specifically analyzes:',
+        'tips': '💡 Tips for better results:',
+        'additional_specs': '📝 Additional specifications for analysis',
+        'additional_specs_placeholder': 'Add any specific requirements or focus areas for the analysis...'
+    },
+    'es': {
+        'title': '🧬 Analizador Comparativo de Modelos Biotecnológicos',
+        'subtitle': 'Especializado en análisis comparativo de resultados de ajuste de modelos matemáticos',
+        'upload_files': '📁 Subir resultados de ajuste (CSV/Excel)',
+        'select_model': '🤖 Modelo Qwen',
+        'select_language': '🌐 Idioma',
+        'select_theme': '🎨 Tema',
+        'detail_level': '📋 Nivel de detalle del análisis',
+        'detailed': 'Detallado',
+        'summarized': 'Resumido',
+        'analyze_button': '🚀 Analizar y Comparar Modelos',
+        'export_format': '📄 Formato de exportación',
+        'export_button': '💾 Exportar Reporte',
+        'comparative_analysis': '📊 Análisis Comparativo',
+        'implementation_code': '💻 Código de Implementación',
+        'data_format': '📋 Formato de datos esperado',
+        'examples': '📚 Ejemplos de análisis',
+        'light': 'Claro',
+        'dark': 'Oscuro',
+        'best_for': 'Mejor para',
+        'loading': 'Cargando...',
+        'error_no_api': 'Por favor configura NEBIUS_API_KEY en los secretos del Space',
+        'error_no_files': 'Por favor sube archivos con resultados de ajuste para analizar',
+        'report_exported': 'Reporte exportado exitosamente como',
+        'specialized_in': '🎯 Especializado en:',
+        'metrics_analyzed': '📊 Métricas analizadas:',
+        'what_analyzes': '🔍 Qué analiza específicamente:',
+        'tips': '💡 Tips para mejores resultados:',
+        'additional_specs': '📝 Especificaciones adicionales para el análisis',
+        'additional_specs_placeholder': 'Agregue cualquier requerimiento específico o áreas de enfoque para el análisis...'
+    },
+    'fr': {
+        'title': '🧬 Analyseur Comparatif de Modèles Biotechnologiques',
+        'subtitle': 'Spécialisé dans l\'analyse comparative des résultats d\'ajustement',
+        'upload_files': '📁 Télécharger les résultats (CSV/Excel)',
+        'select_model': '🤖 Modèle Qwen',
+        'select_language': '🌐 Langue',
+        'select_theme': '🎨 Thème',
+        'detail_level': '📋 Niveau de détail',
+        'detailed': 'Détaillé',
+        'summarized': 'Résumé',
+        'analyze_button': '🚀 Analyser et Comparer',
+        'export_format': '📄 Format d\'export',
+        'export_button': '💾 Exporter le Rapport',
+        'comparative_analysis': '📊 Analyse Comparative',
+        'implementation_code': '💻 Code d\'Implémentation',
+        'data_format': '📋 Format de données attendu',
+        'examples': '📚 Exemples d\'analyse',
+        'light': 'Clair',
+        'dark': 'Sombre',
+        'best_for': 'Meilleur pour',
+        'loading': 'Chargement...',
+        'error_no_api': 'Veuillez configurer NEBIUS_API_KEY',
+        'error_no_files': 'Veuillez télécharger des fichiers à analyser',
+        'report_exported': 'Rapport exporté avec succès comme',
+        'specialized_in': '🎯 Spécialisé dans:',
+        'metrics_analyzed': '📊 Métriques analysées:',
+        'what_analyzes': '🔍 Ce qu\'il analyse spécifiquement:',
+        'tips': '💡 Conseils pour de meilleurs résultats:',
+        'additional_specs': '📝 Spécifications supplémentaires pour l\'analyse',
+        'additional_specs_placeholder': 'Ajoutez des exigences spécifiques ou des domaines d\'intérêt pour l\'analyse...'
+    },
+    'de': {
+        'title': '🧬 Vergleichender Analysator für Biotechnologische Modelle',
+        'subtitle': 'Spezialisiert auf vergleichende Analyse von Modellanpassungsergebnissen',
+        'upload_files': '📁 Ergebnisse hochladen (CSV/Excel)',
+        'select_model': '🤖 Qwen Modell',
+        'select_language': '🌐 Sprache',
+        'select_theme': '🎨 Thema',
+        'detail_level': '📋 Detailgrad der Analyse',
+        'detailed': 'Detailliert',
+        'summarized': 'Zusammengefasst',
+        'analyze_button': '🚀 Analysieren und Vergleichen',
+        'export_format': '📄 Exportformat',
+        'export_button': '💾 Bericht Exportieren',
+        'comparative_analysis': '📊 Vergleichende Analyse',
+        'implementation_code': '💻 Implementierungscode',
+        'data_format': '📋 Erwartetes Datenformat',
+        'examples': '📚 Analysebeispiele',
+        'light': 'Hell',
+        'dark': 'Dunkel',
+        'best_for': 'Am besten für',
+        'loading': 'Laden...',
+        'error_no_api': 'Bitte konfigurieren Sie NEBIUS_API_KEY',
+        'error_no_files': 'Bitte laden Sie Dateien zur Analyse hoch',
+        'report_exported': 'Bericht erfolgreich exportiert als',
+        'specialized_in': '🎯 Spezialisiert auf:',
+        'metrics_analyzed': '📊 Analysierte Metriken:',
+        'what_analyzes': '🔍 Was spezifisch analysiert wird:',
+        'tips': '💡 Tipps für bessere Ergebnisse:',
+        'additional_specs': '📝 Zusätzliche Spezifikationen für die Analyse',
+        'additional_specs_placeholder': 'Fügen Sie spezifische Anforderungen oder Schwerpunktbereiche für die Analyse hinzu...'
+    },
+    'pt': {
+        'title': '🧬 Analisador Comparativo de Modelos Biotecnológicos',
+        'subtitle': 'Especializado em análise comparativa de resultados de ajuste',
+        'upload_files': '📁 Carregar resultados (CSV/Excel)',
+        'select_model': '🤖 Modelo Qwen',
+        'select_language': '🌐 Idioma',
+        'select_theme': '🎨 Tema',
+        'detail_level': '📋 Nível de detalhe',
+        'detailed': 'Detalhado',
+        'summarized': 'Resumido',
+        'analyze_button': '🚀 Analisar e Comparar',
+        'export_format': '📄 Formato de exportação',
+        'export_button': '💾 Exportar Relatório',
+        'comparative_analysis': '📊 Análise Comparativa',
+        'implementation_code': '💻 Código de Implementação',
+        'data_format': '📋 Formato de dados esperado',
+        'examples': '📚 Exemplos de análise',
+        'light': 'Claro',
+        'dark': 'Escuro',
+        'best_for': 'Melhor para',
+        'loading': 'Carregando...',
+        'error_no_api': 'Por favor configure NEBIUS_API_KEY',
+        'error_no_files': 'Por favor carregue arquivos para analisar',
+        'report_exported': 'Relatório exportado com sucesso como',
+        'specialized_in': '🎯 Especializado em:',
+        'metrics_analyzed': '📊 Métricas analisadas:',
+        'what_analyzes': '🔍 O que analisa especificamente:',
+        'tips': '💡 Dicas para melhores resultados:',
+        'additional_specs': '📝 Especificações adicionais para a análise',
+        'additional_specs_placeholder': 'Adicione requisitos específicos ou áreas de foco para a análise...'
+    }
 }
 
-# --- Temas de la Interfaz ---
-
+# Temas disponibles
 THEMES = {
-'light': gr.themes.Soft(),
-'dark': gr.themes.Base(
-primary_hue="blue",
-secondary_hue="gray",
-neutral_hue="gray",
-font=["Arial", "sans-serif"]
-).set(
-body_background_fill="dark",
-body_background_fill_dark="*neutral_950",
-button_primary_background_fill="*primary_600",
-button_primary_background_fill_hover="*primary_500",
-button_primary_text_color="white",
-block_background_fill="*neutral_800",
-block_border_color="*neutral_700",
-block_label_text_color="*neutral_200",
-block_title_text_color="*neutral_100",
-checkbox_background_color="*neutral_700",
-checkbox_background_color_selected="*primary_600",
-input_background_fill="*neutral_700",
-input_border_color="*neutral_600",
-input_placeholder_color="*neutral_400"
-)
+    'light': gr.themes.Soft(),
+    'dark': gr.themes.Base(
+        primary_hue="blue",
+        secondary_hue="gray",
+        neutral_hue="gray",
+        font=["Arial", "sans-serif"]
+    ).set(
+        body_background_fill="dark",
+        body_background_fill_dark="*neutral_950",
+        button_primary_background_fill="*primary_600",
+        button_primary_background_fill_hover="*primary_500",
+        button_primary_text_color="white",
+        block_background_fill="*neutral_800",
+        block_border_color="*neutral_700",
+        block_label_text_color="*neutral_200",
+        block_title_text_color="*neutral_100",
+        checkbox_background_color="*neutral_700",
+        checkbox_background_color_selected="*primary_600",
+        input_background_fill="*neutral_700",
+        input_border_color="*neutral_600",
+        input_placeholder_color="*neutral_400"
+    )
 }
 
-# --- Clases de Datos y Estructuras ---
-
+# Enum para tipos de análisis
 class AnalysisType(Enum):
     MATHEMATICAL_MODEL = "mathematical_model"
     DATA_FITTING = "data_fitting"
     FITTING_RESULTS = "fitting_results"
     UNKNOWN = "unknown"
 
+# Estructura modular para modelos
 @dataclass
 class MathematicalModel:
     name: str
@@ -249,23 +239,29 @@ class MathematicalModel:
     category: str
     biological_meaning: str
 
+# Sistema de registro de modelos escalable
 class ModelRegistry:
     def __init__(self):
         self.models = {}
         self._initialize_default_models()
-
+    
     def register_model(self, model: MathematicalModel):
+        """Registra un nuevo modelo matemático"""
         if model.category not in self.models:
             self.models[model.category] = {}
         self.models[model.category][model.name] = model
-
-    def get_model(self, category: str, name: str) -> Optional[MathematicalModel]:
+    
+    def get_model(self, category: str, name: str) -> MathematicalModel:
+        """Obtiene un modelo específico"""
         return self.models.get(category, {}).get(name)
-
+    
     def get_all_models(self) -> Dict:
+        """Retorna todos los modelos registrados"""
         return self.models
-
+    
     def _initialize_default_models(self):
+        """Inicializa los modelos por defecto"""
+        # Modelos de crecimiento
         self.register_model(MathematicalModel(
             name="Monod",
             equation="μ = μmax × (S / (Ks + S))",
@@ -296,54 +292,70 @@ class ModelRegistry:
             biological_meaning="Incluye fase de adaptación (lag) seguida de crecimiento exponencial y estacionario"
         ))
 
+# Instancia global del registro
 model_registry = ModelRegistry()
 
+# Modelos de Qwen disponibles
 QWEN_MODELS = {
     "Qwen/Qwen3-14B": {
         "name": "Qwen 3 14B",
-        "description": "Modelo potente y versátil de la serie Qwen.",
-        "max_tokens": 4096,
-        "best_for": "Análisis complejos y generación de código detallado."
+        "description": "Modelo potente multilingüe de Alibaba",
+        "max_tokens": 4000,
+        "best_for": "Análisis complejos y detallados"
+    },
+    "Qwen/Qwen3-7B": {
+        "name": "Qwen 3 7B",
+        "description": "Modelo equilibrado para uso general",
+        "max_tokens": 4000,
+        "best_for": "Análisis rápidos y precisos"
+    },
+    "Qwen/Qwen1.5-14B": {
+        "name": "Qwen 1.5 14B",
+        "description": "Modelo avanzado para tareas complejas",
+        "max_tokens": 4000,
+        "best_for": "Análisis técnicos detallados"
     }
 }
 
-# --- Clases de Procesamiento y Exportación ---
-
 class FileProcessor:
+    """Clase para procesar diferentes tipos de archivos"""
+    
     @staticmethod
-    def extract_text_from_pdf(pdf_file: bytes) -> str:
+    def extract_text_from_pdf(pdf_file) -> str:
+        """Extrae texto de un archivo PDF"""
         try:
             pdf_reader = PyPDF2.PdfReader(io.BytesIO(pdf_file))
             text = ""
             for page in pdf_reader.pages:
-                page_text = page.extract_text()
-                if page_text:
-                    text += page_text + "\n"
+                text += page.extract_text() + "\n"
             return text
         except Exception as e:
             return f"Error reading PDF: {str(e)}"
-
+    
     @staticmethod
-    def read_csv(csv_file: bytes) -> Optional[pd.DataFrame]:
+    def read_csv(csv_file) -> pd.DataFrame:
+        """Lee archivo CSV"""
         try:
             return pd.read_csv(io.BytesIO(csv_file))
-        except Exception:
+        except Exception as e:
             return None
-
+    
     @staticmethod
-    def read_excel(excel_file: bytes) -> Optional[pd.DataFrame]:
+    def read_excel(excel_file) -> pd.DataFrame:
+        """Lee archivo Excel"""
         try:
             return pd.read_excel(io.BytesIO(excel_file))
-        except Exception:
+        except Exception as e:
             return None
-
+    
     @staticmethod
-    def extract_from_zip(zip_file: bytes) -> List[Tuple[str, bytes]]:
+    def extract_from_zip(zip_file) -> List[Tuple[str, bytes]]:
+        """Extrae archivos de un ZIP"""
         files = []
         try:
             with zipfile.ZipFile(io.BytesIO(zip_file), 'r') as zip_ref:
                 for file_name in zip_ref.namelist():
-                    if not file_name.startswith('__MACOSX') and not file_name.endswith('/'):
+                    if not file_name.startswith('__MACOSX'):
                         file_data = zip_ref.read(file_name)
                         files.append((file_name, file_data))
         except Exception as e:
@@ -351,65 +363,134 @@ class FileProcessor:
         return files
 
 class ReportExporter:
+    """Clase para exportar reportes a diferentes formatos"""
+    
     @staticmethod
     def export_to_docx(content: str, filename: str, language: str = 'en') -> str:
+        """Exporta el contenido a un archivo DOCX"""
         doc = Document()
+        
+        # Configurar estilos
         title_style = doc.styles['Title']
         title_style.font.size = Pt(24)
         title_style.font.bold = True
         
-        heading1_style = doc.styles['Heading 1']
-        heading1_style.font.size = Pt(18)
-        heading1_style.font.bold = True
+        heading_style = doc.styles['Heading 1']
+        heading_style.font.size = Pt(18)
+        heading_style.font.bold = True
+        
+        # Título
+        title_text = {
+            'en': 'Comparative Analysis Report - Biotechnological Models',
+            'es': 'Informe de Análisis Comparativo - Modelos Biotecnológicos',
+            'fr': 'Rapport d\'Analyse Comparative - Modèles Biotechnologiques',
+            'de': 'Vergleichsanalysebericht - Biotechnologische Modelle',
+            'pt': 'Relatório de Análise Comparativa - Modelos Biotecnológicos'
+        }
         
-        title_text = TRANSLATIONS[language]['title']
-        doc.add_heading(title_text, 0)
+        doc.add_heading(title_text.get(language, title_text['en']), 0)
         
-        date_text = {'en': 'Generated on', 'es': 'Generado el'}
+        # Fecha
+        date_text = {
+            'en': 'Generated on',
+            'es': 'Generado el',
+            'fr': 'Généré le',
+            'de': 'Erstellt am',
+            'pt': 'Gerado em'
+        }
         doc.add_paragraph(f"{date_text.get(language, date_text['en'])}: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
         doc.add_paragraph()
         
+        # Procesar contenido
         lines = content.split('\n')
+        current_paragraph = None
+        
         for line in lines:
             line = line.strip()
+            
             if line.startswith('###'):
-                doc.add_heading(line.replace('###', '').strip(), level=3)
+                doc.add_heading(line.replace('###', '').strip(), level=2)
             elif line.startswith('##'):
-                doc.add_heading(line.replace('##', '').strip(), level=2)
+                doc.add_heading(line.replace('##', '').strip(), level=1)
             elif line.startswith('#'):
-                doc.add_heading(line.replace('#', '').strip(), level=1)
+                doc.add_heading(line.replace('#', '').strip(), level=0)
             elif line.startswith('**') and line.endswith('**'):
+                # Texto en negrita
                 p = doc.add_paragraph()
-                p.add_run(line.replace('**', '')).bold = True
+                run = p.add_run(line.replace('**', ''))
+                run.bold = True
             elif line.startswith('- ') or line.startswith('* '):
+                # Lista
                 doc.add_paragraph(line[2:], style='List Bullet')
+            elif line.startswith(tuple('0123456789')):
+                # Lista numerada
+                doc.add_paragraph(line, style='List Number')
+            elif line == '---' or line.startswith('==='):
+                # Separador
+                doc.add_paragraph('_' * 50)
             elif line:
+                # Párrafo normal
                 doc.add_paragraph(line)
         
+        # Guardar documento
         doc.save(filename)
         return filename
-
+    
     @staticmethod
     def export_to_pdf(content: str, filename: str, language: str = 'en') -> str:
+        """Exporta el contenido a un archivo PDF"""
+        # Crear documento PDF
         doc = SimpleDocTemplate(filename, pagesize=letter)
         story = []
         styles = getSampleStyleSheet()
         
-        title_style = ParagraphStyle('CustomTitle', parent=styles['Title'], fontSize=24, textColor=colors.HexColor('#1f4788'), spaceAfter=20)
-        heading_style = ParagraphStyle('CustomHeading1', parent=styles['Heading1'], fontSize=16, textColor=colors.HexColor('#2e5090'), spaceAfter=12)
+        # Estilos personalizados
+        title_style = ParagraphStyle(
+            'CustomTitle',
+            parent=styles['Title'],
+            fontSize=24,
+            textColor=colors.HexColor('#1f4788'),
+            spaceAfter=30
+        )
+        
+        heading_style = ParagraphStyle(
+            'CustomHeading',
+            parent=styles['Heading1'],
+            fontSize=16,
+            textColor=colors.HexColor('#2e5090'),
+            spaceAfter=12
+        )
+        
+        # Título
+        title_text = {
+            'en': 'Comparative Analysis Report - Biotechnological Models',
+            'es': 'Informe de Análisis Comparativo - Modelos Biotecnológicos',
+            'fr': 'Rapport d\'Analyse Comparative - Modèles Biotechnologiques',
+            'de': 'Vergleichsanalysebericht - Biotechnologische Modelle',
+            'pt': 'Relatório de Análise Comparativa - Modelos Biotecnológicos'
+        }
         
-        title_text = TRANSLATIONS[language]['title']
-        story.append(Paragraph(title_text, title_style))
+        story.append(Paragraph(title_text.get(language, title_text['en']), title_style))
         
-        date_text = {'en': 'Generated on', 'es': 'Generado el'}
+        # Fecha
+        date_text = {
+            'en': 'Generated on',
+            'es': 'Generado el',
+            'fr': 'Généré le',
+            'de': 'Erstellt am',
+            'pt': 'Gerado em'
+        }
         story.append(Paragraph(f"{date_text.get(language, date_text['en'])}: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}", styles['Normal']))
-        story.append(Spacer(1, 0.3 * inch))
+        story.append(Spacer(1, 0.5*inch))
         
+        # Procesar contenido
         lines = content.split('\n')
+        
         for line in lines:
             line = line.strip()
+            
             if not line:
-                continue
+                story.append(Spacer(1, 0.2*inch))
             elif line.startswith('###'):
                 story.append(Paragraph(line.replace('###', '').strip(), styles['Heading3']))
             elif line.startswith('##'):
@@ -417,206 +498,737 @@ class ReportExporter:
             elif line.startswith('#'):
                 story.append(Paragraph(line.replace('#', '').strip(), heading_style))
             elif line.startswith('**') and line.endswith('**'):
-                story.append(Paragraph(f"<b>{line.replace('**', '')}</b>", styles['Normal']))
+                text = line.replace('**', '')
+                story.append(Paragraph(f"<b>{text}</b>", styles['Normal']))
             elif line.startswith('- ') or line.startswith('* '):
-                story.append(Paragraph(f"• {line[2:]}", styles['Normal'], bulletText='•'))
+                story.append(Paragraph(f"• {line[2:]}", styles['Normal']))
+            elif line == '---' or line.startswith('==='):
+                story.append(Spacer(1, 0.3*inch))
+                story.append(Paragraph("_" * 70, styles['Normal']))
+                story.append(Spacer(1, 0.3*inch))
             else:
-                # Limpiar caracteres que pueden dar problemas en ReportLab
-                clean_line = line.replace('🧬', '[DNA]').replace('🤖', '[BOT]').replace('📁', '[FILE]').replace('🚀', '[ROCKET]').replace('📊', '[GRAPH]').replace('💻', '[CODE]').replace('💾', '[SAVE]').replace('🎯', '[TARGET]').replace('🔍', '[SEARCH]').replace('💡', '[TIP]')
+                # Limpiar caracteres especiales para PDF
+                clean_line = line.replace('📊', '[GRAPH]').replace('🎯', '[TARGET]').replace('🔍', '[SEARCH]').replace('💡', '[TIP]')
                 story.append(Paragraph(clean_line, styles['Normal']))
-            story.append(Spacer(1, 0.1 * inch))
         
+        # Construir PDF
         doc.build(story)
         return filename
 
-# --- Clase del Analizador de IA con Qwen ---
-
 class AIAnalyzer:
+    """Clase para análisis con IA usando Qwen"""
+    
     def __init__(self, client, model_registry):
         self.client = client
         self.model_registry = model_registry
-
+    
+    def detect_analysis_type(self, content: Union[str, pd.DataFrame]) -> AnalysisType:
+        """Detecta el tipo de análisis necesario"""
+        if isinstance(content, pd.DataFrame):
+            columns = [col.lower() for col in content.columns]
+            
+            fitting_indicators = [
+                'r2', 'r_squared', 'rmse', 'mse', 'aic', 'bic', 
+                'parameter', 'param', 'coefficient', 'fit',
+                'model', 'equation', 'goodness', 'chi_square',
+                'p_value', 'confidence', 'standard_error', 'se'
+            ]
+            
+            has_fitting_results = any(indicator in ' '.join(columns) for indicator in fitting_indicators)
+            
+            if has_fitting_results:
+                return AnalysisType.FITTING_RESULTS
+            else:
+                return AnalysisType.DATA_FITTING
+        
+        prompt = """
+        Analyze this content and determine if it is:
+        1. A scientific article describing biotechnological mathematical models
+        2. Experimental data for parameter fitting  
+        3. Model fitting results (with parameters, R², RMSE, etc.)
+        
+        Reply only with: "MODEL", "DATA" or "RESULTS"
+        """
+        
+        try:
+            response = self.client.chat.completions.create(
+                model="Qwen/Qwen3-14B",
+                max_tokens=10,
+                temperature=0.0,
+                messages=[{"role": "user", "content": f"{prompt}\n\n{content[:1000]}"}]
+            )
+            
+            result = response.choices[0].message.content.strip().upper()
+            if "MODEL" in result:
+                return AnalysisType.MATHEMATICAL_MODEL
+            elif "RESULTS" in result:
+                return AnalysisType.FITTING_RESULTS
+            elif "DATA" in result:
+                return AnalysisType.DATA_FITTING
+            else:
+                return AnalysisType.UNKNOWN
+                
+        except Exception as e:
+            print(f"Error en detección de tipo: {str(e)}")
+            return AnalysisType.UNKNOWN
+    
     def get_language_prompt_prefix(self, language: str) -> str:
-        return TRANSLATIONS.get(language, TRANSLATIONS['en']).get('response_prefix', f"Please respond in {language}. ")
-
-    def analyze_fitting_results(self, data: pd.DataFrame, qwen_model: str, detail_level: str, language: str, additional_specs: str) -> Dict:
-        if self.client is None:
-            return {"error": "AI client not initialized. Check NEBIUS_API_KEY."}
-
-        data_summary = f"FITTING RESULTS DATA:\n- Columns: {list(data.columns)}\n- Number of models/entries: {len(data)}\n- Full Data:\n{data.to_string()}"
+        """Obtiene el prefijo del prompt según el idioma"""
+        prefixes = {
+            'en': "Please respond in English. ",
+            'es': "Por favor responde en español. ",
+            'fr': "Veuillez répondre en français. ",
+            'de': "Bitte antworten Sie auf Deutsch. ",
+            'pt': "Por favor responda em português. "
+        }
+        return prefixes.get(language, prefixes['en'])
+    
+    def analyze_fitting_results(self, data: pd.DataFrame, qwen_model: str, detail_level: str = "detailed", 
+                              language: str = "en", additional_specs: str = "") -> Dict:
+        """Analiza resultados de ajuste de modelos usando Qwen"""
+        
+        # Preparar resumen completo de los datos
+        data_summary = f"""
+        FITTING RESULTS DATA:
+        
+        Data structure:
+        - Columns: {list(data.columns)}
+        - Number of models evaluated: {len(data)}
+        
+        Complete data:
+        {data.to_string()}
+        
+        Descriptive statistics:
+        {data.describe().to_string()}
+        """
+        
+        # Extraer valores para usar en el código
+        data_dict = data.to_dict('records')
+        
+        # Obtener prefijo de idioma
         lang_prefix = self.get_language_prompt_prefix(language)
-        user_specs_section = f"\nADDITIONAL USER SPECIFICATIONS: {additional_specs}\n" if additional_specs else ""
         
+        # Agregar especificaciones adicionales del usuario si existen
+        user_specs_section = f"""
+        
+        USER ADDITIONAL SPECIFICATIONS:
+        {additional_specs}
+        
+        Please ensure to address these specific requirements in your analysis.
+        """ if additional_specs else ""
+        
+        # Prompt mejorado con instrucciones específicas para cada nivel
         if detail_level == "detailed":
-            prompt = f"""{lang_prefix}{user_specs_section}
-            You are an expert biotechnologist and data scientist. Analyze the provided model fitting results in detail.
-            1.  **Overall Summary:** Briefly describe the dataset (number of experiments, models, metrics).
-            2.  **Analysis by Experiment/Condition:** For each unique experiment/condition found in the data:
-                - Identify the best performing model for each category (e.g., Biomass, Substrate, Product) based on R2 (higher is better) and RMSE (lower is better).
-                - List the best model's name, its key metrics (R2, RMSE), and its fitted parameters.
-                - Provide a brief biological interpretation of the parameters for the best model in that context.
-            3.  **Overall Best Models:** Identify the most robust models across all experiments for each category. Justify your choice (e.g., "Model X was best in 3 out of 4 experiments").
-            4.  **Parameter Trends:** If possible, comment on how key parameters (like μmax, Ks) change across different experimental conditions.
-            5.  **Conclusion and Recommendations:** Summarize the findings and recommend which models to use for future predictions under specific conditions.
-            Format the entire response using clear Markdown headers, lists, and bold text."""
-        else: # summarized
-            prompt = f"""{lang_prefix}{user_specs_section}
-            You are an expert biotechnologist. Provide a concise, summarized analysis of the provided model fitting results.
-            1.  **Best Models Summary Table:** Create a table that shows the best model for each Experiment and Type (Biomass, Substrate, etc.) along with its R2 value.
-            2.  **Overall Winners:** State the single best model for Biomass, Substrate, and Product across all experiments.
-            3.  **Key Insights:** In 2-3 bullet points, what are the most important findings? (e.g., "Gompertz model consistently outperforms others for biomass.", "μmax is highest at pH 7.5.").
-            Format as a brief and clear Markdown report."""
-
+            prompt = f"""
+            {lang_prefix}
+            
+            You are an expert in biotechnology and mathematical modeling. Analyze these kinetic/biotechnological model fitting results.
+            
+            {user_specs_section}
+            
+            DETAIL LEVEL: DETAILED - Provide comprehensive analysis BY EXPERIMENT
+            
+            PERFORM A COMPREHENSIVE COMPARATIVE ANALYSIS PER EXPERIMENT:
+            
+            1. **EXPERIMENT IDENTIFICATION AND OVERVIEW**
+               - List ALL experiments/conditions tested (e.g., pH levels, temperatures, time points)
+               - For EACH experiment, identify:
+                 * Experimental conditions
+                 * Number of models tested
+                 * Variables measured (biomass, substrate, product)
+            
+            2. **MODEL IDENTIFICATION AND CLASSIFICATION BY EXPERIMENT**
+               For EACH EXPERIMENT separately:
+               - Identify ALL fitted mathematical models BY NAME
+               - Classify them: biomass growth, substrate consumption, product formation
+               - Show the mathematical equation of each model
+               - List parameter values obtained for that specific experiment
+            
+            3. **COMPARATIVE ANALYSIS PER EXPERIMENT**
+               Create a section for EACH EXPERIMENT showing:
+               
+               **EXPERIMENT [Name/Condition]:**
+               
+               a) **BIOMASS MODELS** (if applicable):
+                  - Best model: [Name] with R²=[value], RMSE=[value]
+                  - Parameters: μmax=[value], Xmax=[value], etc.
+                  - Ranking of all biomass models tested
+                  
+               b) **SUBSTRATE MODELS** (if applicable):
+                  - Best model: [Name] with R²=[value], RMSE=[value]
+                  - Parameters: Ks=[value], Yxs=[value], etc.
+                  - Ranking of all substrate models tested
+                  
+               c) **PRODUCT MODELS** (if applicable):
+                  - Best model: [Name] with R²=[value], RMSE=[value]
+                  - Parameters: α=[value], β=[value], etc.
+                  - Ranking of all product models tested
+            
+            4. **DETAILED COMPARATIVE TABLES**
+               
+               **Table 1: Summary by Experiment and Variable Type**
+               | Experiment | Variable | Best Model | R² | RMSE | Key Parameters | Ranking |
+               |------------|----------|------------|-------|------|----------------|---------|
+               | Exp1       | Biomass  | [Name]     | [val] | [val]| μmax=X         | 1       |
+               | Exp1       | Substrate| [Name]     | [val] | [val]| Ks=Y           | 1       |
+               | Exp1       | Product  | [Name]     | [val] | [val]| α=Z            | 1       |
+               | Exp2       | Biomass  | [Name]     | [val] | [val]| μmax=X2        | 1       |
+               
+               **Table 2: Complete Model Comparison Across All Experiments**
+               | Model Name | Type | Exp1_R² | Exp1_RMSE | Exp2_R² | Exp2_RMSE | Avg_R² | Best_For |
+            
+            5. **PARAMETER ANALYSIS ACROSS EXPERIMENTS**
+               - Compare how parameters change between experiments
+               - Identify trends (e.g., μmax increases with temperature)
+               - Calculate average parameters and variability
+               - Suggest optimal conditions based on parameters
+            
+            6. **BIOLOGICAL INTERPRETATION BY EXPERIMENT**
+               For each experiment, explain:
+               - What the parameter values mean biologically
+               - Whether values are realistic for the conditions
+               - Key differences between experiments
+               - Critical control parameters identified
+            
+            7. **OVERALL BEST MODELS DETERMINATION**
+               - **BEST BIOMASS MODEL OVERALL**: [Name] - performs best in [X] out of [Y] experiments
+               - **BEST SUBSTRATE MODEL OVERALL**: [Name] - average R²=[value]
+               - **BEST PRODUCT MODEL OVERALL**: [Name] - most consistent across conditions
+               
+               Justify with numerical evidence from multiple experiments.
+            
+            8. **CONCLUSIONS AND RECOMMENDATIONS**
+               - Which models are most robust across different conditions
+               - Specific models to use for each experimental condition
+               - Confidence intervals and prediction reliability
+               - Scale-up recommendations with specific values
+            
+            Use Markdown format with clear structure. Include ALL numerical values from the data.
+            Create clear sections for EACH EXPERIMENT.
+            """
+        else:  # summarized
+            prompt = f"""
+            {lang_prefix}
+            
+            You are an expert in biotechnology. Provide a CONCISE but COMPLETE analysis BY EXPERIMENT.
+            
+            {user_specs_section}
+            
+            DETAIL LEVEL: SUMMARIZED - Be concise but include all experiments and essential information
+            
+            PROVIDE A FOCUSED COMPARATIVE ANALYSIS:
+            
+            1. **EXPERIMENTS OVERVIEW**
+               - Total experiments analyzed: [number]
+               - Conditions tested: [list]
+               - Variables measured: biomass/substrate/product
+            
+            2. **BEST MODELS BY EXPERIMENT - QUICK SUMMARY**
+               
+               📊 **EXPERIMENT 1 [Name/Condition]:**
+               - Biomass: [Model] (R²=[value])
+               - Substrate: [Model] (R²=[value])  
+               - Product: [Model] (R²=[value])
+               
+               📊 **EXPERIMENT 2 [Name/Condition]:**
+               - Biomass: [Model] (R²=[value])
+               - Substrate: [Model] (R²=[value])
+               - Product: [Model] (R²=[value])
+               
+               [Continue for all experiments...]
+            
+            3. **OVERALL WINNERS ACROSS ALL EXPERIMENTS**
+               🏆 **Best Models Overall:**
+               - **Biomass**: [Model] - Best in [X]/[Y] experiments
+               - **Substrate**: [Model] - Average R²=[value]
+               - **Product**: [Model] - Most consistent performance
+            
+            4. **QUICK COMPARISON TABLE**
+               | Experiment | Best Biomass | Best Substrate | Best Product | Overall R² |
+               |------------|--------------|----------------|--------------|------------|
+               | Exp1       | [Model]      | [Model]        | [Model]      | [avg]      |
+               | Exp2       | [Model]      | [Model]        | [Model]      | [avg]      |
+            
+            5. **KEY FINDINGS**
+               - Parameter ranges across experiments: μmax=[min-max], Ks=[min-max]
+               - Best conditions identified: [specific values]
+               - Most robust models: [list with reasons]
+            
+            6. **PRACTICAL RECOMMENDATIONS**
+               - For biomass prediction: Use [Model]
+               - For substrate monitoring: Use [Model]
+               - For product estimation: Use [Model]
+               - Critical parameters: [list with values]
+            
+            Keep it concise but include ALL experiments and model names with their key metrics.
+            """
+        
         try:
             # Análisis principal
-            analysis_response = self.client.chat.completions.create(
+            response = self.client.chat.completions.create(
                 model=qwen_model,
-                messages=[{"role": "user", "content": f"{prompt}\n\n{data_summary}"}],
                 max_tokens=4000,
-                temperature=0.6,
-                top_p=0.95
+                temperature=0.3,
+                messages=[{
+                    "role": "user",
+                    "content": f"{prompt}\n\n{data_summary}"
+                }]
             )
-            analysis_text = analysis_response.choices[0].message.content
-
+            
+            analysis_result = response.choices[0].message.content
+            
             # Generación de código
-            code_prompt = f"""{lang_prefix}
-            Based on the provided data, generate a single, complete, and executable Python script for analysis.
-            The script must:
-            1.  Contain the provided data hardcoded into a pandas DataFrame.
-            2.  Define functions to analyze the data to find the best model per experiment and type.
-            3.  Include functions to create visualizations using matplotlib or seaborn, such as:
-                - A bar chart comparing the R2 values of the best models across experiments.
-                - A summary table of the best models.
-            4.  Have a `if __name__ == "__main__":` block that runs the analysis and shows the plots.
-            The code should be well-commented and self-contained."""
+            code_prompt = f"""
+            {lang_prefix}
+            
+            Based on the analysis and this actual data:
+            {data.to_string()}
+            
+            Generate Python code that:
+            
+            1. Creates a complete analysis system with the ACTUAL NUMERICAL VALUES from the data
+            2. Implements analysis BY EXPERIMENT showing:
+               - Best models for each experiment
+               - Comparison across experiments
+               - Parameter evolution between conditions
+            3. Includes visualization functions that:
+               - Show results PER EXPERIMENT
+               - Compare models across experiments
+               - Display parameter trends
+            4. Shows the best model for biomass, substrate, and product separately
+            
+            The code must include:
+            - Data loading with experiment identification
+            - Model comparison by experiment and variable type
+            - Visualization showing results per experiment
+            - Overall best model selection with justification
+            - Functions to predict using the best models for each category
+            
+            Make sure to include comments indicating which model won for each variable type and why.
+            
+            Format: Complete, executable Python code with actual data values embedded.
+            """
             
             code_response = self.client.chat.completions.create(
                 model=qwen_model,
-                messages=[{"role": "user", "content": f"{code_prompt}\n\n{data_summary}"}],
-                max_tokens=3500,
-                temperature=0.4, # Más determinista para código
-                top_p=0.95
+                max_tokens=3000,
+                temperature=0.1,
+                messages=[{
+                    "role": "user",
+                    "content": code_prompt
+                }]
             )
-            code_text = code_response.choices[0].message.content
-
+            
+            code_result = code_response.choices[0].message.content
+            
             return {
-                "analisis_completo": analysis_text,
-                "codigo_implementacion": code_text,
+                "tipo": "Comparative Analysis of Mathematical Models",
+                "analisis_completo": analysis_result,
+                "codigo_implementacion": code_result,
+                "resumen_datos": {
+                    "n_modelos": len(data),
+                    "columnas": list(data.columns),
+                    "metricas_disponibles": [col for col in data.columns if any(metric in col.lower() 
+                                           for metric in ['r2', 'rmse', 'aic', 'bic', 'mse'])],
+                    "mejor_r2": data['R2'].max() if 'R2' in data.columns else None,
+                    "mejor_modelo_r2": data.loc[data['R2'].idxmax()]['Model'] if 'R2' in data.columns and 'Model' in data.columns else None,
+                    "datos_completos": data_dict  # Incluir todos los datos para el código
+                }
             }
+            
         except Exception as e:
-            return {"error": f"An error occurred with the AI API: {str(e)}"}
-
-# --- Lógica de la Aplicación ---
-
-def process_files(files, model_name: str, detail_level: str, language: str, additional_specs: str) -> Tuple[str, str]:
-    if not files:
-        return TRANSLATIONS[language]['error_no_files'], "Please upload files first."
-    if client is None:
-        return TRANSLATIONS[language]['error_no_api'], "AI client is not configured."
+            print(f"Error en análisis: {str(e)}")
+            return {"error": str(e)}
 
+def process_files(files, qwen_model: str, detail_level: str = "detailed", 
+                 language: str = "en", additional_specs: str = "") -> Tuple[str, str]:
+    """Procesa múltiples archivos usando Qwen"""
+    processor = FileProcessor()
     analyzer = AIAnalyzer(client, model_registry)
-    all_analysis_parts = []
-    all_code_parts = []
-
+    results = []
+    all_code = []
+    
     for file in files:
-        try:
-            with open(file.name, 'rb') as f:
-                file_content = f.read()
+        if file is None:
+            continue
+            
+        file_name = file.name if hasattr(file, 'name') else "archivo"
+        file_ext = Path(file_name).suffix.lower()
+        
+        with open(file.name, 'rb') as f:
+            file_content = f.read()
+        
+        if file_ext in ['.csv', '.xlsx', '.xls']:
+            if language == 'es':
+                results.append(f"## 📊 Análisis de Resultados: {file_name}")
+            else:
+                results.append(f"## 📊 Results Analysis: {file_name}")
             
-            file_name = os.path.basename(file.name)
-            file_ext = Path(file_name).suffix.lower()
-            df = None
-
             if file_ext == '.csv':
-                df = FileProcessor.read_csv(file_content)
-            elif file_ext in ['.xlsx', '.xls']:
-                df = FileProcessor.read_excel(file_content)
+                df = processor.read_csv(file_content)
+            else:
+                df = processor.read_excel(file_content)
             
             if df is not None:
-                all_analysis_parts.append(f"# Analysis for: {file_name}")
-                result = analyzer.analyze_fitting_results(df, model_name, detail_level, language, additional_specs)
+                analysis_type = analyzer.detect_analysis_type(df)
                 
-                if "error" in result:
-                    all_analysis_parts.append(f"An error occurred: {result['error']}")
-                else:
-                    all_analysis_parts.append(result.get("analisis_completo", "No analysis generated."))
-                    all_code_parts.append(f"# Code generated from: {file_name}\n{result.get('codigo_implementacion', '# No code generated.')}")
-            else:
-                 all_analysis_parts.append(f"# Could not process file: {file_name}")
-        except Exception as e:
-            all_analysis_parts.append(f"# Error processing {file.name}: {str(e)}")
-
-    final_analysis = "\n\n---\n\n".join(all_analysis_parts)
-    final_code = "\n\n" + "="*80 + "\n\n".join(all_code_parts) if all_code_parts else generate_implementation_code(final_analysis)
+                if analysis_type == AnalysisType.FITTING_RESULTS:
+                    result = analyzer.analyze_fitting_results(
+                        df, qwen_model, detail_level, language, additional_specs
+                    )
+                    
+                    if language == 'es':
+                        results.append("### 🎯 ANÁLISIS COMPARATIVO DE MODELOS MATEMÁTICOS")
+                    else:
+                        results.append("### 🎯 COMPARATIVE ANALYSIS OF MATHEMATICAL MODELS")
+                    
+                    results.append(result.get("analisis_completo", ""))
+                    if "codigo_implementacion" in result:
+                        all_code.append(result["codigo_implementacion"])
+        
+        results.append("\n---\n")
     
-    return final_analysis, final_code
-
+    analysis_text = "\n".join(results)
+    code_text = "\n\n# " + "="*50 + "\n\n".join(all_code) if all_code else generate_implementation_code(analysis_text)
+    
+    return analysis_text, code_text
 
 def generate_implementation_code(analysis_results: str) -> str:
-    # This is a fallback in case the API fails to generate code.
-    # It provides a generic template.
-    return """
+    """Genera código de implementación con análisis por experimento"""
+    code = """
+import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
+from scipy.integrate import odeint
+from scipy.optimize import curve_fit, differential_evolution
+from sklearn.metrics import r2_score, mean_squared_error
 import seaborn as sns
+from typing import Dict, List, Tuple, Optional
 
-def analyze_data(df):
+# Visualization configuration
+plt.style.use('seaborn-v0_8-darkgrid')
+sns.set_palette("husl")
+
+class ExperimentalModelAnalyzer:
     \"\"\"
-    Analyzes the dataframe to find the best model per experiment and type.
-    This is a template function. You may need to adapt it to your specific column names.
+    Class for comparative analysis of biotechnological models across multiple experiments.
+    Analyzes biomass, substrate and product models separately for each experimental condition.
     \"\"\"
-    # Assuming columns 'Experiment', 'Type', 'R2', 'Model' exist
-    if not all(col in df.columns for col in ['Experiment', 'Type', 'R2', 'Model']):
-        print("DataFrame is missing required columns: 'Experiment', 'Type', 'R2', 'Model'")
-        return None
+    
+    def __init__(self):
+        self.results_df = None
+        self.experiments = {}
+        self.best_models_by_experiment = {}
+        self.overall_best_models = {
+            'biomass': None,
+            'substrate': None,
+            'product': None
+        }
+        
+    def load_results(self, file_path: str = None, data_dict: dict = None) -> pd.DataFrame:
+        \"\"\"Load fitting results from CSV/Excel file or dictionary\"\"\"
+        if data_dict:
+            self.results_df = pd.DataFrame(data_dict)
+        elif file_path:
+            if file_path.endswith('.csv'):
+                self.results_df = pd.read_csv(file_path)
+            else:
+                self.results_df = pd.read_excel(file_path)
+        
+        print(f"✅ Data loaded: {len(self.results_df)} models")
+        print(f"📊 Available columns: {list(self.results_df.columns)}")
+        
+        # Identify experiments
+        if 'Experiment' in self.results_df.columns:
+            self.experiments = self.results_df.groupby('Experiment').groups
+            print(f"🧪 Experiments found: {list(self.experiments.keys())}")
         
-    # Find the index of the max R2 for each group
-    best_models_idx = df.loc[df.groupby(['Experiment', 'Type'])['R2'].idxmax()]
+        return self.results_df
     
-    print("--- Best Models by Experiment and Type ---")
-    print(best_models_idx[['Experiment', 'Type', 'Model', 'R2']].to_string(index=False))
-    return best_models_idx
-
-def visualize_results(best_models_df):
-    \"\"\"
-    Creates a bar plot to visualize the R2 scores of the best models.
-    \"\"\"
-    if best_models_df is None:
-        print("Cannot visualize results. Analysis failed.")
-        return
-
-    plt.figure(figsize=(12, 7))
-    sns.barplot(data=best_models_df, x='Experiment', y='R2', hue='Type', palette='viridis')
-    
-    plt.title('Best Model Performance (R²) by Experiment and Type', fontsize=16)
-    plt.xlabel('Experiment', fontsize=12)
-    plt.ylabel('R² Score', fontsize=12)
-    plt.xticks(rotation=45, ha='right')
-    plt.ylim(bottom=max(0, best_models_df['R2'].min() - 0.05), top=1.0)
-    plt.legend(title='Variable Type')
-    plt.tight_layout()
-    plt.show()
+    def analyze_by_experiment(self, 
+                            experiment_col: str = 'Experiment',
+                            model_col: str = 'Model',
+                            type_col: str = 'Type',
+                            r2_col: str = 'R2',
+                            rmse_col: str = 'RMSE') -> Dict:
+        \"\"\"
+        Analyze models by experiment and variable type.
+        Identifies best models for biomass, substrate, and product in each experiment.
+        \"\"\"
+        if self.results_df is None:
+            raise ValueError("First load data with load_results()")
+        
+        results_by_exp = {}
+        
+        # Get unique experiments
+        if experiment_col in self.results_df.columns:
+            experiments = self.results_df[experiment_col].unique()
+        else:
+            experiments = ['All_Data']
+            self.results_df[experiment_col] = 'All_Data'
+        
+        print("\\n" + "="*80)
+        print("📊 ANALYSIS BY EXPERIMENT AND VARIABLE TYPE")
+        print("="*80)
+        
+        for exp in experiments:
+            print(f"\\n🧪 EXPERIMENT: {exp}")
+            print("-"*50)
+            
+            exp_data = self.results_df[self.results_df[experiment_col] == exp]
+            results_by_exp[exp] = {}
+            
+            # Analyze by variable type if available
+            if type_col in exp_data.columns:
+                var_types = exp_data[type_col].unique()
+                
+                for var_type in var_types:
+                    var_data = exp_data[exp_data[type_col] == var_type]
+                    
+                    if not var_data.empty:
+                        # Find best model for this variable type
+                        best_idx = var_data[r2_col].idxmax()
+                        best_model = var_data.loc[best_idx]
+                        
+                        results_by_exp[exp][var_type] = {
+                            'best_model': best_model[model_col],
+                            'r2': best_model[r2_col],
+                            'rmse': best_model[rmse_col],
+                            'all_models': var_data[[model_col, r2_col, rmse_col]].to_dict('records')
+                        }
+                        
+                        print(f"\\n  📈 {var_type.upper()}:")
+                        print(f"    Best Model: {best_model[model_col]}")
+                        print(f"    R² = {best_model[r2_col]:.4f}")
+                        print(f"    RMSE = {best_model[rmse_col]:.4f}")
+                        
+                        # Show all models for this variable
+                        print(f"\\n    All {var_type} models tested:")
+                        for _, row in var_data.iterrows():
+                            print(f"      - {row[model_col]}: R²={row[r2_col]:.4f}, RMSE={row[rmse_col]:.4f}")
+            else:
+                # If no type column, analyze all models together
+                best_idx = exp_data[r2_col].idxmax()
+                best_model = exp_data.loc[best_idx]
+                
+                results_by_exp[exp]['all'] = {
+                    'best_model': best_model[model_col],
+                    'r2': best_model[r2_col],
+                    'rmse': best_model[rmse_col],
+                    'all_models': exp_data[[model_col, r2_col, rmse_col]].to_dict('records')
+                }
+        
+        self.best_models_by_experiment = results_by_exp
+        
+        # Determine overall best models
+        self._determine_overall_best_models()
+        
+        return results_by_exp
+    
+    def _determine_overall_best_models(self):
+        \"\"\"Determine the best models across all experiments\"\"\"
+        print("\\n" + "="*80)
+        print("🏆 OVERALL BEST MODELS ACROSS ALL EXPERIMENTS")
+        print("="*80)
+        
+        # Aggregate performance by model and type
+        model_performance = {}
+        
+        for exp, exp_results in self.best_models_by_experiment.items():
+            for var_type, var_results in exp_results.items():
+                if var_type not in model_performance:
+                    model_performance[var_type] = {}
+                
+                for model_data in var_results['all_models']:
+                    model_name = model_data['Model']
+                    if model_name not in model_performance[var_type]:
+                        model_performance[var_type][model_name] = {
+                            'r2_values': [],
+                            'rmse_values': [],
+                            'experiments': []
+                        }
+                    
+                    model_performance[var_type][model_name]['r2_values'].append(model_data['R2'])
+                    model_performance[var_type][model_name]['rmse_values'].append(model_data['RMSE'])
+                    model_performance[var_type][model_name]['experiments'].append(exp)
+        
+        # Calculate average performance and select best
+        for var_type, models in model_performance.items():
+            best_avg_r2 = -1
+            best_model = None
+            
+            print(f"\\n📊 {var_type.upper()} MODELS:")
+            for model_name, perf_data in models.items():
+                avg_r2 = np.mean(perf_data['r2_values'])
+                avg_rmse = np.mean(perf_data['rmse_values'])
+                n_exp = len(perf_data['experiments'])
+                
+                print(f"  {model_name}:")
+                print(f"    Average R² = {avg_r2:.4f}")
+                print(f"    Average RMSE = {avg_rmse:.4f}")
+                print(f"    Tested in {n_exp} experiments")
+                
+                if avg_r2 > best_avg_r2:
+                    best_avg_r2 = avg_r2
+                    best_model = {
+                        'name': model_name,
+                        'avg_r2': avg_r2,
+                        'avg_rmse': avg_rmse,
+                        'n_experiments': n_exp
+                    }
+            
+            if var_type.lower() in ['biomass', 'substrate', 'product']:
+                self.overall_best_models[var_type.lower()] = best_model
+                print(f"\\n  🏆 BEST {var_type.upper()} MODEL: {best_model['name']} (Avg R²={best_model['avg_r2']:.4f})")
+    
+    def create_comparison_visualizations(self):
+        \"\"\"Create visualizations comparing models across experiments\"\"\"
+        if not self.best_models_by_experiment:
+            raise ValueError("First run analyze_by_experiment()")
+        
+        # Prepare data for visualization
+        experiments = []
+        biomass_r2 = []
+        substrate_r2 = []
+        product_r2 = []
+        
+        for exp, results in self.best_models_by_experiment.items():
+            experiments.append(exp)
+            biomass_r2.append(results.get('Biomass', {}).get('r2', 0))
+            substrate_r2.append(results.get('Substrate', {}).get('r2', 0))
+            product_r2.append(results.get('Product', {}).get('r2', 0))
+        
+        # Create figure with subplots
+        fig, axes = plt.subplots(2, 2, figsize=(15, 12))
+        fig.suptitle('Model Performance Comparison Across Experiments', fontsize=16)
+        
+        # 1. R² comparison by experiment and variable type
+        ax1 = axes[0, 0]
+        x = np.arange(len(experiments))
+        width = 0.25
+        
+        ax1.bar(x - width, biomass_r2, width, label='Biomass', color='green', alpha=0.8)
+        ax1.bar(x, substrate_r2, width, label='Substrate', color='blue', alpha=0.8)
+        ax1.bar(x + width, product_r2, width, label='Product', color='red', alpha=0.8)
+        
+        ax1.set_xlabel('Experiment')
+        ax1.set_ylabel('R²')
+        ax1.set_title('Best Model R² by Experiment and Variable Type')
+        ax1.set_xticks(x)
+        ax1.set_xticklabels(experiments, rotation=45, ha='right')
+        ax1.legend()
+        ax1.grid(True, alpha=0.3)
+        
+        # Add value labels
+        for i, (b, s, p) in enumerate(zip(biomass_r2, substrate_r2, product_r2)):
+            if b > 0: ax1.text(i - width, b + 0.01, f'{b:.3f}', ha='center', va='bottom', fontsize=8)
+            if s > 0: ax1.text(i, s + 0.01, f'{s:.3f}', ha='center', va='bottom', fontsize=8)
+            if p > 0: ax1.text(i + width, p + 0.01, f'{p:.3f}', ha='center', va='bottom', fontsize=8)
+        
+        # 2. Model frequency heatmap
+        ax2 = axes[0, 1]
+        # This would show which models appear most frequently as best
+        # Implementation depends on actual data structure
+        ax2.text(0.5, 0.5, 'Model Frequency Analysis\\n(Most Used Models)', 
+                ha='center', va='center', transform=ax2.transAxes)
+        ax2.set_title('Most Frequently Selected Models')
+        
+        # 3. Parameter evolution across experiments
+        ax3 = axes[1, 0]
+        ax3.text(0.5, 0.5, 'Parameter Evolution\\nAcross Experiments', 
+                ha='center', va='center', transform=ax3.transAxes)
+        ax3.set_title('Parameter Trends')
+        
+        # 4. Overall best models summary
+        ax4 = axes[1, 1]
+        ax4.axis('off')
+        
+        summary_text = "🏆 OVERALL BEST MODELS\\n\\n"
+        for var_type, model_info in self.overall_best_models.items():
+            if model_info:
+                summary_text += f"{var_type.upper()}:\\n"
+                summary_text += f"  Model: {model_info['name']}\\n"
+                summary_text += f"  Avg R²: {model_info['avg_r2']:.4f}\\n"
+                summary_text += f"  Tested in: {model_info['n_experiments']} experiments\\n\\n"
+        
+        ax4.text(0.1, 0.9, summary_text, transform=ax4.transAxes, 
+                fontsize=12, verticalalignment='top', fontfamily='monospace')
+        ax4.set_title('Overall Best Models Summary')
+        
+        plt.tight_layout()
+        plt.show()
+    
+    def generate_summary_table(self) -> pd.DataFrame:
+        \"\"\"Generate a summary table of best models by experiment and type\"\"\"
+        summary_data = []
+        
+        for exp, results in self.best_models_by_experiment.items():
+            for var_type, var_results in results.items():
+                summary_data.append({
+                    'Experiment': exp,
+                    'Variable_Type': var_type,
+                    'Best_Model': var_results['best_model'],
+                    'R2': var_results['r2'],
+                    'RMSE': var_results['rmse']
+                })
+        
+        summary_df = pd.DataFrame(summary_data)
+        
+        print("\\n📋 SUMMARY TABLE: BEST MODELS BY EXPERIMENT AND VARIABLE TYPE")
+        print("="*80)
+        print(summary_df.to_string(index=False))
+        
+        return summary_df
 
-if __name__ == '__main__':
-    # TODO: Replace this with your actual data
-    # This is placeholder data.
-    data = {
-        'Experiment': ['pH_7.0', 'pH_7.0', 'pH_7.5', 'pH_7.5', 'pH_7.0', 'pH_7.5'],
-        'Model': ['Monod', 'Logistic', 'Monod', 'Logistic', 'FirstOrder', 'FirstOrder'],
-        'Type': ['Biomass', 'Biomass', 'Biomass', 'Biomass', 'Substrate', 'Substrate'],
-        'R2': [0.98, 0.99, 0.97, 0.96, 0.95, 0.99],
-        'RMSE': [0.1, 0.05, 0.12, 0.15, 0.2, 0.08]
+# Example usage
+if __name__ == "__main__":
+    print("🧬 Experimental Model Comparison System")
+    print("="*60)
+    
+    # Example data structure with experiments
+    example_data = {
+        'Experiment': ['pH_7.0', 'pH_7.0', 'pH_7.0', 'pH_7.5', 'pH_7.5', 'pH_7.5',
+                      'pH_7.0', 'pH_7.0', 'pH_7.5', 'pH_7.5',
+                      'pH_7.0', 'pH_7.0', 'pH_7.5', 'pH_7.5'],
+        'Model': ['Monod', 'Logistic', 'Gompertz', 'Monod', 'Logistic', 'Gompertz',
+                 'First_Order', 'Monod_Substrate', 'First_Order', 'Monod_Substrate',
+                 'Luedeking_Piret', 'Linear', 'Luedeking_Piret', 'Linear'],
+        'Type': ['Biomass', 'Biomass', 'Biomass', 'Biomass', 'Biomass', 'Biomass',
+                'Substrate', 'Substrate', 'Substrate', 'Substrate',
+                'Product', 'Product', 'Product', 'Product'],
+        'R2': [0.9845, 0.9912, 0.9956, 0.9789, 0.9834, 0.9901,
+              0.9723, 0.9856, 0.9698, 0.9812,
+              0.9634, 0.9512, 0.9687, 0.9423],
+        'RMSE': [0.0234, 0.0189, 0.0145, 0.0267, 0.0223, 0.0178,
+                0.0312, 0.0245, 0.0334, 0.0289,
+                0.0412, 0.0523, 0.0389, 0.0567],
+        'mu_max': [0.45, 0.48, 0.52, 0.42, 0.44, 0.49,
+                  None, None, None, None, None, None, None, None],
+        'Ks': [None, None, None, None, None, None,
+              2.1, 1.8, 2.3, 1.9, None, None, None, None]
     }
-    df = pd.DataFrame(data)
     
-    print("--- Input Data ---")
-    print(df)
-    print("\\n")
-
-    best_models = analyze_data(df)
-    visualize_results(best_models)
+    # Create analyzer
+    analyzer = ExperimentalModelAnalyzer()
+    
+    # Load data
+    analyzer.load_results(data_dict=example_data)
+    
+    # Analyze by experiment
+    results = analyzer.analyze_by_experiment()
+    
+    # Create visualizations
+    analyzer.create_comparison_visualizations()
+    
+    # Generate summary table
+    summary = analyzer.generate_summary_table()
+    
+    print("\\n✨ Analysis complete! Best models identified for each experiment and variable type.")
 """
+    
+    return code
 
+# Estado global para almacenar resultados
 class AppState:
     def __init__(self):
         self.current_analysis = ""
@@ -625,12 +1237,20 @@ class AppState:
 
 app_state = AppState()
 
-def export_report(export_format: str, language: str) -> Tuple[str, Optional[str]]:
+def export_report(export_format: str, language: str) -> Tuple[str, str]:
+    """Exporta el reporte al formato seleccionado"""
     if not app_state.current_analysis:
-        error_msg = TRANSLATIONS[language]['error_no_files'].replace('analizar', 'exportar')
-        return error_msg, None
-
+        error_msg = {
+            'en': "No analysis available to export",
+            'es': "No hay análisis disponible para exportar",
+            'fr': "Aucune analyse disponible pour exporter",
+            'de': "Keine Analyse zum Exportieren verfügbar",
+            'pt': "Nenhuma análise disponível para exportar"
+        }
+        return error_msg.get(language, error_msg['en']), ""
+    
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    
     try:
         if export_format == "DOCX":
             filename = f"biotech_analysis_report_{timestamp}.docx"
@@ -642,164 +1262,243 @@ def export_report(export_format: str, language: str) -> Tuple[str, Optional[str]
         success_msg = TRANSLATIONS[language]['report_exported']
         return f"{success_msg} {filename}", filename
     except Exception as e:
-        return f"Error during export: {str(e)}", None
-
-# --- Interfaz de Gradio ---
+        return f"Error: {str(e)}", ""
 
+# Interfaz Gradio con soporte multiidioma y temas
 def create_interface():
+    # Estado inicial
+    current_theme = "light"
     current_language = "en"
-
-    def update_interface_language(language: str):
+    
+    def update_interface_language(language):
+        """Actualiza el idioma de la interfaz"""
         app_state.current_language = language
         t = TRANSLATIONS[language]
+        
         return [
-            gr.update(value=f"# {t['title']}"),
-            gr.update(value=t['subtitle']),
-            gr.update(label=t['upload_files']),
-            gr.update(label=t['select_model']),
-            gr.update(label=t['select_language']),
-            gr.update(label=t['select_theme']),
-            gr.update(label=t['detail_level'], choices=[(t['detailed'], "detailed"), (t['summarized'], "summarized")]),
-            gr.update(label=t['additional_specs'], placeholder=t['additional_specs_placeholder']),
-            gr.update(value=t['analyze_button']),
-            gr.update(label=t['export_format']),
-            gr.update(value=t['export_button']),
-            gr.update(label=t['comparative_analysis']),
-            gr.update(label=t['implementation_code']),
-            gr.update(label=t['data_format']),
-            gr.update(label=t['examples'])
+            gr.update(value=f"# {t['title']}"),  # title_text
+            gr.update(value=t['subtitle']),       # subtitle_text
+            gr.update(label=t['upload_files']),   # files_input
+            gr.update(label=t['select_model']),   # model_selector
+            gr.update(label=t['select_language']), # language_selector
+            gr.update(label=t['select_theme']),   # theme_selector
+            gr.update(label=t['detail_level']),   # detail_level
+            gr.update(label=t['additional_specs'], placeholder=t['additional_specs_placeholder']), # additional_specs
+            gr.update(value=t['analyze_button']), # analyze_btn
+            gr.update(label=t['export_format']),  # export_format
+            gr.update(value=t['export_button']),  # export_btn
+            gr.update(label=t['comparative_analysis']), # analysis_output
+            gr.update(label=t['implementation_code']),  # code_output
+            gr.update(label=t['data_format'])    # data_format_accordion
         ]
-
+    
     def process_and_store(files, model, detail, language, additional_specs):
+        """Procesa archivos y almacena resultados"""
         if not files:
-            return TRANSLATIONS[language]['error_no_files'], ""
+            error_msg = TRANSLATIONS[language]['error_no_files']
+            return error_msg, ""
         
         analysis, code = process_files(files, model, detail, language, additional_specs)
         app_state.current_analysis = analysis
         app_state.current_code = code
         return analysis, code
-
-    with gr.Blocks(theme=THEMES['light']) as demo:
-        # Estructura de la UI
-        with gr.Column():
-            with gr.Row():
-                with gr.Column(scale=3):
-                    title_text = gr.Markdown(f"# {TRANSLATIONS[current_language]['title']}")
-                    subtitle_text = gr.Markdown(TRANSLATIONS[current_language]['subtitle'])
-                with gr.Column(scale=1):
-                    language_selector = gr.Dropdown(choices=[("English", "en"), ("Español", "es"), ("Français", "fr"), ("Deutsch", "de"), ("Português", "pt")], value=current_language, label="Language", interactive=True)
-                    theme_selector = gr.Dropdown(choices=["Light", "Dark"], value="Light", label="Theme", interactive=True, visible=False) # Theme switching is complex, hiding for now
-
-            with gr.Row():
-                with gr.Column(scale=1):
-                    files_input = gr.File(label=TRANSLATIONS[current_language]['upload_files'], file_count="multiple", file_types=[".csv", ".xlsx", ".xls"], type="filepath")
-                    model_selector = gr.Dropdown(choices=list(QWEN_MODELS.keys()), value="Qwen/Qwen3-14B", label=TRANSLATIONS[current_language]['select_model'], info=QWEN_MODELS["Qwen/Qwen3-14B"]['best_for'])
-                    detail_level = gr.Radio(choices=[(TRANSLATIONS[current_language]['detailed'], "detailed"), (TRANSLATIONS[current_language]['summarized'], "summarized")], value="detailed", label=TRANSLATIONS[current_language]['detail_level'])
-                    additional_specs = gr.Textbox(label=TRANSLATIONS[current_language]['additional_specs'], placeholder=TRANSLATIONS[current_language]['additional_specs_placeholder'], lines=3, max_lines=5, interactive=True)
-                    analyze_btn = gr.Button(TRANSLATIONS[current_language]['analyze_button'], variant="primary", size="lg")
-                    
-                    gr.Markdown("---")
-                    
-                    export_format = gr.Radio(choices=["PDF", "DOCX"], value="PDF", label=TRANSLATIONS[current_language]['export_format'])
-                    export_btn = gr.Button(TRANSLATIONS[current_language]['export_button'], variant="secondary")
-                    export_status = gr.Textbox(label="Export Status", interactive=False, visible=False)
-                    export_file = gr.File(label="Download Report", visible=False)
-
-                with gr.Column(scale=2):
-                    analysis_output = gr.Markdown(label=TRANSLATIONS[current_language]['comparative_analysis'])
-                    code_output = gr.Code(label=TRANSLATIONS[current_language]['implementation_code'], language="python", interactive=True, lines=20)
-
-            with gr.Accordion(label=TRANSLATIONS[current_language]['data_format'], open=False) as data_format_accordion:
-                gr.Markdown("""
-                ### Expected CSV/Excel Structure:
-                The file should contain columns representing your model fitting results. Essential columns are:
-                - **Experiment**: An identifier for the experimental condition (e.g., `pH_7.0`, `Temp_30C`).
-                - **Model**: The name of the mathematical model (e.g., `Monod`, `Logistic`).
-                - **Type**: The type of process being modeled (e.g., `Biomass`, `Substrate`, `Product`). This is crucial for categorical analysis.
-                - **R2 / R_squared**: The coefficient of determination. Higher is better.
-                - **RMSE**: Root Mean Squared Error. Lower is better.
-                - **[Parameter_Columns]**: Additional columns for each model parameter (e.g., `mu_max`, `Ks`, `Xmax`).
-
-                | Experiment | Model    | Type      |    R2 |   RMSE |  mu_max |
-                |:-----------|:---------|:----------|------:|-------:|--------:|
-                | pH_7.0     | Monod    | Biomass   | 0.985 |  0.023 |    0.45 |
-                | pH_7.0     | Logistic | Biomass   | 0.991 |  0.018 |    0.48 |
-                | pH_7.5     | Monod    | Biomass   | 0.978 |  0.027 |    0.43 |
-                """)
-
-            examples_ui = gr.Examples(
-                examples=[
-                    [["examples/biomass_models_comparison.csv"], "Qwen/Qwen3-14B", "detailed", ""],
-                    [["examples/substrate_kinetics_results.xlsx"], "Qwen/Qwen3-14B", "summarized", "Focus on temperature effects and which temp is optimal."]
-                ],
-                inputs=[files_input, model_selector, detail_level, additional_specs],
-                label=TRANSLATIONS[current_language]['examples']
-            )
-
-        # Event Handlers
+    
+    with gr.Blocks(theme=THEMES[current_theme]) as demo:
+        # Componentes de UI
+        with gr.Row():
+            with gr.Column(scale=3):
+                title_text = gr.Markdown(f"# {TRANSLATIONS[current_language]['title']}")
+                subtitle_text = gr.Markdown(TRANSLATIONS[current_language]['subtitle'])
+            with gr.Column(scale=1):
+                with gr.Row():
+                    language_selector = gr.Dropdown(
+                        choices=[("English", "en"), ("Español", "es"), ("Français", "fr"), 
+                                ("Deutsch", "de"), ("Português", "pt")],
+                        value="en",
+                        label=TRANSLATIONS[current_language]['select_language'],
+                        interactive=True
+                    )
+                    theme_selector = gr.Dropdown(
+                        choices=[("Light", "light"), ("Dark", "dark")],
+                        value="light",
+                        label=TRANSLATIONS[current_language]['select_theme'],
+                        interactive=True
+                    )
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                files_input = gr.File(
+                    label=TRANSLATIONS[current_language]['upload_files'],
+                    file_count="multiple",
+                    file_types=[".csv", ".xlsx", ".xls", ".pdf", ".zip"],
+                    type="filepath"
+                )
+                
+                model_selector = gr.Dropdown(
+                    choices=list(QWEN_MODELS.keys()),
+                    value="Qwen/Qwen3-14B",
+                    label=TRANSLATIONS[current_language]['select_model'],
+                    info=f"{TRANSLATIONS[current_language]['best_for']}: {QWEN_MODELS['Qwen/Qwen3-14B']['best_for']}"
+                )
+                
+                detail_level = gr.Radio(
+                    choices=[
+                        (TRANSLATIONS[current_language]['detailed'], "detailed"),
+                        (TRANSLATIONS[current_language]['summarized'], "summarized")
+                    ],
+                    value="detailed",
+                    label=TRANSLATIONS[current_language]['detail_level']
+                )
+                
+                # Nueva entrada para especificaciones adicionales
+                additional_specs = gr.Textbox(
+                    label=TRANSLATIONS[current_language]['additional_specs'],
+                    placeholder=TRANSLATIONS[current_language]['additional_specs_placeholder'],
+                    lines=3,
+                    max_lines=5,
+                    interactive=True
+                )
+                
+                analyze_btn = gr.Button(
+                    TRANSLATIONS[current_language]['analyze_button'],
+                    variant="primary",
+                    size="lg"
+                )
+                
+                gr.Markdown("---")
+                
+                export_format = gr.Radio(
+                    choices=["DOCX", "PDF"],
+                    value="PDF",
+                    label=TRANSLATIONS[current_language]['export_format']
+                )
+                
+                export_btn = gr.Button(
+                    TRANSLATIONS[current_language]['export_button'],
+                    variant="secondary"
+                )
+                
+                export_status = gr.Textbox(
+                    label="Export Status",
+                    interactive=False,
+                    visible=False
+                )
+                
+                export_file = gr.File(
+                    label="Download Report",
+                    visible=False
+                )
+            
+            with gr.Column(scale=2):
+                analysis_output = gr.Markdown(
+                    label=TRANSLATIONS[current_language]['comparative_analysis']
+                )
+                
+                code_output = gr.Code(
+                    label=TRANSLATIONS[current_language]['implementation_code'],
+                    language="python",
+                    interactive=True,
+                    lines=20
+                )
+        
+        data_format_accordion = gr.Accordion(
+            label=TRANSLATIONS[current_language]['data_format'],
+            open=False
+        )
+        
+        with data_format_accordion:
+            gr.Markdown("""
+            ### Expected CSV/Excel structure:
+            
+            | Experiment | Model | Type | R2 | RMSE | AIC | BIC | mu_max | Ks | Parameters |
+            |------------|-------|------|-----|------|-----|-----|--------|-------|------------|
+            | pH_7.0 | Monod | Biomass | 0.985 | 0.023 | -45.2 | -42.1 | 0.45 | 2.1 | {...} |
+            | pH_7.0 | Logistic | Biomass | 0.976 | 0.031 | -42.1 | -39.5 | 0.42 | - | {...} |
+            | pH_7.0 | First_Order | Substrate | 0.992 | 0.018 | -48.5 | -45.2 | - | 1.8 | {...} |
+            | pH_7.5 | Monod | Biomass | 0.978 | 0.027 | -44.1 | -41.2 | 0.43 | 2.2 | {...} |
+            
+            **Important columns:**
+            - **Experiment**: Experimental condition identifier
+            - **Model**: Model name
+            - **Type**: Variable type (Biomass/Substrate/Product)
+            - **R2, RMSE**: Fit quality metrics
+            - **Parameters**: Model-specific parameters
+            """)
+        
+        # Definir ejemplos
+        examples = gr.Examples(
+            examples=[
+                [["examples/biomass_models_comparison.csv"], "Qwen/Qwen3-14B", "detailed", ""],
+                [["examples/substrate_kinetics_results.xlsx"], "Qwen/Qwen3-14B", "summarized", "Focus on temperature effects"]
+            ],
+            inputs=[files_input, model_selector, detail_level, additional_specs],
+            label=TRANSLATIONS[current_language]['examples']
+        )
+        
+        # Eventos - Actualizado para incluir additional_specs
         language_selector.change(
             update_interface_language,
             inputs=[language_selector],
-            outputs=[title_text, subtitle_text, files_input, model_selector, language_selector, theme_selector, detail_level, additional_specs, analyze_btn, export_format, export_btn, analysis_output, code_output, data_format_accordion, examples_ui]
+            outputs=[
+                title_text, subtitle_text, files_input, model_selector,
+                language_selector, theme_selector, detail_level, additional_specs,
+                analyze_btn, export_format, export_btn, analysis_output, 
+                code_output, data_format_accordion
+            ]
+        )
+        
+        def change_theme(theme_name):
+            """Cambia el tema de la interfaz"""
+            # Nota: En Gradio actual, cambiar el tema dinámicamente requiere recargar
+            # Esta es una limitación conocida
+            return gr.Info("Theme will be applied on next page load")
+        
+        theme_selector.change(
+            change_theme,
+            inputs=[theme_selector],
+            outputs=[]
         )
         
         analyze_btn.click(
             fn=process_and_store,
             inputs=[files_input, model_selector, detail_level, language_selector, additional_specs],
-            outputs=[analysis_output, code_output],
-            api_name="analyze"
+            outputs=[analysis_output, code_output]
         )
         
-        def handle_export(fmt, lang):
-            status, file_path = export_report(fmt, lang)
-            if file_path:
-                return gr.update(value=status, visible=True), gr.update(value=file_path, visible=True)
+        def handle_export(format, language):
+            status, file = export_report(format, language)
+            if file:
+                return gr.update(value=status, visible=True), gr.update(value=file, visible=True)
             else:
                 return gr.update(value=status, visible=True), gr.update(visible=False)
-
+        
         export_btn.click(
             fn=handle_export,
             inputs=[export_format, language_selector],
             outputs=[export_status, export_file]
         )
-
+    
     return demo
 
-# --- Punto de Entrada Principal ---
-
+# Función principal
 def main():
-    if client is None:
+    if not os.getenv("NEBIUS_API_KEY"):
+        print("⚠️ Configure NEBIUS_API_KEY in HuggingFace Space secrets")
         return gr.Interface(
-            fn=lambda: TRANSLATIONS['en']['error_no_api'],
-            inputs=[],
-            outputs=gr.Textbox(label="Error"),
+            fn=lambda x: TRANSLATIONS['en']['error_no_api'],
+            inputs=gr.Textbox(),
+            outputs=gr.Textbox(),
             title="Configuration Error"
         )
+    
     return create_interface()
 
+# Para ejecución local
 if __name__ == "__main__":
-    # Crear archivos y carpetas de ejemplo si no existen para que la UI no falle
-    if not os.path.exists("examples"):
-        os.makedirs("examples")
-    if not os.path.exists("examples/biomass_models_comparison.csv"):
-        pd.DataFrame({
-            'Experiment': ['Exp1_pH7', 'Exp1_pH7', 'Exp2_pH8', 'Exp2_pH8'],
-            'Model': ['Monod', 'Logistic', 'Monod', 'Logistic'],
-            'Type': ['Biomass', 'Biomass', 'Biomass', 'Biomass'],
-            'R2': [0.98, 0.99, 0.97, 0.96],
-            'RMSE': [0.1, 0.05, 0.12, 0.15],
-            'mu_max': [0.5, 0.52, 0.45, 0.46]
-        }).to_csv("examples/biomass_models_comparison.csv", index=False)
-    if not os.path.exists("examples/substrate_kinetics_results.xlsx"):
-         pd.DataFrame({
-            'Experiment': ['T30C', 'T30C', 'T37C', 'T37C'],
-            'Model': ['FirstOrder', 'MichaelisMenten', 'FirstOrder', 'MichaelisMenten'],
-            'Type': ['Substrate', 'Substrate', 'Substrate', 'Substrate'],
-            'R2': [0.95, 0.94, 0.99, 0.98],
-            'RMSE': [0.2, 0.25, 0.08, 0.1],
-            'Ks': [None, 1.5, None, 1.2]
-        }).to_excel("examples/substrate_kinetics_results.xlsx", index=False)
-        
     demo = main()
     if demo:
-        demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False
+        )