native progress bar via generator (forwards on ZeroGPU)

app.py

@@ -5,6 +5,8 @@ os.environ.setdefault("TORCHDYNAMO_DISABLE", "1")
 
 import random
 import tempfile
+import threading
+import time
 
 import numpy as np
 import imageio.v3 as iio
@@ -46,11 +48,7 @@ pipe.to("cuda")
 pipe.vae.enable_tiling()
 _lora_path = hf_hub_download(LORA_REPO, LORA_FILE, token=HF_TOKEN)
 pipe.load_lora_weights(load_file(_lora_path), adapter_name="inpaint")
-pipe.fuse_lora(lora_scale=LORA_SCALE)
-pipe.unload_lora_weights()
-# AOTI: load precompiled transformer blocks at ROOT level (ZeroGPU loads on cuda at
-# module scope; do NOT lazy-load or move to cuda inside @spaces.GPU).
-spaces.aoti_load(module=pipe.transformer, repo_id="ltx-community/LTX-2.3-Transformer-GroupB-sm120-cu130-r0e")
+pipe.set_adapters("inpaint", LORA_SCALE)
 
 
 def _src_fps(path, default=FPS):
@@ -95,9 +93,38 @@ def _duration(*args, **kwargs):
     return int(70 + int(num_frames) * 1.3)
 
 
+
+class StreamRun:
+    """Run pipe() in a thread; yield live status strings (generator yields DO forward on ZeroGPU)."""
+    def __init__(self, call_pipe, num_steps):
+        self.call_pipe, self.num_steps = call_pipe, num_steps
+        self.state = {"step": 0}
+        self.holder = {}
+    def _cb(self, p, i, t, kw):
+        self.state["step"] = i + 1
+        return {}
+    def _run(self):
+        try:
+            self.holder["out"] = self.call_pipe(self._cb)
+        except Exception as e:
+            self.holder["err"] = e
+    def stream(self):
+        th = threading.Thread(target=self._run); th.start()
+        while th.is_alive():
+            s = self.state["step"]
+            yield (s / self.num_steps if s else 0.0, f"step {s}/{self.num_steps}" if s else "Loading model…")
+            time.sleep(0.4)
+        th.join()
+        if "err" in self.holder:
+            raise self.holder["err"]
+    @property
+    def result(self):
+        return self.holder["out"]
+
+
 @spaces.GPU(duration=_duration)
 def outpaint(video, canvas_key, prompt, num_frames, seed, randomize,
-             progress=gr.Progress(track_tqdm=True)):
+             progress=gr.Progress()):
     if video is None:
         raise gr.Error("Please upload a video.")
     if randomize:
@@ -133,11 +160,9 @@ def outpaint(video, canvas_key, prompt, num_frames, seed, randomize,
     desc = prompt.strip() or "the scene continues naturally beyond the original frame, consistent style and lighting"
     full_prompt = f"{desc}; seamlessly extend the scene into the empty margins, matching the existing content."
 
-    def _cb(p, i, t, kw):
-        progress((i + 1) / NUM_STEPS, desc=f"Outpainting — step {i + 1}/{NUM_STEPS}")
-        return {}
 
-    video_out, audio_out = pipe(
+    def _call_pipe(_cb):
+        return pipe(
         prompt=full_prompt, negative_prompt="",
         reference_conditions=[LTX2ReferenceCondition(frames=ref, strength=1.0)],
         conditioning_attention_mask=attn_mask, reference_downscale_factor=1,
@@ -146,7 +171,12 @@ def outpaint(video, canvas_key, prompt, num_frames, seed, randomize,
         guidance_scale=1.0, stg_scale=0.0, audio_guidance_scale=1.0, audio_stg_scale=0.0,
         generator=torch.Generator(device="cuda").manual_seed(seed),
         output_type="np", return_dict=False, callback_on_step_end=_cb,
-    )
+        )
+    runner = StreamRun(_call_pipe, NUM_STEPS)
+    for _frac, _desc in runner.stream():
+        progress(_frac, desc=_desc)
+        yield gr.update(), gr.update()
+    video_out, audio_out = runner.result
 
     # keep the original pixels exactly in the center; use generated pixels in the margins (feathered).
     gen = (np.clip(video_out[0], 0, 1) * 255).astype(np.uint8)
@@ -161,7 +191,7 @@ def outpaint(video, canvas_key, prompt, num_frames, seed, randomize,
 
     out_path = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False).name
     _export(out, audio_out, out_path)
-    return out_path, seed
+    yield out_path, seed
 
 
 with gr.Blocks(title="LTX-2.3 Video Outpaint") as demo: