Update brain_lazy.py

brain_lazy.py

@@ -1,21 +1,21 @@
 """
-brain_lazy.py — Lazy loader with background auto-install
+brain_lazy.py — Lazy loader with progress indicator
 Purpose:
 - Start your app FAST (no startup timeout on Hugging Face).
-- Automatically install heavy packages in the background after startup.
-- Load multimodular_modul_v7 asynchronously once packages are installed.
-- Keep your original multimodular_modul_v7.py untouched.
+- Preload multimodular_modul_v7 in the background after startup.
+- Keep the original module untouched.
+- Shows a dynamic “loading step” for better UX.
+- Does NOT attempt any runtime package installation.
 """
 
 import os
 import time
 import threading
 import importlib
-import subprocess
 from typing import Optional, Any
 
 # -----------------------------------------------------------------------------
-# Persistent cache (Hugging Face → enable Persistent storage in Space settings)
+# Persistent cache
 # -----------------------------------------------------------------------------
 CACHE_DIR = "/home/user/app/cache"
 os.environ.setdefault("TRANSFORMERS_CACHE", CACHE_DIR)
@@ -30,140 +30,113 @@ _lock = threading.Lock()
 _is_loading = False
 _is_ready = False
 _last_error: Optional[str] = None
-_packages_installed = False
+_loading_step: Optional[str] = None
 
-# Max wait for background preload before returning warming-up
 PROXY_WAIT_SECONDS = 25
 
-# List of heavy packages to install automatically
-HEAVY_PACKAGES = ["torch", "torchvision", "timm", "diffusers", "faiss-cpu"]
-
 # -----------------------------------------------------------------------------
-# Background package installer
+# Internal helpers
 # -----------------------------------------------------------------------------
-def _install_heavy_packages():
-    global _packages_installed
-    try:
-        print("⏳ [brain_lazy] Installing heavy packages in background...")
-        subprocess.run(
-            ["pip", "install", "--upgrade"] + HEAVY_PACKAGES,
-            check=True,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-        )
-        _packages_installed = True
-        print("✅ [brain_lazy] Heavy packages installed.")
-    except Exception as e:
-        print(f"❌ [brain_lazy] Failed to install packages: {e}")
-        _packages_installed = False
+def _set_step(step: str):
+    global _loading_step
+    _loading_step = step
+    print(f"⏳ [brain_lazy] {step}")
+
+def _warming_up_message(op: str) -> Any:
+    return {
+        "status": "warming_up",
+        "operation": op,
+        "detail": f"CHB is loading models in the background. Current step: {_loading_step or 'starting'}",
+        "ready": _is_ready,
+        "error": _last_error,
+    }
+
+def is_ready() -> bool:
+    return _is_ready
+
+def last_error() -> Optional[str]:
+    return _last_error
+
+def _ensure_loaded_with_wait(timeout_s: float) -> Optional[Any]:
+    if _brain is not None and _is_ready:
+        return _brain
+
+    if not _is_loading and _brain is None:
+        threading.Thread(target=_load_brain_blocking, daemon=True).start()
+
+    waited = 0.0
+    interval = 0.25
+    while waited < timeout_s:
+        if _brain is not None and _is_ready:
+            return _brain
+        time.sleep(interval)
+        waited += interval
+    return None
 
 # -----------------------------------------------------------------------------
 # Brain loader
 # -----------------------------------------------------------------------------
 def _load_brain_blocking() -> Optional[Any]:
-    """
-    Imports multimodular_modul_v7 and performs light warm-up.
-    """
     global _brain, _is_ready, _is_loading, _last_error
     with _lock:
         if _brain is not None:
             return _brain
         if _is_loading:
-            return None  # Another thread is loading
+            return None
 
         _is_loading = True
         _last_error = None
         start = time.time()
         try:
-            # Ensure packages are installed before importing
-            if not _packages_installed:
-                _install_heavy_packages()
-
-            print("⏳ [brain_lazy] Importing multimodular_modul_v7 ...")
+            _set_step("importing multimodular_modul_v7")
             brain = importlib.import_module("multimodular_modul_v7")
 
-            # Optional warm-up
             warm_started = False
+
             if hasattr(brain, "init"):
+                _set_step("running brain.init()")
                 try:
                     brain.init()
                     warm_started = True
-                    print("✅ [brain_lazy] brain.init() finished.")
                 except Exception as e:
                     print(f"⚠️ brain.init() failed: {e}")
 
             if hasattr(brain, "warm_up"):
+                _set_step("running brain.warm_up()")
                 try:
                     brain.warm_up()
                     warm_started = True
-                    print("✅ [brain_lazy] brain.warm_up() finished.")
                 except Exception as e:
                     print(f"⚠️ brain.warm_up() failed: {e}")
 
             if not warm_started and hasattr(brain, "process_input"):
+                _set_step("minimal warm-up via process_input('ping')")
                 try:
                     _ = brain.process_input("ping")
-                    print("✅ [brain_lazy] minimal warm-up via process_input('ping') done.")
                 except Exception as e:
                     print(f"⚠️ Minimal warm-up failed: {e}")
 
             _brain = brain
             _is_ready = True
+            _set_step("ready")
             print(f"✅ [brain_lazy] Brain loaded in {time.time() - start:.2f}s")
             return _brain
         except Exception as e:
             _last_error = str(e)
+            _set_step("failed")
             print(f"❌ [brain_lazy] Brain load failed: {e}")
             return None
         finally:
             _is_loading = False
 
 # -----------------------------------------------------------------------------
-# Background thread startup
+# Background startup
 # -----------------------------------------------------------------------------
 def _background_startup():
-    """
-    Run immediately on import: install packages and preload brain asynchronously.
-    """
-    _install_heavy_packages()
     _load_brain_blocking()
 
 threading.Thread(target=_background_startup, daemon=True).start()
 
-# -----------------------------------------------------------------------------
-# Helpers
-# -----------------------------------------------------------------------------
-def is_ready() -> bool:
-    return _is_ready
-
-def last_error() -> Optional[str]:
-    return _last_error
-
-def _ensure_loaded_with_wait(timeout_s: float) -> Optional[Any]:
-    if _brain is not None and _is_ready:
-        return _brain
-
-    if not _is_loading and _brain is None:
-        threading.Thread(target=_load_brain_blocking, daemon=True).start()
-
-    waited = 0.0
-    interval = 0.25
-    while waited < timeout_s:
-        if _brain is not None and _is_ready:
-            return _brain
-        time.sleep(interval)
-        waited += interval
-    return None
-
-def _warming_up_message(op: str) -> Any:
-    return {
-        "status": "warming_up",
-        "operation": op,
-        "detail": "CHB is installing packages and loading models in the background. Please retry shortly.",
-        "ready": _is_ready,
-        "error": _last_error,
-    }
-
 # -----------------------------------------------------------------------------
 # Public proxy API
 # -----------------------------------------------------------------------------