Update app.py

app.py

@@ -9,6 +9,7 @@ from scipy.stats import t, f
 import gradio as gr
 import io
 import zipfile
+import tempfile
 from datetime import datetime
 
 class RSM_BoxBehnken:
@@ -31,7 +32,7 @@ class RSM_BoxBehnken:
         self.model_simplified = None
         self.optimized_results = None
         self.optimal_levels = None
-        self.all_figures = []  # Lista para almacenar las 9 figuras
+        self.all_figures = []  # Lista para almacenar las figuras
         self.x1_name = x1_name
         self.x2_name = x2_name
         self.x3_name = x3_name
@@ -164,14 +165,11 @@ class RSM_BoxBehnken:
         # Calcular los valores predichos
         z_pred = self.model_simplified.predict(prediction_data).values.reshape(x_grid_coded.shape)
 
-        # 1. Identificar los dos factores que varían
-        varying_variables = [var for var in [self.x1_name, self.x2_name, self.x3_name] if var != fixed_variable]
-
-        # 2. Filtrar por el nivel de la variable fija (en codificado)
+        # 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)]
 
-        # 3. Filtrar por niveles válidos en las variables que varían
+        # 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) &
@@ -212,19 +210,16 @@ class RSM_BoxBehnken:
         # --- 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
-        # Crear una lista de colores y etiquetas para los puntos
         colors = px.colors.qualitative.Safe
-        point_labels = []
-        for i, row in experiments_data.iterrows():
-            point_labels.append(f"{row[self.y_name]:.3f}")  # Redondear a 3 decimales
+        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)]),  # Usar colores de la lista
-            text=point_labels,  # Usar las etiquetas creadas
+            marker=dict(size=4, color=colors[:len(experiments_x_natural)]),
+            text=point_labels,
             textposition='top center',
             name='Experimentos'
         ))
@@ -232,17 +227,36 @@ class RSM_BoxBehnken:
         # Añadir etiquetas y título con variables naturales
         fig.update_layout(
             scene=dict(
-                xaxis_title=f"{varying_variables[0]} (g/L)",
-                yaxis_title=f"{varying_variables[1]} (g/L)",
+                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} (g/L) (Modelo Simplificado)</sup>",
+            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.
+
+        Args:
+            variable_name (str): Nombre de la variable.
+
+        Returns:
+            str: Unidades de la variable.
+        """
+        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.
@@ -567,13 +581,12 @@ def load_data(x1_name, x2_name, x3_name, y_name, x1_levels_str, x2_levels_str, x
         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:
-        # Nota: Para mostrar mensajes de error, Gradio necesita manejarlo de manera diferente
-        # Aquí, simplemente retornamos nada y ocultamos la sección de análisis
+        # Mostrar mensaje de error
         return None, "", "", "", "", [], [], [], gr.update(visible=False)
 
 def fit_and_optimize_model():
     if 'rsm' not in globals():
-        return [None]*10, 0
+        return [None]*10
     
     # Ajustar modelos y optimizar
     model_completo, pareto_completo = rsm.fit_model()
@@ -601,8 +614,7 @@ def fit_and_optimize_model():
         prediction_table,
         contribution_table,
         anova_table,
-        rsm.all_figures,  # Devuelve todas las figuras generadas
-        0  # Inicializar el índice actual
+        rsm.all_figures  # Devuelve todas las figuras generadas
     )
 
 def show_plot(all_figures, current_index):
@@ -648,13 +660,19 @@ def download_current_plot(all_figures, current_index):
         current_index (int): Índice de la figura actual.
 
     Returns:
-        tuple: (bytes, str)
+        str: Ruta del archivo PNG temporal.
     """
     if not all_figures:
-        return None, "grafico_actual.png"
+        return "grafico_actual.png"  # Ruta predeterminada en caso de error
     fig = all_figures[current_index]
     img_bytes = rsm.save_fig_to_bytes(fig)
-    return img_bytes, f"Grafico_RSM_{current_index + 1}.png"
+    
+    # Crear un archivo temporal
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
+    temp_file.write(img_bytes)
+    temp_file.close()
+    
+    return temp_file.name
 
 def download_all_plots_zip(all_figures):
     """
@@ -664,32 +682,47 @@ def download_all_plots_zip(all_figures):
         all_figures (list): Lista de figuras.
 
     Returns:
-        tuple: (bytes, str)
+        str: Ruta del archivo ZIP temporal.
     """
     zip_bytes = rsm.save_figures_to_zip()
     if zip_bytes:
         timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-        return zip_bytes, f"Graficos_RSM_{timestamp}.zip"
-    return None, "Graficos_RSM.zip"
+        zip_filename = f"Graficos_RSM_{timestamp}.zip"
+        
+        # Crear un archivo temporal para el ZIP
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".zip")
+        temp_file.write(zip_bytes)
+        temp_file.close()
+        
+        return temp_file.name
+    return "Graficos_RSM.zip"  # Ruta predeterminada en caso de error
 
 def download_all_tables_excel():
     """
     Descarga todas las tablas en un archivo Excel con múltiples hojas.
 
     Returns:
-        tuple: (bytes, str)
+        str: Ruta del archivo Excel temporal.
     """
     if 'rsm' not in globals():
-        return None, "Tablas_RSM.xlsx"
-
+        return "Tablas_RSM.xlsx"
+    
     tables = rsm.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)
+    
+    # Crear un archivo temporal para el Excel
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx")
+    temp_file.write(excel_buffer.read())
+    temp_file.close()
+    
     timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-    return excel_buffer.getvalue(), f"Tablas_RSM_{timestamp}.xlsx"
+    excel_filename = f"Tablas_RSM_{timestamp}.xlsx"
+    
+    return temp_file.name
 
 # --- Crear la interfaz de Gradio ---
 
@@ -727,7 +760,7 @@ with gr.Blocks() as demo:
             gr.Markdown("## Datos Cargados")
             data_output = gr.Dataframe(label="Tabla de Datos", interactive=False)
     
-    # Hacer que la sección de análisis sea visible solo después de cargar los datos
+    # 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")