Upload 3 files

app.py

@@ -1,44 +1,48 @@
 # app.py
-from UI import create_interface
-import interface as app_interface_module # Necesitamos la función process_and_plot
-import sys # Para manipulación de path si es necesario
+import sys
 from pathlib import Path
 
-# --- Intento de Neutralizar el decorador problemático para ejecución local ---
-# Esto es un hack para evitar el error de 'No @spaces.GPU' si Gradio lo busca.
+# 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:
-    # Intentar importar el módulo 'decorators' de tu proyecto
-    # Asume que app.py está en la raíz del proyecto y decorators.py también
-    current_dir = Path(__file__).parent
-    if str(current_dir) not in sys.path:
-         sys.path.insert(0, str(current_dir))
     import decorators
-    
-    class _GPUNeutralizerLocal:
-        def __init__(self, *args, **kwargs): pass
-        def __call__(self, func): return func
-    
-    # Sobrescribir si existen para que no causen error
-    if hasattr(decorators, 'GPU'):
-        decorators.GPU = _GPUNeutralizerLocal
-        print("INFO (app.py): 'decorators.GPU' neutralizado para ejecución local.")
-    if hasattr(decorators, 'gpu_decorator'):
-        decorators.gpu_decorator = lambda duration=0: lambda func: func
-        print("INFO (app.py): 'decorators.gpu_decorator' neutralizado para ejecución local.")
-
-except ImportError:
-    print("ADVERTENCIA (app.py): Módulo 'decorators' no encontrado, no se pudo neutralizar GPU. Puede que no sea necesario.")
-except Exception as e_dec:
-    print(f"ADVERTENCIA (app.py): Error al intentar neutralizar decoradores: {e_dec}")
-# --- Fin de la neutralización ---
+    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.")
+    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.")
+    
+    @decorators.gpu_decorator(duration=1) # Usa TU gpu_decorator
+    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("Lanzando interfaz Gradio localmente...")
+    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()
 
 if __name__ == "__main__":

decorators.py

@@ -1,32 +1,48 @@
 # decorators.py
 from functools import wraps
-# La importación original 'from spaces import GPU' es específica de Hugging Face Spaces.
-# Para un uso general o con Modal, este decorador necesitaría ser adaptado o
-# la gestión de GPU se haría directamente a través de la configuración de la función Modal.
 
-# Por ahora, mantenemos la estructura, pero ten en cuenta que @GPU no funcionará
-# fuera del entorno de HF Spaces tal como está. Modal tiene su propia forma de asignar GPUs.
+_actual_spaces_GPU_imported = False
+_GPU_decorator_target = None
+
+try:
+    from spaces import GPU as ActualSpacesGPU_real # Intentar importar el real
+    _GPU_decorator_target = ActualSpacesGPU_real
+    _actual_spaces_GPU_imported = True
+    print("INFO (decorators.py): Se importó 'GPU' correctamente desde 'spaces'.")
+except ImportError:
+    print("ADVERTENCIA (decorators.py): No se pudo importar 'GPU' desde 'spaces'. Se usará un placeholder. "
+          "Esto es normal si no se ejecuta en un Hugging Face Space con GPU habilitada.")
+    class PlaceholderGPU:
+        def __init__(self, duration=100, **kwargs): # Aceptar kwargs comunes como sdk_version
+            self.duration = duration
+            # print(f"PlaceholderGPU inicializado (duración: {self.duration}s)")
+
+        def __call__(self, func):
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                # print(f"PlaceholderGPU: Ejecutando función decorada '{func.__name__}'")
+                return func(*args, **kwargs)
+            return wrapper
+    _GPU_decorator_target = PlaceholderGPU
+except Exception as e:
+    print(f"ERROR (decorators.py): Error inesperado al intentar importar/definir GPU: {e}")
+    # Fallback a un decorador que no hace absolutamente nada si todo lo demás falla
+    _GPU_decorator_target = lambda duration=100, **kwargs: lambda func: func
 
-class GPU: # Placeholder para simular la estructura si no se ejecuta en HF Spaces
-    def __init__(self, duration=100):
-        self.duration = duration
-    def __call__(self, func):
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            # print(f"Simulando ejecución con GPU (duración: {self.duration}s) para: {func.__name__}")
-            return func(*args, **kwargs)
-        return wrapper
 
 def gpu_decorator(duration=100):
     """
-    Decorador personalizado que simula el uso de GPU.
-    En un entorno de Hugging Face Spaces con GPU asignada,
-    el decorador `spaces.GPU` real se encargaría de la gestión.
+    Decorador que aplica el @spaces.GPU real si está disponible,
+    o un placeholder funcional en otros casos.
     """
     def decorator(func):
-        @GPU(duration=duration) # Usando nuestro placeholder o el real de `spaces`
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            return func(*args, **kwargs)
-        return wrapper
-    return decorator
+        # Usar _GPU_decorator_target que es o el real o el placeholder
+        decorated_func = _GPU_decorator_target(duration=duration)(func)
+        return decorated_func
+    return decorator
+
+def was_real_spaces_gpu_imported():
+    """
+    Permite a otros módulos verificar si el decorador GPU real de HF Spaces fue importado.
+    """
+    return _actual_spaces_GPU_imported

model_app.py

@@ -9,39 +9,39 @@ import traceback
 PYTHON_VERSION = "3.10"
 APP_NAME = "bioprocess-custom-eq-agent-modal"
 LOCAL_APP_DIR = Path(__file__).parent
-REMOTE_APP_DIR = "/app"
+REMOTE_APP_DIR = "/app" # Directorio donde se copiarán los archivos en el contenedor Modal
 
 stub = modal.Stub(APP_NAME)
 
 app_image = (
     modal.Image.debian_slim(python_version=PYTHON_VERSION)
-    .pip_install_from_requirements(LOCAL_APP_DIR / "requirements.txt")
-    .copy_mount(
+    .pip_install_from_requirements(LOCAL_APP_DIR / "requirements.txt") # Lee desde tu requirements.txt
+    .copy_mount( # Copia todos los archivos de la app
         modal.Mount.from_local_dir(LOCAL_APP_DIR, remote_path=REMOTE_APP_DIR)
     )
-    .env({
-        "PYTHONPATH": REMOTE_APP_DIR,
+    .env({ # Configura variables de entorno dentro del contenedor
+        "PYTHONPATH": REMOTE_APP_DIR, # Permite importar módulos desde /app
         "HF_HOME": "/cache/huggingface",
         "HF_HUB_CACHE": "/cache/huggingface/hub",
         "TRANSFORMERS_CACHE": "/cache/huggingface/hub",
-        "MPLCONFIGDIR": "/tmp/matplotlib_cache"
+        "MPLCONFIGDIR": "/tmp/matplotlib_cache" # Evita warnings de matplotlib
     })
-    .run_commands(
+    .run_commands( # Comandos a ejecutar durante la construcción de la imagen
         "apt-get update && apt-get install -y git git-lfs && rm -rf /var/lib/apt/lists/*",
-        "mkdir -p /cache/huggingface/hub /tmp/matplotlib_cache"
+        "mkdir -p /cache/huggingface/hub /tmp/matplotlib_cache" # Crea directorios de caché
     )
 )
 
-# --- Función Modal para LLM (sin cambios respecto a la anterior respuesta completa) ---
+# --- Función Modal para LLM (sin cambios significativos respecto a la respuesta completa anterior) ---
 @stub.function(
-    image=app_image, # Hereda la imagen base del stub si está definida, o usa esta.
-    gpu="any",
+    image=app_image,
+    gpu="any", 
     secrets=[modal.Secret.from_name("huggingface-read-token", optional=True)],
-    timeout=600, # 10 minutos
+    timeout=600,
     volumes={"/cache/huggingface": modal.Volume.persisted(f"{APP_NAME}-hf-cache-vol")}
 )
 def generate_analysis_llm_modal_remote(prompt: str, model_path_config: str, max_new_tokens_config: int) -> str:
-    import torch # Importaciones pesadas dentro de la función Modal
+    import torch 
     from transformers import AutoTokenizer, AutoModelForCausalLM
     
     hf_token = os.environ.get("HUGGING_FACE_TOKEN") 
@@ -57,14 +57,14 @@ def generate_analysis_llm_modal_remote(prompt: str, model_path_config: str, max_
             device_map="auto",
             cache_dir="/cache/huggingface/hub",
             token=hf_token,
-            trust_remote_code=True # Necesario para algunos modelos como Qwen
+            trust_remote_code=True
         )
         
-        model_context_window = getattr(model.config, 'max_position_embeddings', getattr(model.config, 'sliding_window', 4096)) # Para Qwen2 sliding_window
-        if model_context_window is None : model_context_window = 4096 # Fallback
+        model_context_window = getattr(model.config, 'max_position_embeddings', getattr(model.config, 'sliding_window', 4096))
+        if model_context_window is None : model_context_window = 4096
         
-        max_prompt_len = model_context_window - max_new_tokens_config - 50 # Buffer
-        if max_prompt_len <=0 : max_prompt_len = model_context_window // 2 # Si max_new_tokens es muy grande
+        max_prompt_len = model_context_window - max_new_tokens_config - 50 
+        if max_prompt_len <=0 : max_prompt_len = model_context_window // 2 
 
         inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=max_prompt_len).to(model.device)
 
@@ -74,9 +74,7 @@ def generate_analysis_llm_modal_remote(prompt: str, model_path_config: str, max_
                 max_new_tokens=max_new_tokens_config,
                 eos_token_id=tokenizer.eos_token_id,
                 pad_token_id=tokenizer.pad_token_id if tokenizer.pad_token_id is not None else tokenizer.eos_token_id,
-                do_sample=True,
-                temperature=0.6, 
-                top_p=0.9,
+                do_sample=True, temperature=0.6, top_p=0.9,
             )
         
         input_length = inputs.input_ids.shape[1]
@@ -91,69 +89,64 @@ def generate_analysis_llm_modal_remote(prompt: str, model_path_config: str, max_
         return f"Error al generar análisis con el modelo LLM: {str(e)}"
 
 # --- Servidor Gradio ---
-@stub.asgi_app(image=app_image) # Especificar la imagen para el endpoint ASGI también
+@stub.asgi_app(image=app_image)
 def serve_gradio_app_asgi():
     import gradio as gr
     
-    # sys.path ya está configurado por la imagen de Modal debido a .env({"PYTHONPATH": REMOTE_APP_DIR})
-    # y .copy_mount(... remote_path=REMOTE_APP_DIR)
-    # No obstante, una comprobación o inserción explícita no daña:
+    # El PYTHONPATH ya está configurado en la imagen, pero una verificación no daña.
     if REMOTE_APP_DIR not in sys.path:
         sys.path.insert(0, REMOTE_APP_DIR)
-        print(f"INFO (modal_app.py): Añadido {REMOTE_APP_DIR} a sys.path")
+        print(f"INFO (modal_app.py @asgi): Añadido {REMOTE_APP_DIR} a sys.path")
     
-    # --- Intento de Neutralizar el decorador problemático ANTES de las importaciones de la app ---
-    # Esto es para evitar el error "No @spaces.GPU function detected" si Gradio lo busca.
+    # --- Neutralización del decorador GPU de Spaces, DENTRO del contexto Modal ---
+    # Esto asegura que cualquier importación de `gradio` o `decorators`
+    # no cause problemas con el chequeo de `@spaces.GPU`.
     try:
-        import decorators # Intenta importar TU decorators.py
-        class _GPUNeutralizerModal:
+        import decorators # Importa TU decorators.py
+        class _GPUNeutralizerInModal:
             def __init__(self, *args, **kwargs): pass
             def __call__(self, func): return func
         
-        if hasattr(decorators, 'GPU'):
-            decorators.GPU = _GPUNeutralizerModal
-            print("INFO (modal_app.py): 'decorators.GPU' neutralizado para el entorno Modal.")
-        if hasattr(decorators, 'gpu_decorator'):
-            decorators.gpu_decorator = lambda duration=0: lambda func: func
-            print("INFO (modal_app.py): 'decorators.gpu_decorator' neutralizado para el entorno Modal.")
+        # Sobrescribir la clase GPU y el decorador en el módulo 'decorators'
+        # para esta instancia del servidor ASGI.
+        decorators.ActualSpacesGPU = _GPUNeutralizerInModal # Si decorators.py usa este nombre
+        decorators._GPU_decorator_target = _GPUNeutralizerInModal # Si decorators.py usa este
+        decorators.gpu_decorator = lambda duration=0: lambda func: func # Neutralizar el decorador
+        print("INFO (modal_app.py @asgi): Decoradores GPU de 'spaces' neutralizados para el entorno Modal.")
     except ImportError:
-        print("ADVERTENCIA (modal_app.py): Módulo 'decorators' no encontrado durante la neutralización. Esto puede ser OK.")
-    except Exception as e_neut:
-        print(f"ADVERTENCIA (modal_app.py): Error durante la neutralización de decoradores: {e_neut}")
+        print("ADVERTENCIA (modal_app.py @asgi): Módulo 'decorators' no encontrado durante la neutralización. Puede ser OK.")
+    except Exception as e_neut_modal:
+        print(f"ADVERTENCIA (modal_app.py @asgi): Error durante la neutralización de decoradores en Modal: {e_neut_modal}")
     # --- Fin de la neutralización ---
 
-    # Importar los módulos de la aplicación AHORA
+    # Importar los módulos de la aplicación DESPUÉS de la neutralización y config de path
     from UI import create_interface
     import interface as app_interface_module
     from config import MODEL_PATH as cfg_MODEL_PATH, MAX_LENGTH as cfg_MAX_LENGTH
 
-    # Wrapper para llamar a la función Modal remota desde tu interface.py
+    # Wrapper para llamar a la función Modal remota
     def analysis_func_wrapper_for_interface_modal(prompt: str) -> str:
         print("Gradio Backend (Modal): Llamando a generate_analysis_llm_modal_remote.remote...")
         return generate_analysis_llm_modal_remote.remote(prompt, cfg_MODEL_PATH, cfg_MAX_LENGTH)
 
-    # Inyectar esta función wrapper en el módulo `interface` que usa Gradio
     app_interface_module.generate_analysis_from_modal = analysis_func_wrapper_for_interface_modal
     app_interface_module.USE_MODAL_FOR_LLM_ANALYSIS = True
-    print("INFO (modal_app.py): Runner de LLM Modal inyectado en el módulo 'interface'.")
+    print("INFO (modal_app.py @asgi): Runner de LLM Modal inyectado en el módulo 'interface'.")
 
-    # Crear la app Gradio, pasándole la función de procesamiento real
     gradio_ui_instance = create_interface(process_function_for_button=app_interface_module.process_and_plot)
     
-    print("INFO (modal_app.py): Interfaz Gradio creada y lista para ser servida.")
+    print("INFO (modal_app.py @asgi): Interfaz Gradio creada y lista para ser servida por Modal.")
     return gr.routes.App.create_app(gradio_ui_instance)
 
 @stub.local_entrypoint()
-def test_llm_local_entry(): # Renombrado para evitar conflicto con el `test_llm` de la respuesta anterior
+def test_llm_local_entry():
     print("Probando la generación de LLM con Modal (local_entrypoint)...")
-    if REMOTE_APP_DIR not in sys.path: # Asegurar path para pruebas locales también
+    if str(LOCAL_APP_DIR) not in sys.path:
         sys.path.insert(0, str(LOCAL_APP_DIR))
     from config import MODEL_PATH, MAX_LENGTH
     
     sample_prompt = "Explica brevemente el concepto de R cuadrado (R²) en el ajuste de modelos."
     try:
-        # Para ejecutar esto, necesitarías que el stub esté activo.
-        # `modal run modal_app.py test_llm_local_entry`
         analysis = generate_analysis_llm_modal_remote.remote(sample_prompt, MODEL_PATH, MAX_LENGTH)
         print("\nRespuesta del LLM:")
         print(analysis)