still initial commit

app.py

@@ -1,5 +1,4 @@
 import os
-import asyncio
 import gradio as gr
 import cv2
 import numpy as np
@@ -16,27 +15,28 @@ if not has_tokens:
 
 
 # ── Thread-Safe Client Resolver ─────────────────────────────────────────────
+_backend_cache = None
+
 def get_modal_backend():
-    """Resolves the Modal method safely on the active worker thread."""
+    """Resolves the Modal method lazily and caches it for standard threads."""
+    global _backend_cache
     if not has_tokens:
         return None
-    try:
-        VoxelModelCls = modal.Cls.from_name("flux-klein-voxel-backend", "VoxelModel")
-        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)
+        
+    if _backend_cache is None:
+        try:
+            VoxelModelCls = modal.Cls.from_name("flux-klein-voxel-backend", "VoxelModel")
+            _backend_cache = VoxelModelCls().process_frame
+        except Exception as e:
+            print(f"❌ Failed to resolve Modal class: {e}")
+            return None
+            
+    return _backend_cache
 
 
-# ── 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."""
+# ── Core Sync Execution (No Async/Await!) ───────────────────────────────────
+def run_modal_backend(frame: np.ndarray) -> np.ndarray:
+    """Compresses the frame and executes strictly synchronously."""
     backend = get_modal_backend()
     if backend is None:
         return frame
@@ -47,10 +47,8 @@ async def run_modal_backend(frame: np.ndarray) -> np.ndarray:
         return frame
 
     try:
-        # CRITICAL: asyncio.to_thread completely bypasses Python 3.13 loop deadlocks!
-        processed_bytes = await asyncio.to_thread(
-            _execute_remote_call, backend, encoded.tobytes()
-        )
+        # PURE SYNCHRONOUS CALL: Gradio's background threadpool handles this perfectly safely
+        processed_bytes = backend.remote(encoded.tobytes())
         
         # Decode the returning bytes back into an OpenCV image
         result = cv2.imdecode(np.frombuffer(processed_bytes, dtype=np.uint8), cv2.IMREAD_COLOR)
@@ -63,40 +61,19 @@ async def run_modal_backend(frame: np.ndarray) -> np.ndarray:
         return err_frame
 
 
-# ── Activation & Pre-Warming Logic ──────────────────────────────────────────
-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...")
-    
-    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 ─────────────────────────────────────────────────────────
-async def process_video_stream(frame: np.ndarray, mode: str, is_running: bool) -> np.ndarray:
+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.
+    # CRITICAL: If the user hasn't clicked Start, just return the raw webcam feed.
+    # No dummy frames, no early wakeups.
     if not is_running:
         return frame
 
-    # 1. Process the frame through our async-safe Modal bridge
-    processed = await run_modal_backend(frame)
+    # 1. Process the actual webcam frame synchronously
+    processed = run_modal_backend(frame)
 
     # 2. Format the output based on the selected UI mode
     if mode == "Minecraft Filter":
@@ -140,11 +117,11 @@ 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 buttons to manage state and trigger container wakeup
-    start_btn.click(fn=start_and_warmup_container, inputs=None, outputs=is_running)
+    # Wire buttons to simply toggle the boolean. The video stream loop handles the rest.
+    start_btn.click(fn=lambda: True, inputs=None, outputs=is_running)
     stop_btn.click(fn=lambda: False, inputs=None, outputs=is_running)
 
-    # Main non-blocking stream loop
+    # Main stream loop
     input_stream.stream(
         fn=process_video_stream,
         inputs=[input_stream, mode_dropdown, is_running],