still initial commit

app.py

@@ -5,35 +5,33 @@ import gradio as gr
 import modal
 from fastrtc import WebRTC, get_cloudflare_turn_credentials
 
-# Environment control flag to swap pipelines from the HF Space configuration dashboard
-USE_GPU_INFERENCE = os.getenv("USE_GPU_INFERENCE", "false").lower() == "true"
-
-# Connect to your deployed serverless backend running on Modal using 1.0+ SDK syntax
+# Initialize Modal connection securely on startup with clear logging
 try:
-    if USE_GPU_INFERENCE:
-        print("🚀 Mode: Full GPU FLUX.2 Klein Inference")
-        voxel_model_cls = modal.Cls.from_name("flux-klein-voxel-backend", "VoxelModel")
-        voxel_backend = voxel_model_cls().process_frame
-    else:
-        print("🏎️ Mode: Zero-latency WebRTC Passthrough Demo")
-        voxel_backend = modal.Function.from_name("flux-klein-voxel-backend", "demo_stream_frame")
+    print("🚀 Attempting to connect to Modal VoxelModel class...")
+    VoxelModelCls = modal.Cls.from_name("flux-klein-voxel-backend", "VoxelModel")
+    voxel_backend = VoxelModelCls().process_frame
 except Exception as e:
-    print(f"⚠️ Could not bind Modal backend function layout: {e}")
-    voxel_backend = None
+    print(f"⚠️ Modal Cls lookup failed: {e}. Falling back to Function lookup.")
+    try:
+        voxel_backend = modal.Function.from_name("flux-klein-voxel-backend", "demo_stream_frame")
+    except Exception as ex:
+        print(f"⚠️ Modal Function lookup also failed: {ex}. Backend will be offline.")
+        voxel_backend = None
+
 
-# --- STREAM HANDLING ARCHITECTURE ---
+# --- STREAM HANDLING FUNCTIONS ---
 
 def process_video_stream(frame: np.ndarray, prompt: str, strength: float) -> np.ndarray:
     """
     Handles single viewport mode (Minecraft Filter).
-    Receives frames, processes them via Modal, and returns them to the same component.
+    Receives frames via WebRTC, processes them, and returns them to the same viewport.
     """
     if frame is None:
         return None
 
     if voxel_backend is None:
         output_frame = frame.copy()
-        cv2.putText(output_frame, "ERROR: Backend App Offline", (20, 40), 
+        cv2.putText(output_frame, "ERROR: Modal Backend Offline", (20, 40), 
                     cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 2)
         return output_frame
 
@@ -44,24 +42,27 @@ def process_video_stream(frame: np.ndarray, prompt: str, strength: float) -> np.
     frame_bytes = encoded_image.tobytes()
 
     try:
-        if USE_GPU_INFERENCE:
+        # Dynamically handle single-parameter or multi-parameter signatures
+        try:
             processed_bytes = voxel_backend.remote(frame_bytes, prompt, strength)
-        else:
+        except TypeError:
             processed_bytes = voxel_backend.remote(frame_bytes)
         
         numpy_buffer = np.frombuffer(processed_bytes, dtype=np.uint8)
         return cv2.imdecode(numpy_buffer, cv2.IMREAD_COLOR)
     except Exception as err:
         fallback_frame = frame.copy()
-        cv2.putText(fallback_frame, "⚡ Serverless Warm-up...", (20, 40), 
+        cv2.putText(fallback_frame, "⚡ Serverless Warm-up / Processing Error...", (20, 40), 
                     cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 255), 2)
+        cv2.putText(fallback_frame, str(err)[:40], (20, 70), 
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 1)
         return fallback_frame
 
 
 def process_demo_stream(frame: np.ndarray) -> np.ndarray:
     """
     Handles separate multi-viewport tracking (Streaming Demo).
-    Ingests frames from the raw hardware box and outputs onto the separate Modal display container.
+    Ingests raw hardware frames and renders processed outputs to a separate container.
     """
     if frame is None:
         return None
@@ -83,26 +84,22 @@ def process_demo_stream(frame: np.ndarray) -> np.ndarray:
     frame_bytes = encoded_image.tobytes()
 
     try:
-        if USE_GPU_INFERENCE:
+        try:
             processed_bytes = voxel_backend.remote(frame_bytes, "vanilla minecraft voxel landscape", 0.55)
-        else:
+        except TypeError:
             processed_bytes = voxel_backend.remote(frame_bytes)
         
         numpy_buffer = np.frombuffer(processed_bytes, dtype=np.uint8)
         return cv2.imdecode(numpy_buffer, cv2.IMREAD_COLOR)
 
     except Exception as err:
-        # Format and write runtime cluster/cold-start exceptions right onto the video frame bounding container
+        # Format and write runtime cluster exceptions directly onto the video container
         error_frame = np.zeros((480, 640, 3), dtype=np.uint8)
         error_frame[:] = 20
         cv2.putText(error_frame, "⚡ MODAL RUNTIME EXCEPTION", (40, 180), 
                     cv2.FONT_HERSHEY_DUPLEX, 0.8, (0, 140, 255), 2)
-        
-        err_msg = str(err)
-        cv2.putText(error_frame, f"Error trace: {err_msg[:50]}...", (40, 240), 
+        cv2.putText(error_frame, f"Error trace: {str(err)[:50]}...", (40, 240), 
                     cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
-        cv2.putText(error_frame, "Check cluster logs for container scaling behavior.", (40, 290), 
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 255, 255), 1)
         return error_frame
 
 
@@ -113,7 +110,7 @@ custom_css = """
 .header-text h1 { color: #5c8e32; font-family: 'Courier New', Courier, monospace; font-weight: bold; margin-bottom: 5px; }
 .header-text p { color: #666; font-size: 1.1em; }
 
-/* Constrain video bounding tracks to stop screen-flooding layout shifts */
+/* Constrain video bounding tracks to prevent screen-flooding layout shifts */
 video, .webrtc-video, div[class*="webrtc"] {
     max-height: 440px !important;
     width: 100% !important;
@@ -133,9 +130,9 @@ with gr.Blocks(css=custom_css, title="Minecraft Spatial Voxel Filter") as demo:
         
         gr.HTML("<hr style='border: 1px solid #ddd; margin-bottom: 20px;'>")
         
-        # Context switcher selection interface
+        # Pipeline view selector
         mode_dropdown = gr.Dropdown(
-            choices=["Streaming Demo", "Minecraft Filter"],
+            choices=["Minecraft Filter", "Streaming Demo"],
             value="Minecraft Filter",
             label="🎯 Pipeline View Configuration",
             interactive=True
@@ -162,16 +159,17 @@ with gr.Blocks(css=custom_css, title="Minecraft Spatial Voxel Filter") as demo:
                         label="Voxelization Denoising Strength"
                     )
                 
+                status_msg = "Connected" if voxel_backend is not None else "Offline / Error"
                 gr.Markdown(
                     f"""
-                    > **💡 Pipeline Status:** Deployed via FastRTC. Current Target Mode: `{"GPU Inference (FLUX)" if USE_GPU_INFERENCE else "CPU Passthrough Demo"}`. Change this via the `USE_GPU_INFERENCE` Space Secret.
+                    > **💡 Pipeline Status:** Deployed via FastRTC. Modal Backend Status: `{status_msg}`.
                     """
                 )
             
             # Right Hand Side Viewport Area
             with gr.Column(scale=2):
                 
-                # --- LAYOUT VARIANT 1: MINECRAFT FILTER MODE (Standard Single Viewport) ---
+                # --- VARIANT 1: MINECRAFT FILTER MODE (Bidirectional Single Box) ---
                 with gr.Column(visible=True) as minecraft_layout:
                     gr.Markdown("### 📺 Spatial Render Pipeline")
                     webrtc_single = WebRTC(
@@ -181,7 +179,7 @@ with gr.Blocks(css=custom_css, title="Minecraft Spatial Voxel Filter") as demo:
                         rtc_configuration=get_cloudflare_turn_credentials
                     )
                 
-                # --- LAYOUT VARIANT 2: STREAMING DEMO MODE (Decoupled Dual Viewports) ---
+                # --- VARIANT 2: STREAMING DEMO MODE (Decoupled dual boxes) ---
                 with gr.Column(visible=False) as demo_layout:
                     gr.Markdown("### 📺 Dual-Feed Stream Monitor")
                     with gr.Row():
@@ -212,4 +210,21 @@ with gr.Blocks(css=custom_css, title="Minecraft Spatial Voxel Filter") as demo:
         outputs=[minecraft_layout, demo_layout]
     )
 
-    # Wire
+    # Wire up single component bidirectional streaming pipeline
+    webrtc_single.stream(
+        fn=process_video_stream,
+        inputs=[webrtc_single, prompt_input, denoise_strength],
+        outputs=[webrtc_single],
+        time_limit=150
+    )
+
+    # Wire up cross-component dual tracking streaming pipeline
+    webrtc_raw.stream(
+        fn=process_demo_stream,
+        inputs=[webrtc_raw],
+        outputs=[webrtc_processed],
+        time_limit=150
+    )
+
+if __name__ == "__main__":
+    demo.launch()