added multi user

Dockerfile

@@ -44,18 +44,19 @@ RUN ln -sf /usr/bin/python3.12 /usr/bin/python && \
 
 # ---------------- Writable app data & HF cache ----------------
 ENV APP_DATA_DIR=/data
-ENV HF_HOME=/data/hf_home
-ENV HUGGINGFACE_HUB_CACHE=/data/hf_home
-ENV TRANSFORMERS_CACHE=/data/hf_home
-ENV MPLCONFIGDIR=/data/matplotlib   
+ENV HF_HOME=/data/shared/hf_home
+ENV HUGGINGFACE_HUB_CACHE=/data/shared/hf_home
+ENV TRANSFORMERS_CACHE=/data/shared/hf_home
+ENV MPLCONFIGDIR=/data/matplotlib
 
-RUN mkdir -p /data/geometry /data/solution /data/weights /data/hf_home /data/matplotlib \
+# Create shared directories (for models/HF cache) and per-user directories will be created at runtime
+RUN mkdir -p /data/shared/weights /data/shared/hf_home /data/matplotlib \
  && chmod -R 777 /data
 
 # ---------------- Install frpc for Gradio share=True ----------------
-RUN mkdir -p /data/hf_home/gradio/frpc && \
-    wget https://cdn-media.huggingface.co/frpc-gradio-0.3/frpc_linux_amd64 -O /data/hf_home/gradio/frpc/frpc_linux_amd64_v0.3 && \
-    chmod +x /data/hf_home/gradio/frpc/frpc_linux_amd64_v0.3
+RUN mkdir -p /data/shared/hf_home/gradio/frpc && \
+    wget https://cdn-media.huggingface.co/frpc-gradio-0.3/frpc_linux_amd64 -O /data/shared/hf_home/gradio/frpc/frpc_linux_amd64_v0.3 && \
+    chmod +x /data/shared/hf_home/gradio/frpc/frpc_linux_amd64_v0.3
 
 # ---------------- Application setup ----------------
 WORKDIR /app
@@ -81,9 +82,10 @@ RUN chown -R 1000:1000 /app
 EXPOSE 7860
 
 # Set HOST and PORT via environment variables
-ENV HOST=0.0.0.0
-ENV PORT=7860
+# ENV HOST=0.0.0.0
+# ENV PORT=7860
 
-# Run app
-CMD ["python", "app.py"]
+# Run app with trame.tools.serve; bind explicitly to 0.0.0.0:7860
+# This uses the create_app factory pattern for proper multi-user session management
+CMD ["python", "-m", "trame.tools.serve", "--exec", "app:create_app", "--host", "0.0.0.0", "--port", "7860"]
 

app.py

@@ -20,11 +20,25 @@ import traceback
 import signal
 
 
-# Writable base dir
-DATA_DIR = os.environ.get("APP_DATA_DIR", os.path.join(tempfile.gettempdir(), "appdata"))
+# Writable base dir (matches alphaLPFM pattern)
+# Use APP_DATA_DIR to match alphaLPFM's expectation
+DATA_DIR = os.environ.get("APP_DATA_DIR", os.path.join(tempfile.gettempdir(), "appdata_trame"))
 os.makedirs(DATA_DIR, exist_ok=True)
+os.environ.setdefault("APP_DATA_DIR", DATA_DIR)  # Ensure it's set for the private app
 os.environ.setdefault("MPLCONFIGDIR", DATA_DIR)
 
+# Set up shared directories structure (matches alphaLPFM)
+SHARED_DIR = os.path.join(DATA_DIR, "shared")
+SHARED_HF_DIR = os.path.join(SHARED_DIR, "hf_home")
+SHARED_WEIGHTS_DIR = os.path.join(SHARED_DIR, "weights")
+for d in (SHARED_DIR, SHARED_HF_DIR, SHARED_WEIGHTS_DIR):
+    os.makedirs(d, exist_ok=True)
+
+# Set HF cache environment variables (matches alphaLPFM)
+os.environ.setdefault("HF_HOME", SHARED_HF_DIR)
+os.environ.setdefault("HUGGINGFACE_HUB_CACHE", SHARED_HF_DIR)
+os.environ.setdefault("TRANSFORMERS_CACHE", SHARED_HF_DIR)
+
 def setup_environment():
     cache_dir = Path("cache")
     cache_dir.mkdir(exist_ok=True)
@@ -73,7 +87,27 @@ def download_private_repo(cache_dir, repo_id, hf_token):
     
     return repo_path
 
-def load_private_app(repo_path):
+# Cache for loaded private app
+_PRIVATE_APP_CACHE = None
+_PRIVATE_APP_CREATE_APP = None
+
+def _load_private_app_once():
+    """Load the private app once and cache it. Called by create_app() or main()."""
+    global _PRIVATE_APP_CACHE, _PRIVATE_APP_CREATE_APP
+    
+    if _PRIVATE_APP_CACHE is not None:
+        return _PRIVATE_APP_CACHE, _PRIVATE_APP_CREATE_APP
+    
+    hf_token = os.environ.get("HF_TOKEN")
+    repo_id = os.environ.get("REPO_ID")
+
+    if not hf_token or not repo_id:
+        raise ValueError("HF_TOKEN and REPO_ID must be set")
+
+    print(f"🔍 Loading private app from repo_id: {repo_id}")
+    cache_dir = setup_environment()
+    repo_path = download_private_repo(cache_dir, repo_id, hf_token)
+    
     sys.path.insert(0, str(repo_path))
     try:
         import app as private_app
@@ -87,23 +121,56 @@ def load_private_app(repo_path):
             # Thumbnails are optional; don't break startup if this fails.
             traceback.print_exc()
 
+        # ✅ PREFER create_app factory (for multi-user session management)
+        if hasattr(private_app, "create_app"):
+            print("✅ Found create_app factory in private app (supports multi-user sessions)")
+            _PRIVATE_APP_CREATE_APP = private_app.create_app
         # Check for app or demo attribute
-        if hasattr(private_app, "app"):
-            return private_app.app
+        elif hasattr(private_app, "app"):
+            _PRIVATE_APP_CREATE_APP = lambda: private_app.app
         elif hasattr(private_app, "demo"):
-            return private_app.demo
-        # Check if PFMDemo class exists and instantiate it
+            _PRIVATE_APP_CREATE_APP = lambda: private_app.demo
+        # Check if PFMDemo class exists and instantiate it (fallback, but not ideal for multi-user)
         elif hasattr(private_app, "PFMDemo"):
-            app_instance = private_app.PFMDemo()
-            app_instance.server.controller.add("decimate_again", app_instance.decimate_again)
-            app_instance.server.controller.add("reset_mesh", app_instance.reset_mesh)
-            return app_instance
-        raise RuntimeError("No demo/app found in private repo")
+            print("⚠️  Using PFMDemo directly (may not support multi-user sessions)")
+            def _create_pfmdemo_app(server=None):
+                from trame.app import get_server
+                if server is None:
+                    server = get_server()
+                app_instance = private_app.PFMDemo(server)
+                app_instance.server.controller.add("decimate_again", app_instance.decimate_again)
+                app_instance.server.controller.add("reset_mesh", app_instance.reset_mesh)
+                return app_instance
+            _PRIVATE_APP_CREATE_APP = _create_pfmdemo_app
+        else:
+            raise RuntimeError("No demo/app/create_app found in private repo")
+        
+        _PRIVATE_APP_CACHE = (private_app, repo_path)
+        return _PRIVATE_APP_CACHE, _PRIVATE_APP_CREATE_APP
     except Exception as e:
         traceback.print_exc()
         raise RuntimeError(f"Failed to load app from private repo: {e}")
 
+def create_app(server=None, **kwargs):
+    """
+    Trame application factory (matches alphaLPFM pattern).
+    
+    This function is called by trame.tools.serve to create the app instance.
+    It loads the private app and returns its create_app result (or wraps it).
+    """
+    _, create_app_fn = _load_private_app_once()
+    
+    if create_app_fn is None:
+        raise RuntimeError("No create_app function found in private app")
+    
+    # Call the private app's create_app (or wrapper)
+    return create_app_fn(server=server, **kwargs)
+
 def main():
+    """
+    Main entry point (fallback if not using trame.tools.serve).
+    This is kept for backward compatibility but trame.tools.serve is preferred.
+    """
     # Setup signal handlers for graceful shutdown
     def signal_handler(sig, frame):
         print("\n🛑 Received shutdown signal, cleaning up...")
@@ -113,37 +180,31 @@ def main():
     signal.signal(signal.SIGTERM, signal_handler)
     
     try:
-        hf_token = os.environ.get("HF_TOKEN")
-        repo_id = os.environ.get("REPO_ID")
-
-        if not hf_token or not repo_id:
-            raise ValueError("HF_TOKEN and REPO_ID must be set")
-
-        print(f"🚀 Starting app with repo_id: {repo_id}")
+        print(f"🚀 Starting app (using main() - consider using trame.tools.serve for multi-user support)")
         print(f"📂 Current working directory: {os.getcwd()}")
         
-        cache_dir = setup_environment()
-        repo_path = download_private_repo(cache_dir, repo_id, hf_token)    
-        demo = load_private_app(repo_path)
+        # Load private app (will be cached)
+        _, create_app_fn = _load_private_app_once()
+        
+        if create_app_fn is None:
+            raise RuntimeError("No create_app function found in private app")
+        
+        # Create app instance
+        demo = create_app()
 
-        # Check if it's a Trame app (has server.start method) or Gradio app (has launch method)
+        # Check if it's a Trame app (has server.start method)
         if hasattr(demo, 'server') and hasattr(demo.server, 'start'):
             # Trame app
-            port = int(os.environ.get("PORT", "7860"))
-            host = os.environ.get("HOST", "0.0.0.0")  # Allow host to be configured via env var
-            
-            print(f"🚀 Starting Trame server on {host}:{port}")
+            print(f"🚀 Starting Trame server (host/port from trame.tools.serve or defaults)")
             
-            if demo.server.state.health == "running":
+            if hasattr(demo.server.state, 'health') and demo.server.state.health == "running":
                 print("Trame server already running, not starting again.")
                 return
 
-            # Configure server to bind to the specified host
+            # Configure server - host/port come from trame.tools.serve or environment
             try:
                 # Try with host parameter first (if supported)
                 demo.server.start(
-                    host=host,
-                    port=port,
                     open_browser=False,
                     show_connection_info=True,
                     backend="aiohttp",
@@ -153,7 +214,6 @@ def main():
                 # If host parameter is not supported, configure via server options
                 # Most Trame versions bind to 0.0.0.0 by default with aiohttp
                 demo.server.start(
-                    port=port,
                     open_browser=False,
                     show_connection_info=True,
                     backend="aiohttp",
@@ -161,12 +221,13 @@ def main():
                 )
         elif hasattr(demo, 'launch'):
             # Gradio app
+            _, repo_path = _PRIVATE_APP_CACHE if _PRIVATE_APP_CACHE else (None, None)
             demo.launch(
                 server_name="0.0.0.0",
-                server_port=int(os.environ.get("PORT", "7860")),
+                server_port=7860,
                 share=False,
                 show_error=True,
-                allowed_paths=[str(repo_path), DATA_DIR]
+                allowed_paths=[str(repo_path) if repo_path else ".", DATA_DIR]
             )
         else:
             raise RuntimeError("App does not have launch() or server.start() method")