Update app.py

app.py

@@ -1,826 +1,729 @@
-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 os
+import re
+import time
+import logging
+import zipfile
+import requests
+import bibtexparser
+from tqdm import tqdm
+from urllib.parse import quote, urlencode
 import gradio as gr
+from bs4 import BeautifulSoup
 import io
-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)
+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/'
         ]
 
-        # 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
+        # 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',
         }
 
-        # 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.")
+    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:
             return None
 
-        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.")
+         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")
             return None
 
-        self.data['Predicho'] = self.model_simplified.predict(self.data)
-        self.data['Residual'] = self.data[self.y_name] - self.data['Predicho']
+        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}")
 
-        return self.data[[self.y_name, 'Predicho', 'Residual']].round(3)
+        return None
 
-    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.")
+    async def download_paper_libgen_async(self, session, doi):
+        """Download from Libgen, handles the query and the redirection"""
+        if not doi:
             return None
 
-        # 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
+        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)
 
-        # --- 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()
+            if not text or "No results" in text:
+                logger.debug(f"No results for DOI: {doi} on libgen")
+                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)
+            links = soup.select('table.c > tbody > tr:nth-child(2) > td:nth-child(1) > a')
 
-        # 4. Grados de libertad totales
-        df_total = len(self.data) - 1
+            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
 
-        # 5. Suma de cuadrados de la regresión
-        ss_regression = anova_reduced['sum_sq'][:-1].sum()  # Sumar todo excepto 'Residual'
+    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:
+            return None
 
-        # 6. Grados de libertad de la regresión
-        df_regression = len(anova_reduced) - 1
+        try:
+            query = f'doi:"{doi}"'
+            params = {'q': query}
+            url = f'https://scholar.google.com/scholar?{urlencode(params)}'
 
-        # 7. Suma de cuadrados del error residual
-        ss_residual = self.model_simplified.ssr
-        df_residual = self.model_simplified.df_resid
+            text, headers = await self.fetch_with_headers(session, url, timeout=10)
+            if not text:
+                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
-        }
+            soup = BeautifulSoup(text, 'html.parser')
+
+            # Find any links with [PDF]
+            links = soup.find_all('a', string=re.compile(r'\[PDF\]', re.IGNORECASE))
+
+            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}")
 
-    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
+
+    async def download_paper_crossref_async(self, session, doi):
+        """Alternative search method using Crossref"""
+        if not doi:
             return None
 
-        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():
+        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
+
+    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
+
+        return None
+
+    def download_paper_scihub(self, doi):
+        """Improved method to download paper from Sci-Hub"""
+        if not doi:
+            logger.warning("DOI not provided")
             return None
 
-        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()
+        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}")
 
-        # 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
+        return None
 
-        return temp_path
+    def download_paper_libgen(self, doi):
+        """Download from Libgen, handles the query and the redirection"""
+        if not doi:
+            return None
 
-# --- Funciones para la interfaz de Gradio ---
+        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()
 
-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
-    )
+            if "No results" in response.text:
+                logger.debug(f"No results for DOI: {doi} on libgen")
+                return None
 
-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
+            soup = BeautifulSoup(response.text, 'html.parser')
 
-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
+            # Find the link using a specific selector
+            links = soup.select('table.c > tbody > tr:nth-child(2) > td:nth-child(1) > a')
 
-def download_current_plot(all_figures, current_index):
-    """
-    Descarga la figura actual como PNG.
-    """
-    if not all_figures:
+            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
-    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_all_plots_zip(all_figures):
-    """
-    Descarga todas las figuras en un archivo ZIP.
-    """
-    if not all_figures:
+    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
+
+        try:
+            query = f'doi:"{doi}"'
+            params = {'q': query}
+            url = f'https://scholar.google.com/scholar?{urlencode(params)}'
+
+            response = requests.get(url, headers=self.headers, timeout=10)
+            response.raise_for_status()
+
+            soup = BeautifulSoup(response.text, 'html.parser')
+
+            # Find any links with [PDF]
+            links = soup.find_all('a', string=re.compile(r'\[PDF\]', re.IGNORECASE))
+
+            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}")
+
         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_all_tables_excel():
-    """
-    Descarga todas las tablas en un archivo Excel con múltiples hojas.
-    """
-    if 'rsm' not in globals():
+    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}")
+
         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
 
-# --- Crear la interfaz de Gradio ---
+    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
 
-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=[],
+        return None
+
+    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...")
+        ],
         outputs=[
-            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
-        ]
-    )
-    
-    # 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
+            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,
     )
+
+    # 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];
+       }
+    """
     
-    # 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()
+    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()