Upload 3 files

UI.py

@@ -1,23 +1,14 @@
 # UI.py
 import gradio as gr
 
-# La importación de process_and_plot ya no es necesaria aquí,
-# la función de procesamiento se pasará como argumento a create_interface.
-
 def create_interface(process_function_for_button):
-    """
-    Esta función crea la interfaz de usuario y la devuelve.
-    Conecta el botón de submit a la 'process_function_for_button' proporcionada.
-    """
-    
-    with gr.Blocks(theme='upsatwal/mlsc_tiet') as demo: # O usa gr.themes.Soft() o tu theme preferido
+    with gr.Blocks(theme='upsatwal/mlsc_tiet') as demo:
         gr.Markdown("# Modelado de Bioprocesos con Ecuaciones Personalizadas y Análisis por IA")
 
         with gr.Row():
             with gr.Column(scale=2):
                 gr.Markdown("### Carga de Datos y Configuración General")
                 file_input = gr.File(label="Subir archivo Excel (.xlsx)", file_types=[".xlsx"])
-                
                 show_legend_ui = gr.Checkbox(label="Mostrar leyenda en gráficos", value=True)
                 show_params_ui = gr.Checkbox(label="Mostrar parámetros ajustados en gráficos", value=True)
                 legend_position_ui = gr.Dropdown(
@@ -31,34 +22,30 @@ def create_interface(process_function_for_button):
                 substrate_eq_count_ui = gr.Number(label="Sustrato (1-3)", value=1, minimum=1, maximum=3, precision=0, step=1)
                 product_eq_count_ui = gr.Number(label="Producto (1-3)", value=1, minimum=1, maximum=3, precision=0, step=1)
 
-        # --- Sección de Biomasa ---
         with gr.Accordion("Ecuaciones y Parámetros de Biomasa", open=True):
             with gr.Row():
                 with gr.Column():
                     biomass_eq1_ui = gr.Textbox(label="Ecuación de Biomasa 1", value="Xm * (1 - exp(-um * (t - t_lag)))", lines=2, placeholder="Ej: Xm * (1 - exp(-um * (t - t_lag)))")
                     biomass_param1_ui = gr.Textbox(label="Parámetros Biomasa 1", value="Xm, um, t_lag", info="Nombres de parámetros, coma sep. Use 't' para tiempo. 'X_val' para X(t) en S/P.")
                     biomass_bound1_ui = gr.Textbox(label="Límites Biomasa 1", value="(0, np.inf), (0, np.inf), (0, np.inf)", info="Formato: (low,high) para cada param. Use np.inf.")
-                # Columna 2 para Biomasa (inicialmente oculta)
-                biomass_col2 = gr.Column(visible=False)
-                with biomass_col2:
+                biomass_col2 = gr.Column(visible=False) # Columna para la segunda ecuación de biomasa
+                with biomass_col2: # Contenido de la columna 2
                     biomass_eq2_ui = gr.Textbox(label="Ecuación de Biomasa 2", value="X0 * exp(um * t)", lines=2)
                     biomass_param2_ui = gr.Textbox(label="Parámetros Biomasa 2", value="X0, um")
                     biomass_bound2_ui = gr.Textbox(label="Límites Biomasa 2", value="(0, np.inf), (0, np.inf)")
-                # Columna 3 para Biomasa (inicialmente oculta)
-                biomass_col3 = gr.Column(visible=False)
-                with biomass_col3:
+                biomass_col3 = gr.Column(visible=False) # Columna para la tercera ecuación de biomasa
+                with biomass_col3: # Contenido de la columna 3
                     biomass_eq3_ui = gr.Textbox(label="Ecuación de Biomasa 3", lines=2)
                     biomass_param3_ui = gr.Textbox(label="Parámetros Biomasa 3")
                     biomass_bound3_ui = gr.Textbox(label="Límites Biomasa 3")
         
-        # --- Sección de Sustrato ---
         with gr.Accordion("Ecuaciones y Parámetros de Sustrato", open=True):
-            gr.Markdown("Para ecuaciones de Sustrato y Producto que dependen de la biomasa X(t), usa la variable `X_val` en tu ecuación. Ejemplo: `S0 - (X_val / YXS)`.")
+            gr.Markdown("Para Sustrato/Producto, usa `X_val` para X(t). Ejemplo: `S0 - (X_val / YXS)` donde YXS es un parámetro.")
             with gr.Row():
                 with gr.Column():
                     substrate_eq1_ui = gr.Textbox(label="Ecuación de Sustrato 1", value="S0 - (X_val / YXS) - mS * t", lines=2)
                     substrate_param1_ui = gr.Textbox(label="Parámetros Sustrato 1", value="S0, YXS, mS")
-                    substrate_bound1_ui = gr.Textbox(label="Límites Sustrato 1", value="(0, np.inf), (1e-9, np.inf), (0, np.inf)") # YXS no debe ser cero
+                    substrate_bound1_ui = gr.Textbox(label="Límites Sustrato 1", value="(0, np.inf), (1e-9, np.inf), (0, np.inf)")
                 substrate_col2 = gr.Column(visible=False)
                 with substrate_col2:
                     substrate_eq2_ui = gr.Textbox(label="Ecuación de Sustrato 2", lines=2)
@@ -70,7 +57,6 @@ def create_interface(process_function_for_button):
                     substrate_param3_ui = gr.Textbox(label="Parámetros Sustrato 3")
                     substrate_bound3_ui = gr.Textbox(label="Límites Sustrato 3")
 
-        # --- Sección de Producto ---
         with gr.Accordion("Ecuaciones y Parámetros de Producto", open=True):
             with gr.Row():
                 with gr.Column():
@@ -88,14 +74,12 @@ def create_interface(process_function_for_button):
                     product_param3_ui = gr.Textbox(label="Parámetros Producto 3")
                     product_bound3_ui = gr.Textbox(label="Límites Producto 3")
 
-        # Lógica para mostrar/ocultar campos de ecuación dinámicamente
-        # La función `update_visibility` devuelve una tupla de diccionarios para Gradio
-        def update_visibility_fn(count):
-            return gr.Column(visible=count >= 2), gr.Column(visible=count >= 3)
+        def update_visibility_gradio(count):
+            return gr.update(visible=count >= 2), gr.update(visible=count >= 3)
 
-        biomass_eq_count_ui.change(fn=update_visibility_fn, inputs=biomass_eq_count_ui, outputs=[biomass_col2, biomass_col3])
-        substrate_eq_count_ui.change(fn=update_visibility_fn, inputs=substrate_eq_count_ui, outputs=[substrate_col2, substrate_col3])
-        product_eq_count_ui.change(fn=update_visibility_fn, inputs=product_eq_count_ui, outputs=[product_col2, product_col3])
+        biomass_eq_count_ui.change(fn=update_visibility_gradio, inputs=biomass_eq_count_ui, outputs=[biomass_col2, biomass_col3])
+        substrate_eq_count_ui.change(fn=update_visibility_gradio, inputs=substrate_eq_count_ui, outputs=[substrate_col2, substrate_col3])
+        product_eq_count_ui.change(fn=update_visibility_gradio, inputs=product_eq_count_ui, outputs=[product_col2, product_col3])
         
         submit_button = gr.Button("Procesar y Analizar", variant="primary", scale=1)
         
@@ -105,7 +89,6 @@ def create_interface(process_function_for_button):
             with gr.Column(scale=3):
                 analysis_output = gr.Markdown(label="Análisis del Modelo por IA")
         
-        # Lista de todos los inputs para el botón de submit
         all_inputs_for_button = [
             file_input,
             biomass_eq1_ui, biomass_eq2_ui, biomass_eq3_ui,
@@ -124,26 +107,23 @@ def create_interface(process_function_for_button):
             substrate_eq_count_ui,
             product_eq_count_ui
         ]
-        
         outputs_for_button = [image_output, analysis_output]
 
-        # Conexión del botón DENTRO del contexto de Blocks
         submit_button.click(
-            fn=process_function_for_button, # Usa la función pasada como argumento
+            fn=process_function_for_button,
             inputs=all_inputs_for_button,
             outputs=outputs_for_button
         )
 
-        # Inicializar la visibilidad correctamente al cargar la demo
-        # para los campos de ecuación 2 y 3.
-        def initial_visibility_setup(val_b, val_s, val_p):
-            return (
-                update_visibility_fn(val_b)[0], update_visibility_fn(val_b)[1],
-                update_visibility_fn(val_s)[0], update_visibility_fn(val_s)[1],
-                update_visibility_fn(val_p)[0], update_visibility_fn(val_p)[1]
-            )
+        # Inicializar visibilidad usando demo.load para que se aplique al cargar la UI
+        def set_initial_visibility_on_load(b_c, s_c, p_c):
+            b_vis2_update, b_vis3_update = update_visibility_gradio(b_c)
+            s_vis2_update, s_vis3_update = update_visibility_gradio(s_c)
+            p_vis2_update, p_vis3_update = update_visibility_gradio(p_c)
+            return b_vis2_update, b_vis3_update, s_vis2_update, s_vis3_update, p_vis2_update, p_vis3_update
+
         demo.load(
-            fn=initial_visibility_setup, 
+            fn=set_initial_visibility_on_load, 
             inputs=[biomass_eq_count_ui, substrate_eq_count_ui, product_eq_count_ui], 
             outputs=[
                 biomass_col2, biomass_col3, 

app.py

@@ -2,48 +2,46 @@
 import sys
 from pathlib import Path
 
-# Añadir el directorio actual al path para asegurar que se encuentran los módulos locales
-# como UI, interface, decorators, config, models.
 CURRENT_DIR = Path(__file__).parent
 if str(CURRENT_DIR) not in sys.path:
     sys.path.insert(0, str(CURRENT_DIR))
 
-# Ahora que el path está configurado, podemos importar los módulos locales.
 try:
-    import decorators
+    import decorators # Importa tu archivo decorators.py
     from UI import create_interface
     import interface as app_interface_module
 except ImportError as e:
-    print(f"Error crítico de importación en app.py: {e}. Asegúrate de que todos los archivos .py estén en el mismo directorio.")
+    print(f"Error crítico de importación en app.py: {e}. Asegúrate de que todos los archivos .py estén en el mismo directorio o en PYTHONPATH.")
     sys.exit(1)
 
-# --- Manejo del decorador GPU para el arranque de Gradio local ---
-# Si el decorador real de HF Spaces fue importado (incluso si es un stub de una lib),
-# Gradio podría esperar que una función esté decorada.
-if decorators.was_real_spaces_gpu_imported():
-    print("INFO (app.py): El decorador GPU de 'spaces' parece estar disponible (o es un stub).")
-    print("INFO (app.py): Se definirá una función dummy decorada para satisfacer el chequeo de Gradio.")
+
+if decorators.was_real_spaces_gpu_imported(): # Usa la función de decorators.py
+    print("INFO (app.py): El decorador GPU de 'spaces' parece estar disponible.")
+    print("INFO (app.py): Se definirá una función dummy decorada para satisfacer el chequeo de Gradio si es necesario.")
     
-    @decorators.gpu_decorator(duration=1) # Usa TU gpu_decorator
+    @decorators.gpu_decorator(duration=1) 
     def _app_py_dummy_gpu_function_for_gradio_startup():
-        """Esta función es solo para satisfacer el chequeo de Gradio."""
-        # print("Función dummy GPU de app.py ejecutada (no debería hacer nada).")
         pass
 else:
     print("INFO (app.py): El decorador GPU real de 'spaces' no fue importado. No se necesita función dummy para GPU.")
-# --- Fin del manejo del decorador GPU ---
+
 
 def main():
-    # Pasa la función de procesamiento real (process_and_plot) a create_interface
-    # app_interface_module.process_and_plot es la función que queremos que el botón llame.
-    
     print("INFO (app.py): Creando la interfaz Gradio...")
     demo_instance = create_interface(process_function_for_button=app_interface_module.process_and_plot)
     
     print("INFO (app.py): Lanzando la interfaz Gradio localmente...")
-    # Para desarrollo, puedes habilitar debug y share si es necesario.
-    # demo_instance.launch(debug=True, share=True)
-    demo_instance.launch()
+    # Si el error de localhost persiste, prueba con share=True
+    # Esto es más probable si estás en un entorno contenedorizado incluso para "local"
+    try:
+        demo_instance.launch() 
+    except ValueError as ve:
+        if "shareable link must be created" in str(ve):
+            print("ADVERTENCIA (app.py): Falló el lanzamiento local directo, intentando con share=True...")
+            demo_instance.launch(share=True)
+        else:
+            raise ve
+
 
 if __name__ == "__main__":
     main()