Update app.py

app.py

@@ -1,730 +1,826 @@
-import os
-import re
-import time
-import logging
-import zipfile
-import requests
-import bibtexparser
-from tqdm import tqdm
-from urllib.parse import quote, urlencode
+import numpy as np
+import pandas as pd
+import statsmodels.formula.api as smf
+import statsmodels.api as sm
+import plotly.graph_objects as go
+from scipy.optimize import minimize
+import plotly.express as px
+from scipy.stats import t, f
 import gradio as gr
-from bs4 import BeautifulSoup
 import io
-import asyncio
-import aiohttp
-
-# Configure logging
-logging.basicConfig(level=logging.INFO,
-                    format='%(asctime)s - %(levelname)s: %(message)s')
-logger = logging.getLogger(__name__)
-
-
-class PaperDownloader:
-    def __init__(self, output_dir='papers'):
-        self.output_dir = output_dir
-        os.makedirs(output_dir, exist_ok=True)
-
-        # Updated download sources
-        self.download_sources = [
-            'https://sci-hub.ee/',
-            'https://sci-hub.st/',
-            'https://sci-hub.ru/',
-            'https://sci-hub.ren/',
-            'https://sci-hub.mksa.top/',
-            'https://sci-hub.se/',
-            'https://libgen.rs/scimag/'
+import zipfile
+import tempfile
+from datetime import datetime
+
+class RSM_BoxBehnken:
+    def __init__(self, data, x1_name, x2_name, x3_name, y_name, x1_levels, x2_levels, x3_levels):
+        """
+        Inicializa la clase con los datos del diseño Box-Behnken.
+        """
+        self.data = data.copy()
+        self.model = None
+        self.model_simplified = None
+        self.optimized_results = None
+        self.optimal_levels = None
+        self.all_figures = []  # Lista para almacenar las figuras
+        self.x1_name = x1_name
+        self.x2_name = x2_name
+        self.x3_name = x3_name
+        self.y_name = y_name
+
+        # Niveles originales de las variables
+        self.x1_levels = x1_levels
+        self.x2_levels = x2_levels
+        self.x3_levels = x3_levels
+
+    def get_levels(self, variable_name):
+        """
+        Obtiene los niveles para una variable específica.
+        """
+        if variable_name == self.x1_name:
+            return self.x1_levels
+        elif variable_name == self.x2_name:
+            return self.x2_levels
+        elif variable_name == self.x3_name:
+            return self.x3_levels
+        else:
+            raise ValueError(f"Variable desconocida: {variable_name}")
+
+    def fit_model(self):
+        """
+        Ajusta el modelo de segundo orden completo a los datos.
+        """
+        formula = f'{self.y_name} ~ {self.x1_name} + {self.x2_name} + {self.x3_name} + ' \
+                  f'I({self.x1_name}**2) + I({self.x2_name}**2) + I({self.x3_name}**2) + ' \
+                  f'{self.x1_name}:{self.x2_name} + {self.x1_name}:{self.x3_name} + {self.x2_name}:{self.x3_name}'
+        self.model = smf.ols(formula, data=self.data).fit()
+        print("Modelo Completo:")
+        print(self.model.summary())
+        return self.model, self.pareto_chart(self.model, "Pareto - Modelo Completo")
+
+    def fit_simplified_model(self):
+        """
+        Ajusta el modelo de segundo orden a los datos, eliminando términos no significativos.
+        """
+        formula = f'{self.y_name} ~ {self.x1_name} + {self.x2_name} + ' \
+                  f'I({self.x1_name}**2) + I({self.x2_name}**2) + I({self.x3_name}**2)'
+        self.model_simplified = smf.ols(formula, data=self.data).fit()
+        print("\nModelo Simplificado:")
+        print(self.model_simplified.summary())
+        return self.model_simplified, self.pareto_chart(self.model_simplified, "Pareto - Modelo Simplificado")
+
+    def optimize(self, method='Nelder-Mead'):
+        """
+        Encuentra los niveles óptimos de los factores para maximizar la respuesta usando el modelo simplificado.
+        """
+        if self.model_simplified is None:
+            print("Error: Ajusta el modelo simplificado primero.")
+            return
+
+        def objective_function(x):
+            return -self.model_simplified.predict(pd.DataFrame({
+                self.x1_name: [x[0]],
+                self.x2_name: [x[1]],
+                self.x3_name: [x[2]]
+            })).values[0]
+
+        bounds = [(-1, 1), (-1, 1), (-1, 1)]
+        x0 = [0, 0, 0]
+
+        self.optimized_results = minimize(objective_function, x0, method=method, bounds=bounds)
+        self.optimal_levels = self.optimized_results.x
+
+        # Convertir niveles óptimos de codificados a naturales
+        optimal_levels_natural = [
+            self.coded_to_natural(self.optimal_levels[0], self.x1_name),
+            self.coded_to_natural(self.optimal_levels[1], self.x2_name),
+            self.coded_to_natural(self.optimal_levels[2], self.x3_name)
+        ]
+        # Crear la tabla de optimización
+        optimization_table = pd.DataFrame({
+            'Variable': [self.x1_name, self.x2_name, self.x3_name],
+            'Nivel Óptimo (Natural)': optimal_levels_natural,
+            'Nivel Óptimo (Codificado)': self.optimal_levels
+        })
+
+        return optimization_table.round(3)  # Redondear a 3 decimales
+
+    def plot_rsm_individual(self, fixed_variable, fixed_level):
+        """
+        Genera un gráfico de superficie de respuesta (RSM) individual para una configuración específica.
+        """
+        if self.model_simplified is None:
+            print("Error: Ajusta el modelo simplificado primero.")
+            return None
+
+        # Determinar las variables que varían y sus niveles naturales
+        varying_variables = [var for var in [self.x1_name, self.x2_name, self.x3_name] if var != fixed_variable]
+        
+        # Establecer los niveles naturales para las variables que varían
+        x_natural_levels = self.get_levels(varying_variables[0])
+        y_natural_levels = self.get_levels(varying_variables[1])
+
+        # Crear una malla de puntos para las variables que varían (en unidades naturales)
+        x_range_natural = np.linspace(x_natural_levels[0], x_natural_levels[-1], 100)
+        y_range_natural = np.linspace(y_natural_levels[0], y_natural_levels[-1], 100)
+        x_grid_natural, y_grid_natural = np.meshgrid(x_range_natural, y_range_natural)
+
+        # Convertir la malla de variables naturales a codificadas
+        x_grid_coded = self.natural_to_coded(x_grid_natural, varying_variables[0])
+        y_grid_coded = self.natural_to_coded(y_grid_natural, varying_variables[1])
+
+        # Crear un DataFrame para la predicción con variables codificadas
+        prediction_data = pd.DataFrame({
+            varying_variables[0]: x_grid_coded.flatten(),
+            varying_variables[1]: y_grid_coded.flatten(),
+        })
+        prediction_data[fixed_variable] = self.natural_to_coded(fixed_level, fixed_variable)
+
+        # Calcular los valores predichos
+        z_pred = self.model_simplified.predict(prediction_data).values.reshape(x_grid_coded.shape)
+
+        # Filtrar por el nivel de la variable fija (en codificado)
+        fixed_level_coded = self.natural_to_coded(fixed_level, fixed_variable)
+        subset_data = self.data[np.isclose(self.data[fixed_variable], fixed_level_coded)]
+
+        # Filtrar por niveles válidos en las variables que varían
+        valid_levels = [-1, 0, 1]
+        experiments_data = subset_data[
+            subset_data[varying_variables[0]].isin(valid_levels) &
+            subset_data[varying_variables[1]].isin(valid_levels)
         ]
 
-        # Request headers
-        self.headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36',
-            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
-            'Accept-Language': 'en-US,en;q=0.9',
+        # Convertir coordenadas de experimentos a naturales
+        experiments_x_natural = experiments_data[varying_variables[0]].apply(lambda x: self.coded_to_natural(x, varying_variables[0]))
+        experiments_y_natural = experiments_data[varying_variables[1]].apply(lambda x: self.coded_to_natural(x, varying_variables[1]))
+
+        # Crear el gráfico de superficie con variables naturales en los ejes y transparencia
+        fig = go.Figure(data=[go.Surface(z=z_pred, x=x_grid_natural, y=y_grid_natural, colorscale='Viridis', opacity=0.7, showscale=True)])
+
+        # --- Añadir cuadrícula a la superficie ---
+        # Líneas en la dirección x
+        for i in range(x_grid_natural.shape[0]):
+            fig.add_trace(go.Scatter3d(
+                x=x_grid_natural[i, :],
+                y=y_grid_natural[i, :],
+                z=z_pred[i, :],
+                mode='lines',
+                line=dict(color='gray', width=2),
+                showlegend=False,
+                hoverinfo='skip'
+            ))
+        # Líneas en la dirección y
+        for j in range(x_grid_natural.shape[1]):
+            fig.add_trace(go.Scatter3d(
+                x=x_grid_natural[:, j],
+                y=y_grid_natural[:, j],
+                z=z_pred[:, j],
+                mode='lines',
+                line=dict(color='gray', width=2),
+                showlegend=False,
+                hoverinfo='skip'
+            ))
+
+        # --- Fin de la adición de la cuadrícula ---
+
+        # Añadir los puntos de los experimentos en la superficie de respuesta con diferentes colores y etiquetas
+        colors = px.colors.qualitative.Safe
+        point_labels = [f"{row[self.y_name]:.3f}" for _, row in experiments_data.iterrows()]
+
+        fig.add_trace(go.Scatter3d(
+            x=experiments_x_natural,
+            y=experiments_y_natural,
+            z=experiments_data[self.y_name].round(3),
+            mode='markers+text',
+            marker=dict(size=4, color=colors[:len(experiments_x_natural)]),
+            text=point_labels,
+            textposition='top center',
+            name='Experimentos'
+        ))
+
+        # Añadir etiquetas y título con variables naturales
+        fig.update_layout(
+            scene=dict(
+                xaxis_title=f"{varying_variables[0]} ({self.get_units(varying_variables[0])})",
+                yaxis_title=f"{varying_variables[1]} ({self.get_units(varying_variables[1])})",
+                zaxis_title=self.y_name,
+            ),
+            title=f"{self.y_name} vs {varying_variables[0]} y {varying_variables[1]}<br><sup>{fixed_variable} fijo en {fixed_level:.3f} ({self.get_units(fixed_variable)}) (Modelo Simplificado)</sup>",
+            height=800,
+            width=1000,
+            showlegend=True
+        )
+        return fig
+
+    def get_units(self, variable_name):
+        """
+        Define las unidades de las variables para etiquetas.
+        Puedes personalizar este método según tus necesidades.
+        """
+        units = {
+            'Glucosa': 'g/L',
+            'Extracto_de_Levadura': 'g/L',
+            'Triptofano': 'g/L',
+            'AIA_ppm': 'ppm'
+        }
+        return units.get(variable_name, '')
+
+    def generate_all_plots(self):
+        """
+        Genera todas las gráficas de RSM, variando la variable fija y sus niveles usando el modelo simplificado.
+        Almacena las figuras en self.all_figures.
+        """
+        if self.model_simplified is None:
+            print("Error: Ajusta el modelo simplificado primero.")
+            return
+
+        self.all_figures = []  # Resetear la lista de figuras
+
+        # Niveles naturales para graficar
+        levels_to_plot_natural = {
+            self.x1_name: self.x1_levels,
+            self.x2_name: self.x2_levels,
+            self.x3_name: self.x3_levels
         }
 
-    def clean_doi(self, doi):
-        """Clean and encode DOI for URL"""
-        if not isinstance(doi, str):
-            return None
-        return quote(doi.strip()) if doi else None
-
-    async def fetch_with_headers(self, session, url, timeout=10):
-        """Utility method to fetch an URL with headers and timeout"""
-        try:
-            async with session.get(url, headers=self.headers, timeout=timeout, allow_redirects=True) as response:
-                response.raise_for_status()
-                return await response.text(), response.headers
-        except Exception as e:
-            logger.debug(f"Error fetching {url}: {e}")
-            return None, None
-    
-    
-    async def download_paper_direct_doi_async(self, session, doi):
-      """Attempt to download the pdf from the landing page of the doi"""
-      if not doi:
-         return None
-      
-      try:
-         doi_url = f"https://doi.org/{self.clean_doi(doi)}"
-         text, headers = await self.fetch_with_headers(session, doi_url, timeout=15)
-         if not text:
+        # Generar y almacenar gráficos individuales
+        for fixed_variable in [self.x1_name, self.x2_name, self.x3_name]:
+            for level in levels_to_plot_natural[fixed_variable]:
+                fig = self.plot_rsm_individual(fixed_variable, level)
+                if fig is not None:
+                    self.all_figures.append(fig)
+
+    def coded_to_natural(self, coded_value, variable_name):
+        """Convierte un valor codificado a su valor natural."""
+        levels = self.get_levels(variable_name)
+        return levels[0] + (coded_value + 1) * (levels[-1] - levels[0]) / 2
+
+    def natural_to_coded(self, natural_value, variable_name):
+        """Convierte un valor natural a su valor codificado."""
+        levels = self.get_levels(variable_name)
+        return -1 + 2 * (natural_value - levels[0]) / (levels[-1] - levels[0])
+
+    def pareto_chart(self, model, title):
+        """
+        Genera un diagrama de Pareto para los efectos estandarizados de un modelo,
+        incluyendo la línea de significancia.
+        """
+        # Calcular los efectos estandarizados
+        tvalues = model.tvalues[1:]  # Excluir la Intercept
+        abs_tvalues = np.abs(tvalues)
+        sorted_idx = np.argsort(abs_tvalues)[::-1]
+        sorted_tvalues = abs_tvalues[sorted_idx]
+        sorted_names = tvalues.index[sorted_idx]
+
+        # Calcular el valor crítico de t para la línea de significancia
+        alpha = 0.05  # Nivel de significancia
+        dof = model.df_resid  # Grados de libertad residuales
+        t_critical = t.ppf(1 - alpha / 2, dof)
+
+        # Crear el diagrama de Pareto
+        fig = px.bar(
+            x=sorted_tvalues.round(3),
+            y=sorted_names,
+            orientation='h',
+            labels={'x': 'Efecto Estandarizado', 'y': 'Término'},
+            title=title
+        )
+        fig.update_yaxes(autorange="reversed")
+
+        # Agregar la línea de significancia
+        fig.add_vline(x=t_critical, line_dash="dot",
+                      annotation_text=f"t crítico = {t_critical:.3f}",
+                      annotation_position="bottom right")
+
+        return fig
+
+    def get_simplified_equation(self):
+        """
+        Imprime la ecuación del modelo simplificado.
+        """
+        if self.model_simplified is None:
+            print("Error: Ajusta el modelo simplificado primero.")
             return None
 
-         pdf_patterns = [
-           r'(https?://[^\s<>"]+?\.pdf)',
-           r'(https?://[^\s<>"]+?download/[^\s<>"]+)',
-           r'(https?://[^\s<>"]+?\/pdf\/[^\s<>"]+)',
-         ]
-            
-         pdf_urls = []
-         for pattern in pdf_patterns:
-            pdf_urls.extend(re.findall(pattern, text))
-
-         for pdf_url in pdf_urls:
-           try:
-               pdf_response = await session.get(pdf_url, headers=self.headers, timeout=10)
-               if 'application/pdf' in pdf_response.headers.get('Content-Type', ''):
-                    logger.debug(f"Found PDF from: {pdf_url}")
-                    return await pdf_response.read()
-           except Exception as e:
-               logger.debug(f"Error downloading PDF from {pdf_url}: {e}")
-
-
-      except Exception as e:
-           logger.debug(f"Error trying to get the PDF from {doi}: {e}")
-      
-      return None
-
-    async def download_paper_scihub_async(self, session, doi):
-        """Improved method to download paper from Sci-Hub using async requests"""
-        if not doi:
-            logger.warning("DOI not provided")
+        coefficients = self.model_simplified.params
+        equation = f"{self.y_name} = {coefficients['Intercept']:.3f}"
+
+        for term, coef in coefficients.items():
+            if term != 'Intercept':
+                if term == f'{self.x1_name}':
+                    equation += f" + {coef:.3f}*{self.x1_name}"
+                elif term == f'{self.x2_name}':
+                    equation += f" + {coef:.3f}*{self.x2_name}"
+                elif term == f'{self.x3_name}':
+                    equation += f" + {coef:.3f}*{self.x3_name}"
+                elif term == f'I({self.x1_name} ** 2)':
+                    equation += f" + {coef:.3f}*{self.x1_name}^2"
+                elif term == f'I({self.x2_name} ** 2)':
+                    equation += f" + {coef:.3f}*{self.x2_name}^2"
+                elif term == f'I({self.x3_name} ** 2)':
+                    equation += f" + {coef:.3f}*{self.x3_name}^2"
+
+        return equation
+
+    def generate_prediction_table(self):
+        """
+        Genera una tabla con los valores actuales, predichos y residuales.
+        """
+        if self.model_simplified is None:
+            print("Error: Ajusta el modelo simplificado primero.")
             return None
 
-        for base_url in self.download_sources:
-            try:
-                scihub_url = f"{base_url}{self.clean_doi(doi)}"
-                text, headers = await self.fetch_with_headers(session, scihub_url, timeout=15)
-                if not text:
-                    continue
-
-                # Search for multiple PDF URL patterns
-                pdf_patterns = [
-                    r'(https?://[^\s<>"]+?\.pdf)',
-                    r'(https?://[^\s<>"]+?download/[^\s<>"]+)',
-                    r'(https?://[^\s<>"]+?\/pdf\/[^\s<>"]+)',
-                ]
-
-                pdf_urls = []
-                for pattern in pdf_patterns:
-                    pdf_urls.extend(re.findall(pattern, text))
-
-                # Try downloading from found URLs
-                for pdf_url in pdf_urls:
-                    try:
-                        pdf_response = await session.get(pdf_url, headers=self.headers, timeout=10)
-                        # Verify if it's a PDF
-                        if 'application/pdf' in pdf_response.headers.get('Content-Type', ''):
-                            logger.debug(f"Found PDF from: {pdf_url}")
-                            return await pdf_response.read()
-                    except Exception as e:
-                        logger.debug(f"Error downloading PDF from {pdf_url}: {e}")
-
-            except Exception as e:
-                logger.debug(f"Error trying to download {doi} from {base_url}: {e}")
+        self.data['Predicho'] = self.model_simplified.predict(self.data)
+        self.data['Residual'] = self.data[self.y_name] - self.data['Predicho']
 
-        return None
+        return self.data[[self.y_name, 'Predicho', 'Residual']].round(3)
 
-    async def download_paper_libgen_async(self, session, doi):
-        """Download from Libgen, handles the query and the redirection"""
-        if not doi:
+    def calculate_contribution_percentage(self):
+        """
+        Calcula el porcentaje de contribución de cada factor a la variabilidad de la respuesta (AIA).
+        """
+        if self.model_simplified is None:
+            print("Error: Ajusta el modelo simplificado primero.")
             return None
 
-        base_url = 'https://libgen.rs/scimag/'
-        try:
-            search_url = f"{base_url}?q={self.clean_doi(doi)}"
-            text, headers = await self.fetch_with_headers(session, search_url, timeout=10)
-
-            if not text or "No results" in text:
-                logger.debug(f"No results for DOI: {doi} on libgen")
-                return None
-
-            soup = BeautifulSoup(text, 'html.parser')
-
-            links = soup.select('table.c > tbody > tr:nth-child(2) > td:nth-child(1) > a')
-
-            if links:
-                link = links[0]
-                pdf_url = link['href']
-                pdf_response = await session.get(pdf_url, headers=self.headers, allow_redirects=True, timeout=10)
-                if 'application/pdf' in pdf_response.headers.get('Content-Type', ''):
-                    logger.debug(f"Found PDF from: {pdf_url}")
-                    return await pdf_response.read()
-        except Exception as e:
-            logger.debug(f"Error trying to download {doi} from libgen: {e}")
-        return None
-
-    async def download_paper_google_scholar_async(self, session, doi):
-        """Search google scholar to find an article with the given doi, try to get the pdf"""
-        if not doi:
+        # ANOVA del modelo simplificado
+        anova_table = sm.stats.anova_lm(self.model_simplified, typ=2)
+
+        # Suma de cuadrados total
+        ss_total = anova_table['sum_sq'].sum()
+
+        # Crear tabla de contribución
+        contribution_table = pd.DataFrame({
+            'Factor': [],
+            'Suma de Cuadrados': [],
+            '% Contribución': []
+        })
+        
+        # Calcular porcentaje de contribución para cada factor
+        for index, row in anova_table.iterrows():
+            if index != 'Residual':
+                factor_name = index
+                if factor_name == f'I({self.x1_name} ** 2)':
+                    factor_name = f'{self.x1_name}^2'
+                elif factor_name == f'I({self.x2_name} ** 2)':
+                    factor_name = f'{self.x2_name}^2'
+                elif factor_name == f'I({self.x3_name} ** 2)':
+                    factor_name = f'{self.x3_name}^2'
+                
+                ss_factor = row['sum_sq']
+                contribution_percentage = (ss_factor / ss_total) * 100
+
+                contribution_table = pd.concat([contribution_table, pd.DataFrame({
+                    'Factor': [factor_name],
+                    'Suma de Cuadrados': [ss_factor],
+                    '% Contribución': [contribution_percentage]
+                })], ignore_index=True)
+
+        return contribution_table.round(3)
+
+    def calculate_detailed_anova(self):
+        """
+        Calcula la tabla ANOVA detallada con la descomposición del error residual.
+        """
+        if self.model_simplified is None:
+            print("Error: Ajusta el modelo simplificado primero.")
             return None
 
-        try:
-            query = f'doi:"{doi}"'
-            params = {'q': query}
-            url = f'https://scholar.google.com/scholar?{urlencode(params)}'
+        # --- ANOVA detallada ---
+        # 1. Ajustar un modelo solo con los términos de primer orden y cuadráticos
+        formula_reduced = f'{self.y_name} ~ {self.x1_name} + {self.x2_name} + {self.x3_name} + ' \
+                          f'I({self.x1_name}**2) + I({self.x2_name}**2) + I({self.x3_name}**2)'
+        model_reduced = smf.ols(formula_reduced, data=self.data).fit()
 
-            text, headers = await self.fetch_with_headers(session, url, timeout=10)
-            if not text:
-                return None
+        # 2. ANOVA del modelo reducido (para obtener la suma de cuadrados de la regresión)
+        anova_reduced = sm.stats.anova_lm(model_reduced, typ=2)
 
-            soup = BeautifulSoup(text, 'html.parser')
+        # 3. Suma de cuadrados total
+        ss_total = np.sum((self.data[self.y_name] - self.data[self.y_name].mean())**2)
 
-            # Find any links with [PDF]
-            links = soup.find_all('a', string=re.compile(r'\[PDF\]', re.IGNORECASE))
+        # 4. Grados de libertad totales
+        df_total = len(self.data) - 1
 
-            if links:
-                pdf_url = links[0]['href']
-                pdf_response = await session.get(pdf_url, headers=self.headers, timeout=10)
-                if 'application/pdf' in pdf_response.headers.get('Content-Type', ''):
-                    logger.debug(f"Found PDF from: {pdf_url}")
-                    return await pdf_response.read()
-        except Exception as e:
-            logger.debug(f"Google Scholar error for {doi}: {e}")
+        # 5. Suma de cuadrados de la regresión
+        ss_regression = anova_reduced['sum_sq'][:-1].sum()  # Sumar todo excepto 'Residual'
 
-        return None
-
-    async def download_paper_crossref_async(self, session, doi):
-        """Alternative search method using Crossref"""
-        if not doi:
-            return None
-
-        try:
-            # Search for open access link
-            url = f"https://api.crossref.org/works/{doi}"
-            response = await session.get(url, headers=self.headers, timeout=10)
-
-            if response.status == 200:
-                data = await response.json()
-                work = data.get('message', {})
-
-                # Search for open access links
-                links = work.get('link', [])
-                for link in links:
-                    if link.get('content-type') == 'application/pdf':
-                        pdf_url = link.get('URL')
-                        if pdf_url:
-                            pdf_response = await session.get(pdf_url, headers=self.headers)
-                            if 'application/pdf' in pdf_response.headers.get('Content-Type', ''):
-                                logger.debug(f"Found PDF from: {pdf_url}")
-                                return await pdf_response.read()
-
-        except Exception as e:
-            logger.debug(f"Crossref error for {doi}: {e}")
-
-        return None
+        # 6. Grados de libertad de la regresión
+        df_regression = len(anova_reduced) - 1
 
-    async def download_with_retry_async(self, doi, max_retries=3, initial_delay=2):
-        """Downloads a paper using multiple strategies with exponential backoff and async requests"""
-        pdf_content = None
-        retries = 0
-        delay = initial_delay
-
-        async with aiohttp.ClientSession() as session:
-            while retries < max_retries and not pdf_content:
-                try:
-                    pdf_content = (
-                        await self.download_paper_direct_doi_async(session, doi) or
-                        await self.download_paper_scihub_async(session, doi) or
-                        await self.download_paper_libgen_async(session, doi) or
-                        await self.download_paper_google_scholar_async(session, doi) or
-                        await self.download_paper_crossref_async(session, doi)
-
-                    )
-                    if pdf_content:
-                        return pdf_content
-                except Exception as e:
-                    logger.error(f"Error in download attempt {retries + 1} for DOI {doi}: {e}")
-
-                if not pdf_content:
-                    retries += 1
-                    logger.warning(f"Retry attempt {retries} for DOI: {doi} after {delay} seconds")
-                    await asyncio.sleep(delay)
-                    delay *= 2  # Exponential backoff
+        # 7. Suma de cuadrados del error residual
+        ss_residual = self.model_simplified.ssr
+        df_residual = self.model_simplified.df_resid
 
-        return None
+        # 8. Suma de cuadrados del error puro (se calcula a partir de las réplicas)
+        replicas = self.data[self.data.duplicated(subset=[self.x1_name, self.x2_name, self.x3_name], keep=False)]
+        if not replicas.empty:
+            ss_pure_error = replicas.groupby([self.x1_name, self.x2_name, self.x3_name])[self.y_name].var().sum() * replicas.groupby([self.x1_name, self.x2_name, self.x3_name]).ngroups
+            df_pure_error = len(replicas) - replicas.groupby([self.x1_name, self.x2_name, self.x3_name]).ngroups
+        else:
+            ss_pure_error = np.nan
+            df_pure_error = np.nan
+
+        # 9. Suma de cuadrados de la falta de ajuste
+        ss_lack_of_fit = ss_residual - ss_pure_error if not np.isnan(ss_pure_error) else np.nan
+        df_lack_of_fit = df_residual - df_pure_error if not np.isnan(df_pure_error) else np.nan
+
+        # 10. Cuadrados medios
+        ms_regression = ss_regression / df_regression
+        ms_residual = ss_residual / df_residual
+        ms_lack_of_fit = ss_lack_of_fit / df_lack_of_fit if not np.isnan(ss_lack_of_fit) else np.nan
+        ms_pure_error = ss_pure_error / df_pure_error if not np.isnan(ss_pure_error) else np.nan
+
+        # 11. Estadístico F y valor p para la falta de ajuste
+        f_lack_of_fit = ms_lack_of_fit / ms_pure_error if not np.isnan(ms_lack_of_fit) else np.nan
+        p_lack_of_fit = 1 - f.cdf(f_lack_of_fit, df_lack_of_fit, df_pure_error) if not np.isnan(f_lack_of_fit) else np.nan
+
+        # 12. Crear la tabla ANOVA detallada
+        detailed_anova_table = pd.DataFrame({
+            'Fuente de Variación': ['Regresión', 'Residual', 'Falta de Ajuste', 'Error Puro', 'Total'],
+            'Suma de Cuadrados': [ss_regression, ss_residual, ss_lack_of_fit, ss_pure_error, ss_total],
+            'Grados de Libertad': [df_regression, df_residual, df_lack_of_fit, df_pure_error, df_total],
+            'Cuadrado Medio': [ms_regression, ms_residual, ms_lack_of_fit, ms_pure_error, np.nan],
+            'F': [np.nan, np.nan, f_lack_of_fit, np.nan, np.nan],
+            'Valor p': [np.nan, np.nan, p_lack_of_fit, np.nan, np.nan]
+        })
+        
+        # Calcular la suma de cuadrados y grados de libertad para la curvatura
+        ss_curvature = anova_reduced['sum_sq'][f'I({self.x1_name} ** 2)'] + anova_reduced['sum_sq'][f'I({self.x2_name} ** 2)'] + anova_reduced['sum_sq'][f'I({self.x3_name} ** 2)']
+        df_curvature = 3
+
+        # Añadir la fila de curvatura a la tabla ANOVA
+        detailed_anova_table.loc[len(detailed_anova_table)] = ['Curvatura', ss_curvature, df_curvature, ss_curvature / df_curvature, np.nan, np.nan]
+
+        # Reorganizar las filas para que la curvatura aparezca después de la regresión
+        detailed_anova_table = detailed_anova_table.reindex([0, 5, 1, 2, 3, 4])
+        
+        # Resetear el índice para que sea consecutivo
+        detailed_anova_table = detailed_anova_table.reset_index(drop=True)
+
+        return detailed_anova_table.round(3)
+
+    def get_all_tables(self):
+        """
+        Obtiene todas las tablas generadas para ser exportadas a Excel.
+        """
+        prediction_table = self.generate_prediction_table()
+        contribution_table = self.calculate_contribution_percentage()
+        detailed_anova_table = self.calculate_detailed_anova()
+
+        return {
+            'Predicciones': prediction_table,
+            '% Contribución': contribution_table,
+            'ANOVA Detallada': detailed_anova_table
+        }
 
-    def download_paper_scihub(self, doi):
-        """Improved method to download paper from Sci-Hub"""
-        if not doi:
-            logger.warning("DOI not provided")
+    def save_figures_to_zip(self):
+        """
+        Guarda todas las figuras almacenadas en self.all_figures a un archivo ZIP en memoria.
+        """
+        if not self.all_figures:
             return None
 
-        for base_url in self.download_sources:
-            try:
-                scihub_url = f"{base_url}{self.clean_doi(doi)}"
-
-                # Request with more tolerance
-                response = requests.get(scihub_url,
-                                        headers=self.headers,
-                                        allow_redirects=True,
-                                        timeout=15)
-
-                # Search for multiple PDF URL patterns
-                pdf_patterns = [
-                    r'(https?://[^\s<>"]+?\.pdf)',
-                    r'(https?://[^\s<>"]+?download/[^\s<>"]+)',
-                    r'(https?://[^\s<>"]+?\/pdf\/[^\s<>"]+)',
-                ]
-
-                pdf_urls = []
-                for pattern in pdf_patterns:
-                    pdf_urls.extend(re.findall(pattern, response.text))
-
-                # Try downloading from found URLs
-                for pdf_url in pdf_urls:
-                    try:
-                        pdf_response = requests.get(pdf_url,
-                                                    headers=self.headers,
-                                                    timeout=10)
-
-                        # Verify if it's a PDF
-                        if 'application/pdf' in pdf_response.headers.get('Content-Type', ''):
-                            logger.debug(f"Found PDF from: {pdf_url}")
-                            return pdf_response.content
-                    except Exception as e:
-                        logger.debug(f"Error downloading PDF from {pdf_url}: {e}")
-
-            except Exception as e:
-                logger.debug(f"Error trying to download {doi} from {base_url}: {e}")
-
-        return None
-
-    def download_paper_libgen(self, doi):
-        """Download from Libgen, handles the query and the redirection"""
-        if not doi:
+        zip_buffer = io.BytesIO()
+        with zipfile.ZipFile(zip_buffer, 'w') as zip_file:
+            for idx, fig in enumerate(self.all_figures, start=1):
+                img_bytes = fig.to_image(format="png")
+                zip_file.writestr(f'Grafico_{idx}.png', img_bytes)
+        zip_buffer.seek(0)
+
+        # Guardar en un archivo temporal
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".zip") as temp_file:
+            temp_file.write(zip_buffer.read())
+            temp_path = temp_file.name
+
+        return temp_path
+
+    def save_fig_to_bytes(self, fig):
+        """
+        Convierte una figura Plotly a bytes en formato PNG.
+        """
+        return fig.to_image(format="png")
+
+    def save_all_figures_png(self):
+        """
+        Guarda todas las figuras en archivos PNG temporales y retorna las rutas.
+        """
+        png_paths = []
+        for idx, fig in enumerate(self.all_figures, start=1):
+            img_bytes = fig.to_image(format="png")
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as temp_file:
+                temp_file.write(img_bytes)
+                temp_path = temp_file.name
+                png_paths.append(temp_path)
+        return png_paths
+
+    def save_tables_to_excel(self):
+        """
+        Guarda todas las tablas en un archivo Excel con múltiples hojas y retorna la ruta del archivo.
+        """
+        if 'rsm' not in globals():
             return None
 
-        base_url = 'https://libgen.rs/scimag/'
-        try:
-            search_url = f"{base_url}?q={self.clean_doi(doi)}"
-            response = requests.get(search_url, headers=self.headers, allow_redirects=True, timeout=10)
-            response.raise_for_status()
+        tables = self.get_all_tables()
+        excel_buffer = io.BytesIO()
+        with pd.ExcelWriter(excel_buffer, engine='xlsxwriter') as writer:
+            for sheet_name, table in tables.items():
+                table.to_excel(writer, sheet_name=sheet_name, index=False)
+        excel_buffer.seek(0)
+        excel_bytes = excel_buffer.read()
 
-            if "No results" in response.text:
-                logger.debug(f"No results for DOI: {doi} on libgen")
-                return None
+        # Guardar en un archivo temporal
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx") as temp_file:
+            temp_file.write(excel_bytes)
+            temp_path = temp_file.name
 
-            soup = BeautifulSoup(response.text, 'html.parser')
-
-            # Find the link using a specific selector
-            links = soup.select('table.c > tbody > tr:nth-child(2) > td:nth-child(1) > a')
-
-            if links:
-                link = links[0]
-                pdf_url = link['href']
-                pdf_response = requests.get(pdf_url, headers=self.headers, allow_redirects=True, timeout=10)
-                if 'application/pdf' in pdf_response.headers.get('Content-Type', ''):
-                    logger.debug(f"Found PDF from: {pdf_url}")
-                    return pdf_response.content
-
-        except Exception as e:
-            logger.debug(f"Error trying to download {doi} from libgen: {e}")
-        return None
-
-    def download_paper_google_scholar(self, doi):
-        """Search google scholar to find an article with the given doi, try to get the pdf"""
-        if not doi:
-            return None
+        return temp_path
 
-        try:
-            query = f'doi:"{doi}"'
-            params = {'q': query}
-            url = f'https://scholar.google.com/scholar?{urlencode(params)}'
+# --- Funciones para la interfaz de Gradio ---
 
-            response = requests.get(url, headers=self.headers, timeout=10)
-            response.raise_for_status()
-
-            soup = BeautifulSoup(response.text, 'html.parser')
+def load_data(x1_name, x2_name, x3_name, y_name, x1_levels_str, x2_levels_str, x3_levels_str, data_str):
+    """
+    Carga los datos del diseño Box-Behnken desde cajas de texto y crea la instancia de RSM_BoxBehnken.
+    """
+    try:
+        # Convertir los niveles a listas de números
+        x1_levels = [float(x.strip()) for x in x1_levels_str.split(',')]
+        x2_levels = [float(x.strip()) for x in x2_levels_str.split(',')]
+        x3_levels = [float(x.strip()) for x in x3_levels_str.split(',')]
+
+        # Crear DataFrame a partir de la cadena de datos
+        data_list = [row.split(',') for row in data_str.strip().split('\n')]
+        column_names = ['Exp.', x1_name, x2_name, x3_name, y_name]
+        data = pd.DataFrame(data_list, columns=column_names)
+        data = data.apply(pd.to_numeric, errors='coerce')  # Convertir a numérico
+
+        # Validar que el DataFrame tenga las columnas correctas
+        if not all(col in data.columns for col in column_names):
+            raise ValueError("El formato de los datos no es correcto.")
+
+        # Crear la instancia de RSM_BoxBehnken
+        global rsm
+        rsm = RSM_BoxBehnken(data, x1_name, x2_name, x3_name, y_name, x1_levels, x2_levels, x3_levels)
+
+        return data.round(3), x1_name, x2_name, x3_name, y_name, x1_levels, x2_levels, x3_levels, gr.update(visible=True)
+    
+    except Exception as e:
+        # Mostrar mensaje de error
+        error_message = f"Error al cargar los datos: {str(e)}"
+        print(error_message)
+        return None, "", "", "", "", [], [], [], gr.update(visible=False)
+
+def fit_and_optimize_model():
+    if 'rsm' not in globals():
+        return [None]*10
+    
+    # Ajustar modelos y optimizar
+    model_completo, pareto_completo = rsm.fit_model()
+    model_simplificado, pareto_simplificado = rsm.fit_simplified_model()
+    optimization_table = rsm.optimize()
+    equation = rsm.get_simplified_equation()
+    prediction_table = rsm.generate_prediction_table()
+    contribution_table = rsm.calculate_contribution_percentage()
+    anova_table = rsm.calculate_detailed_anova()
+    
+    # Generar todas las figuras y almacenarlas
+    rsm.generate_all_plots()
+    
+    # Formatear la ecuación para que se vea mejor en Markdown
+    equation_formatted = equation.replace(" + ", "<br>+ ").replace(" ** ", "^").replace("*", " × ")
+    equation_formatted = f"### Ecuación del Modelo Simplificado:<br>{equation_formatted}"
+    
+    # Guardar las tablas en Excel temporal
+    excel_path = rsm.save_tables_to_excel()
+
+    # Guardar todas las figuras en un ZIP temporal
+    zip_path = rsm.save_figures_to_zip()
+
+    return (
+        model_completo.summary().as_html(),
+        pareto_completo,
+        model_simplificado.summary().as_html(),
+        pareto_simplificado,
+        equation_formatted,
+        optimization_table,
+        prediction_table,
+        contribution_table,
+        anova_table,
+        zip_path,  # Ruta del ZIP de gráficos
+        excel_path  # Ruta del Excel de tablas
+    )
 
-            # Find any links with [PDF]
-            links = soup.find_all('a', string=re.compile(r'\[PDF\]', re.IGNORECASE))
+def show_plot(current_index, all_figures):
+    if not all_figures:
+        return None, "No hay gráficos disponibles.", current_index
+    selected_fig = all_figures[current_index]
+    plot_info_text = f"Gráfico {current_index + 1} de {len(all_figures)}"
+    return selected_fig, plot_info_text, current_index
 
-            if links:
-                pdf_url = links[0]['href']
-                pdf_response = requests.get(pdf_url, headers=self.headers, timeout=10)
-                if 'application/pdf' in pdf_response.headers.get('Content-Type', ''):
-                    logger.debug(f"Found PDF from: {pdf_url}")
-                    return pdf_response.content
-        except Exception as e:
-            logger.debug(f"Google Scholar error for {doi}: {e}")
+def navigate_plot(direction, current_index, all_figures):
+    """
+    Navega entre los gráficos.
+    """
+    if not all_figures:
+        return None, "No hay gráficos disponibles.", current_index
+    
+    if direction == 'left':
+        new_index = (current_index - 1) % len(all_figures)
+    elif direction == 'right':
+        new_index = (current_index + 1) % len(all_figures)
+    else:
+        new_index = current_index
+    
+    selected_fig = all_figures[new_index]
+    plot_info_text = f"Gráfico {new_index + 1} de {len(all_figures)}"
+    
+    return selected_fig, plot_info_text, new_index
 
+def download_current_plot(all_figures, current_index):
+    """
+    Descarga la figura actual como PNG.
+    """
+    if not all_figures:
         return None
+    fig = all_figures[current_index]
+    img_bytes = rsm.save_fig_to_bytes(fig)
+    filename = f"Grafico_RSM_{current_index + 1}.png"
+    
+    # Crear un archivo temporal
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as temp_file:
+        temp_file.write(img_bytes)
+        temp_path = temp_file.name
+    
+    return temp_path  # Retornar solo la ruta
 
-    def download_paper_crossref(self, doi):
-        """Alternative search method using Crossref"""
-        if not doi:
-            return None
-
-        try:
-            # Search for open access link
-            url = f"https://api.crossref.org/works/{doi}"
-            response = requests.get(url, headers=self.headers, timeout=10)
-
-            if response.status_code == 200:
-                data = response.json()
-                work = data.get('message', {})
-
-                # Search for open access links
-                links = work.get('link', [])
-                for link in links:
-                    if link.get('content-type') == 'application/pdf':
-                        pdf_url = link.get('URL')
-                        if pdf_url:
-                            pdf_response = requests.get(pdf_url, headers=self.headers)
-                            if 'application/pdf' in pdf_response.headers.get('Content-Type', ''):
-                                logger.debug(f"Found PDF from: {pdf_url}")
-                                return pdf_response.content
-
-        except Exception as e:
-            logger.debug(f"Crossref error for {doi}: {e}")
-
+def download_all_plots_zip(all_figures):
+    """
+    Descarga todas las figuras en un archivo ZIP.
+    """
+    if not all_figures:
         return None
+    zip_path = rsm.save_figures_to_zip()
+    filename = f"Graficos_RSM_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip"
+    return zip_path  # Retornar solo la ruta
 
-    def download_with_retry(self, doi, max_retries=3, initial_delay=2):
-        """Downloads a paper using multiple strategies with exponential backoff"""
-        pdf_content = None
-        retries = 0
-        delay = initial_delay
-
-        while retries < max_retries and not pdf_content:
-            try:
-                 pdf_content = (
-                     self.download_paper_scihub(doi) or
-                     self.download_paper_libgen(doi) or
-                     self.download_paper_google_scholar(doi) or
-                     self.download_paper_crossref(doi)
-
-                  )
-
-                 if pdf_content:
-                     return pdf_content
-            except Exception as e:
-                logger.error(f"Error in download attempt {retries + 1} for DOI {doi}: {e}")
-
-            if not pdf_content:
-                retries += 1
-                logger.warning(f"Retry attempt {retries} for DOI: {doi} after {delay} seconds")
-                time.sleep(delay)
-                delay *= 2  # Exponential backoff
-
+def download_all_tables_excel():
+    """
+    Descarga todas las tablas en un archivo Excel con múltiples hojas.
+    """
+    if 'rsm' not in globals():
         return None
+    excel_path = rsm.save_tables_to_excel()
+    filename = f"Tablas_RSM_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
+    return excel_path  # Retornar solo la ruta
 
-    def download_single_doi(self, doi):
-        """Downloads a single paper using a DOI"""
-        if not doi:
-            return None, "Error: DOI not provided", "Error: DOI not provided"
-
-        try:
-            pdf_content = self.download_with_retry(doi)
-
-            if pdf_content:
-                if doi is None:
-                    return None, "Error: DOI not provided", "Error: DOI not provided"
-                filename = f"{str(doi).replace('/', '_').replace('.', '_')}.pdf"
-                filepath = os.path.join(self.output_dir, filename)
-                with open(filepath, 'wb') as f:
-                    f.write(pdf_content)
-                logger.info(f"Successfully downloaded: {filename}")
-                return filepath, f'<div style="display: flex; align-items: center;">✓ <a href="https://doi.org/{doi}">{doi}</a> <button onclick="copyLink(this)">Copy</button></div>', ""
-            else:
-                logger.warning(f"Could not download: {doi}")
-                return None, f"Could not download {doi}", f'<div style="display: flex; align-items: center;">❌ <a href="https://doi.org/{doi}">{doi}</a>  <button onclick="copyLink(this)">Copy</button></div>'
-
-        except Exception as e:
-            logger.error(f"Error processing {doi}: {e}")
-            return None, f"Error processing {doi}: {e}", f"Error processing {doi}: {e}"
-
-    def download_multiple_dois(self, dois_text):
-        """Downloads multiple papers from a list of DOIs"""
-        if not dois_text:
-            return None, "Error: No DOIs provided", "Error: No DOIs provided"
-
-        dois = [doi.strip() for doi in dois_text.split('\n') if doi.strip()]
-        if not dois:
-            return None, "Error: No valid DOIs provided", "Error: No valid DOIs provided"
-
-        downloaded_files = []
-        failed_dois = []
-        downloaded_links = []
-        for i, doi in enumerate(tqdm(dois, desc="Downloading papers")):
-            filepath, success_message, fail_message = self.download_single_doi(doi)
-            if filepath:
-                # Unique filename for zip
-                filename = f"{str(doi).replace('/', '_').replace('.', '_')}_{i}.pdf"
-                filepath_unique = os.path.join(self.output_dir, filename)
-                os.rename(filepath, filepath_unique)
-                downloaded_files.append(filepath_unique)
-                downloaded_links.append(f'<div style="display: flex; align-items: center;">✓ <a href="https://doi.org/{doi}">{doi}</a>  <button onclick="copyLink(this)">Copy</button></div>')
-
-            else:
-                failed_dois.append(f'<div style="display: flex; align-items: center;">❌ <a href="https://doi.org/{doi}">{doi}</a>  <button onclick="copyLink(this)">Copy</button></div>')
-
-        if downloaded_files:
-            zip_filename = 'papers.zip'
-            with zipfile.ZipFile(zip_filename, 'w') as zipf:
-                for file_path in downloaded_files:
-                    zipf.write(file_path, arcname=os.path.basename(file_path))
-            logger.info(f"ZIP file created: {zip_filename}")
-
-        return zip_filename if downloaded_files else None, "\n".join(downloaded_links), "\n".join(failed_dois)
-
-    def process_bibtex(self, bib_file):
-        """Process BibTeX file and download papers with multiple strategies"""
-        # Read BibTeX file content from the uploaded object
-        try:
-            with open(bib_file.name, 'r', encoding='utf-8') as f:
-                bib_content = f.read()
-        except Exception as e:
-            logger.error(f"Error reading uploaded file {bib_file.name}: {e}")
-            return None, f"Error reading uploaded file {bib_file.name}: {e}", f"Error reading uploaded file {bib_file.name}: {e}", None
-
-        # Parse BibTeX data
-        try:
-            bib_database = bibtexparser.loads(bib_content)
-        except Exception as e:
-            logger.error(f"Error parsing BibTeX data: {e}")
-            return None, f"Error parsing BibTeX data: {e}", f"Error parsing BibTeX data: {e}", None
-
-        # Extract DOIs
-        dois = [entry.get('doi') for entry in bib_database.entries if entry.get('doi')]
-        logger.info(f"Found {len(dois)} DOIs to download")
-
-        # Result lists
-        downloaded_files = []
-        failed_dois = []
-        downloaded_links = []
-
-        # Download PDFs
-        for doi in tqdm(dois, desc="Downloading papers"):
-            try:
-                # Try to download with multiple methods with retries
-                pdf_content = self.download_with_retry(doi)
-
-                # Save PDF
-                if pdf_content:
-                    if doi is None:
-                        return None, "Error: DOI not provided", "Error: DOI not provided", None
-                    filename = f"{str(doi).replace('/', '_').replace('.', '_')}.pdf"
-                    filepath = os.path.join(self.output_dir, filename)
-
-                    with open(filepath, 'wb') as f:
-                        f.write(pdf_content)
-
-                    downloaded_files.append(filepath)
-                    downloaded_links.append(f'<div style="display: flex; align-items: center;">✓ <a href="https://doi.org/{doi}">{doi}</a>  <button onclick="copyLink(this)">Copy</button></div>')
-                    logger.info(f"Successfully downloaded: {filename}")
-                else:
-                    failed_dois.append(f'<div style="display: flex; align-items: center;">❌ <a href="https://doi.org/{doi}">{doi}</a>  <button onclick="copyLink(this)">Copy</button></div>')
-
-            except Exception as e:
-                failed_dois.append(f'<div style="display: flex; align-items: center;">❌ <a href="https://doi.org/{doi}">{doi}</a>  <button onclick="copyLink(this)">Copy</button></div>')
-                logger.error(f"Error processing {doi}: {e}")
-
-        # Create ZIP of downloaded papers
-        if downloaded_files:
-            zip_filename = 'papers.zip'
-            with zipfile.ZipFile(zip_filename, 'w') as zipf:
-                for file_path in downloaded_files:
-                    zipf.write(file_path, arcname=os.path.basename(file_path))
-            logger.info(f"ZIP file created: {zip_filename}")
-
-        return zip_filename, "\n".join(downloaded_links), "\n".join(failed_dois), None
-
-    async def process_bibtex_async(self, bib_file):
-        """Process BibTeX file and download papers with multiple strategies"""
-        # Read BibTeX file content from the uploaded object
-        try:
-            with open(bib_file.name, 'r', encoding='utf-8') as f:
-                bib_content = f.read()
-        except Exception as e:
-            logger.error(f"Error reading uploaded file {bib_file.name}: {e}")
-            return None, f"Error reading uploaded file {bib_file.name}: {e}", f"Error reading uploaded file {bib_file.name}: {e}", None
-
-        # Parse BibTeX data
-        try:
-            bib_database = bibtexparser.loads(bib_content)
-        except Exception as e:
-            logger.error(f"Error parsing BibTeX data: {e}")
-            return None, f"Error parsing BibTeX data: {e}", f"Error parsing BibTeX data: {e}", None
-
-        # Extract DOIs
-        dois = [entry.get('doi') for entry in bib_database.entries if entry.get('doi')]
-        logger.info(f"Found {len(dois)} DOIs to download")
-
-        # Result lists
-        downloaded_files = []
-        failed_dois = []
-        downloaded_links = []
-
-        # Download PDFs
-        for doi in tqdm(dois, desc="Downloading papers"):
-            try:
-                # Try to download with multiple methods with retries
-                pdf_content = await self.download_with_retry_async(doi)
-
-                # Save PDF
-                if pdf_content:
-                    if doi is None:
-                        return None, "Error: DOI not provided", "Error: DOI not provided", None
-                    filename = f"{str(doi).replace('/', '_').replace('.', '_')}.pdf"
-                    filepath = os.path.join(self.output_dir, filename)
-
-                    with open(filepath, 'wb') as f:
-                        f.write(pdf_content)
-
-                    downloaded_files.append(filepath)
-                    downloaded_links.append(f'<div style="display: flex; align-items: center;">✓ <a href="https://doi.org/{doi}">{doi}</a>  <button onclick="copyLink(this)">Copy</button></div>')
-                    logger.info(f"Successfully downloaded: {filename}")
-                else:
-                    failed_dois.append(f'<div style="display: flex; align-items: center;">❌ <a href="https://doi.org/{doi}">{doi}</a>  <button onclick="copyLink(this)">Copy</button></div>')
-
-            except Exception as e:
-                failed_dois.append(f'<div style="display: flex; align-items: center;">❌ <a href="https://doi.org/{doi}">{doi}</a>  <button onclick="copyLink(this)">Copy</button></div>')
-                logger.error(f"Error processing {doi}: {e}")
-
-        # Create ZIP of downloaded papers
-        if downloaded_files:
-            zip_filename = 'papers.zip'
-            with zipfile.ZipFile(zip_filename, 'w') as zipf:
-                for file_path in downloaded_files:
-                    zipf.write(file_path, arcname=os.path.basename(file_path))
-            logger.info(f"ZIP file created: {zip_filename}")
-
-        return zip_filename, "\n".join(downloaded_links), "\n".join(failed_dois), None
-
-def create_gradio_interface():
-    """Create Gradio interface for Paper Downloader"""
-    downloader = PaperDownloader()
-
-    async def download_papers(bib_file, doi_input, dois_input):
-        if bib_file:
-            # Check file type
-            if not bib_file.name.lower().endswith('.bib'):
-                return None, "Error: Please upload a .bib file", "Error: Please upload a .bib file", None
-
-            zip_path, downloaded_dois, failed_dois, _ = await downloader.process_bibtex_async(bib_file)
-            return zip_path, downloaded_dois, failed_dois, None
-        elif doi_input:
-            filepath, message, failed_doi = downloader.download_single_doi(doi_input)
-            return None, message, failed_doi, filepath
-        elif dois_input:
-            zip_path, downloaded_dois, failed_dois = downloader.download_multiple_dois(dois_input)
-            return zip_path, downloaded_dois, failed_dois, None
-        else:
-            return None, "Please provide a .bib file, a single DOI, or a list of DOIs", "Please provide a .bib file, a single DOI, or a list of DOIs", None
-
-    # Gradio Interface
-    interface = gr.Interface(
-        fn=download_papers,
-        inputs=[
-            gr.File(file_types=['.bib'], label="Upload BibTeX File"),
-            gr.Textbox(label="Enter Single DOI", placeholder="10.xxxx/xxxx"),
-            gr.Textbox(label="Enter Multiple DOIs (one per line)", placeholder="10.xxxx/xxxx\n10.yyyy/yyyy\n...")
-        ],
+# --- Crear la interfaz de Gradio ---
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Optimización de la producción de AIA usando RSM Box-Behnken")
+    
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("## Configuración del Diseño")
+            x1_name_input = gr.Textbox(label="Nombre de la Variable X1 (ej. Glucosa)", value="Glucosa")
+            x2_name_input = gr.Textbox(label="Nombre de la Variable X2 (ej. Extracto de Levadura)", value="Extracto_de_Levadura")
+            x3_name_input = gr.Textbox(label="Nombre de la Variable X3 (ej. Triptófano)", value="Triptofano")
+            y_name_input = gr.Textbox(label="Nombre de la Variable Dependiente (ej. AIA (ppm))", value="AIA_ppm")
+            x1_levels_input = gr.Textbox(label="Niveles de X1 (separados por comas)", value="1, 3.5, 5.5")
+            x2_levels_input = gr.Textbox(label="Niveles de X2 (separados por comas)", value="0.03, 0.2, 0.3")
+            x3_levels_input = gr.Textbox(label="Niveles de X3 (separados por comas)", value="0.4, 0.65, 0.9")
+            data_input = gr.Textbox(label="Datos del Experimento (formato CSV)", lines=10, value="""1,-1,-1,0,166.594
+2,1,-1,0,177.557
+3,-1,1,0,127.261
+4,1,1,0,147.573
+5,-1,0,-1,188.883
+6,1,0,-1,224.527
+7,-1,0,1,190.238
+8,1,0,1,226.483
+9,0,-1,-1,195.550
+10,0,1,-1,149.493
+11,0,-1,1,187.683
+12,0,1,1,148.621
+13,0,0,0,278.951
+14,0,0,0,297.238
+15,0,0,0,280.896""")
+            load_button = gr.Button("Cargar Datos")
+        
+        with gr.Column():
+            gr.Markdown("## Datos Cargados")
+            data_output = gr.Dataframe(label="Tabla de Datos", interactive=False)
+    
+    # Sección de análisis visible solo después de cargar los datos
+    with gr.Row(visible=False) as analysis_row:
+        with gr.Column():
+            fit_button = gr.Button("Ajustar Modelo y Optimizar")
+            gr.Markdown("**Modelo Completo**")
+            model_completo_output = gr.HTML()
+            pareto_completo_output = gr.Plot()
+            gr.Markdown("**Modelo Simplificado**")
+            model_simplificado_output = gr.HTML()
+            pareto_simplificado_output = gr.Plot()
+            gr.Markdown("**Ecuación del Modelo Simplificado**")
+            equation_output = gr.HTML()
+            optimization_table_output = gr.Dataframe(label="Tabla de Optimización", interactive=False)
+            prediction_table_output = gr.Dataframe(label="Tabla de Predicciones", interactive=False)
+            contribution_table_output = gr.Dataframe(label="Tabla de % de Contribución", interactive=False)
+            anova_table_output = gr.Dataframe(label="Tabla ANOVA Detallada", interactive=False)
+            gr.Markdown("## Descargar Todas las Tablas")
+            download_excel_button = gr.DownloadButton("Descargar Tablas en Excel")
+        
+        with gr.Column():
+            gr.Markdown("## Generar Gráficos de Superficie de Respuesta")
+            fixed_variable_input = gr.Dropdown(label="Variable Fija", choices=["Glucosa", "Extracto_de_Levadura", "Triptofano"], value="Glucosa")
+            fixed_level_input = gr.Slider(label="Nivel de Variable Fija", minimum=-1, maximum=1, step=0.01, value=0.0)
+            plot_button = gr.Button("Generar Gráficos")
+            with gr.Row():
+                left_button = gr.Button("<")
+                right_button = gr.Button(">")
+            rsm_plot_output = gr.Plot()
+            plot_info = gr.Textbox(label="Información del Gráfico", value="Gráfico 1 de 9", interactive=False)
+            with gr.Row():
+                download_plot_button = gr.DownloadButton("Descargar Gráfico Actual (PNG)")
+                download_all_plots_button = gr.DownloadButton("Descargar Todos los Gráficos (ZIP)")
+            current_index_state = gr.State(0)  # Estado para el índice actual
+            all_figures_state = gr.State([])  # Estado para todas las figuras
+    
+    # Cargar datos
+    load_button.click(
+        load_data,
+        inputs=[x1_name_input, x2_name_input, x3_name_input, y_name_input, x1_levels_input, x2_levels_input, x3_levels_input, data_input],
+        outputs=[data_output, x1_name_input, x2_name_input, x3_name_input, y_name_input, x1_levels_input, x2_levels_input, x3_levels_input, analysis_row]
+    )
+    
+    # Ajustar modelo y optimizar
+    fit_button.click(
+        fit_and_optimize_model,
+        inputs=[],
         outputs=[
-            gr.File(label="Download Papers (ZIP) or Single PDF"),
-            gr.HTML(label="""
-                <div style='padding-bottom: 5px; font-weight: bold;'>
-                    Found DOIs
-                </div>
-                <div style='border: 1px solid #ddd; padding: 5px; border-radius: 5px;'>
-                    <div id="downloaded-dois"></div>
-                </div>
-            """),
-            gr.HTML(label="""
-                <div style='padding-bottom: 5px; font-weight: bold;'>
-                    Missed DOIs
-                </div>
-                <div style='border: 1px solid #ddd; padding: 5px; border-radius: 5px;'>
-                    <div id="failed-dois"></div>
-                </div>
-            """),
-            gr.File(label="Downloaded Single PDF")
-        ],
-        title="🔬 Academic Paper Batch Downloader",
-        description="Upload a BibTeX file or enter DOIs to download PDFs. We'll attempt to fetch PDFs from multiple sources like Sci-Hub, Libgen, Google Scholar and Crossref. You can use any of the three inputs at any moment.",
-        theme="Hev832/Applio",
-        examples=[
-            ["example.bib", None, None],  # Bibtex File
-            [None, "10.1038/nature12373", None],  # Single DOI
-            [None, None, "10.1109/5.771073\n10.3390/horticulturae8080677"],  # Multiple DOIs
-        ],
-        css="""
-        .gradio-container {
-            background-color: black;
-        }
-        .gr-interface {
-            max-width: 800px;
-            margin: 0 auto;
-        }
-        .gr-box {
-            background-color: black;
-            border-radius: 10px;
-            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-        }
-           .output-text a {
-               color: #007bff; /* Blue color for hyperlinks */
-            }
-        """,
-        cache_examples=False,
+            model_completo_output,
+            pareto_completo_output,
+            model_simplificado_output,
+            pareto_simplificado_output,
+            equation_output,
+            optimization_table_output,
+            prediction_table_output,
+            contribution_table_output,
+            anova_table_output,
+            download_all_plots_button,
+            download_excel_button
+        ]
     )
-
-    # Add Javascript to update HTML
-    interface.load = """
-       function(downloaded_dois, failed_dois) {
-          let downloaded_html = '';
-          downloaded_dois.split('\\n').filter(Boolean).forEach(doi => {
-              downloaded_html +=  doi + '<br>';
-          });
-          document.querySelector("#downloaded-dois").innerHTML = downloaded_html;
-
-          let failed_html = '';
-            failed_dois.split('\\n').filter(Boolean).forEach(doi => {
-            failed_html += doi + '<br>';
-          });
-          document.querySelector("#failed-dois").innerHTML = failed_html;
-          return [downloaded_html, failed_html];
-       }
-    """
     
-    interface.head = """
-    <script>
-        function copyLink(button) {
-            const linkElement = button.previousElementSibling;
-            const link = linkElement.href;
-            navigator.clipboard.writeText(link)
-            .then(() => {
-                button.innerText = '✓ Copied';
-                button.style.color = 'green';
-                setTimeout(() => {
-                    button.innerText = 'Copy';
-                    button.style.color = '';
-                }, 2000);
-            })
-            .catch(err => {
-                console.error('Failed to copy link: ', err);
-            });
-        }
-    </script>
-    """
-    return interface
-
-
-def main():
-    interface = create_gradio_interface()
-    interface.launch(share=True)
-
-
-if __name__ == "__main__":
-    main()
+    # Generar y mostrar los gráficos
+    plot_button.click(
+        lambda fixed_var, fixed_lvl: (rsm.plot_rsm_individual(fixed_var, fixed_lvl), "Gráfico 1 de " + str(len(rsm.all_figures)), 0),
+        inputs=[fixed_variable_input, fixed_level_input],
+        outputs=[rsm_plot_output, plot_info, current_index_state]
+    )
+    
+    # Navegación de gráficos
+    left_button.click(
+        navigate_plot,
+        inputs=[gr.Button.get_value(left_button), current_index_state, all_figures_state],
+        outputs=[rsm_plot_output, plot_info, current_index_state]
+    )
+    right_button.click(
+        navigate_plot,
+        inputs=[gr.Button.get_value(right_button), current_index_state, all_figures_state],
+        outputs=[rsm_plot_output, plot_info, current_index_state]
+    )
+    
+    # Descargar gráfico actual
+    download_plot_button.click(
+        download_current_plot,
+        inputs=[all_figures_state, current_index_state],
+        outputs=download_plot_button
+    )
+    
+    # Descargar todos los gráficos en ZIP
+    download_all_plots_button.click(
+        download_all_plots_zip,
+        inputs=[all_figures_state],
+        outputs=download_all_plots_button
+    )
+    
+    # Descargar todas las tablas en Excel
+    download_excel_button.click(
+        download_all_tables_excel,
+        inputs=[],
+        outputs=download_excel_button
+    )
+    
+    # Ejemplo de uso
+    gr.Markdown("## Ejemplo de uso")
+    gr.Markdown("""
+    1. Introduce los nombres de las variables y sus niveles en las cajas de texto correspondientes.
+    2. Copia y pega los datos del experimento en la caja de texto 'Datos del Experimento'.
+    3. Haz clic en 'Cargar Datos' para cargar los datos en la tabla.
+    4. Haz clic en 'Ajustar Modelo y Optimizar' para ajustar el modelo y encontrar los niveles óptimos de los factores.
+    5. Selecciona una variable fija y su nivel en los controles deslizantes.
+    6. Haz clic en 'Generar Gráficos' para generar los gráficos de superficie de respuesta.
+    7. Navega entre los gráficos usando los botones '<' y '>'.
+    8. Descarga el gráfico actual en PNG o descarga todos los gráficos en un ZIP.
+    9. Descarga todas las tablas en un archivo Excel con el botón correspondiente.
+    """)
+
+demo.launch()