Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.
Python agentaichatgptdeepseekfine-tuninggemmaimage-generationllamallmllmsopenaipythonqwenreinforcement-learningself-hostedstable-diffusiontext-to-speechttsuiunsloth
Studio: quiet image and video generation logs (#9885)
oobabooga20c8f693f367
diff --git a/studio/backend/core/inference/sd_cpp_engine.py b/studio/backend/core/inference/sd_cpp_engine.pyindex a3102caa980..042aec9539c 100644--- a/studio/backend/core/inference/sd_cpp_engine.py+++ b/studio/backend/core/inference/sd_cpp_engine.py@@ -63,6 +63,88 @@ OWNER_MARKER = ".unsloth-studio-owned"# cancel_event is the user-facing abort.NATIVE_GENERATION_TIMEOUT_S = 6 * 60 * 60.0+_PRIVATE_TEXT_OPTIONS = frozenset({"--prompt", "--negative-prompt", "-p", "-n"})+++def _verbose_native_logs() -> bool:+ """Return whether Studio verbose logging is enabled."""+ try:+ from loggers.config import verbose_logging_requested+ return verbose_logging_requested()+ except Exception:+ return False+++def _last_option_value(cmd: list[str], option: str) -> Optional[str]:+ """Return an option's effective last value, including ``--option=value`` form."""+ value = None+ prefix = f"{option}="+ for index, token in enumerate(cmd):+ if token == option and index + 1 < len(cmd):+ value = str(cmd[index + 1])+ elif str(token).startswith(prefix):+ value = str(token)[len(prefix) :]+ return value+++def _sd_cpp_command_for_log(cmd: list[str]) -> list[str]:+ """Redact prompt text from argv before logging."""+ out: list[str] = []+ index = 0+ while index < len(cmd):+ token = str(cmd[index])+ if token in _PRIVATE_TEXT_OPTIONS:+ out.append(token)+ if index + 1 < len(cmd):+ out.append("<redacted>")+ index += 2+ continue+ index += 1+ continue+ replaced = False+ for option in _PRIVATE_TEXT_OPTIONS:+ if token.startswith(f"{option}="):+ out.append(f"{option}=<redacted>")+ replaced = True+ break+ if not replaced:+ out.append(token)+ index += 1+ return out+++def _compact_log_value(value: str, limit: int = 48) -> str:+ text = str(value)+ return text if len(text) <= limit else text[: limit - 3] + "..."+++def _sd_cpp_command_summary(cmd: list[str], *, default_mode: str = "img_gen") -> str:+ """Summarize argv without paths or prompt text."""+ # Prompt values can resemble options; redact them before extracting settings.+ cmd = _sd_cpp_command_for_log(cmd)+ mode = _compact_log_value(_last_option_value(cmd, "--mode") or default_mode)+ fields = [f"mode={mode}"]+ model = _last_option_value(cmd, "--diffusion-model")+ if model:+ model_name = str(model).replace("\\", "/").rsplit("/", 1)[-1]+ fields.append(f"model={_compact_log_value(model_name)}")+ width = _last_option_value(cmd, "--width")+ height = _last_option_value(cmd, "--height")+ if width is not None and height is not None:+ fields.append(f"size={_compact_log_value(width)}x{_compact_log_value(height)}")+ for label, option in (+ ("steps", "--steps"),+ ("frames", "--video-frames"),+ ("fps", "--fps"),+ ("seed", "--seed"),+ ("port", "--listen-port"),+ ("threads", "--threads"),+ ):+ value = _last_option_value(cmd, option)+ if value is not None:+ fields.append(f"{label}={_compact_log_value(value)}")+ return " ".join(fields)+# sd-cli redraws its progress bar IN PLACE. Each redraw is one printf + fflush shaped "\r<bar> <step>/<steps> -# <speed>\033[K", with a trailing newline only on the final step of a phase. So the carriage return LEADS the record and@@ -753,7 +835,12 @@ class SdCppEngine:if env:base.update(env)run_env = runtime_env(self._require_binary(), base)- logger.info("sd-cli run: %s", " ".join(cmd))+ summary = _sd_cpp_command_summary(cmd)+ verbose_logs = _verbose_native_logs()+ if verbose_logs:+ logger.info("sd-cli run: %s", " ".join(_sd_cpp_command_for_log(cmd)))+ else:+ logger.info("sd-cli run started: %s", summary)t0 = time.time()proc = subprocess.Popen(@@ -832,7 +919,11 @@ class SdCppEngine:f"sd-cli reported success but no image at {out}. Last output:\n"+ "\n".join(tail[-12:]))- logger.info("sd-cli run ok in %.1fs -> %s", time.time() - t0, out)+ elapsed = time.time() - t0+ if verbose_logs:+ logger.info("sd-cli run ok in %.1fs -> %s", elapsed, out)+ else:+ logger.info("sd-cli run completed: %s elapsed=%.1fs", summary, elapsed)return outdiff --git a/studio/backend/core/inference/sd_cpp_server.py b/studio/backend/core/inference/sd_cpp_server.pyindex a3d0c1494f0..70448f78ecf 100644--- a/studio/backend/core/inference/sd_cpp_server.py+++ b/studio/backend/core/inference/sd_cpp_server.py@@ -50,6 +50,9 @@ from core.inference.sd_cpp_args import SdCppModelFiles, build_sd_cpp_server_commfrom core.inference.sd_cpp_engine import (NATIVE_GENERATION_TIMEOUT_S,SdCppCancelled,+ _sd_cpp_command_for_log,+ _sd_cpp_command_summary,+ _verbose_native_logs,runtime_env,)from utils.native_path_leases import child_env_without_native_path_secret@@ -241,7 +244,13 @@ class SdCppServer:run_env = runtime_env(self.binary, child_env_without_native_path_secret())if env:run_env.update(env)- logger.info("starting sd-server: %s", " ".join(cmd))+ if _verbose_native_logs():+ logger.info("starting sd-server: %s", " ".join(_sd_cpp_command_for_log(cmd)))+ else:+ logger.info(+ "starting sd-server: %s",+ _sd_cpp_command_summary(cmd, default_mode = "server"),+ )# Clear in place; reassigning [] would drop the maxlen bound and grow unbounded.self._tail.clear()self._resident_params_vram_gb = Nonediff --git a/studio/backend/core/inference/video.py b/studio/backend/core/inference/video.pyindex c6c87c9522d..d0c8486b56c 100644--- a/studio/backend/core/inference/video.py+++ b/studio/backend/core/inference/video.py@@ -5306,6 +5306,14 @@ class VideoBackend:"total": 0,"eta_seconds": None,}+ logger.info(+ "video_generation_progress",+ phase = "failed",+ percent = 0,+ step = 0,+ total_steps = 0,+ error = error,+ )else:self._gen = {"active": False,@@ -5315,6 +5323,14 @@ class VideoBackend:"total": total,"eta_seconds": None,}+ logger.info(+ "video_generation_progress",+ phase = "completed",+ percent = 100,+ step = total,+ total_steps = total,+ video_id = (video or {}).get("id"),+ )def generate(self,diff --git a/studio/backend/loggers/config.py b/studio/backend/loggers/config.pyindex 22376597d06..1c29b0cb1f1 100644--- a/studio/backend/loggers/config.py+++ b/studio/backend/loggers/config.py@@ -284,6 +284,11 @@ def _verbose_logging_requested() -> bool:)+def verbose_logging_requested() -> bool:+ """Return whether Studio verbose logging is enabled."""+ return _verbose_logging_requested()++class _NullStream:"""Somewhere for a progress bar to write that is not the log."""@@ -475,6 +480,8 @@ def quiet_third_party_progress_bars() -> None:except Exception: # noqa: BLE001pass_silence_datasets_bar_output()+ # Direct tqdm users bypass diffusers' toggle; preserve counters but discard redraws.+ _redirect_every_bar_output()class LogConfig:diff --git a/studio/backend/loggers/handlers.py b/studio/backend/loggers/handlers.pyindex 12d52b1c37d..e7e205ec2f4 100644--- a/studio/backend/loggers/handlers.py+++ b/studio/backend/loggers/handlers.py@@ -69,15 +69,8 @@ _QUIET_POLL_PATHS = {"/api/models/download-progress","/api/models/gguf-download-progress","/api/datasets/download-progress",- # Generation is fire-and-forget: its outcome only reaches the UI via these polls.- "/api/inference/images/generate-progress",- "/api/inference/video/generate-progress",# Polled every 1.5s while the train UI is open."/api/train/diffusion/status",- # These handlers log nothing and diffusion.loaded / video.loaded are terminal, so a minutes-long- # load would otherwise emit nothing at all.- "/api/inference/images/load-progress",- "/api/inference/video/load-progress",# Templated; matched through normalize_poll_path. See _TEMPLATED_POLL_PATHS."/api/chat/threads/{id}","/api/chat/threads/{id}/forks",@@ -122,10 +115,15 @@ _EXCLUDED_SUFFIXES = (".woff2",".ttf",)-# GET polls whose 2xx line carries no signal, so drop it entirely; non-2xx still logs. Only /api/hub-# download polls emit events.+# GET polls whose 2xx line carries no signal, so drop it entirely; non-2xx still logs.+# Media progress and /api/hub download polls emit structured events._QUIET_SUCCESS_PATHS = {"/api/inference/load-progress",+ # Their route handlers publish structured phase and 10 percent milestones.+ "/api/inference/images/load-progress",+ "/api/inference/video/load-progress",+ "/api/inference/images/generate-progress",+ "/api/inference/video/generate-progress","/api/llama/update-status","/api/export/logs","/api/export/status",diff --git a/studio/backend/loggers/media_progress.py b/studio/backend/loggers/media_progress.pynew file mode 100644index 00000000000..0d5d823aed9--- /dev/null+++ b/studio/backend/loggers/media_progress.py@@ -0,0 +1,170 @@+# SPDX-License-Identifier: AGPL-3.0-only+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0++"""Compact structured progress logs for image and video work."""++from __future__ import annotations++import math+import threading+from dataclasses import dataclass+from typing import Any, Mapping++from loggers import get_logger++logger = get_logger(__name__)++_GENERATION_EVENT_NAMES = {+ "image": "image_generation_progress",+ "video": "video_generation_progress",+}+_LOAD_EVENT_NAMES = {+ "image": "diffusion_load_progress",+ "video": "video_load_progress",+}+_LOAD_ACTIVE_PHASES = frozenset({"downloading", "finalizing"})+++@dataclass(frozen = True)+class _ProgressState:+ active: bool+ phase: str+ bucket: int+ step: int+++@dataclass(frozen = True)+class _LoadProgressState:+ phase: str+ bucket: int+++_state_lock = threading.Lock()+_last_state: dict[str, _ProgressState] = {}+_last_load_state: dict[str, _LoadProgressState] = {}+++def _int(value: Any) -> int:+ try:+ return max(0, int(value or 0))+ except (TypeError, ValueError, OverflowError):+ return 0+++def _clamped_fraction(value: Any) -> float:+ try:+ fraction = float(value or 0.0)+ except (TypeError, ValueError, OverflowError):+ fraction = 0.0+ if not math.isfinite(fraction):+ fraction = 0.0+ return max(0.0, min(fraction, 1.0))+++def _fraction(progress: Mapping[str, Any], step: int, total: int) -> float:+ value = _clamped_fraction(progress.get("fraction", 0.0))+ return _clamped_fraction(step / total) if value <= 0.0 and total > 0 else value+++def reset_media_generation_progress(media: str) -> None:+ """Clear progress state for a new job."""+ if media not in _GENERATION_EVENT_NAMES:+ raise ValueError(f"unknown media progress stream: {media}")+ with _state_lock:+ _last_state.pop(media, None)+++def reset_media_load_progress(media: str) -> None:+ """Clear progress state for a new load."""+ if media not in _LOAD_EVENT_NAMES:+ raise ValueError(f"unknown media progress stream: {media}")+ with _state_lock:+ _last_load_state.pop(media, None)+++def byte_fraction(done: Any, total: Any) -> float:+ """Return a safe byte ratio when the expected size may be unknown."""+ try:+ done_bytes = float(done or 0)+ total_bytes = float(total or 0)+ except (TypeError, ValueError, OverflowError):+ return 0.0+ if not math.isfinite(done_bytes) or not math.isfinite(total_bytes) or total_bytes <= 0:+ return 0.0+ return done_bytes / total_bytes+++def log_media_load_progress(media: str, phase: Any, fraction: Any) -> None:+ """Emit load phase changes and 10 percent milestones."""+ event = _LOAD_EVENT_NAMES.get(media)+ if event is None:+ raise ValueError(f"unknown media progress stream: {media}")++ phase_name = str(phase or "")+ if phase_name not in _LOAD_ACTIVE_PHASES:+ reset_media_load_progress(media)+ return++ bucket = min(10, int(_clamped_fraction(fraction) * 10))+ current = _LoadProgressState(phase_name, bucket)+ with _state_lock:+ previous = _last_load_state.get(media)+ if previous is not None and bucket < previous.bucket:+ return+ should_log = bool(+ previous is None or phase_name != previous.phase or bucket > previous.bucket+ )+ _last_load_state[media] = current++ if should_log:+ logger.info(event, phase = phase_name, percent = bucket * 10)+++def log_media_generation_progress(media: str, progress: Mapping[str, Any]) -> None:+ """Emit live start, phase, and 10 percent milestones."""+ event = _GENERATION_EVENT_NAMES.get(media)+ if event is None:+ raise ValueError(f"unknown media progress stream: {media}")++ active = bool(progress.get("active", False))+ step = _int(progress.get("step", 0))+ total = _int(progress.get("total_steps", progress.get("total", 0)))+ fraction = _fraction(progress, step, total)+ bucket = min(10, int(fraction * 10))+ phase = str(progress.get("phase") or ("denoise" if active else ""))+ current = _ProgressState(active, phase, bucket, step)++ with _state_lock:+ previous = _last_state.get(media)+ restarted = bool(+ active and previous is not None and previous.active and step < previous.step+ )+ should_log = bool(+ active+ and (+ previous is None+ or not previous.active+ or restarted+ or phase != previous.phase+ or bucket > previous.bucket+ )+ )+ _last_state[media] = current++ if not should_log:+ return++ fields: dict[str, Any] = {+ "phase": phase,+ "percent": bucket * 10,+ "step": step,+ "total_steps": total,+ }+ eta = progress.get("eta_seconds")+ try:+ eta_value = float(eta) if eta is not None else None+ except (TypeError, ValueError, OverflowError):+ eta_value = None+ if eta_value is not None and math.isfinite(eta_value):+ fields["eta_seconds"] = round(max(0.0, eta_value), 1)+ logger.info(event, **fields)diff --git a/studio/backend/routes/inference.py b/studio/backend/routes/inference.pyindex 542ef7367d3..e38153872b7 100644--- a/studio/backend/routes/inference.py+++ b/studio/backend/routes/inference.py@@ -43,6 +43,12 @@ import functoolsimport jsonimport httpxfrom loggers import get_logger+from loggers.media_progress import (+ log_media_generation_progress,+ log_media_load_progress,+ reset_media_generation_progress,+ reset_media_load_progress,+)import asyncioimport contextvarsimport threading@@ -35247,6 +35253,7 @@ async def load_diffusion_model_gated(extract_quant_token(request.gguf_filename) if kind == "gguf" else None,user_action = user_initiated,)+ reset_media_load_progress("image")return DiffusionStatusResponse(**annotate_status(status_dict))except (ValueError, FileNotFoundError) as exc:raise HTTPException(status_code = 400, detail = redact_native_paths(str(exc)))@@ -35311,6 +35318,9 @@ async def generate_diffusion_image()backend = get_active_diffusion_engine()+ # Ahead of the run, like the video route: milestones are keyed on the previous poll, so a+ # run starting at or above where the last one stopped would read as it and log nothing.+ reset_media_generation_progress("image")try:result = await asyncio.to_thread(backend.generate,@@ -35744,7 +35754,10 @@ async def diffusion_inference_info(current_subject: str = Depends(get_current_su@studio_router.get("/images/load-progress", response_model = DiffusionLoadProgressResponse)async def diffusion_load_progress(current_subject: str = Depends(get_current_subject)):from core.inference.diffusion_engine_router import get_active_diffusion_engine- return DiffusionLoadProgressResponse(**get_active_diffusion_engine().load_progress())++ progress = get_active_diffusion_engine().load_progress()+ log_media_load_progress("image", progress.get("phase"), progress.get("fraction"))+ return DiffusionLoadProgressResponse(**progress)@studio_router.get("/images/generate-progress", response_model = DiffusionGenerateProgressResponse)@@ -35752,6 +35765,7 @@ async def diffusion_generate_progress(current_subject: str = Depends(get_currentfrom core.inference.diffusion_engine_router import get_active_diffusion_engineprogress = get_active_diffusion_engine().generate_progress()+ log_media_generation_progress("image", progress)# A finished generation still persisting its gallery record counts as active, so a reload probe keeps polling.if _diffusion_persist_active > 0 and not progress["active"]:progress = {**progress, "active": True}@@ -35984,6 +35998,7 @@ async def _generate_openai_images(# Fall back to the resolved base repo so a local-path load still gets the right per-model steps/guidance.steps, guidance = default_generation_params(status.get("repo_id"), status.get("base_repo"))+ reset_media_generation_progress("image")try:result = await asyncio.to_thread(backend.generate,diff --git a/studio/backend/routes/video.py b/studio/backend/routes/video.pyindex 8d72628ef57..9539cae0565 100644--- a/studio/backend/routes/video.py+++ b/studio/backend/routes/video.py@@ -38,6 +38,13 @@ from auth.authentication import get_current_subject, request_admitted_without_crfrom core.inference.model_ids import public_model_idfrom hub.dependencies import get_hf_tokenfrom loggers import get_logger+from loggers.media_progress import (+ byte_fraction,+ log_media_generation_progress,+ log_media_load_progress,+ reset_media_generation_progress,+ reset_media_load_progress,+)from models.inference import (DiffusionDownloadPlanResponse,GalleryFlagsPatch,@@ -351,6 +358,7 @@ async def load_video_model_gated(request.h3_task or _derived_h3_task(request.gguf_filename, kind),user_action = user_initiated,)+ reset_media_load_progress("video")return VideoStatusResponse(**status_dict)except (ValueError, FileNotFoundError) as exc:raise HTTPException(status_code = 400, detail = redact_native_paths(str(exc)))@@ -362,7 +370,11 @@ async def load_video_model_gated(@router.get("/video/load-progress", response_model = VideoLoadProgressResponse)async def video_load_progress(current_subject: str = Depends(get_current_subject)):from core.inference.video import get_video_backend- return VideoLoadProgressResponse(**get_video_backend().load_progress())++ progress = get_video_backend().load_progress()+ fraction = byte_fraction(progress.get("downloaded_bytes"), progress.get("expected_bytes"))+ log_media_load_progress("video", progress.get("phase"), fraction)+ return VideoLoadProgressResponse(**progress)@router.post("/video/generate", response_model = VideoGenerateResponse)@@ -488,13 +500,17 @@ async def generate_video(logger.error("video.generate_failed: %s", exc, exc_info = True)raise HTTPException(status_code = 500, detail = "Video generation failed.")+ reset_media_generation_progress("video")return VideoGenerateResponse()@router.get("/video/generate-progress", response_model = VideoGenerateProgressResponse)async def video_generate_progress(current_subject: str = Depends(get_current_subject)):from core.inference.video import get_video_backend- return VideoGenerateProgressResponse(**get_video_backend().generate_progress())++ progress = get_video_backend().generate_progress()+ log_media_generation_progress("video", progress)+ return VideoGenerateProgressResponse(**progress)@router.post("/video/generate/cancel")@@ -1437,6 +1453,8 @@ async def _create_openai_video(logger.error("openai_videos.generate_failed: %s", exc, exc_info = True)raise HTTPException(status_code = 500, detail = "Video generation failed.")+ reset_media_generation_progress("video")+# begin_generate hands back the canvas it resolved. Without it a reference-image# request reported the family's first preset while the clip rendered at the source# aspect, so the job advertised one size and the finished record another.diff --git a/studio/backend/tests/log_budget/session.py b/studio/backend/tests/log_budget/session.pyindex 9689ed78818..e10e00a8415 100644--- a/studio/backend/tests/log_budget/session.py+++ b/studio/backend/tests/log_budget/session.py@@ -64,8 +64,8 @@ BUSY_POLLS: dict[str, tuple[float, str]] = {"/api/models/download-progress": (1.0, "declared"),"/api/models/gguf-download-progress": (1.0, "declared"),"/api/datasets/download-progress": (1.0, "declared"),- "/api/inference/images/generate-progress": (1.0, "declared"),- "/api/inference/video/generate-progress": (1.0, "declared"),+ "/api/inference/images/generate-progress": (0.3, "declared"),+ "/api/inference/video/generate-progress": (0.3, "declared"),"/api/inference/images/load-progress": (1.0, "declared"),"/api/inference/video/load-progress": (1.0, "declared"),"/api/train/diffusion/status": (1.5, "declared"),@@ -140,12 +140,10 @@ KNOWN_UNCLASSIFIED_POLLS: frozenset[str] = frozenset()# Re-measure and ratchet again whenever a suppression rule changes. An envelope carrying# the old number after a fix has stopped guarding anything.#-# Busy rose from 260 to 325 for an ACCOUNTING change, not a volume regression.-# /api/chat/threads/{id} and its /forks sibling sat in the `normal` class, in no scenario,-# so the envelope never saw them: modelled over the busy window, 675 lines. A heartbeat-# class brings them in at 59. The number goes up because they are finally being counted.+# Chat detail and fork polls are included in the busy replay at 60 heartbeat lines.+# Media milestones remove 120 access lines, reducing the combined replay from 299 to 179.STEADY_IDLE_LINE_ENVELOPE = 1170-BUSY_LINE_ENVELOPE = 325+BUSY_LINE_ENVELOPE = 195# One-shot requests the app makes once on startup. Present so the boot window is not# mistaken for steady state, and so a mutation record and a failure record exist to assertdiff --git a/studio/backend/tests/test_diffusion_routes.py b/studio/backend/tests/test_diffusion_routes.pyindex 4b44591ca3b..4b30168e619 100644--- a/studio/backend/tests/test_diffusion_routes.py+++ b/studio/backend/tests/test_diffusion_routes.py@@ -20,6 +20,7 @@ import core.inference.diffusion as diffusion_moduleimport core.inference.gpu_arbiter as gpu_arbiterimport core.inference.image_gallery as gallery_modulefrom auth.authentication import get_current_subject+import routes.inference as inference_routesfrom routes.inference import studio_router@@ -302,9 +303,6 @@ def test_gallery_serve_refuses_unowned_id(client):def test_generate_holds_progress_active_during_persist(client, monkeypatch):# generate-progress must stay active while a finished generation is still writing its gallery record. Probe the persist counter from inside save.- import core.inference.image_gallery as gallery_module- import routes.inference as inf-client.post("/api/inference/images/load",json = {@@ -321,7 +319,7 @@ def test_generate_holds_progress_active_during_persist(client, monkeypatch):real_save = gallery_module.savedef _probe_save(image, meta):- seen["during"] = inf._diffusion_persist_active+ seen["during"] = inference_routes._diffusion_persist_activereturn real_save(image, meta)monkeypatch.setattr(gallery_module, "save", _probe_save)@@ -330,10 +328,66 @@ def test_generate_holds_progress_active_during_persist(client, monkeypatch):assert gen.status_code == 200# Active while the record was being persisted, and back to idle once the route returned.assert seen["during"] >= 1- assert inf._diffusion_persist_active == 0+ assert inference_routes._diffusion_persist_active == 0assert client.get("/api/inference/images/generate-progress").json()["active"] is False+def test_generate_progress_route_logs_backend_snapshot(client, monkeypatch):+ seen = []+ monkeypatch.setattr(+ inference_routes,+ "log_media_generation_progress",+ lambda media, progress: seen.append((media, dict(progress))),+ )++ response = client.get("/api/inference/images/generate-progress")++ assert response.status_code == 200+ assert seen == [+ (+ "image",+ {+ "active": False,+ "step": 0,+ "total_steps": 0,+ "fraction": 0.0,+ "eta_seconds": None,+ },+ )+ ]+++def test_generate_resets_the_progress_stream_before_the_run(client, monkeypatch):+ # Milestones are keyed on the previous poll, so a run starting at or above where the last+ # one stopped logs nothing. The image routes must rearm like video, and before generate().+ client.post(+ "/api/inference/images/load",+ json = {+ "model_path": "unsloth/Z-Image-Turbo-GGUF",+ "gguf_filename": "z-image-turbo-Q4_K_S.gguf",+ "base_repo": "unsloth/Z-Image-base",+ },+ )+ order = []+ monkeypatch.setattr(+ inference_routes,+ "reset_media_generation_progress",+ lambda media: order.append(("reset", media)),+ )+ real_save = gallery_module.save++ def _probe_save(image, meta):+ order.append(("generated", "image"))+ return real_save(image, meta)++ monkeypatch.setattr(gallery_module, "save", _probe_save)++ gen = client.post("/api/inference/images/generate", json = {"prompt": "a sloth", "seed": 7})++ assert gen.status_code == 200+ assert order == [("reset", "image"), ("generated", "image")]++def test_load_rejects_untrusted_base_repo(client):# A trusted GGUF paired with an untrusted remote base_repo is rejected at the route, so a client cannot make the server fetch an arbitrary companion repo.r = client.post(@@ -919,7 +973,9 @@ def test_load_refused_during_training_does_not_evict_chat(client, monkeypatch):assert gpu_arbiter.current_owner() == gpu_arbiter.CHAT-def test_load_progress_route(client):+def test_load_progress_route(client, monkeypatch):+ resets = []+ monkeypatch.setattr(inference_routes, "reset_media_load_progress", resets.append)# Before load: idle.idle = client.get("/api/inference/images/load-progress")assert idle.status_code == 200 and idle.json()["phase"] is None@@ -929,6 +985,29 @@ def test_load_progress_route(client):)ready = client.get("/api/inference/images/load-progress")assert ready.json()["phase"] == "ready"+ assert resets == ["image"]+++def test_load_progress_route_logs_backend_snapshot(client, monkeypatch):+ seen = []+ monkeypatch.setattr(+ inference_routes,+ "log_media_load_progress",+ lambda media, phase, fraction: seen.append((media, phase, fraction)),+ )+ backend = diffusion_module.get_diffusion_backend()+ backend.load_progress = lambda: {+ "phase": "downloading",+ "bytes_downloaded": 40,+ "bytes_total": 100,+ "fraction": 0.4,+ "error": None,+ }++ response = client.get("/api/inference/images/load-progress")++ assert response.status_code == 200+ assert seen == [("image", "downloading", 0.4)]def test_routes_require_auth():diff --git a/studio/backend/tests/test_logging_middleware.py b/studio/backend/tests/test_logging_middleware.pyindex 8cf26351520..f62962fdddf 100644--- a/studio/backend/tests/test_logging_middleware.py+++ b/studio/backend/tests/test_logging_middleware.py@@ -461,46 +461,48 @@ def test_legacy_download_progress_heartbeats_not_suppressed(logs, monkeypatch):assert _paths_logged(logs) == ["/api/models/download-progress"]-def test_generation_progress_polls_heartbeat(logs, monkeypatch):- # The 300ms poll timer always landed just outside the 300ms base dedup window.+def test_media_progress_success_polls_are_suppressed(logs, monkeypatch):+ # Their route handlers emit phase and 10% milestone events instead.monkeypatch.setattr(hmod, "_ACCESS_LOG_DEDUP_MS", 0)monkeypatch.setattr(hmod, "_QUIET_POLL_DEDUP_MS", 1000)for path in (+ "/api/inference/images/load-progress",+ "/api/inference/video/load-progress","/api/inference/images/generate-progress","/api/inference/video/generate-progress",- "/api/train/diffusion/status",):mw = LoggingMiddleware(_status_app(200))for _ in range(5):_run(mw(_http_scope(path), _noop_receive, _drop))- assert _paths_logged(logs) == [path]+ assert _paths_logged(logs) == []logs.events.clear()-def test_generation_progress_errors_still_log(logs, monkeypatch):- # Heartbeat dedup is GET/2xx only, so a failing poll stays visible.+def test_diffusion_training_progress_still_heartbeats(logs, monkeypatch):monkeypatch.setattr(hmod, "_ACCESS_LOG_DEDUP_MS", 0)monkeypatch.setattr(hmod, "_QUIET_POLL_DEDUP_MS", 1000)- mw = LoggingMiddleware(_status_app(500))- for _ in range(3):- _run(mw(_http_scope("/api/inference/images/generate-progress"), _noop_receive, _drop))- assert _paths_logged(logs) == ["/api/inference/images/generate-progress"] * 3+ path = "/api/train/diffusion/status"+ mw = LoggingMiddleware(_status_app(200))+ for _ in range(5):+ _run(mw(_http_scope(path), _noop_receive, _drop))+ assert _paths_logged(logs) == [path]-def test_image_video_load_progress_heartbeats(logs, monkeypatch):- # These handlers log nothing themselves, so keep a pulse for a multi-minute load.+def test_media_progress_errors_still_log(logs, monkeypatch):+ # Success suppression is GET/2xx only, so a failing poll stays visible.monkeypatch.setattr(hmod, "_ACCESS_LOG_DEDUP_MS", 0)monkeypatch.setattr(hmod, "_QUIET_POLL_DEDUP_MS", 1000)- for path in ("/api/inference/images/load-progress", "/api/inference/video/load-progress"):- mw = LoggingMiddleware(_status_app(200))- for _ in range(5):+ for path in (+ "/api/inference/images/load-progress",+ "/api/inference/video/load-progress",+ "/api/inference/images/generate-progress",+ "/api/inference/video/generate-progress",+ ):+ mw = LoggingMiddleware(_status_app(500))+ for _ in range(3):_run(mw(_http_scope(path), _noop_receive, _drop))- assert _paths_logged(logs) == [path]+ assert _paths_logged(logs) == [path] * 3logs.events.clear()- mw = LoggingMiddleware(_status_app(503))- for _ in range(3):- _run(mw(_http_scope("/api/inference/images/load-progress"), _noop_receive, _drop))- assert _paths_logged(logs) == ["/api/inference/images/load-progress"] * 3def test_unrelated_image_routes_still_log(logs, monkeypatch):@@ -672,6 +674,10 @@ def test_verbose_restores_the_dropped_success_polls(logs, monkeypatch):monkeypatch.setattr(hmod, "_VERBOSE_ACCESS_LOG", True)for path in ("/api/inference/load-progress",+ "/api/inference/images/load-progress",+ "/api/inference/video/load-progress",+ "/api/inference/images/generate-progress",+ "/api/inference/video/generate-progress","/api/hub/download-progress","/api/export/status","/api/chat/threads",diff --git a/studio/backend/tests/test_media_generation_progress_logs.py b/studio/backend/tests/test_media_generation_progress_logs.pynew file mode 100644index 00000000000..71128a22308--- /dev/null+++ b/studio/backend/tests/test_media_generation_progress_logs.py@@ -0,0 +1,186 @@+# SPDX-License-Identifier: AGPL-3.0-only+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0++"""Semantic image and video progress replaces successful access-poll lines."""++import pytest++from loggers import media_progress+++class _Capture:+ def __init__(self):+ self.events = []++ def info(self, event, **fields):+ self.events.append((event, fields))+++def capture(monkeypatch):+ out = _Capture()+ monkeypatch.setattr(media_progress, "logger", out)+ media_progress.reset_media_generation_progress("image")+ media_progress.reset_media_generation_progress("video")+ media_progress.reset_media_load_progress("image")+ media_progress.reset_media_load_progress("video")+ return out+++def _progress(+ *,+ active = True,+ phase = None,+ step = 0,+ total = 10,+ fraction = None,+ eta = None,+ error = None,+):+ return {+ "active": active,+ "phase": phase,+ "step": step,+ "total_steps": total,+ "fraction": step / total if fraction is None and total else (fraction or 0.0),+ "eta_seconds": eta,+ "error": error,+ }+++def test_image_logs_start_and_ten_percent_milestones(capture):+ for reading in (+ _progress(step = 0, eta = 12.34),+ _progress(step = 0, eta = 12.34),+ _progress(step = 1, eta = 10.02),+ _progress(step = 1, fraction = 0.19),+ _progress(step = 2, eta = 8.0),+ ):+ media_progress.log_media_generation_progress("image", reading)++ assert [event for event, _fields in capture.events] == [+ "image_generation_progress",+ "image_generation_progress",+ "image_generation_progress",+ ]+ assert [fields["percent"] for _event, fields in capture.events] == [0, 10, 20]+ assert capture.events[0][1] == {+ "phase": "denoise",+ "percent": 0,+ "step": 0,+ "total_steps": 10,+ "eta_seconds": 12.3,+ }+++def test_generation_phase_changes_log_but_terminal_poll_does_not(capture):+ readings = (+ _progress(phase = "queued", step = 0),+ _progress(phase = "denoise", step = 0),+ _progress(phase = "denoise", step = 5),+ _progress(phase = "export", step = 10),+ _progress(active = False, phase = "completed", step = 10),+ _progress(active = False, phase = "completed", step = 10),+ )+ for reading in readings:+ media_progress.log_media_generation_progress("video", reading)++ assert [fields["phase"] for _event, fields in capture.events] == [+ "queued",+ "denoise",+ "denoise",+ "export",+ ]+ assert [fields["percent"] for _event, fields in capture.events] == [0, 0, 50, 100]+++def test_failed_generation_poll_is_silent(capture):+ media_progress.log_media_generation_progress(+ "video",+ _progress(+ active = False,+ phase = "failed",+ total = 0,+ error = "Video generation was cancelled.",+ ),+ )+ media_progress.log_media_generation_progress(+ "video",+ _progress(+ active = False,+ phase = "failed",+ total = 0,+ error = "Video generation was cancelled.",+ ),+ )++ assert capture.events == []+++def test_idle_image_poll_is_silent_and_next_run_is_detected(capture):+ idle = _progress(active = False, total = 0)+ media_progress.log_media_generation_progress("image", idle)+ assert capture.events == []++ media_progress.log_media_generation_progress("image", _progress(step = 8))+ media_progress.log_media_generation_progress("image", _progress(step = 1))+ assert [fields["percent"] for _event, fields in capture.events] == [80, 10]+++def test_a_repeat_run_is_silent_until_the_stream_is_reset(capture):+ # The UI drops its 300 ms poll as soon as the POST settles, so a run's last recorded+ # reading is often its final active one. A next run of the same length whose first poll+ # lands on that step is neither a restart nor a new bucket, so it logs nothing.+ media_progress.log_media_generation_progress("image", _progress(step = 10))+ assert [fields["percent"] for _event, fields in capture.events] == [100]++ capture.events.clear()+ media_progress.log_media_generation_progress("image", _progress(step = 10))+ assert capture.events == []++ media_progress.reset_media_generation_progress("image")+ media_progress.log_media_generation_progress("image", _progress(step = 10))+ assert [fields["percent"] for _event, fields in capture.events] == [100]+++def test_load_logs_phase_changes_and_ten_percent_milestones(capture):+ for phase, fraction in (+ ("downloading", 0.0),+ ("downloading", 0.09),+ ("downloading", 0.10),+ ("downloading", 0.19),+ ("downloading", 0.20),+ ("finalizing", 0.20),+ ("finalizing", 1.0),+ ("ready", 1.0),+ ):+ media_progress.log_media_load_progress("image", phase, fraction)++ assert [event for event, _fields in capture.events] == ["diffusion_load_progress"] * 5+ assert [fields for _event, fields in capture.events] == [+ {"phase": "downloading", "percent": 0},+ {"phase": "downloading", "percent": 10},+ {"phase": "downloading", "percent": 20},+ {"phase": "finalizing", "percent": 20},+ {"phase": "finalizing", "percent": 100},+ ]+++def test_load_terminal_rearms_the_next_load(capture):+ media_progress.log_media_load_progress("video", "downloading", 0.4)+ media_progress.log_media_load_progress("video", "ready", 1.0)+ media_progress.log_media_load_progress("video", "downloading", 0.0)++ assert [fields["percent"] for _event, fields in capture.events] == [40, 0]+++def test_load_progress_sanitizes_ratios_and_never_logs_a_regression(capture):+ media_progress.log_media_load_progress("video", "downloading", float("nan"))+ media_progress.log_media_load_progress("video", "downloading", 0.8)+ media_progress.log_media_load_progress("video", "downloading", 0.2)+ media_progress.log_media_load_progress("video", "downloading", 0.3)++ assert [fields["percent"] for _event, fields in capture.events] == [0, 80]+ assert media_progress.byte_fraction(5, 20) == 0.25+ assert media_progress.byte_fraction(5, 0) == 0.0+ assert media_progress.byte_fraction("bad", 20) == 0.0diff --git a/studio/backend/tests/test_openai_images_generations_route.py b/studio/backend/tests/test_openai_images_generations_route.pyindex ff14ff12bbd..3136add0abd 100644--- a/studio/backend/tests/test_openai_images_generations_route.py+++ b/studio/backend/tests/test_openai_images_generations_route.py@@ -25,6 +25,7 @@ from core.inference.diffusion_families import (default_generation_params,load_identity,)+import routes.inference as inference_routesfrom routes.inference import router, _parse_openai_image_sizefrom utils.api_errors import install_api_error_handlers@@ -243,6 +244,27 @@ def test_url_response_shape(client):)+def test_generation_resets_the_image_progress_stream_before_the_run(client, monkeypatch):+ # Shares the image progress stream with /api/inference/images/generate, so it has to rearm+ # the same way or a run starting where the last one stopped emits no milestones.+ order = []+ monkeypatch.setattr(+ inference_routes,+ "reset_media_generation_progress",+ lambda media: order.append(("reset", media)),+ )+ real_generate = client.backend.generate++ def _probe_generate(**kwargs):+ order.append(("generated", "image"))+ return real_generate(**kwargs)++ monkeypatch.setattr(client.backend, "generate", _probe_generate)++ assert _post(client, {"prompt": "a sloth", "size": "256x256"}).status_code == 200+ assert order == [("reset", "image"), ("generated", "image")]++def test_b64_response_shape(client):resp = _post(client, {"prompt": "a sloth", "size": "256x256", "response_format": "b64_json"})assert resp.status_code == 200diff --git a/studio/backend/tests/test_openai_videos_route.py b/studio/backend/tests/test_openai_videos_route.pyindex c1d5a200ce5..fb35ef98d19 100644--- a/studio/backend/tests/test_openai_videos_route.py+++ b/studio/backend/tests/test_openai_videos_route.py@@ -283,6 +283,36 @@ def test_json_body_and_the_studio_mount_work_too(client, backend):assert backend.last_generate_kwargs["width"] is None[email protected]("path", ["/v1/videos", "/api/inference/videos"])+def test_new_jobs_rearm_progress_but_busy_requests_preserve_it(client, backend, monkeypatch, path):+ from loggers import media_progress++ events = []+ monkeypatch.setattr(+ media_progress.logger, "info", lambda *args, **kwargs: events.append(kwargs)+ )+ progress = {"active": True, "phase": "denoise", "step": 10, "total": 10}+ media_progress.reset_media_generation_progress("video")+ try:+ for _ in range(2):+ media_progress.log_media_generation_progress("video", progress)+ events.clear()+ backend.gate.clear()+ response = client.post(path, json = {"prompt": "a cat"})+ assert response.status_code == 200, response.json()+ media_progress.log_media_generation_progress("video", progress)+ assert len(events) == 1+ busy = client.post(path, json = {"prompt": "another"})+ assert busy.status_code == 409, busy.json()+ media_progress.log_media_generation_progress("video", progress)+ assert len(events) == 1+ backend.gate.set()+ _wait_terminal(client, response.json()["id"])+ finally:+ backend.gate.set()+ media_progress.reset_media_generation_progress("video")++def test_omitted_seconds_and_size_use_the_family_defaults(client, backend):resp = client.post("/v1/videos", json = {"prompt": "a cat"})assert resp.status_code == 200, resp.json()diff --git a/studio/backend/tests/test_sd_cpp_engine.py b/studio/backend/tests/test_sd_cpp_engine.pyindex 369623687fc..7c9bc843f50 100644--- a/studio/backend/tests/test_sd_cpp_engine.py+++ b/studio/backend/tests/test_sd_cpp_engine.py@@ -627,6 +627,84 @@ def test_generate_success_returns_path_and_collects_logs(tmp_path, monkeypatch):assert str(Path(e.binary).resolve().parent) in _FakePopen.captured_env.get(var, "")+ "prompt, negative",+ [+ ("private prompt " * 40, "private negative prompt " * 20),+ ("--mode=private-prompt", "a private negative prompt"),+ ("a private prompt", "--mode=private-negative-prompt"),+ ("--diffusion-model=private-prompt", "a private negative prompt"),+ ("a private prompt", "--diffusion-model=private-negative-prompt"),+ ],+)+def test_default_run_log_is_compact_and_omits_user_text_and_paths(+ tmp_path, monkeypatch, caplog, prompt, negative+):+ monkeypatch.setattr(eng, "_verbose_native_logs", lambda: False)+ caplog.set_level("INFO", logger = eng.__name__)+ e = _engine(tmp_path)+ out = tmp_path / "private-output.png"+ _patch_popen(monkeypatch, lines = ["done"], returncode = 0, out_file = out)++ e.generate(+ SdCppModelFiles(diffusion_model = "/private/models/z.gguf"),+ SdCppGenParams(+ prompt = prompt,+ negative_prompt = negative,+ width = 768,+ height = 512,+ steps = 8,+ seed = 7,+ ),+ output_path = str(out),+ )++ messages = [record.getMessage() for record in caplog.records if record.name == eng.__name__]+ assert messages[0] == (+ "sd-cli run started: mode=img_gen model=z.gguf size=768x512 steps=8 seed=7"+ )+ assert messages[1].startswith(+ "sd-cli run completed: mode=img_gen model=z.gguf size=768x512 steps=8 seed=7 elapsed="+ )+ rendered = "\n".join(messages)+ assert prompt not in rendered+ assert negative not in rendered+ assert "/private/models/z.gguf" not in rendered+ assert str(out) not in rendered+ cmd = _FakePopen.captured_cmd+ assert cmd[cmd.index("--prompt") + 1] == prompt+ assert cmd[cmd.index("--negative-prompt") + 1] == negative+++def test_verbose_run_log_keeps_argv_but_redacts_prompts(tmp_path, monkeypatch, caplog):+ monkeypatch.setattr(eng, "_verbose_native_logs", lambda: True)+ caplog.set_level("INFO", logger = eng.__name__)+ e = _engine(tmp_path)+ out = tmp_path / "img.png"+ _patch_popen(monkeypatch, lines = ["done"], returncode = 0, out_file = out)++ e.generate(+ SdCppModelFiles(diffusion_model = "/models/z.gguf"),+ SdCppGenParams(prompt = "a private cat", negative_prompt = "a private dog"),+ output_path = str(out),+ extra_args = ["-p", "a second private cat", "-n=a second private dog"],+ )++ rendered = "\n".join(+ record.getMessage() for record in caplog.records if record.name == eng.__name__+ )+ assert "/models/z.gguf" in rendered+ assert str(out) in rendered+ assert "--prompt <redacted>" in rendered+ assert "--negative-prompt <redacted>" in rendered+ assert "-p <redacted>" in rendered+ assert "-n=<redacted>" in rendered+ assert "a private cat" not in rendered+ assert "a private dog" not in rendered+ assert "a second private cat" not in rendered+ assert "a second private dog" not in rendered++def test_generate_raises_on_nonzero_exit(tmp_path, monkeypatch):e = _engine(tmp_path)out = tmp_path / "img.png"diff --git a/studio/backend/tests/test_sd_cpp_server.py b/studio/backend/tests/test_sd_cpp_server.pyindex c53b4e69778..cb21ff8159b 100644--- a/studio/backend/tests/test_sd_cpp_server.py+++ b/studio/backend/tests/test_sd_cpp_server.py@@ -156,7 +156,9 @@ def _server_with(popen, client):# ── start / readiness ──────────────────────────────────────────────────────────-def test_start_becomes_ready_when_capabilities_200(patched):+def test_start_becomes_ready_when_capabilities_200(patched, caplog):+ patched.setattr(srv, "_verbose_native_logs", lambda: False)+ caplog.set_level("INFO", logger = srv.__name__)popen = _FakePopen(lines = ["loading model", "listening on: http://127.0.0.1:1"])patched.setattr(srv.subprocess, "Popen", lambda *a, **k: popen)s = _server_with(@@ -165,6 +167,10 @@ def test_start_becomes_ready_when_capabilities_200(patched):s.start(_FILES, startup_timeout = 5.0)assert s.is_alive() is Trueassert s.port is not None+ messages = [record.getMessage() for record in caplog.records if record.name == srv.__name__]+ start = next(message for message in messages if message.startswith("starting sd-server:"))+ assert start.startswith("starting sd-server: mode=server model=z.gguf port=")+ assert "/m/z.gguf" not in startdef test_start_fails_fast_when_process_exits(patched):diff --git a/studio/backend/tests/test_third_party_progress_bars.py b/studio/backend/tests/test_third_party_progress_bars.pyindex fb79914d115..a95e9f4aff8 100644--- a/studio/backend/tests/test_third_party_progress_bars.py+++ b/studio/backend/tests/test_third_party_progress_bars.py@@ -84,6 +84,45 @@ def test_the_hub_is_not_imported_just_to_quiet_it():assert "HUB_ABSENT" in out.stdout, out.stdout + out.stderr+def test_direct_tqdm_users_are_quiet_too():+ code = (+ "import sys; sys.path.insert(0, %r)\n"+ "import os\n"+ "os.environ.pop('HF_HUB_DISABLE_PROGRESS_BARS', None)\n"+ "os.environ.pop('UNSLOTH_STUDIO_ACCESS_LOG_DEDUP_MS', None)\n"+ "os.environ.pop('UNSLOTH_STUDIO_ACCESS_LOG_POLL_DEDUP_MS', None)\n"+ "from loggers.config import quiet_third_party_progress_bars\n"+ "quiet_third_party_progress_bars()\n"+ "from tqdm import tqdm\n"+ "for _ in tqdm(range(2), desc='Encoding video chunks'): pass\n"+ "from tqdm.auto import tqdm as auto_tqdm\n"+ "for _ in auto_tqdm(range(2), desc='Denoising video'): pass\n"+ "print('DONE')\n"+ ) % str(_BACKEND)+ out = subprocess.run([sys.executable, "-c", code], capture_output = True, text = True, timeout = 300)+ assert out.returncode == 0, out.stdout + out.stderr+ assert "DONE" in out.stdout+ assert "Encoding video chunks" not in out.stdout + out.stderr+ assert "Denoising video" not in out.stdout + out.stderr+++def test_verbose_keeps_direct_tqdm_users_visible():+ code = (+ "import sys; sys.path.insert(0, %r)\n"+ "import os\n"+ "os.environ.pop('HF_HUB_DISABLE_PROGRESS_BARS', None)\n"+ "os.environ['UNSLOTH_STUDIO_ACCESS_LOG_DEDUP_MS'] = '0'\n"+ "os.environ['UNSLOTH_STUDIO_ACCESS_LOG_POLL_DEDUP_MS'] = '0'\n"+ "from loggers.config import quiet_third_party_progress_bars\n"+ "quiet_third_party_progress_bars()\n"+ "from tqdm.auto import tqdm\n"+ "for _ in tqdm(range(2), desc='Denoising video'): pass\n"+ ) % str(_BACKEND)+ out = subprocess.run([sys.executable, "-c", code], capture_output = True, text = True, timeout = 300)+ assert out.returncode == 0, out.stdout + out.stderr+ assert "Denoising video" in out.stdout + out.stderr++def test_allow_progress_bars_only_undoes_our_own_default(monkeypatch):monkeypatch.setattr(log_config, "_BARS_RESTORED", False)monkeypatch.setenv(_HUB, "1")diff --git a/studio/backend/tests/test_video_backend.py b/studio/backend/tests/test_video_backend.pyindex 425d46bf3f8..22e36dcaa31 100644--- a/studio/backend/tests/test_video_backend.py+++ b/studio/backend/tests/test_video_backend.py@@ -1420,6 +1420,58 @@ def test_generate_progress_derives_total_steps_and_fraction(fake_runtime):assert gen["step"] == 5 and gen["fraction"] == 0.25+ "video, error, total, expected",+ [+ (+ {"id": "clip-1"},+ None,+ 12,+ {+ "phase": "completed",+ "percent": 100,+ "step": 12,+ "total_steps": 12,+ "video_id": "clip-1",+ },+ ),+ (+ None,+ "negative_prompt is not supported by this family.",+ 0,+ {+ "phase": "failed",+ "percent": 0,+ "step": 0,+ "total_steps": 0,+ "error": "negative_prompt is not supported by this family.",+ },+ ),+ ],+)+def test_finish_generate_job_logs_each_terminal_outcome_once(+ fake_runtime, monkeypatch, video, error, total, expected+):+ import core.inference.video as video_mod++ events = []++ class _Recorder:+ def info(self, event, **fields):+ events.append((event, fields))++ monkeypatch.setattr(video_mod, "logger", _Recorder())+ backend = VideoBackend()+ token = object()+ backend._generate_job_token = token+ backend._generate_job_active = True++ backend._finish_generate_job(job_token = token, video = video, error = error, total = total)+ backend._finish_generate_job(job_token = token, video = video, error = error, total = total)++ assert events == [("video_generation_progress", expected)]++def test_failed_background_generate_retains_terminal_error(fake_runtime, tmp_path, monkeypatch):# A page mounted AFTER a background job failed reads the outcome from this retained terminal record, so a failure must stay pollable until the next job.backend = VideoBackend()diff --git a/studio/backend/tests/test_video_routes.py b/studio/backend/tests/test_video_routes.pyindex 8d0e22e70bf..6129fe6f1af 100644--- a/studio/backend/tests/test_video_routes.py+++ b/studio/backend/tests/test_video_routes.py@@ -28,6 +28,7 @@ from core.inference.video_families import (VIDEO_GENERATION_BUSY_MSG,VIDEO_NOT_LOADED_MSG,)+import routes.video as video_routesfrom routes.video import router as video_router@@ -459,7 +460,9 @@ def test_load_rejects_bad_text_encoder_quant_422(client):assert resp.status_code == 422-def test_load_progress_route(client):+def test_load_progress_route(client, monkeypatch):+ resets = []+ monkeypatch.setattr(video_routes, "reset_media_load_progress", resets.append)idle = client.get("/api/inference/video/load-progress")assert idle.status_code == 200 and idle.json()["phase"] is Noneclient.post(@@ -468,6 +471,28 @@ def test_load_progress_route(client):)ready = client.get("/api/inference/video/load-progress")assert ready.json()["phase"] == "ready"+ assert resets == ["video"]+++def test_load_progress_route_logs_backend_snapshot(client, monkeypatch):+ seen = []+ monkeypatch.setattr(+ video_routes,+ "log_media_load_progress",+ lambda media, phase, fraction: seen.append((media, phase, fraction)),+ )+ backend = video_module.get_video_backend()+ backend.load_progress = lambda: {+ "phase": "downloading",+ "downloaded_bytes": 30,+ "expected_bytes": 100,+ "error": None,+ }++ response = client.get("/api/inference/video/load-progress")++ assert response.status_code == 200+ assert seen == [("video", "downloading", 0.3)]def test_load_local_single_file_dir_routes_through_single_file(client, tmp_path):@@ -501,13 +526,16 @@ def test_load_local_pipeline_dir_stays_pipeline(client, tmp_path):assert not kwargs.get("gguf_filename")-def test_generate_happy_path_persists_and_reports_record(client):+def test_generate_happy_path_persists_and_reports_record(client, monkeypatch):+ resets = []+ monkeypatch.setattr(video_routes, "reset_media_generation_progress", resets.append)client.post("/api/inference/video/load",json = {"model_path": "unsloth/LTX-2.3-GGUF", "gguf_filename": "q.gguf"},)# The POST returns at once ("started"); the saved record arrives through the generate-progress terminal state.video = _generate_and_wait(client, {"prompt": "a sloth surfing", "seed": 7})+ assert resets == ["video"]assert video["seed"] == 7 and video["prompt"] == "a sloth surfing" and video["id"]assert video["has_audio"] is Trueassert video["model"] == "unsloth/LTX-2.3-GGUF"@@ -636,12 +664,19 @@ def test_generate_concurrent_second_returns_409(client, monkeypatch):assert _generate_and_wait(client, {"prompt": "c", "seed": 2})["seed"] == 2-def test_generate_progress_route(client):+def test_generate_progress_route(client, monkeypatch):+ seen = []+ monkeypatch.setattr(+ video_routes,+ "log_media_generation_progress",+ lambda media, progress: seen.append((media, dict(progress))),+ )resp = client.get("/api/inference/video/generate-progress")assert resp.status_code == 200body = resp.json()assert body["active"] is Falseassert body["phase"] is None and body["video"] is None and body["error"] is None+ assert seen == [("video", {"active": False, "total_steps": 0, "fraction": 0.0})]def test_cancel_generation_route(client):