new update fix

app.py

@@ -7,6 +7,9 @@ Beautiful Minecraft-themed Gradio UI with a dummy inference function
 
 import os
 import sys
+import logging
+import threading
+import time
 import torch
 import gradio as gr
 import spaces
@@ -14,6 +17,19 @@ from PIL import Image
 from huggingface_hub import snapshot_download
 from diffusers import DiffusionPipeline
 
+logging.basicConfig(
+    level=logging.INFO,
+    format="[%(asctime)s] [%(levelname)s] %(message)s",
+    force=True,
+)
+logger = logging.getLogger("minecraftify")
+
+
+def log_event(message: str):
+    logger.info(message)
+    print(f"[minecraftify] {message}", flush=True)
+
+
 _original_unraisablehook = sys.unraisablehook
 
 
@@ -32,6 +48,7 @@ def _ignore_asyncio_closed_fd_warning(unraisable):
 
 
 sys.unraisablehook = _ignore_asyncio_closed_fd_warning
+log_event("App module imported")
 
 # ----------------------------------------------------------------------
 # CUSTOM MINECRAFT CSS — THE ULTIMATE THEME
@@ -635,6 +652,11 @@ LORA_DIR = "AnimeOverlord/flux2-klein-4b-mc-v2"
 
 _pipe = None
 _pipe_ready = False
+_live_lock = threading.Lock()
+_live_latest_frame = None
+_live_latest_frame_id = 0
+_live_capture_count = 0
+_live_active = False
 
 IMAGE_MODE = "Image"
 LIVE_MODE = "Live Camera"
@@ -655,35 +677,48 @@ if GRADIO_MAJOR >= 6:
 else:
     BLOCKS_KWARGS.update({"css": CUSTOM_CSS, "theme": MC_THEME})
 
+log_event(f"Gradio version detected: {gr.__version__}")
+log_event(f"Blocks kwargs: {BLOCKS_KWARGS}")
+log_event(f"Launch kwargs: {LAUNCH_KWARGS}")
+
 
 def _ensure_model_files():
+    log_event("Checking model files")
     os.makedirs(MODEL_DIR, exist_ok=True)
     os.makedirs(LORA_DIR, exist_ok=True)
 
     # Download base model once into the volume
     if not os.path.exists(os.path.join(MODEL_DIR, "model_index.json")):
+        log_event(f"Downloading base model: {BASE_MODEL_ID}")
         snapshot_download(
             repo_id=BASE_MODEL_ID,
             local_dir=MODEL_DIR,
             local_dir_use_symlinks=False,
         )
+    else:
+        log_event("Base model already present")
 
     # Download LoRA once into the volume
     if not os.path.exists(os.path.join(LORA_DIR, "pytorch_lora_weights.safetensors")):
+        log_event(f"Downloading LoRA: {LORA_ID}")
         snapshot_download(
             repo_id=LORA_ID,
             local_dir=LORA_DIR,
             local_dir_use_symlinks=False,
             allow_patterns=["pytorch_lora_weights.safetensors"],
         )
+    else:
+        log_event("LoRA already present")
 
 
 def _load_pipe():
     global _pipe, _pipe_ready
 
     if _pipe_ready and _pipe is not None:
+        log_event("Pipeline already loaded")
         return _pipe
 
+    log_event("Loading pipeline")
     _ensure_model_files()
 
     pipe = DiffusionPipeline.from_pretrained(
@@ -706,6 +741,7 @@ def _load_pipe():
 
     _pipe = pipe
     _pipe_ready = True
+    log_event("Pipeline ready")
     return pipe
 
 
@@ -720,6 +756,10 @@ def _minecraftify_image(
     seed: int,
     extra_details: str,
 ):
+    log_event(
+        f"Starting inference: size={getattr(image, 'size', None)}, "
+        f"steps={steps}, guidance={guidance_scale}, seed={seed}"
+    )
     pipe = _load_pipe()
     image = image.convert("RGB")
 
@@ -746,6 +786,7 @@ def _minecraftify_image(
             generator=generator,
         )
 
+    log_event("Inference complete")
     return out.images[0]
 
 
@@ -758,28 +799,75 @@ def minecraftify(
     extra_details: str,
 ):
     if image is None:
+        log_event("Still image inference blocked: no image")
         raise gr.Error("⛏️ Please upload a photo first!")
 
+    log_event("Still image inference requested")
     return _minecraftify_image(image, steps, guidance_scale, seed, extra_details)
 
 
+def capture_live_frame(image: Image.Image):
+    global _live_latest_frame, _live_latest_frame_id, _live_capture_count
+
+    if image is None:
+        return None
+
+    with _live_lock:
+        _live_latest_frame = image.copy()
+        _live_latest_frame_id += 1
+        _live_capture_count += 1
+        frame_id = _live_latest_frame_id
+        capture_count = _live_capture_count
+
+    if capture_count == 1 or capture_count % 30 == 0:
+        log_event(f"Captured live webcam frame id={frame_id}, size={getattr(image, 'size', None)}")
+
+    return None
+
+
 @spaces.GPU(duration=120)
-def minecraftify_live(
-    image: Image.Image,
-    is_running: bool,
+def minecraftify_live_loop(
     steps: int,
     guidance_scale: float,
     seed: int,
     extra_details: str,
 ):
-    if not is_running or image is None:
-        return gr.skip()
+    log_event("Live GPU loop started")
+    last_processed_frame_id = 0
 
-    return _minecraftify_image(image, steps, guidance_scale, seed, extra_details)
+    while True:
+        with _live_lock:
+            is_active = _live_active
+            frame = _live_latest_frame.copy() if _live_latest_frame is not None else None
+            frame_id = _live_latest_frame_id
+
+        if not is_active:
+            log_event("Live GPU loop stopped")
+            yield gr.skip(), "Live camera is stopped."
+            return
+
+        if frame is None:
+            time.sleep(0.1)
+            continue
+
+        if frame_id == last_processed_frame_id:
+            time.sleep(0.02)
+            continue
+
+        last_processed_frame_id = frame_id
+        log_event(f"Processing newest live frame id={frame_id}")
+        output = _minecraftify_image(frame, steps, guidance_scale, seed, extra_details)
+        yield output, f"Live camera is running. Processed frame {frame_id}."
 
 
 def switch_input_mode(mode: str):
+    global _live_active
+
+    log_event(f"Input mode changed: {mode}")
     image_mode = mode == IMAGE_MODE
+    if image_mode:
+        _live_active = False
+
     return (
         gr.update(visible=image_mode),
         gr.update(visible=image_mode),
@@ -787,21 +875,49 @@ def switch_input_mode(mode: str):
         gr.update(interactive=True),
         gr.update(visible=not image_mode, interactive=False),
         False,
+        "Live camera is stopped.",
     )
 
 
-def start_live():
-    return True, gr.update(interactive=False), gr.update(interactive=True)
+def start_live(image: Image.Image):
+    global _live_active
+
+    with _live_lock:
+        has_captured_frame = _live_latest_frame is not None
+
+    if not has_captured_frame:
+        log_event("Start live blocked: webcam is not on or no streamed frame was captured")
+        raise gr.Error("📷 Webcam is not streaming yet. Click Record and wait for the preview before starting live.")
+
+    _live_active = True
+    log_event(f"Live mode started with webcam frame size={getattr(image, 'size', None)}")
+    return (
+        True,
+        gr.update(interactive=False),
+        gr.update(interactive=True),
+        "Live camera is running. Minecraft frames will appear on the right.",
+    )
 
 
 def stop_live():
-    return False, gr.update(interactive=True), gr.update(interactive=False)
+    global _live_active
+
+    _live_active = False
+    log_event("Live mode stopped")
+    return (
+        False,
+        gr.update(interactive=True),
+        gr.update(interactive=False),
+        "Live camera is stopped.",
+    )
 
 
 # ----------------------------------------------------------------------
 # UI
 # ----------------------------------------------------------------------
 
+log_event("Building Gradio UI")
+
 with gr.Blocks(**BLOCKS_KWARGS) as demo:
 
     # ── Title Banner ──
@@ -862,6 +978,13 @@ with gr.Blocks(**BLOCKS_KWARGS) as demo:
                             interactive=False,
                         )
 
+                    live_status = gr.Textbox(
+                        label="Live status",
+                        value="Live camera is stopped.",
+                        interactive=False,
+                        lines=1,
+                    )
+
                 extra_details = gr.Textbox(
                     label="🗒️ Extra scene details (optional)",
                     placeholder="e.g. 'this is a beach at sunset' or 'make the dog a wolf mob'...",
@@ -945,6 +1068,7 @@ with gr.Blocks(**BLOCKS_KWARGS) as demo:
             start_live_btn,
             stop_live_btn,
             live_running,
+            live_status,
         ],
         queue=False,
     )
@@ -955,27 +1079,35 @@ with gr.Blocks(**BLOCKS_KWARGS) as demo:
         outputs=output_image,
     )
 
-    start_live_btn.click(
+    start_live_event = start_live_btn.click(
         fn=start_live,
-        inputs=None,
-        outputs=[live_running, start_live_btn, stop_live_btn],
+        inputs=live_image,
+        outputs=[live_running, start_live_btn, stop_live_btn, live_status],
         queue=False,
     )
 
+    start_live_event.then(
+        fn=minecraftify_live_loop,
+        inputs=[steps, guidance_scale, seed, extra_details],
+        outputs=[output_image, live_status],
+        concurrency_limit=1,
+    )
+
     stop_live_btn.click(
         fn=stop_live,
         inputs=None,
-        outputs=[live_running, start_live_btn, stop_live_btn],
+        outputs=[live_running, start_live_btn, stop_live_btn, live_status],
         queue=False,
     )
 
     live_image.stream(
-        fn=minecraftify_live,
-        inputs=[live_image, live_running, steps, guidance_scale, seed, extra_details],
-        outputs=output_image,
-        stream_every=0.3,
+        fn=capture_live_frame,
+        inputs=live_image,
+        outputs=None,
+        stream_every=0.1,
         trigger_mode="always_last",
-        concurrency_limit=1,
+        queue=False,
     )
 
+log_event("Launching Gradio app")
 demo.queue(max_size=1).launch(**LAUNCH_KWARGS)