Un-mix against the raw matte (kills the last halo), real progress bar, native-res sprites, filter retry

app.py

@@ -20,7 +20,6 @@ import shutil
 import tempfile
 import time
 import traceback
-from concurrent.futures import ThreadPoolExecutor
 
 import gradio as gr
 
@@ -91,6 +90,7 @@ def forge(
     playback_fps,
     sprite_height,
     request: gr.Request,
+    progress=gr.Progress(),
 ):
     """Character -> one clip per move -> keyed extremes -> packed sheet -> playable demo, as one generator.
 
@@ -128,10 +128,11 @@ def forge(
     # ---- 2. one clip per move, concurrently ----
     # These requests are fully independent, so they are fired together: the wall clock becomes the slowest single
     # clip instead of the sum. Each gets its own seed so two moves never collapse onto the same motion.
-    def one(index_preset):
-        index, preset = index_preset
-        return preset, backends.animate(
-            prompt=preset.prompt(subject if not uploaded else "the character"),
+    who = subject if not uploaded else "the character"
+
+    def submit(preset, index, minimal=False):
+        return backends.animate_job(
+            prompt=preset.prompt(who, minimal=minimal),
             image_path=character,
             canvas_label=canvas_label,
             duration=float(duration),
@@ -140,19 +141,68 @@ def forge(
             ip_token=ip_token,
         )
 
-    clips, failures = [], []
-    with ThreadPoolExecutor(max_workers=max(1, len(presets))) as pool:
-        for preset, result in zip(presets, pool.map(_safe(one), enumerate(presets))):
-            if isinstance(result, Exception):
-                failures.append(f"**{preset.label}**: `{type(result).__name__}: {result}`")
+    def await_all(pending, label):
+        """Poll a batch of in-flight jobs, driving the progress bar off the slowest one."""
+        started = time.time()
+        while not all(job.done() for _p, _i, job in pending):
+            finished = sum(1 for _p, _i, job in pending if job.done())
+            elapsed = time.time() - started
+            # All the requests start together, so the batch takes as long as its slowest member and elapsed time is
+            # a fair proxy for how far along that one is. The completed count is the ground truth and always wins;
+            # the clock only fills the gap between completions, and is capped short of 1 so the bar never claims to
+            # be finished before the work is.
+            clock = min(elapsed / max(ANIMATE_SECONDS, 1.0), 0.95)
+            fraction = max(finished / len(pending), clock)
+            progress(0.1 + 0.65 * fraction, desc=f"{label} — {finished}/{len(pending)} done")
+            time.sleep(0.4)
+        return pending
+
+    ANIMATE_SECONDS = 18 + 2.5 * int(steps) + 5.0 * float(duration)
+
+    progress(0.1, desc=f"Animating {len(presets)} moves")
+    inflight = [(preset, i, submit(preset, i)) for i, preset in enumerate(presets)]
+    await_all(inflight, f"Animating {len(presets)} moves")
+
+    clips, failures, refused = [], [], []
+    for preset, index, job in inflight:
+        try:
+            video, report = backends.unwrap(job.result())
+        except Exception as error:  # noqa: BLE001 — reported per move in the status line
+            # The H3 Space runs a content classifier over the prompt of every keyframed request, and it is touchy in
+            # ways the wording does not predict — "the foot sweeping up and out" is refused where "a front kick to
+            # the right" is not. It runs *before* the GPU booking, so a refusal costs no quota and retrying is cheap.
+            if "content filter" in str(error):
+                refused.append((preset, index))
+            else:
+                failures.append(f"**{preset.label}**: `{type(error).__name__}: {error}`")
+            continue
+        clips.append({
+            "key": preset.key,
+            "label": preset.label,
+            "video": _adopt(video, f"{preset.key}.mp4"),
+            "frames": preset.frames,
+        })
+
+    if refused:
+        # One retry wave, plainer phrasing and no character description.
+        print(f"[forge] retrying {[p.key for p, _ in refused]} minimally", flush=True)
+        retries = [(preset, i, submit(preset, i, minimal=True)) for preset, i in refused]
+        await_all(retries, "Retrying refused moves")
+        for preset, _index, job in retries:
+            try:
+                video, report = backends.unwrap(job.result())
+            except Exception as error:  # noqa: BLE001
+                failures.append(f"**{preset.label}**: `{type(error).__name__}: {error}`")
                 continue
-            _preset, (video, report) = result
             clips.append({
                 "key": preset.key,
                 "label": preset.label,
                 "video": _adopt(video, f"{preset.key}.mp4"),
                 "frames": preset.frames,
             })
+        # Keep sheet order matching the order the moves were requested in.
+        order = {preset.key: i for i, preset in enumerate(presets)}
+        clips.sort(key=lambda c: order[c["key"]])
 
     if not clips:
         raise gr.Error("Every move failed. " + (failures[0] if failures else ""))
@@ -162,7 +212,8 @@ def forge(
 
     # ---- 3. key, cut to extremes, pack ----
     packed, previews, key_hex = [], [], None
-    for clip in clips:
+    for i, clip in enumerate(clips):
+        progress(0.75 + 0.2 * i / len(clips), desc=f"Keying {clip['label']}")
         frames, _fps = sk.read_video(clip["video"])
         keyed, key_rgb = sk.key_clip(
             frames,
@@ -215,19 +266,6 @@ def forge(
     )
 
 
-def _safe(fn):
-    """Let one failed move return its exception instead of cancelling the others."""
-
-    def wrapped(item):
-        try:
-            return fn(item)
-        except Exception as error:  # noqa: BLE001 — surfaced per move in the status line
-            traceback.print_exc()
-            return error
-
-    return wrapped
-
-
 # ---------------------------------------------------------------------------
 # ui
 # ---------------------------------------------------------------------------
@@ -293,7 +331,10 @@ with gr.Blocks(title="Sprite Forge") as demo:
                         steps = gr.Slider(4, 8, value=6, step=1, label="H3 steps")
                     with gr.Row():
                         playback_fps = gr.Slider(4, 24, value=12, step=1, label="Playback fps")
-                        sprite_height = gr.Slider(64, 512, value=256, step=32, label="Max sprite height")
+                        sprite_height = gr.Slider(
+                            128, 768, value=512, step=32, label="Max sprite height",
+                            info="Only ever downscales. 512 keeps a 544px clip at native size.",
+                        )
                     with gr.Row():
                         tolerance = gr.Slider(0.02, 0.30, value=0.10, step=0.01, label="Key tolerance")
                         softness = gr.Slider(0.01, 0.25, value=0.09, step=0.01, label="Edge softness")

backends.py

@@ -124,11 +124,45 @@ def _as_path(result) -> str:
     return value
 
 
+def animate_job(
+    prompt: str,
+    image_path: str,
+    canvas_label: str,
+    duration: float = 3.0,
+    steps: int = 6,
+    seed: int = 42,
+    ip_token: str | None = None,
+):
+    """Same request as `animate`, submitted rather than awaited, so several can be in flight and polled.
+
+    Returns a `gradio_client` Job. `.done()` and `.result()` are the whole interface the caller needs.
+    """
+    return _client(H3_SPACE, ip_token).submit(
+        prompt=prompt,
+        image_path=handle_file(image_path),
+        last_image_path=handle_file(image_path),
+        canvas=CANVASES[canvas_label][0],
+        duration=duration,
+        steps=steps,
+        seed=seed,
+        upsample=False,
+        use_lora=True,
+        lora="larry",
+        api_name="/generate",
+    )
+
+
+def unwrap(result) -> tuple[str, str]:
+    """`(video path, the report line the H3 Space emits)` out of a raw prediction tuple."""
+    report = result[1] if isinstance(result, (list, tuple)) and len(result) > 1 else ""
+    return _as_path(result), str(report)
+
+
 def animate(
     prompt: str,
     image_path: str,
     canvas_label: str,
-    duration: float = 2.0,
+    duration: float = 3.0,
     steps: int = 6,
     seed: int = 42,
     ip_token: str | None = None,

moves.py

@@ -82,8 +82,17 @@ class MovePreset:
     label: str
     action: str
     frames: int = 6
+    #: A plainer phrasing of the same move, used only to retry a request the content classifier refused.
+    fallback: str = ""
 
-    def prompt(self, subject: str) -> str:
+    def prompt(self, subject: str, minimal: bool = False) -> str:
+        """The animation prompt. ``minimal`` swaps in the fallback phrasing and drops the character description.
+
+        The subject is safe to drop on a retry because H3 is *also* given the character as its conditioning
+        keyframe — the description is there to keep the model on-model, not to define who it is.
+        """
+        if minimal:
+            return f"{self.fallback or self.action} {ANIMATION_RULES}"
         who = (subject or "the character").strip().rstrip(".,")
         return f"{who}. {self.action} {ANIMATION_RULES}"
 
@@ -97,8 +106,9 @@ PRESETS: list[MovePreset] = [
         "idle",
         "Idle",
         "The character stands in place with a subtle idle animation, bobbing gently up and down, "
-        "swaying slightly, with a small head movement. The feet never leave their spot.",
+        "swaying slightly, with a small head movement.",
         frames=4,
+        fallback="The character holds a relaxed standing pose with a gentle breathing motion.",
     ),
     MovePreset(
         "walk",
@@ -131,9 +141,9 @@ PRESETS: list[MovePreset] = [
     MovePreset(
         "kick",
         "Kick",
-        "The character throws a high kick forward to the right, the foot sweeping up and out, "
-        "then plants back down into the standing pose.",
+        "The character performs a front kick to the right, then returns to the standing pose.",
         frames=6,
+        fallback="The character performs a martial arts kick to the right, then recovers.",
     ),
     MovePreset(
         "block",

spritekit.py

@@ -165,9 +165,22 @@ def key_frame(
     shrink: float = 0.2,
     feather: float = 0.6,
 ) -> np.ndarray:
-    """matte -> refine -> unmix, in that order. Returns RGBA float 0..1."""
-    alpha = refine_matte(matte(frame, key_rgb, tolerance, softness), despeckle, shrink, feather)
-    return np.concatenate([unmix(frame, alpha, key_rgb, despill), alpha[..., None]], axis=-1).astype(np.float32)
+    """Returns RGBA float 0..1.
+
+    The two alphas are deliberately different, and mixing them up is what leaves a pink rim:
+
+    * ``raw`` is the measured coverage, and it is the only alpha for which ``observed = a*F + (1-a)*key`` holds. It
+      is therefore what `unmix` must solve against.
+    * ``refined`` is the *output* matte — despeckled, choked, feathered. Feeding it back into the un-mixing equation
+      asks it to invert a composite that never happened: a choked rim pixel claims 6% coverage where the real
+      composite had 25%, the division extrapolates wildly, gets clipped, and the pixel stays the backdrop's color
+      while remaining faintly opaque. That is the halo, reintroduced one step after being removed.
+
+    So: recover color against the truth, then hand out the tidied matte.
+    """
+    raw = matte(frame, key_rgb, tolerance, softness)
+    refined = refine_matte(raw, despeckle, shrink, feather)
+    return np.concatenate([unmix(frame, raw, key_rgb, despill), refined[..., None]], axis=-1).astype(np.float32)
 
 
 def key_clip(