still initial commit

app.py

@@ -1,3 +1,19 @@
+import sys
+
+# ── 🛠️ 0. GRADIO SCHEMAS BUG MONKEYPATCH ─────────────────────────────────────
+# Fixes: TypeError: argument of type 'bool' is not iterable inside gradio_client.
+# This prevents the app from crashing during initialization on Hugging Face Spaces.
+try:
+    import gradio_client.utils
+    old_get_type = gradio_client.utils.get_type
+    def patched_get_type(schema):
+        if isinstance(schema, bool):
+            return "bool"
+        return old_get_type(schema)
+    gradio_client.utils.get_type = patched_get_type
+except Exception:
+    pass
+
 import os
 import cv2
 import numpy as np
@@ -45,13 +61,14 @@ def _offline_frame(frame: np.ndarray, message: str) -> np.ndarray:
     return out
 
 
-def _run_voxel_backend(frame: np.ndarray) -> np.ndarray:
-    """Encodes and ships raw image bytes to the Modal worker."""
+def _run_voxel_backend(frame: np.ndarray, prompt: str, strength: float) -> np.ndarray:
+    """Encodes and ships raw image bytes along with UI parameters to the Modal worker."""
     success, encoded = cv2.imencode(".jpg", frame, [int(cv2.IMWRITE_JPEG_QUALITY), 85])
     if not success:
         return frame
     try:
-        processed_bytes = voxel_backend.remote(encoded.tobytes())
+        # Match the 3 required arguments expected by the VoxelModel class on Modal
+        processed_bytes = voxel_backend.remote(encoded.tobytes(), prompt, strength)
         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 err:
@@ -64,9 +81,9 @@ def _run_voxel_backend(frame: np.ndarray) -> np.ndarray:
 # ── Core Stream Handler ─────────────────────────────────────────────────────
 frame_counter = 0
 
-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, prompt: str, strength: float) -> np.ndarray:
     """
-    Accepts incoming frame from the webcam, pipeline settings, and execution state flag.
+    Accepts incoming frame from the webcam, pipeline settings, execution state, and prompt config.
     """
     global frame_counter
     if frame is None:
@@ -85,10 +102,10 @@ def process_video_stream(frame: np.ndarray, mode: str, is_running: bool) -> np.n
     # Runtime console indicator: logs transmission health to terminal every 15 frames
     frame_counter += 1
     if frame_counter % 15 == 0:
-        print(f"🚀 [LIVE PIPELINE] Actively transmitting frames. Dispatched {frame_counter} payloads to Modal worker.")
+        print(f"🚀 [LIVE PIPELINE] Transmitting frames. Dispatched {frame_counter} payloads to Modal.")
 
-    # Process via the lightweight single-image pipeline
-    processed = _run_voxel_backend(frame)
+    # Process via the single-image pipeline, passing down prompt strings and context values
+    processed = _run_voxel_backend(frame, prompt, strength)
 
     # Mode A: Full view rendering
     if mode == "Minecraft Filter":
@@ -126,8 +143,8 @@ with gr.Blocks(title="⛏️ Minecraft Spatial Voxel Filter") as demo:
             ui_logs = gr.Textbox(
                 value="\n".join(init_logs),
                 label="💻 System Initialization Logs",
-                lines=6,
-                max_lines=10,
+                lines=4,
+                max_lines=5,
                 interactive=False,
             )
             
@@ -137,6 +154,23 @@ with gr.Blocks(title="⛏️ Minecraft Spatial Voxel Filter") as demo:
                 label="🎯 Pipeline Mode",
                 interactive=True,
             )
+
+            # Added controls to dynamically configure the FLUX diffusion backend
+            prompt_input = gr.Textbox(
+                value="isometric 3d minecraft block voxel style, high resolution, volumetric lighting",
+                label="✨ Generation Prompt",
+                lines=2,
+                interactive=True
+            )
+            
+            strength_slider = gr.Slider(
+                minimum=0.1,
+                maximum=1.0,
+                value=0.45,
+                step=0.05,
+                label="🎛️ Image Transformation Strength",
+                interactive=True
+            )
             
             with gr.Row():
                 start_btn = gr.Button("🚀 Start Processing", variant="primary")
@@ -151,10 +185,10 @@ with gr.Blocks(title="⛏️ Minecraft Spatial Voxel Filter") as demo:
     start_btn.click(fn=lambda: True, inputs=None, outputs=is_running)
     stop_btn.click(fn=lambda: False, inputs=None, outputs=is_running)
 
-    # Core engine transmission loop
+    # Core engine transmission loop linked up with the new UI input arguments
     input_stream.stream(
         fn=process_video_stream,
-        inputs=[input_stream, mode_dropdown, is_running],
+        inputs=[input_stream, mode_dropdown, is_running, prompt_input, strength_slider],
         outputs=[output_stream]
     )
 

backend/backend.py

@@ -2,13 +2,26 @@ import io
 import os
 import modal
 
+# ==============================================================================
+# 💾 0. CACHE VOLUME SETUP
+# ==============================================================================
+# This creates a persistent volume that survives between container cold-starts.
+cache_volume = modal.Volume.from_name("flux-inductor-cache", create_if_missing=True)
+CACHE_DIR = "/root/.cache/torch/inductor"
+
 # Define container environment
-image = modal.Image.debian_slim(python_version="3.12").pip_install(
-    "diffusers",
-    "transformers",
-    "accelerate",
-    "pillow",
-    "torch"
+image = (
+    modal.Image.debian_slim(python_version="3.12")
+    .pip_install(
+        "diffusers",
+        "transformers",
+        "accelerate",
+        "pillow",
+        "torch",
+        "triton"  # Essential for torch.compile
+    )
+    # Tell PyTorch Inductor to write its cache to our persistent volume directory
+    .env({"TORCHINDUCTOR_CACHE_DIR": CACHE_DIR})
 )
 
 app = modal.App("flux-klein-voxel-backend", image=image)
@@ -34,20 +47,21 @@ def demo_stream_frame(img_bytes: bytes) -> bytes:
 # ==============================================================================
 @app.cls(
     gpu="A10G",
-    # Using the secret name from your example: "huggingface-secret"
     secrets=[modal.Secret.from_name("huggingface-secret")],
-    max_containers=5
+    max_containers=5,
+    # Mount the persistent cache volume to the exact path PyTorch is looking at
+    volumes={CACHE_DIR: cache_volume} 
 )
 class VoxelModel:
     
     @modal.enter()
     def load_pipeline(self):
         import torch
+        from PIL import Image
         from diffusers import AutoPipelineForImage2Image
         
         model_id = "AnimeOverlord/flux2-klein-4b-mc"
         
-        # Following your provided pattern for auth
         self.pipe = AutoPipelineForImage2Image.from_pretrained(
             model_id,
             torch_dtype=torch.bfloat16,
@@ -56,6 +70,36 @@ class VoxelModel:
         self.pipe.to("cuda")
         self.pipe.enable_attention_slicing()
 
+        # ---------------------------------------------------------
+        # ✨ COMPILE AND OPTIMIZE THE TRANSFORMER
+        # ---------------------------------------------------------
+        print("Initializing torch.compile on the transformer block...")
+        
+        # Channels-last memory format often yields slightly faster compiled kernels
+        self.pipe.transformer.to(memory_format=torch.channels_last)
+        
+        # Compile the heaviest part of the FLUX architecture
+        self.pipe.transformer = torch.compile(
+            self.pipe.transformer,
+            mode="reduce-overhead", # Trades a bit of compile time for faster inference
+            fullgraph=False
+        )
+
+        # WARMUP RUN: We force a dummy inference right now. 
+        # If the cache is empty (first run ever), this traces the graph and saves to the Modal Volume.
+        # If the cache exists (subsequent cold-starts), it loads from the Volume in seconds.
+        print("Running warmup to build/load inductor cache...")
+        dummy_image = Image.new("RGB", (512, 512), (0, 0, 0))
+        with torch.inference_mode():
+            self.pipe(
+                prompt="warmup pass",
+                image=dummy_image,
+                strength=0.5,
+                num_inference_steps=2,
+                guidance_scale=1.0,
+            )
+        print("Warmup complete. Ready for real-time requests!")
+
     @modal.method()
     def process_frame(self, img_bytes: bytes, prompt: str, strength: float) -> bytes:
         from PIL import Image