Update app.py

app.py

@@ -1,1374 +1,280 @@
-# --- INSTALACIÓN DE DEPENDENCIAS ADICIONALES ---
-import os
-import sys
-import subprocess
-
-os.system("pip install gradio==5.38.1")
-
-# --- IMPORTACIONES ---
-import os
-import io
-import tempfile
-import traceback
-import zipfile
-from typing import List, Tuple, Dict, Any, Optional, Union
-from abc import ABC, abstractmethod
-from unittest.mock import MagicMock
-from dataclasses import dataclass
-from enum import Enum
-import json
-
-from PIL import Image
+# app.py - Versión simplificada para Hugging Face Spaces
 import gradio as gr
+import pandas as pd
+import numpy as np
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
-import numpy as np
-import pandas as pd
-import matplotlib.pyplot as plt
-import seaborn as sns
-from scipy.integrate import odeint
+import tempfile
+import traceback
+from typing import List, Dict, Any, Optional, Tuple
 from scipy.optimize import curve_fit, differential_evolution
 from sklearn.metrics import mean_squared_error, r2_score
-from docx import Document
-from docx.shared import Inches
-from fpdf import FPDF
-from fpdf.enums import XPos, YPos
-from fastapi import FastAPI
-import uvicorn
-
-# --- SISTEMA DE INTERNACIONALIZACIÓN ---
-class Language(Enum):
-    ES = "Español"
-    EN = "English"
-    PT = "Português"
-    FR = "Français"
-    DE = "Deutsch"
-    ZH = "中文"
-    JA = "日本語"
-
-TRANSLATIONS = {
-    Language.ES: {
-        "title": "🔬 Analizador de Cinéticas de Bioprocesos",
-        "subtitle": "Análisis avanzado de modelos matemáticos biotecnológicos",
-        "welcome": "Bienvenido al Analizador de Cinéticas",
-        "upload": "Sube tu archivo Excel (.xlsx)",
-        "select_models": "Modelos a Probar",
-        "analysis_mode": "Modo de Análisis",
-        "analyze": "Analizar y Graficar",
-        "results": "Resultados",
-        "download": "Descargar",
-        "biomass": "Biomasa",
-        "substrate": "Sustrato", 
-        "product": "Producto",
-        "time": "Tiempo",
-        "parameters": "Parámetros",
-        "model_comparison": "Comparación de Modelos",
-        "dark_mode": "Modo Oscuro",
-        "light_mode": "Modo Claro",
-        "language": "Idioma",
-        "theory": "Teoría y Modelos",
-        "guide": "Guía de Uso",
-        "api_docs": "Documentación API"
-    },
-    Language.EN: {
-        "title": "🔬 Bioprocess Kinetics Analyzer",
-        "subtitle": "Advanced analysis of biotechnological mathematical models",
-        "welcome": "Welcome to the Kinetics Analyzer",
-        "upload": "Upload your Excel file (.xlsx)",
-        "select_models": "Models to Test",
-        "analysis_mode": "Analysis Mode",
-        "analyze": "Analyze and Plot",
-        "results": "Results",
-        "download": "Download",
-        "biomass": "Biomass",
-        "substrate": "Substrate",
-        "product": "Product",
-        "time": "Time",
-        "parameters": "Parameters",
-        "model_comparison": "Model Comparison",
-        "dark_mode": "Dark Mode",
-        "light_mode": "Light Mode", 
-        "language": "Language",
-        "theory": "Theory and Models",
-        "guide": "User Guide",
-        "api_docs": "API Documentation"
-    },
-}
-
-# --- CONSTANTES MEJORADAS ---
-C_TIME = 'tiempo'
-C_BIOMASS = 'biomass'
-C_SUBSTRATE = 'substrate'
-C_PRODUCT = 'product'
-C_OXYGEN = 'oxygen'
-C_CO2 = 'co2'
-C_PH = 'ph'
-COMPONENTS = [C_BIOMASS, C_SUBSTRATE, C_PRODUCT]
-
-# --- SISTEMA DE TEMAS ---
-THEMES = {
-    "light": gr.themes.Soft(
-        primary_hue="blue",
-        secondary_hue="sky",
-        neutral_hue="gray",
-        font=[gr.themes.GoogleFont("Inter"), "ui-sans-serif", "sans-serif"]
-    ),
-    "dark": gr.themes.Base(
-        primary_hue="blue",
-        secondary_hue="cyan",
-        neutral_hue="slate",
-        font=[gr.themes.GoogleFont("Inter"), "ui-sans-serif", "sans-serif"]
-    ).set(
-        body_background_fill="*neutral_950",
-        body_background_fill_dark="*neutral_950",
-        button_primary_background_fill="*primary_600",
-        button_primary_background_fill_hover="*primary_700",
-    )
-}
-
-# --- MODELOS CINÉTICOS COMPLETOS ---
-
-class KineticModel(ABC):
-    def __init__(self, name: str, display_name: str, param_names: List[str], 
-                 description: str = "", equation: str = "", reference: str = ""):
-        self.name = name
-        self.display_name = display_name
-        self.param_names = param_names
-        self.num_params = len(param_names)
-        self.description = description
-        self.equation = equation
-        self.reference = reference
-
-    @abstractmethod
-    def model_function(self, t: np.ndarray, *params: float) -> np.ndarray: 
-        pass
-    
-    def diff_function(self, X: float, t: float, params: List[float]) -> float: 
-        return 0.0
-    
-    @abstractmethod
-    def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]: 
-        pass
-    
-    @abstractmethod
-    def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]: 
-        pass
-
-# Modelo Logístico
-class LogisticModel(KineticModel):
-    def __init__(self):
-        super().__init__(
-            "logistic", 
-            "Logístico", 
-            ["X0", "Xm", "μm"],
-            "Modelo de crecimiento logístico clásico para poblaciones limitadas",
-            r"X(t) = \frac{X_0 X_m e^{\mu_m t}}{X_m - X_0 + X_0 e^{\mu_m t}}",
-            "Verhulst (1838)"
-        )
-    
-    def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
-        X0, Xm, um = params
-        if Xm <= 0 or X0 <= 0 or Xm < X0: 
-            return np.full_like(t, np.nan)
-        exp_arg = np.clip(um * t, -700, 700)
-        term_exp = np.exp(exp_arg)
-        denominator = Xm - X0 + X0 * term_exp
-        denominator = np.where(denominator == 0, 1e-9, denominator)
-        return (X0 * term_exp * Xm) / denominator
-    
-    def diff_function(self, X: float, t: float, params: List[float]) -> float:
-        _, Xm, um = params
-        return um * X * (1 - X / Xm) if Xm > 0 else 0.0
-    
-    def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
-        return [
-            biomass[0] if len(biomass) > 0 and biomass[0] > 1e-6 else 1e-3,
-            max(biomass) if len(biomass) > 0 else 1.0,
-            0.1
-        ]
-    
-    def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
-        initial_biomass = biomass[0] if len(biomass) > 0 else 1e-9
-        max_biomass = max(biomass) if len(biomass) > 0 else 1.0
-        return ([1e-9, initial_biomass, 1e-9], [max_biomass * 1.2, max_biomass * 5, np.inf])
-
-# Modelo Gompertz
-class GompertzModel(KineticModel):
-    def __init__(self):
-        super().__init__(
-            "gompertz", 
-            "Gompertz", 
-            ["Xm", "μm", "λ"],
-            "Modelo de crecimiento asimétrico con fase lag",
-            r"X(t) = X_m \exp\left(-\exp\left(\frac{\mu_m e}{X_m}(\lambda-t)+1\right)\right)",
-            "Gompertz (1825)"
-        )
-    
-    def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
-        Xm, um, lag = params
-        if Xm <= 0 or um <= 0:
-            return np.full_like(t, np.nan)
-        exp_term = (um * np.e / Xm) * (lag - t) + 1
-        exp_term_clipped = np.clip(exp_term, -700, 700)
-        return Xm * np.exp(-np.exp(exp_term_clipped))
-    
-    def diff_function(self, X: float, t: float, params: List[float]) -> float:
-        Xm, um, lag = params
-        k_val = um * np.e / Xm
-        u_val = k_val * (lag - t) + 1
-        u_val_clipped = np.clip(u_val, -np.inf, 700)
-        return X * k_val * np.exp(u_val_clipped) if Xm > 0 and X > 0 else 0.0
-    
-    def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
-        return [
-            max(biomass) if len(biomass) > 0 else 1.0,
-            0.1,
-            time[np.argmax(np.gradient(biomass))] if len(biomass) > 1 else 0
-        ]
-    
-    def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
-        initial_biomass = min(biomass) if len(biomass) > 0 else 1e-9
-        max_biomass = max(biomass) if len(biomass) > 0 else 1.0
-        return ([max(1e-9, initial_biomass), 1e-9, 0], [max_biomass * 5, np.inf, max(time) if len(time) > 0 else 1])
-
-# Modelo Moser
-class MoserModel(KineticModel):
-    def __init__(self):
-        super().__init__(
-            "moser", 
-            "Moser", 
-            ["Xm", "μm", "Ks"],
-            "Modelo exponencial simple de Moser",
-            r"X(t) = X_m (1 - e^{-\mu_m (t - K_s)})",
-            "Moser (1958)"
-        )
-    
-    def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
-        Xm, um, Ks = params
-        return Xm * (1 - np.exp(-um * (t - Ks))) if Xm > 0 and um > 0 else np.full_like(t, np.nan)
-    
-    def diff_function(self, X: float, t: float, params: List[float]) -> float:
-        Xm, um, _ = params
-        return um * (Xm - X) if Xm > 0 else 0.0
-    
-    def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
-        return [max(biomass) if len(biomass) > 0 else 1.0, 0.1, 0]
-    
-    def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
-        initial_biomass = min(biomass) if len(biomass) > 0 else 1e-9
-        max_biomass = max(biomass) if len(biomass) > 0 else 1.0
-        return ([max(1e-9, initial_biomass), 1e-9, -np.inf], [max_biomass * 5, np.inf, np.inf])
-
-# Modelo Baranyi
-class BaranyiModel(KineticModel):
-    def __init__(self):
-        super().__init__(
-            "baranyi", 
-            "Baranyi", 
-            ["X0", "Xm", "μm", "λ"],
-            "Modelo de Baranyi con fase lag explícita",
-            r"X(t) = X_m / [1 + ((X_m/X_0) - 1) \exp(-\mu_m A(t))]",
-            "Baranyi & Roberts (1994)"
-        )
-    
-    def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
-        X0, Xm, um, lag = params
-        if X0 <= 0 or Xm <= X0 or um <= 0 or lag < 0:
-            return np.full_like(t, np.nan)
-        A_t = t + (1 / um) * np.log(np.exp(-um * t) + np.exp(-um * lag) - np.exp(-um * (t + lag)))
-        exp_um_At = np.exp(np.clip(um * A_t, -700, 700))
-        numerator = Xm
-        denominator = 1 + ((Xm / X0) - 1) * (1 / exp_um_At)
-        return numerator / np.where(denominator == 0, 1e-9, denominator)
-    
-    def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
-        return [
-            biomass[0] if len(biomass) > 0 and biomass[0] > 1e-6 else 1e-3,
-            max(biomass) if len(biomass) > 0 else 1.0,
-            0.1,
-            time[np.argmax(np.gradient(biomass))] if len(biomass) > 1 else 0.0
-        ]
-    
-    def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
-        initial_biomass = biomass[0] if len(biomass) > 0 else 1e-9
-        max_biomass = max(biomass) if len(biomass) > 0 else 1.0
-        return ([1e-9, max(1e-9, initial_biomass), 1e-9, 0], [max_biomass * 1.2, max_biomass * 10, np.inf, max(time) if len(time) > 0 else 1])
 
-# Modelo Monod
-class MonodModel(KineticModel):
-    def __init__(self):
-        super().__init__(
-            "monod",
-            "Monod",
-            ["μmax", "Ks", "Y", "m"],
-            "Modelo de Monod con mantenimiento celular",
-            r"\mu = \frac{\mu_{max} \cdot S}{K_s + S} - m",
-            "Monod (1949)"
-        )
-    
-    def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
-        # Implementación simplificada para ajuste
-        μmax, Ks, Y, m = params
-        # Este es un modelo más complejo que requiere integración numérica
-        return np.full_like(t, np.nan)  # Se usa solo con EDO
-    
-    def diff_function(self, X: float, t: float, params: List[float]) -> float:
-        μmax, Ks, Y, m = params
-        S = 10.0  # Valor placeholder, necesita integrarse con sustrato
-        μ = (μmax * S / (Ks + S)) - m
-        return μ * X
-    
-    def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
-        return [0.5, 0.1, 0.5, 0.01]
-    
-    def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
-        return ([0.01, 0.001, 0.1, 0.0], [2.0, 5.0, 1.0, 0.1])
+# Configuración básica
+print("Iniciando aplicación...")
 
-# Modelo Contois
-class ContoisModel(KineticModel):
+# --- MODELOS BÁSICOS ---
+class LogisticModel:
     def __init__(self):
-        super().__init__(
-            "contois",
-            "Contois",
-            ["μmax", "Ksx", "Y", "m"],
-            "Modelo de Contois para alta densidad celular",
-            r"\mu = \frac{\mu_{max} \cdot S}{K_{sx} \cdot X + S} - m",
-            "Contois (1959)"
-        )
-    
-    def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
-        return np.full_like(t, np.nan)  # Requiere EDO
-    
-    def diff_function(self, X: float, t: float, params: List[float]) -> float:
-        μmax, Ksx, Y, m = params
-        S = 10.0  # Placeholder
-        μ = (μmax * S / (Ksx * X + S)) - m
-        return μ * X
-    
-    def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
-        return [0.5, 0.5, 0.5, 0.01]
-    
-    def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
-        return ([0.01, 0.01, 0.1, 0.0], [2.0, 10.0, 1.0, 0.1])
-
-# Modelo Andrews
-class AndrewsModel(KineticModel):
-    def __init__(self):
-        super().__init__(
-            "andrews",
-            "Andrews (Haldane)",
-            ["μmax", "Ks", "Ki", "Y", "m"],
-            "Modelo de inhibición por sustrato",
-            r"\mu = \frac{\mu_{max} \cdot S}{K_s + S + \frac{S^2}{K_i}} - m",
-            "Andrews (1968)"
-        )
-    
-    def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
-        return np.full_like(t, np.nan)
-    
-    def diff_function(self, X: float, t: float, params: List[float]) -> float:
-        μmax, Ks, Ki, Y, m = params
-        S = 10.0  # Placeholder
-        μ = (μmax * S / (Ks + S + S**2/Ki)) - m
-        return μ * X
-    
-    def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
-        return [0.5, 0.1, 50.0, 0.5, 0.01]
-    
-    def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
-        return ([0.01, 0.001, 1.0, 0.1, 0.0], [2.0, 5.0, 200.0, 1.0, 0.1])
-
-# Modelo Tessier
-class TessierModel(KineticModel):
-    def __init__(self):
-        super().__init__(
-            "tessier",
-            "Tessier",
-            ["μmax", "Ks", "X0"],
-            "Modelo exponencial de Tessier",
-            r"\mu = \mu_{max} \cdot (1 - e^{-S/K_s})",
-            "Tessier (1942)"
-        )
-    
-    def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
-        μmax, Ks, X0 = params
-        # Implementación simplificada
-        return X0 * np.exp(μmax * t * 0.5)  # Aproximación
-    
-    def diff_function(self, X: float, t: float, params: List[float]) -> float:
-        μmax, Ks, X0 = params
-        return μmax * X * 0.5  # Simplificado
-    
-    def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
-        return [0.5, 1.0, biomass[0] if len(biomass) > 0 else 0.1]
-    
-    def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
-        return ([0.01, 0.1, 1e-9], [2.0, 10.0, 1.0])
-
-# Modelo Richards
-class RichardsModel(KineticModel):
-    def __init__(self):
-        super().__init__(
-            "richards",
-            "Richards",
-            ["A", "μm", "λ", "ν", "X0"],
-            "Modelo generalizado de Richards",
-            r"X(t) = A \cdot [1 + \nu \cdot e^{-\mu_m(t-\lambda)}]^{-1/\nu}",
-            "Richards (1959)"
-        )
-    
-    def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
-        A, μm, λ, ν, X0 = params
-        if A <= 0 or μm <= 0 or ν <= 0:
-            return np.full_like(t, np.nan)
-        exp_term = np.exp(-μm * (t - λ))
-        return A * (1 + ν * exp_term) ** (-1/ν)
-    
-    def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
-        return [
-            max(biomass) if len(biomass) > 0 else 1.0,
-            0.5,
-            time[len(time)//4] if len(time) > 0 else 1.0,
-            1.0,
-            biomass[0] if len(biomass) > 0 else 0.1
-        ]
-    
-    def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
-        max_biomass = max(biomass) if len(biomass) > 0 else 10.0
-        max_time = max(time) if len(time) > 0 else 100.0
-        return (
-            [0.1, 0.01, 0.0, 0.1, 1e-9],
-            [max_biomass * 2, 5.0, max_time, 10.0, max_biomass]
-        )
-
-# Modelo Stannard
-class StannardModel(KineticModel):
-    def __init__(self):
-        super().__init__(
-            "stannard",
-            "Stannard",
-            ["Xm", "μm", "λ", "α"],
-            "Modelo de Stannard modificado",
-            r"X(t) = X_m \cdot [1 - e^{-\mu_m(t-\lambda)^\alpha}]",
-            "Stannard et al. (1985)"
-        )
-    
-    def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
-        Xm, μm, λ, α = params
-        if Xm <= 0 or μm <= 0 or α <= 0:
+        self.name = "logistic"
+        self.display_name = "Logístico"
+        self.param_names = ["X0", "Xm", "μm"]
+        
+    def model_function(self, t, X0, Xm, um):
+        try:
+            if Xm <= 0 or X0 <= 0 or Xm < X0:
+                return np.full_like(t, np.nan)
+            exp_arg = np.clip(um * t, -700, 700)
+            term_exp = np.exp(exp_arg)
+            denominator = Xm - X0 + X0 * term_exp
+            denominator = np.where(denominator == 0, 1e-9, denominator)
+            return (X0 * term_exp * Xm) / denominator
+        except:
             return np.full_like(t, np.nan)
-        t_shifted = np.maximum(t - λ, 0)
-        return Xm * (1 - np.exp(-μm * t_shifted ** α))
-    
-    def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
-        return [
-            max(biomass) if len(biomass) > 0 else 1.0,
-            0.5,
-            0.0,
-            1.0
-        ]
-    
-    def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
-        max_biomass = max(biomass) if len(biomass) > 0 else 10.0
-        max_time = max(time) if len(time) > 0 else 100.0
-        return ([0.1, 0.01, -max_time/10, 0.1], [max_biomass * 2, 5.0, max_time/2, 3.0])
 
-# Modelo Huang
-class HuangModel(KineticModel):
+class GompertzModel:
     def __init__(self):
-        super().__init__(
-            "huang",
-            "Huang",
-            ["Xm", "μm", "λ", "n", "m"],
-            "Modelo de Huang para fase lag variable",
-            r"X(t) = X_m \cdot \frac{1}{1 + e^{-\mu_m(t-\lambda-m/n)}}",
-            "Huang (2008)"
-        )
-    
-    def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
-        Xm, μm, λ, n, m = params
-        if Xm <= 0 or μm <= 0 or n <= 0:
+        self.name = "gompertz"
+        self.display_name = "Gompertz"
+        self.param_names = ["Xm", "μm", "λ"]
+        
+    def model_function(self, t, Xm, um, lag):
+        try:
+            if Xm <= 0 or um <= 0:
+                return np.full_like(t, np.nan)
+            exp_term = (um * np.e / Xm) * (lag - t) + 1
+            exp_term_clipped = np.clip(exp_term, -700, 700)
+            return Xm * np.exp(-np.exp(exp_term_clipped))
+        except:
             return np.full_like(t, np.nan)
-        return Xm / (1 + np.exp(-μm * (t - λ - m/n)))
-    
-    def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
-        return [
-            max(biomass) if len(biomass) > 0 else 1.0,
-            0.5,
-            time[len(time)//4] if len(time) > 0 else 1.0,
-            1.0,
-            0.5
-        ]
-    
-    def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
-        max_biomass = max(biomass) if len(biomass) > 0 else 10.0
-        max_time = max(time) if len(time) > 0 else 100.0
-        return (
-            [0.1, 0.01, 0.0, 0.1, 0.0],
-            [max_biomass * 2, 5.0, max_time/2, 10.0, 5.0]
-        )
 
-# --- REGISTRO ACTUALIZADO DE MODELOS ---
-AVAILABLE_MODELS: Dict[str, KineticModel] = {
-    model.name: model for model in [
-        LogisticModel(), 
-        GompertzModel(), 
-        MoserModel(), 
-        BaranyiModel(),
-        MonodModel(),
-        ContoisModel(),
-        AndrewsModel(),
-        TessierModel(),
-        RichardsModel(),
-        StannardModel(),
-        HuangModel()
-    ]
+# Modelos disponibles
+MODELS = {
+    "logistic": LogisticModel(),
+    "gompertz": GompertzModel()
 }
 
-# --- CLASE MEJORADA DE AJUSTE ---
-class BioprocessFitter:
-    def __init__(self, kinetic_model: KineticModel, maxfev: int = 50000, 
-                 use_differential_evolution: bool = False):
-        self.model = kinetic_model
-        self.maxfev = maxfev
-        self.use_differential_evolution = use_differential_evolution
-        self.params: Dict[str, Dict[str, float]] = {c: {} for c in COMPONENTS}
-        self.r2: Dict[str, float] = {}
-        self.rmse: Dict[str, float] = {}
-        self.mae: Dict[str, float] = {}  # Mean Absolute Error
-        self.aic: Dict[str, float] = {}  # Akaike Information Criterion
-        self.bic: Dict[str, float] = {}  # Bayesian Information Criterion
-        self.data_time: Optional[np.ndarray] = None
-        self.data_means: Dict[str, Optional[np.ndarray]] = {c: None for c in COMPONENTS}
-        self.data_stds: Dict[str, Optional[np.ndarray]] = {c: None for c in COMPONENTS}
-
-    def _get_biomass_at_t(self, t: np.ndarray, p: List[float]) -> np.ndarray: 
-        return self.model.model_function(t, *p)
-    
-    def _get_initial_biomass(self, p: List[float]) -> float:
-        if not p: return 0.0
-        if any(k in self.model.param_names for k in ["Xo", "X0"]):
-            try:
-                idx = self.model.param_names.index("Xo") if "Xo" in self.model.param_names else self.model.param_names.index("X0")
-                return p[idx]
-            except (ValueError, IndexError): pass
-        return float(self.model.model_function(np.array([0]), *p)[0])
-    
-    def _calc_integral(self, t: np.ndarray, p: List[float]) -> Tuple[np.ndarray, np.ndarray]:
-        X_t = self._get_biomass_at_t(t, p)
-        if np.any(np.isnan(X_t)): return np.full_like(t, np.nan), np.full_like(t, np.nan)
-        integral_X = np.zeros_like(X_t)
-        if len(t) > 1:
-            dt = np.diff(t, prepend=t[0] - (t[1] - t[0] if len(t) > 1 else 1))
-            integral_X = np.cumsum(X_t * dt)
-        return integral_X, X_t
-    
-    def substrate(self, t: np.ndarray, so: float, p_c: float, q: float, bio_p: List[float]) -> np.ndarray:
-        integral, X_t = self._calc_integral(t, bio_p)
-        X0 = self._get_initial_biomass(bio_p)
-        return so - p_c * (X_t - X0) - q * integral
-    
-    def product(self, t: np.ndarray, po: float, alpha: float, beta: float, bio_p: List[float]) -> np.ndarray:
-        integral, X_t = self._calc_integral(t, bio_p)
-        X0 = self._get_initial_biomass(bio_p)
-        return po + alpha * (X_t - X0) + beta * integral
-    
-    def process_data_from_df(self, df: pd.DataFrame) -> None:
-        try:
-            time_col = [c for c in df.columns if c[1].strip().lower() == C_TIME][0]
-            self.data_time = df[time_col].dropna().to_numpy()
-            min_len = len(self.data_time)
-            
-            def extract(name: str) -> Tuple[np.ndarray, np.ndarray]:
-                cols = [c for c in df.columns if c[1].strip().lower() == name.lower()]
-                if not cols: return np.array([]), np.array([])
-                reps = [df[c].dropna().values[:min_len] for c in cols]
-                reps = [r for r in reps if len(r) == min_len]
-                if not reps: return np.array([]), np.array([])
-                arr = np.array(reps)
-                mean = np.mean(arr, axis=0)
-                std = np.std(arr, axis=0, ddof=1) if arr.shape[0] > 1 else np.zeros_like(mean)
-                return mean, std
-            
-            self.data_means[C_BIOMASS], self.data_stds[C_BIOMASS] = extract('Biomasa')
-            self.data_means[C_SUBSTRATE], self.data_stds[C_SUBSTRATE] = extract('Sustrato')
-            self.data_means[C_PRODUCT], self.data_stds[C_PRODUCT] = extract('Producto')
-        except (IndexError, KeyError) as e:
-            raise ValueError(f"Estructura de DataFrame inválida. Error: {e}")
+# --- FUNCIONES DE ANÁLISIS SIMPLIFICADAS ---
+def fit_model(model, time_data, biomass_data):
+    """Ajusta un modelo a los datos"""
+    try:
+        # Parámetros iniciales
+        if model.name == "logistic":
+            p0 = [biomass_data[0], max(biomass_data), 0.1]
+            bounds = ([1e-9, biomass_data[0], 1e-9], 
+                     [max(biomass_data)*2, max(biomass_data)*5, 10])
+        else:  # gompertz
+            p0 = [max(biomass_data), 0.1, 0]
+            bounds = ([biomass_data[0], 1e-9, 0], 
+                     [max(biomass_data)*5, 10, max(time_data)])
         
-    def _calculate_metrics(self, y_true: np.ndarray, y_pred: np.ndarray, 
-                          n_params: int) -> Dict[str, float]:
-        """Calcula métricas adicionales de bondad de ajuste"""
-        n = len(y_true)
-        residuals = y_true - y_pred
-        ss_res = np.sum(residuals**2)
-        ss_tot = np.sum((y_true - np.mean(y_true))**2)
+        popt, _ = curve_fit(model.model_function, time_data, biomass_data, 
+                           p0=p0, bounds=bounds, maxfev=10000)
         
-        r2 = 1 - (ss_res / ss_tot) if ss_tot > 0 else 0
-        rmse = np.sqrt(ss_res / n)
-        mae = np.mean(np.abs(residuals))
+        # Calcular métricas
+        y_pred = model.model_function(time_data, *popt)
+        r2 = r2_score(biomass_data, y_pred)
+        rmse = np.sqrt(mean_squared_error(biomass_data, y_pred))
         
-        # AIC y BIC
-        if n > n_params + 1:
-            aic = n * np.log(ss_res/n) + 2 * n_params
-            bic = n * np.log(ss_res/n) + n_params * np.log(n)
-        else:
-            aic = bic = np.inf
-            
         return {
+            'success': True,
+            'parameters': dict(zip(model.param_names, popt)),
             'r2': r2,
             'rmse': rmse,
-            'mae': mae,
-            'aic': aic,
-            'bic': bic
+            'predictions': y_pred
         }
-    
-    def _fit_component_de(self, func, t, data, bounds, *args):
-        """Ajuste usando evolución diferencial para optimización global"""
-        def objective(params):
-            try:
-                pred = func(t, *params, *args)
-                if np.any(np.isnan(pred)):
-                    return 1e10
-                return np.sum((data - pred)**2)
-            except:
-                return 1e10
-        
-        result = differential_evolution(objective, bounds=list(zip(*bounds)), 
-                                      maxiter=1000, seed=42)
-        if result.success:
-            popt = result.x
-            pred = func(t, *popt, *args)
-            metrics = self._calculate_metrics(data, pred, len(popt))
-            return list(popt), metrics
-        return None, {'r2': np.nan, 'rmse': np.nan, 'mae': np.nan, 
-                     'aic': np.nan, 'bic': np.nan}
-    
-    def _fit_component(self, func, t, data, p0, bounds, sigma=None, *args):
-        try:
-            if self.use_differential_evolution:
-                return self._fit_component_de(func, t, data, bounds, *args)
-                
-            if sigma is not None:
-                sigma = np.where(sigma == 0, 1e-9, sigma)
-                
-            popt, _ = curve_fit(func, t, data, p0, bounds=bounds, 
-                              maxfev=self.maxfev, ftol=1e-9, xtol=1e-9,
-                              sigma=sigma, absolute_sigma=bool(sigma is not None))
-            
-            pred = func(t, *popt, *args)
-            if np.any(np.isnan(pred)):
-                return None, {'r2': np.nan, 'rmse': np.nan, 'mae': np.nan,
-                            'aic': np.nan, 'bic': np.nan}
-                
-            metrics = self._calculate_metrics(data, pred, len(popt))
-            return list(popt), metrics
-            
-        except (RuntimeError, ValueError):
-            return None, {'r2': np.nan, 'rmse': np.nan, 'mae': np.nan,
-                        'aic': np.nan, 'bic': np.nan}
-    
-    def fit_all_models(self) -> None:
-        t, bio_m, bio_s = self.data_time, self.data_means[C_BIOMASS], self.data_stds[C_BIOMASS]
-        if t is None or bio_m is None or len(bio_m) == 0: return
-        popt_bio = self._fit_biomass_model(t, bio_m, bio_s)
-        if popt_bio:
-            bio_p = list(self.params[C_BIOMASS].values())
-            if self.data_means[C_SUBSTRATE] is not None and len(self.data_means[C_SUBSTRATE]) > 0: 
-                self._fit_substrate_model(t, self.data_means[C_SUBSTRATE], self.data_stds[C_SUBSTRATE], bio_p)
-            if self.data_means[C_PRODUCT] is not None and len(self.data_means[C_PRODUCT]) > 0: 
-                self._fit_product_model(t, self.data_means[C_PRODUCT], self.data_stds[C_PRODUCT], bio_p)
-    
-    def _fit_biomass_model(self, t, data, std):
-        p0, bounds = self.model.get_initial_params(t, data), self.model.get_param_bounds(t, data)
-        popt, metrics = self._fit_component(self.model.model_function, t, data, p0, bounds, std)
-        if popt: 
-            self.params[C_BIOMASS] = dict(zip(self.model.param_names, popt))
-            self.r2[C_BIOMASS] = metrics['r2']
-            self.rmse[C_BIOMASS] = metrics['rmse']
-            self.mae[C_BIOMASS] = metrics['mae']
-            self.aic[C_BIOMASS] = metrics['aic']
-            self.bic[C_BIOMASS] = metrics['bic']
-        return popt
-    
-    def _fit_substrate_model(self, t, data, std, bio_p):
-        p0, b = [data[0], 0.1, 0.01], ([0, -np.inf, -np.inf], [np.inf, np.inf, np.inf])
-        popt, metrics = self._fit_component(lambda t, so, p, q: self.substrate(t, so, p, q, bio_p), t, data, p0, b, std)
-        if popt: 
-            self.params[C_SUBSTRATE] = {'So': popt[0], 'p': popt[1], 'q': popt[2]}
-            self.r2[C_SUBSTRATE] = metrics['r2']
-            self.rmse[C_SUBSTRATE] = metrics['rmse']
-            self.mae[C_SUBSTRATE] = metrics['mae']
-            self.aic[C_SUBSTRATE] = metrics['aic']
-            self.bic[C_SUBSTRATE] = metrics['bic']
-    
-    def _fit_product_model(self, t, data, std, bio_p):
-        p0, b = [data[0] if len(data)>0 else 0, 0.1, 0.01], ([0, -np.inf, -np.inf], [np.inf, np.inf, np.inf])
-        popt, metrics = self._fit_component(lambda t, po, a, b: self.product(t, po, a, b, bio_p), t, data, p0, b, std)
-        if popt: 
-            self.params[C_PRODUCT] = {'Po': popt[0], 'alpha': popt[1], 'beta': popt[2]}
-            self.r2[C_PRODUCT] = metrics['r2']
-            self.rmse[C_PRODUCT] = metrics['rmse']
-            self.mae[C_PRODUCT] = metrics['mae']
-            self.aic[C_PRODUCT] = metrics['aic']
-            self.bic[C_PRODUCT] = metrics['bic']
-    
-    def system_ode(self, y, t, bio_p, sub_p, prod_p):
-        X, _, _ = y
-        dXdt = self.model.diff_function(X, t, bio_p)
-        return [dXdt, -sub_p.get('p',0)*dXdt - sub_p.get('q',0)*X, prod_p.get('alpha',0)*dXdt + prod_p.get('beta',0)*X]
-    
-    def solve_odes(self, t_fine):
-        p = self.params
-        bio_d, sub_d, prod_d = p[C_BIOMASS], p[C_SUBSTRATE], p[C_PRODUCT]
-        if not bio_d: return None, None, None
-        try:
-            bio_p = list(bio_d.values())
-            y0 = [self._get_initial_biomass(bio_p), sub_d.get('So',0), prod_d.get('Po',0)]
-            sol = odeint(self.system_ode, y0, t_fine, args=(bio_p, sub_d, prod_d))
-            return sol[:, 0], sol[:, 1], sol[:, 2]
-        except:
-            return None, None, None
-    
-    def _generate_fine_time_grid(self, t_exp):
-        return np.linspace(min(t_exp), max(t_exp), 500) if t_exp is not None and len(t_exp) > 1 else np.array([])
-    
-    def get_model_curves_for_plot(self, t_fine, use_diff):
-        if use_diff and self.model.diff_function(1, 1, [1]*self.model.num_params) != 0:
-            return self.solve_odes(t_fine)
-        X, S, P = None, None, None
-        if self.params[C_BIOMASS]:
-            bio_p = list(self.params[C_BIOMASS].values())
-            X = self.model.model_function(t_fine, *bio_p)
-            if self.params[C_SUBSTRATE]:
-                S = self.substrate(t_fine, *list(self.params[C_SUBSTRATE].values()), bio_p)
-            if self.params[C_PRODUCT]:
-                P = self.product(t_fine, *list(self.params[C_PRODUCT].values()), bio_p)
-        return X, S, P
-
-# --- FUNCIONES AUXILIARES ---
-
-def format_number(value: Any, decimals: int) -> str:
-    """Formatea un número para su visualización"""
-    if not isinstance(value, (int, float, np.number)) or pd.isna(value):
-        return "" if pd.isna(value) else str(value)
-    
-    decimals = int(decimals)
-    
-    if decimals == 0:
-        if 0 < abs(value) < 1:
-            return f"{value:.2e}"
-        else:
-            return str(int(round(value, 0)))
-            
-    return str(round(value, decimals))
-
-# --- FUNCIONES DE PLOTEO MEJORADAS CON PLOTLY ---
-
-def create_interactive_plot(plot_config: Dict, models_results: List[Dict], 
-                          selected_component: str = "all") -> go.Figure:
-    """Crea un gráfico interactivo mejorado con Plotly"""
-    time_exp = plot_config['time_exp']
-    time_fine = np.linspace(min(time_exp), max(time_exp), 500)
-    
-    # Configuración de subplots si se muestran todos los componentes
-    if selected_component == "all":
-        fig = make_subplots(
-            rows=3, cols=1,
-            subplot_titles=('Biomasa', 'Sustrato', 'Producto'),
-            vertical_spacing=0.08,
-            shared_xaxes=True
-        )
-        components_to_plot = [C_BIOMASS, C_SUBSTRATE, C_PRODUCT]
-        rows = [1, 2, 3]
-    else:
-        fig = go.Figure()
-        components_to_plot = [selected_component]
-        rows = [None]
-    
-    # Colores para diferentes modelos
-    colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', 
-              '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf']
-    
-    # Agregar datos experimentales
-    for comp, row in zip(components_to_plot, rows):
-        data_exp = plot_config.get(f'{comp}_exp')
-        data_std = plot_config.get(f'{comp}_std')
-        
-        if data_exp is not None:
-            error_y = dict(
-                type='data',
-                array=data_std,
-                visible=True
-            ) if data_std is not None and np.any(data_std > 0) else None
-            
-            trace = go.Scatter(
-                x=time_exp,
-                y=data_exp,
-                mode='markers',
-                name=f'{comp.capitalize()} (Experimental)',
-                marker=dict(size=10, symbol='circle'),
-                error_y=error_y,
-                legendgroup=comp,
-                showlegend=True
-            )
-            
-            if selected_component == "all":
-                fig.add_trace(trace, row=row, col=1)
-            else:
-                fig.add_trace(trace)
-    
-    # Agregar curvas de modelos
-    for i, res in enumerate(models_results):
-        color = colors[i % len(colors)]
-        model_name = AVAILABLE_MODELS[res["name"]].display_name
-        
-        for comp, row, key in zip(components_to_plot, rows, ['X', 'S', 'P']):
-            if res.get(key) is not None:
-                trace = go.Scatter(
-                    x=time_fine,
-                    y=res[key],
-                    mode='lines',
-                    name=f'{model_name} - {comp.capitalize()}',
-                    line=dict(color=color, width=2),
-                    legendgroup=f'{res["name"]}_{comp}',
-                    showlegend=True
-                )
-                
-                if selected_component == "all":
-                    fig.add_trace(trace, row=row, col=1)
-                else:
-                    fig.add_trace(trace)
-    
-    # Actualizar diseño
-    theme = plot_config.get('theme', 'light')
-    template = "plotly_white" if theme == 'light' else "plotly_dark"
-    
-    fig.update_layout(
-        title=f"Análisis de Cinéticas: {plot_config.get('exp_name', '')}",
-        template=template,
-        hovermode='x unified',
-        legend=dict(
-            orientation="v",
-            yanchor="middle",
-            y=0.5,
-            xanchor="left",
-            x=1.02
-        ),
-        margin=dict(l=80, r=250, t=100, b=80)
-    )
-    
-    # Actualizar ejes
-    if selected_component == "all":
-        fig.update_xaxes(title_text="Tiempo", row=3, col=1)
-        fig.update_yaxes(title_text="Biomasa (g/L)", row=1, col=1)
-        fig.update_yaxes(title_text="Sustrato (g/L)", row=2, col=1)
-        fig.update_yaxes(title_text="Producto (g/L)", row=3, col=1)
-    else:
-        fig.update_xaxes(title_text="Tiempo")
-        labels = {
-            C_BIOMASS: "Biomasa (g/L)",
-            C_SUBSTRATE: "Sustrato (g/L)",
-            C_PRODUCT: "Producto (g/L)"
+    except Exception as e:
+        return {
+            'success': False,
+            'error': str(e),
+            'parameters': {},
+            'r2': np.nan,
+            'rmse': np.nan,
+            'predictions': np.full_like(time_data, np.nan)
         }
-        fig.update_yaxes(title_text=labels.get(selected_component, "Valor"))
-    
-    # Agregar botones para cambiar entre modos de visualización
-    fig.update_layout(
-        updatemenus=[
-            dict(
-                type="dropdown",
-                showactive=True,
-                buttons=[
-                    dict(label="Todos los componentes",
-                         method="update",
-                         args=[{"visible": [True] * len(fig.data)}]),
-                    dict(label="Solo Biomasa",
-                         method="update",
-                         args=[{"visible": [i < len(fig.data)//3 for i in range(len(fig.data))]}]),
-                    dict(label="Solo Sustrato",
-                         method="update",
-                         args=[{"visible": [len(fig.data)//3 <= i < 2*len(fig.data)//3 for i in range(len(fig.data))]}]),
-                    dict(label="Solo Producto",
-                         method="update",
-                         args=[{"visible": [i >= 2*len(fig.data)//3 for i in range(len(fig.data))]}]),
-                ],
-                x=0.1,
-                y=1.15,
-                xanchor="left",
-                yanchor="top"
-            )
-        ]
-    )
-    
-    return fig
 
-# --- FUNCIÓN PRINCIPAL DE ANÁLISIS ---
-def run_analysis(file, model_names, component, use_de, maxfev, exp_names, theme='light'):
-    if not file: return None, pd.DataFrame(), "Error: Sube un archivo Excel."
-    if not model_names: return None, pd.DataFrame(), "Error: Selecciona un modelo."
-    
-    try: 
-        xls = pd.ExcelFile(file.name)
-    except Exception as e: 
-        return None, pd.DataFrame(), f"Error al leer archivo: {e}"
-    
-    results_data, msgs = [], []
-    models_results = []
-    
-    exp_list = [n.strip() for n in exp_names.split('\n') if n.strip()] if exp_names else []
-    
-    for i, sheet in enumerate(xls.sheet_names):
-        exp_name = exp_list[i] if i < len(exp_list) else f"Hoja '{sheet}'"
-        try:
-            df = pd.read_excel(xls, sheet_name=sheet, header=[0,1])
-            reader = BioprocessFitter(list(AVAILABLE_MODELS.values())[0])
-            reader.process_data_from_df(df)
-            
-            if reader.data_time is None: 
-                msgs.append(f"WARN: Sin datos de tiempo en '{sheet}'.")
-                continue
-            
-            plot_config = {
-                'exp_name': exp_name, 
-                'time_exp': reader.data_time,
-                'theme': theme
-            }
+def process_excel_file(file_path):
+    """Procesa archivo Excel y extrae datos"""
+    try:
+        # Leer archivo Excel
+        xls = pd.ExcelFile(file_path)
+        results = []
+        
+        for sheet_name in xls.sheet_names:
+            df = pd.read_excel(xls, sheet_name=sheet_name, header=[0,1])
             
-            for c in COMPONENTS: 
-                plot_config[f'{c}_exp'] = reader.data_means[c]
-                plot_config[f'{c}_std'] = reader.data_stds[c]
+            # Buscar columnas de tiempo y biomasa
+            time_col = None
+            biomass_cols = []
             
-            t_fine = reader._generate_fine_time_grid(reader.data_time)
+            for col in df.columns:
+                if 'tiempo' in str(col[1]).lower():
+                    time_col = col
+                elif 'biomasa' in str(col[1]).lower():
+                    biomass_cols.append(col)
             
-            for m_name in model_names:
-                if m_name not in AVAILABLE_MODELS: 
-                    msgs.append(f"WARN: Modelo '{m_name}' no disponible.")
-                    continue
-                    
-                fitter = BioprocessFitter(
-                    AVAILABLE_MODELS[m_name], 
-                    maxfev=int(maxfev),
-                    use_differential_evolution=use_de
-                )
-                fitter.data_time = reader.data_time
-                fitter.data_means = reader.data_means
-                fitter.data_stds = reader.data_stds
-                fitter.fit_all_models()
-                
-                row = {'Experimento': exp_name, 'Modelo': fitter.model.display_name}
-                for c in COMPONENTS:
-                    if fitter.params[c]: 
-                        row.update({f'{c.capitalize()}_{k}': v for k, v in fitter.params[c].items()})
-                    row[f'R2_{c.capitalize()}'] = fitter.r2.get(c)
-                    row[f'RMSE_{c.capitalize()}'] = fitter.rmse.get(c)
-                    row[f'MAE_{c.capitalize()}'] = fitter.mae.get(c)
-                    row[f'AIC_{c.capitalize()}'] = fitter.aic.get(c)
-                    row[f'BIC_{c.capitalize()}'] = fitter.bic.get(c)
-                
-                results_data.append(row)
-                
-                X, S, P = fitter.get_model_curves_for_plot(t_fine, False)
-                models_results.append({
-                    'name': m_name, 
-                    'X': X, 
-                    'S': S, 
-                    'P': P, 
-                    'params': fitter.params, 
-                    'r2': fitter.r2, 
-                    'rmse': fitter.rmse
-                })
-                
-        except Exception as e: 
-            msgs.append(f"ERROR en '{sheet}': {e}")
-            traceback.print_exc()
-    
-    msg = "Análisis completado." + ("\n" + "\n".join(msgs) if msgs else "")
-    df_res = pd.DataFrame(results_data).dropna(axis=1, how='all')
-    
-    # Crear gráfico interactivo
-    fig = None
-    if models_results and reader.data_time is not None:
-        fig = create_interactive_plot(plot_config, models_results, component)
-    
-    return fig, df_res, msg
-
-# --- API ENDPOINTS PARA AGENTES DE IA ---
-
-app = FastAPI(title="Bioprocess Kinetics API", version="2.0")
-
-@app.get("/")
-def read_root():
-    return {"message": "Bioprocess Kinetics Analysis API", "version": "2.0"}
-
-@app.post("/api/analyze")
-async def analyze_data(
-    data: Dict[str, List[float]],
-    models: List[str],
-    options: Optional[Dict[str, Any]] = None
-):
-    """Endpoint para análisis de datos cinéticos"""
-    try:
-        results = {}
-        
-        for model_name in models:
-            if model_name not in AVAILABLE_MODELS:
+            if time_col is None or not biomass_cols:
                 continue
                 
-            model = AVAILABLE_MODELS[model_name]
-            fitter = BioprocessFitter(model)
+            # Extraer datos
+            time_data = df[time_col].dropna().values
+            biomass_data = df[biomass_cols[0]].dropna().values
             
-            # Configurar datos
-            fitter.data_time = np.array(data['time'])
-            fitter.data_means[C_BIOMASS] = np.array(data.get('biomass', []))
-            fitter.data_means[C_SUBSTRATE] = np.array(data.get('substrate', []))
-            fitter.data_means[C_PRODUCT] = np.array(data.get('product', []))
+            # Asegurar mismo tamaño
+            min_len = min(len(time_data), len(biomass_data))
+            time_data = time_data[:min_len]
+            biomass_data = biomass_data[:min_len]
             
-            # Ajustar modelo
-            fitter.fit_all_models()
-            
-            results[model_name] = {
-                'parameters': fitter.params,
-                'metrics': {
-                    'r2': fitter.r2,
-                    'rmse': fitter.rmse,
-                    'mae': fitter.mae,
-                    'aic': fitter.aic,
-                    'bic': fitter.bic
-                }
-            }
-            
-        return {"status": "success", "results": results}
+            results.append({
+                'sheet': sheet_name,
+                'time': time_data,
+                'biomass': biomass_data
+            })
         
+        return results
     except Exception as e:
-        return {"status": "error", "message": str(e)}
-
-@app.get("/api/models")
-def get_available_models():
-    """Retorna lista de modelos disponibles con su información"""
-    models_info = {}
-    for name, model in AVAILABLE_MODELS.items():
-        models_info[name] = {
-            "display_name": model.display_name,
-            "parameters": model.param_names,
-            "description": model.description,
-            "equation": model.equation,
-            "reference": model.reference,
-            "num_params": model.num_params
-        }
-    return {"models": models_info}
+        print(f"Error procesando archivo: {e}")
+        return []
 
-@app.post("/api/predict")
-async def predict_kinetics(
-    model_name: str,
-    parameters: Dict[str, float],
-    time_points: List[float]
-):
-    """Predice valores usando un modelo y parámetros específicos"""
-    if model_name not in AVAILABLE_MODELS:
-        return {"status": "error", "message": f"Model {model_name} not found"}
-        
+def analyze_data(file, selected_models):
+    """Función principal de análisis"""
+    if file is None:
+        return None, "Error: No se ha subido ningún archivo"
+    
     try:
-        model = AVAILABLE_MODELS[model_name]
-        time_array = np.array(time_points)
-        params = [parameters[name] for name in model.param_names]
+        # Procesar archivo
+        datasets = process_excel_file(file.name)
         
-        predictions = model.model_function(time_array, *params)
+        if not datasets:
+            return None, "Error: No se encontraron datos válidos en el archivo"
         
-        return {
-            "status": "success",
-            "predictions": predictions.tolist(),
-            "time_points": time_points
-        }
-    except Exception as e:
-        return {"status": "error", "message": str(e)}
-
-# --- INTERFAZ GRADIO MEJORADA ---
-
-def create_gradio_interface() -> gr.Blocks:
-    """Crea la interfaz mejorada con soporte multiidioma y tema"""
-    
-    def change_language(lang_key: str) -> Dict:
-        """Cambia el idioma de la interfaz"""
-        lang = Language[lang_key]
-        trans = TRANSLATIONS.get(lang, TRANSLATIONS[Language.ES])
+        all_results = []
         
-        return trans["title"], trans["subtitle"]
-    
-    # Obtener opciones de modelo
-    MODEL_CHOICES = [(model.display_name, model.name) for model in AVAILABLE_MODELS.values()]
-    DEFAULT_MODELS = [m.name for m in list(AVAILABLE_MODELS.values())[:4]]
-    
-    with gr.Blocks(theme=THEMES["light"], css="""
-        .gradio-container {font-family: 'Inter', sans-serif;}
-        .theory-box {background-color: #f0f9ff; padding: 20px; border-radius: 10px; margin: 10px 0;}
-        .dark .theory-box {background-color: #1e293b;}
-        .model-card {border: 1px solid #e5e7eb; padding: 15px; border-radius: 8px; margin: 10px 0;}
-        .dark .model-card {border-color: #374151;}
-    """) as demo:
+        # Por cada dataset
+        for dataset in datasets:
+            sheet_name = dataset['sheet']
+            time_data = dataset['time']
+            biomass_data = dataset['biomass']
+            
+            # Por cada modelo seleccionado
+            for model_name in selected_models:
+                if model_name in MODELS:
+                    model = MODELS[model_name]
+                    result = fit_model(model, time_data, biomass_data)
+                    
+                    all_results.append({
+                        'Experimento': sheet_name,
+                        'Modelo': model.display_name,
+                        'R²': result['r2'],
+                        'RMSE': result['rmse'],
+                        **{f'Param_{k}': v for k, v in result['parameters'].items()}
+                    })
         
-        # Estado para tema e idioma
-        current_theme = gr.State("light")
-        current_language = gr.State("ES")
+        # Crear DataFrame de resultados
+        results_df = pd.DataFrame(all_results)
         
-        # Header con controles de tema e idioma
-        with gr.Row():
-            with gr.Column(scale=8):
-                title_text = gr.Markdown("# 🔬 Analizador de Cinéticas de Bioprocesos")
-                subtitle_text = gr.Markdown("Análisis avanzado de modelos matemáticos biotecnológicos")
-            with gr.Column(scale=2):
-                with gr.Row():
-                    theme_toggle = gr.Checkbox(label="🌙 Modo Oscuro", value=False)
-                    language_select = gr.Dropdown(
-                        choices=[(lang.value, lang.name) for lang in Language],
-                        value="ES",
-                        label="🌐 Idioma"
-                    )
+        # Crear gráfico simple
+        fig = go.Figure()
         
-        with gr.Tabs() as tabs:
-            # --- TAB 1: TEORÍA Y MODELOS ---
-            with gr.TabItem("📚 Teoría y Modelos"):
-                gr.Markdown("""
-                ## Introducción a los Modelos Cinéticos
-                
-                Los modelos cinéticos en biotecnología describen el comportamiento dinámico
-                de los microorganismos durante su crecimiento. Estos modelos son fundamentales
-                para:
-                
-                - **Optimización de procesos**: Determinar condiciones óptimas de operación
-                - **Escalamiento**: Predecir comportamiento a escala industrial
-                - **Control de procesos**: Diseñar estrategias de control efectivas
-                - **Análisis económico**: Evaluar viabilidad de procesos
-                """)
-                
-                # Cards para cada modelo
-                for model_name, model in AVAILABLE_MODELS.items():
-                    with gr.Accordion(f"📊 {model.display_name}", open=False):
-                        with gr.Row():
-                            with gr.Column(scale=3):
-                                gr.Markdown(f"""
-                                **Descripción**: {model.description}
-                                
-                                **Ecuación**: ${model.equation}$
-                                
-                                **Parámetros**: {', '.join(model.param_names)}
-                                
-                                **Referencia**: {model.reference}
-                                """)
-                            with gr.Column(scale=1):
-                                gr.Markdown(f"""
-                                **Características**:
-                                - Parámetros: {model.num_params}
-                                - Complejidad: {'⭐' * min(model.num_params, 5)}
-                                """)
+        if datasets:
+            dataset = datasets[0]  # Usar primer dataset para el gráfico
             
-            # --- TAB 2: ANÁLISIS ---
-            with gr.TabItem("🔬 Análisis"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        file_input = gr.File(
-                            label="📁 Sube tu archivo Excel (.xlsx)",
-                            file_types=['.xlsx']
-                        )
-                        
-                        exp_names_input = gr.Textbox(
-                            label="🏷️ Nombres de Experimentos",
-                            placeholder="Experimento 1\nExperimento 2\n...",
-                            lines=3
-                        )
-                        
-                        model_selection_input = gr.CheckboxGroup(
-                            choices=MODEL_CHOICES,
-                            label="📊 Modelos a Probar",
-                            value=DEFAULT_MODELS
-                        )
-                        
-                        with gr.Accordion("⚙️ Opciones Avanzadas", open=False):
-                            use_de_input = gr.Checkbox(
-                                label="Usar Evolución Diferencial",
-                                value=False,
-                                info="Optimización global más robusta pero más lenta"
-                            )
-                            
-                            maxfev_input = gr.Number(
-                                label="Iteraciones máximas",
-                                value=50000
-                            )
-                    
-                    with gr.Column(scale=2):
-                        # Selector de componente para visualización
-                        component_selector = gr.Dropdown(
-                            choices=[
-                                ("Todos los componentes", "all"),
-                                ("Solo Biomasa", C_BIOMASS),
-                                ("Solo Sustrato", C_SUBSTRATE),
-                                ("Solo Producto", C_PRODUCT)
-                            ],
-                            value="all",
-                            label="📈 Componente a visualizar"
-                        )
-                        
-                        plot_output = gr.Plot(label="Visualización Interactiva")
+            # Datos experimentales
+            fig.add_trace(go.Scatter(
+                x=dataset['time'],
+                y=dataset['biomass'],
+                mode='markers',
+                name='Datos Experimentales',
+                marker=dict(size=8)
+            ))
+            
+            # Predicciones de modelos
+            colors = ['red', 'blue', 'green', 'orange']
+            for i, model_name in enumerate(selected_models):
+                if model_name in MODELS:
+                    model = MODELS[model_name]
+                    result = fit_model(model, dataset['time'], dataset['biomass'])
+                    if result['success']:
+                        t_fine = np.linspace(min(dataset['time']), max(dataset['time']), 100)
+                        y_pred = model.model_function(t_fine, *result['parameters'].values())
                         
-                analyze_button = gr.Button("🚀 Analizar y Graficar", variant="primary")
+                        fig.add_trace(go.Scatter(
+                            x=t_fine,
+                            y=y_pred,
+                            mode='lines',
+                            name=f'{model.display_name} (R²={result["r2"]:.3f})',
+                            line=dict(color=colors[i % len(colors)])
+                        ))
             
-            # --- TAB 3: RESULTADOS ---
-            with gr.TabItem("📊 Resultados"):
-                status_output = gr.Textbox(
-                    label="Estado del Análisis",
-                    interactive=False
+            fig.update_layout(
+                title='Análisis de Cinéticas de Crecimiento',
+                xaxis_title='Tiempo',
+                yaxis_title='Biomasa',
+                template='plotly_white'
+            )
+        
+        return fig, f"Análisis completado exitosamente. Procesados {len(datasets)} experimentos."
+        
+    except Exception as e:
+        error_msg = f"Error en el análisis: {str(e)}"
+        print(error_msg)
+        print(traceback.format_exc())
+        return None, error_msg
+
+# --- INTERFAZ GRADIO SIMPLIFICADA ---
+def create_interface():
+    """Crear interfaz Gradio simplificada"""
+    
+    with gr.Blocks(title="Analizador de Cinéticas") as demo:
+        gr.Markdown("# 🔬 Analizador de Cinéticas de Bioprocesos")
+        gr.Markdown("Versión simplificada para análisis de modelos de crecimiento")
+        
+        with gr.Row():
+            with gr.Column():
+                file_input = gr.File(
+                    label="📁 Subir archivo Excel (.xlsx)",
+                    file_types=['.xlsx']
                 )
                 
-                results_table = gr.DataFrame(
-                    label="Tabla de Resultados",
-                    wrap=True
+                model_selection = gr.CheckboxGroup(
+                    choices=[("Logístico", "logistic"), ("Gompertz", "gompertz")],
+                    label="🔬 Seleccionar Modelos",
+                    value=["logistic"]
                 )
                 
-                with gr.Row():
-                    download_excel = gr.Button("📥 Descargar Excel")
-                    download_json = gr.Button("📥 Descargar JSON")
-                    api_docs_button = gr.Button("📖 Ver Documentación API")
-                
-                download_file = gr.File(label="Archivo descargado")
+                analyze_btn = gr.Button("🚀 Analizar", variant="primary")
             
-            # --- TAB 4: API ---
-            with gr.TabItem("🔌 API"):
-                gr.Markdown("""
-                ## Documentación de la API
-                
-                La API REST permite integrar el análisis de cinéticas en aplicaciones externas
-                y agentes de IA.
-                
-                ### Endpoints disponibles:
-                
-                #### 1. `GET /api/models`
-                Retorna la lista de modelos disponibles con su información.
-                
-                ```python
-                import requests
-                response = requests.get("http://localhost:8000/api/models")
-                models = response.json()
-                ```
-                
-                #### 2. `POST /api/analyze`
-                Analiza datos con los modelos especificados.
-                
-                ```python
-                data = {
-                    "data": {
-                        "time": [0, 1, 2, 3, 4],
-                        "biomass": [0.1, 0.3, 0.8, 1.5, 2.0],
-                        "substrate": [10, 8, 5, 2, 0.5]
-                    },
-                    "models": ["logistic", "gompertz"],
-                    "options": {"maxfev": 50000}
-                }
-                response = requests.post("http://localhost:8000/api/analyze", json=data)
-                results = response.json()
-                ```
-                
-                #### 3. `POST /api/predict`
-                Predice valores usando un modelo y parámetros específicos.
-                
-                ```python
-                data = {
-                    "model_name": "logistic",
-                    "parameters": {"X0": 0.1, "Xm": 10.0, "μm": 0.5},
-                    "time_points": [0, 1, 2, 3, 4, 5]
-                }
-                response = requests.post("http://localhost:8000/api/predict", json=data)
-                predictions = response.json()
-                ```
-                
-                ### Iniciar servidor API:
-                ```bash
-                uvicorn script_name:app --reload --port 8000
-                ```
-                """)
-                
-                # Botón para copiar comando
-                gr.Textbox(
-                    value="uvicorn bioprocess_analyzer:app --reload --port 8000",
-                    label="Comando para iniciar API",
-                    interactive=False
-                )
-        
-        # --- EVENTOS ---
+            with gr.Column():
+                plot_output = gr.Plot(label="📊 Resultados")
+                status_output = gr.Textbox(label="📋 Estado", interactive=False)
         
-        def run_analysis_wrapper(file, models, component, use_de, maxfev, exp_names, theme):
-            """Wrapper para ejecutar el análisis"""
-            try:
-                return run_analysis(file, models, component, use_de, maxfev, exp_names, 
-                                  'dark' if theme else 'light')
-            except Exception as e:
-                print(f"--- ERROR EN ANÁLISIS ---\n{traceback.format_exc()}")
-                return None, pd.DataFrame(), f"Error: {str(e)}"
-        
-        analyze_button.click(
-            fn=run_analysis_wrapper,
-            inputs=[
-                file_input,
-                model_selection_input,
-                component_selector,
-                use_de_input,
-                maxfev_input,
-                exp_names_input,
-                theme_toggle
-            ],
-            outputs=[plot_output, results_table, status_output]
-        )
-        
-        # Cambio de idioma
-        language_select.change(
-            fn=change_language,
-            inputs=[language_select],
-            outputs=[title_text, subtitle_text]
-        )
-        
-        # Cambio de tema
-        def apply_theme(is_dark):
-            return gr.Info("Tema cambiado. Los gráficos nuevos usarán el tema seleccionado.")
-        
-        theme_toggle.change(
-            fn=apply_theme,
-            inputs=[theme_toggle],
-            outputs=[]
-        )
-        
-        # Funciones de descarga
-        def download_results_excel(df):
-            if df is None or df.empty:
-                gr.Warning("No hay datos para descargar")
-                return None
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx") as tmp:
-                df.to_excel(tmp.name, index=False)
-                return tmp.name
-        
-        def download_results_json(df):
-            if df is None or df.empty:
-                gr.Warning("No hay datos para descargar")
-                return None
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".json") as tmp:
-                df.to_json(tmp.name, orient='records', indent=2)
-                return tmp.name
-        
-        download_excel.click(
-            fn=download_results_excel,
-            inputs=[results_table],
-            outputs=[download_file]
-        )
-        
-        download_json.click(
-            fn=download_results_json,
-            inputs=[results_table],
-            outputs=[download_file]
+        # Conectar eventos
+        analyze_btn.click(
+            fn=analyze_data,
+            inputs=[file_input, model_selection],
+            outputs=[plot_output, status_output]
         )
     
     return demo
 
 # --- PUNTO DE ENTRADA ---
-
-if __name__ == '__main__':
-    # Lanzar aplicación Gradio
-    gradio_app = create_gradio_interface()
-    gradio_app.launch(share=True, debug=True)
+if __name__ == "__main__":
+    print("Creando interfaz...")
+    
+    try:
+        demo = create_interface()
+        print("Interfaz creada, lanzando aplicación...")
+        
+        # Configuración para Hugging Face Spaces
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,  # No usar share en HF Spaces
+            debug=False,  # Desactivar debug en producción
+            show_error=True,
+            quiet=False
+        )
+        
+    except Exception as e:
+        print(f"Error al lanzar la aplicación: {e}")
+        print(traceback.format_exc())