fix(progress): stream per-step progress for anima image models

The default Anime/Realistic models use the anima family (Cosmos-Predict2
modular pipeline), whose __call__ accepts no callback_on_step_end — so the
diffusers-style step callback never fired and generate_image yielded no
per-step frames. The web progress bar sat at 0% until the final upload.

Wrap the modular pipeline's scheduler.step (called once per denoise step)
to drive the same callback the queue-fed generator already reads, via a
_anima_step_progress context manager that restores the original method in a
finally (no leak across requests) and no-ops if scheduler/callback is absent.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

app.py

@@ -1,3 +1,4 @@
+import contextlib
 import inspect
 import io
 import json
@@ -933,6 +934,47 @@ def _supports_step_callback(pipe):
         return False
 
 
+@contextlib.contextmanager
+def _anima_step_progress(pipe, callback, total_steps):
+    """Emit per-step progress for the modular Anima pipeline by wrapping its
+    scheduler's ``step``.
+
+    The modular (Cosmos-Predict2) pipeline's ``__call__`` doesn't accept
+    ``callback_on_step_end``, so the diffusers-style ``callback`` the rest of the
+    generator relies on never fires for the anima family. The denoise loop calls
+    ``scheduler.step`` exactly once per inference step, so wrapping it gives a
+    reliable per-step tick. We forward into the existing ``callback`` (shape:
+    ``callback(pipe, step, timestep, callback_kwargs)`` — only the 0-based
+    ``step`` is used downstream). The original method is always restored, so a
+    no-op (missing scheduler / callback) or an exception can't leave the shared
+    pipeline patched across requests.
+    """
+    sched = getattr(pipe, "scheduler", None)
+    orig = getattr(sched, "step", None) if sched is not None else None
+    if callback is None or orig is None:
+        yield
+        return
+
+    state = {"i": 0}
+
+    def _counting_step(*args, **kwargs):
+        out = orig(*args, **kwargs)
+        i = state["i"]
+        if i < total_steps:
+            state["i"] = i + 1
+            try:
+                callback(pipe, i, None, {})
+            except Exception:  # noqa: BLE001 - progress must never break sampling
+                pass
+        return out
+
+    sched.step = _counting_step
+    try:
+        yield
+    finally:
+        sched.step = orig
+
+
 @spaces.GPU
 def generate_image(
     model_name,
@@ -1134,17 +1176,27 @@ def _generate_image_inner(
         generator = torch.Generator("cuda").manual_seed(seed)
         prompt = _apply_prefix(prompt, entry.get("prefix", ""))
         negative_prompt = _resolve_negative(entry, negative_prompt, use_negative_prompt, model_name)
-        images = pipe(
-            prompt=prompt,
-            negative_prompt=negative_prompt or None,
-            height=int(height),
-            width=int(width),
-            num_inference_steps=int(num_inference_steps),
-            num_images_per_prompt=1,
-            generator=generator,
-            output_type="pil",
-            output="images",
-        )
+        # Per-step progress: the modular pipeline doesn't accept
+        # `callback_on_step_end`, so we can't wire the callback the way the
+        # illustrious / zimageturbo branches do. Instead wrap the scheduler's
+        # `step` (called exactly once per denoise step) to drive the same
+        # callback the queue-fed generator reads. Without this the anima family
+        # — which backs the *default* Anime/Realistic models — emits no
+        # sampling frames, so the web progress bar sits at 0% until the final
+        # upload. Restored in a finally so a patched method never leaks across
+        # requests sharing this pipeline.
+        with _anima_step_progress(pipe, callback, int(num_inference_steps)):
+            images = pipe(
+                prompt=prompt,
+                negative_prompt=negative_prompt or None,
+                height=int(height),
+                width=int(width),
+                num_inference_steps=int(num_inference_steps),
+                num_images_per_prompt=1,
+                generator=generator,
+                output_type="pil",
+                output="images",
+            )
         image = images[0] if isinstance(images, (list, tuple)) else images
         return image, seed