Update app.py

app.py

@@ -98,7 +98,6 @@ TRANSLATIONS = {
         "guide": "User Guide",
         "api_docs": "API Documentation"
     },
-    # Agregar más traducciones según necesidad
 }
 
 # --- CONSTANTES MEJORADAS ---
@@ -109,7 +108,7 @@ C_PRODUCT = 'product'
 C_OXYGEN = 'oxygen'
 C_CO2 = 'co2'
 C_PH = 'ph'
-COMPONENTS = [C_BIOMASS, C_SUBSTRATE, C_PRODUCT, C_OXYGEN, C_CO2, C_PH]
+COMPONENTS = [C_BIOMASS, C_SUBSTRATE, C_PRODUCT]
 
 # --- SISTEMA DE TEMAS ---
 THEMES = {
@@ -132,7 +131,7 @@ THEMES = {
     )
 }
 
-# --- MODELOS CINÉTICOS AMPLIADOS ---
+# --- MODELOS CINÉTICOS COMPLETOS ---
 
 class KineticModel(ABC):
     def __init__(self, name: str, display_name: str, param_names: List[str], 
@@ -160,7 +159,7 @@ class KineticModel(ABC):
     def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]: 
         pass
 
-# Modelos existentes mejorados
+# Modelo Logístico
 class LogisticModel(KineticModel):
     def __init__(self):
         super().__init__(
@@ -178,9 +177,9 @@ class LogisticModel(KineticModel):
             return np.full_like(t, np.nan)
         exp_arg = np.clip(um * t, -700, 700)
         term_exp = np.exp(exp_arg)
-        denominator = 1 - (X0 / Xm) * (1 - term_exp)
+        denominator = Xm - X0 + X0 * term_exp
         denominator = np.where(denominator == 0, 1e-9, denominator)
-        return (X0 * term_exp * Xm) / (Xm - X0 + X0 * term_exp)
+        return (X0 * term_exp * Xm) / denominator
     
     def diff_function(self, X: float, t: float, params: List[float]) -> float:
         _, Xm, um = params
@@ -198,7 +197,109 @@ class LogisticModel(KineticModel):
         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])
 
-# Nuevos modelos con 3-5 parámetros
+# 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__(
@@ -228,6 +329,7 @@ class MonodModel(KineticModel):
     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])
 
+# Modelo Contois
 class ContoisModel(KineticModel):
     def __init__(self):
         super().__init__(
@@ -254,6 +356,7 @@ class ContoisModel(KineticModel):
     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__(
@@ -280,6 +383,7 @@ class AndrewsModel(KineticModel):
     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__(
@@ -296,12 +400,17 @@ class TessierModel(KineticModel):
         # 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__(
@@ -337,6 +446,7 @@ class RichardsModel(KineticModel):
             [max_biomass * 2, 5.0, max_time, 10.0, max_biomass]
         )
 
+# Modelo Stannard
 class StannardModel(KineticModel):
     def __init__(self):
         super().__init__(
@@ -368,6 +478,7 @@ class StannardModel(KineticModel):
         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):
     def __init__(self):
         super().__init__(
@@ -435,6 +546,60 @@ class BioprocessFitter:
         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}")
         
     def _calculate_metrics(self, y_true: np.ndarray, y_pred: np.ndarray, 
                           n_params: int) -> Dict[str, float]:
@@ -508,15 +673,106 @@ class BioprocessFitter:
             return None, {'r2': np.nan, 'rmse': np.nan, 'mae': np.nan,
                         'aic': np.nan, 'bic': np.nan}
     
-    # El resto de los métodos permanecen similares con ajustes menores...
+    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
-    """
+    """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)
     
@@ -572,8 +828,7 @@ def create_interactive_plot(plot_config: Dict, models_results: List[Dict],
         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']):
+        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,
@@ -591,9 +846,12 @@ def create_interactive_plot(plot_config: Dict, models_results: List[Dict],
                     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="plotly_white" if plot_config.get('theme') == 'light' else "plotly_dark",
+        template=template,
         hovermode='x unified',
         legend=dict(
             orientation="v",
@@ -650,6 +908,96 @@ def create_interactive_plot(plot_config: Dict, models_results: List[Dict],
     
     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
+            }
+            
+            for c in COMPONENTS: 
+                plot_config[f'{c}_exp'] = reader.data_means[c]
+                plot_config[f'{c}_std'] = reader.data_stds[c]
+            
+            t_fine = reader._generate_fine_time_grid(reader.data_time)
+            
+            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")
@@ -664,14 +1012,7 @@ async def analyze_data(
     models: List[str],
     options: Optional[Dict[str, Any]] = None
 ):
-    """
-    Endpoint para análisis de datos cinéticos
-    
-    Parameters:
-    - data: Diccionario con 'time', 'biomass', 'substrate', 'product'
-    - models: Lista de nombres de modelos a ajustar
-    - options: Opciones adicionales de análisis
-    """
+    """Endpoint para análisis de datos cinéticos"""
     try:
         results = {}
         
@@ -757,19 +1098,7 @@ def create_gradio_interface() -> gr.Blocks:
         lang = Language[lang_key]
         trans = TRANSLATIONS.get(lang, TRANSLATIONS[Language.ES])
         
-        return {
-            title_text: trans["title"],
-            subtitle_text: trans["subtitle"],
-            upload_label: trans["upload"],
-            models_label: trans["select_models"],
-            analyze_button: trans["analyze"],
-            # ... actualizar todos los componentes
-        }
-    
-    def toggle_theme(is_dark: bool) -> gr.Blocks:
-        """Cambia entre tema claro y oscuro"""
-        theme = THEMES["dark"] if is_dark else THEMES["light"]
-        return gr.Blocks(theme=theme)
+        return trans["title"], trans["subtitle"]
     
     # Obtener opciones de modelo
     MODEL_CHOICES = [(model.display_name, model.name) for model in AVAILABLE_MODELS.values()]
@@ -906,91 +1235,78 @@ def create_gradio_interface() -> gr.Blocks:
                     api_docs_button = gr.Button("📖 Ver Documentación API")
                 
                 download_file = gr.File(label="Archivo descargado")
-        
-        # --- 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
-            )
+            # --- 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 ---
         
-        def run_analysis_wrapper(file, models, component, use_de, maxfev, exp_names):
+        def run_analysis_wrapper(file, models, component, use_de, maxfev, exp_names, theme):
             """Wrapper para ejecutar el análisis"""
             try:
-                # Aquí iría la lógica de análisis adaptada
-                # Por brevedad, retorno valores de ejemplo
-                fig = create_interactive_plot(
-                    {"time_exp": np.linspace(0, 10, 20)},
-                    [{"name": m, "X": np.random.rand(500)*10} for m in models[:2]],
-                    component
-                )
-                
-                df = pd.DataFrame({
-                    "Modelo": ["Logístico", "Gompertz"],
-                    "R²": [0.95, 0.93],
-                    "RMSE": [0.12, 0.15]
-                })
-                
-                return fig, df, "Análisis completado exitosamente"
-                
+                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(
@@ -1001,7 +1317,8 @@ def create_gradio_interface() -> gr.Blocks:
                 component_selector,
                 use_de_input,
                 maxfev_input,
-                exp_names_input
+                exp_names_input,
+                theme_toggle
             ],
             outputs=[plot_output, results_table, status_output]
         )
@@ -1010,20 +1327,47 @@ def create_gradio_interface() -> gr.Blocks:
         language_select.change(
             fn=change_language,
             inputs=[language_select],
-            outputs=[title_text, subtitle_text]  # Agregar todos los componentes
+            outputs=[title_text, subtitle_text]
         )
         
         # Cambio de tema
         def apply_theme(is_dark):
-            # Aquí se aplicaría el cambio de tema
-            # Por limitaciones de Gradio, esto requeriría recargar la interfaz
-            return gr.Info("Tema cambiado. Recarga la página para ver los cambios.")
+            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]
+        )
     
     return demo