still initial commit

app.py

@@ -1,40 +1,44 @@
 import os
+import asyncio
 import gradio as gr
 import cv2
 import numpy as np
 import modal
-# ── Authentication & Modal Connection ───────────────────────────────────────
+
+# ── Authentication & Token Guard ────────────────────────────────────────────
 token_id = os.environ.get("MODAL_TOKEN_ID")
 token_secret = os.environ.get("MODAL_TOKEN_SECRET")
 has_tokens = bool(token_id and token_secret)
 
-status_text = "🟢 Ready" if has_tokens else "🔴 Offline (Missing Tokens)"
+status_text = "🟢 Connected to Modal" if has_tokens else "🔴 Offline (Missing Tokens)"
 if not has_tokens:
     print("⚠️ [AUTH ERROR] Modal tokens missing! Check your Hugging Face Secrets.")
 
-# Cache to prevent Python 3.13 cross-thread loop crashes
-_voxel_backend = None
 
+# ── Thread-Safe Client Resolver ─────────────────────────────────────────────
 def get_modal_backend():
-    """Lazy-loads the Modal client inside the execution thread to protect the event loop."""
-    global _voxel_backend
-    if _voxel_backend is None and has_tokens:
-        print("🔑 Connecting to Modal...")
-        VoxelModelCls = modal.Cls.from_name("flux-klein-voxel-backend", "VoxelModel")
-        _voxel_backend = VoxelModelCls().process_frame
-        print("✅ Successfully connected to Modal backend.")
-    return _voxel_backend
-
-
-# ── Core Backend Execution ──────────────────────────────────────────────────
-def run_modal_backend(frame: np.ndarray) -> np.ndarray:
-    """Compresses the frame, sends it to Modal, and decodes the returned bytes."""
-    # Look up dynamically to prevent cross-thread event loop pollution
+    """Resolves the Modal method safely on the active worker thread."""
+    if not has_tokens:
+        return None
     try:
         VoxelModelCls = modal.Cls.from_name("flux-klein-voxel-backend", "VoxelModel")
-        backend = VoxelModelCls().process_frame
+        return VoxelModelCls().process_frame
     except Exception as e:
         print(f"❌ Failed to resolve Modal class: {e}")
+        return None
+
+
+# ── Sync Execution Core (Isolated) ─────────────────────────────────────────
+def _execute_remote_call(backend, payload_bytes: bytes) -> bytes:
+    """The raw network request executed completely outside the event loop."""
+    return backend.remote(payload_bytes)
+
+
+# ── Core Async Wrapper ──────────────────────────────────────────────────────
+async def run_modal_backend(frame: np.ndarray) -> np.ndarray:
+    """Compresses the frame and uses to_thread to bypass event loop deadlocks."""
+    backend = get_modal_backend()
+    if backend is None:
         return frame
 
     # Compress to JPEG to save network bandwidth
@@ -43,59 +47,62 @@ def run_modal_backend(frame: np.ndarray) -> np.ndarray:
         return frame
 
     try:
-        # Fire bytes to Modal serverless container synchronously
-        processed_bytes = backend.remote(encoded.tobytes())
+        # CRITICAL: asyncio.to_thread completely bypasses Python 3.13 loop deadlocks!
+        processed_bytes = await asyncio.to_thread(
+            _execute_remote_call, backend, encoded.tobytes()
+        )
+        
         # Decode the returning bytes back into an OpenCV image
         result = cv2.imdecode(np.frombuffer(processed_bytes, dtype=np.uint8), cv2.IMREAD_COLOR)
         return result if result is not None else frame
     except Exception as e:
         print(f"Modal execution error: {e}")
-        # Draw error text on frame if backend crashes
         err_frame = frame.copy()
         cv2.putText(err_frame, "Backend Error - Check Console", (10, 40), 
                     cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
         return err_frame
 
+
 # ── Activation & Pre-Warming Logic ──────────────────────────────────────────
-def start_and_warmup_container():
-    """Forces the Modal container to start up before enabling the webcam stream."""
+async def start_and_warmup_container():
+    """Forces the Modal container to start up via an isolated worker thread."""
     print("🚀 [START CLICKED] Waking up Modal container to prevent cold-start lag...")
-    try:
-        VoxelModelCls = modal.Cls.from_name("flux-klein-voxel-backend", "VoxelModel")
-        backend = VoxelModelCls().process_frame
-        
-        # Create a tiny 1x1 blank image payload
-        dummy_frame = np.zeros((1, 1, 3), dtype=np.uint8)
-        success, encoded = cv2.imencode(".jpg", dummy_frame)
-        if success:
-            print("⏳ Sending ignition payload to remote container...")
-            backend.remote(encoded.tobytes())
-            print("✅ [CONTAINER READY] Modal container is hot and ready for frames.")
-    except Exception as e:
-        print(f"ℹ️ [CONTAINER NOTIFICATION] Warmup pipeline updated: {e}")
-        
+    
+    backend = get_modal_backend()
+    if backend is not None:
+        try:
+            # Create a tiny 1x1 blank image payload
+            dummy_frame = np.zeros((1, 1, 3), dtype=np.uint8)
+            success, encoded = cv2.imencode(".jpg", dummy_frame)
+            if success:
+                print("⏳ Sending ignition payload to remote container...")
+                # Fire the warmup safely on its own isolated thread context
+                await asyncio.to_thread(_execute_remote_call, backend, encoded.tobytes())
+                print("✅ [CONTAINER READY] Modal container is hot and ready for frames.")
+        except Exception as e:
+            print(f"ℹ️ [CONTAINER NOTIFICATION] Warmup call dispatched: {e}")
+            
     return True
 
+
 # ── Streaming Logic ─────────────────────────────────────────────────────────
-def process_video_stream(frame: np.ndarray, mode: str, is_running: bool) -> np.ndarray:
+async def process_video_stream(frame: np.ndarray, mode: str, is_running: bool) -> np.ndarray:
     """Handles the webcam feed and respects the Start/Stop toggle."""
     if frame is None:
         return None
 
     # CRITICAL: If the user hasn't clicked Start, do NOT send to Modal.
-    # Just loop the raw webcam feed back to the UI.
     if not is_running:
         return frame
 
-    # 1. Process the frame through the Modal network
-    processed = run_modal_backend(frame)
+    # 1. Process the frame through our async-safe Modal bridge
+    processed = await run_modal_backend(frame)
 
     # 2. Format the output based on the selected UI mode
     if mode == "Minecraft Filter":
         return processed
         
     elif mode == "Streaming Demo":
-        # Force matching dimensions for side-by-side concatenation
         if processed.shape != frame.shape:
             processed = cv2.resize(processed, (frame.shape[1], frame.shape[0]))
             
@@ -109,7 +116,6 @@ def process_video_stream(frame: np.ndarray, mode: str, is_running: bool) -> np.n
 
 # ── Gradio UI Layout ────────────────────────────────────────────────────────
 with gr.Blocks(title="⛏️ Minecraft Spatial Voxel Filter") as demo:
-    # State tracking variable: Controls whether data flows to Modal or not
     is_running = gr.State(value=False)
     
     gr.Markdown("# ⛏️ Minecraft Spatial Voxel Filter")
@@ -134,17 +140,16 @@ with gr.Blocks(title="⛏️ Minecraft Spatial Voxel Filter") as demo:
             input_stream = gr.Image(sources=["webcam"], streaming=True, label="Live Webcam Input")
             output_stream = gr.Image(interactive=False, label="Voxel Output Viewport")
 
-    # Wire the buttons to manage the state boolean
-    # The start button runs the ignition function first before setting state to True
+    # Wire buttons to manage state and trigger container wakeup
     start_btn.click(fn=start_and_warmup_container, inputs=None, outputs=is_running)
     stop_btn.click(fn=lambda: False, inputs=None, outputs=is_running)
 
-    # The core continuous loop
+    # Main non-blocking stream loop
     input_stream.stream(
         fn=process_video_stream,
         inputs=[input_stream, mode_dropdown, is_running],
         outputs=[output_stream],
-        trigger_mode="always_last" # Drops frames if network backs up to prevent lag
+        trigger_mode="always_last"
     )
 
 if __name__ == "__main__":