Skip to content

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.

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.py
index 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 out
diff --git a/studio/backend/core/inference/sd_cpp_server.py b/studio/backend/core/inference/sd_cpp_server.py
index 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_comm
from 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 = None
diff --git a/studio/backend/core/inference/video.py b/studio/backend/core/inference/video.py
index 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.py
index 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: BLE001
pass
_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.py
index 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.py
new file mode 100644
index 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.py
index 542ef7367d3..e38153872b7 100644
--- a/studio/backend/routes/inference.py
+++ b/studio/backend/routes/inference.py
@@ -43,6 +43,12 @@ import functools
import json
import httpx
from 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 asyncio
import contextvars
import 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_current
from core.inference.diffusion_engine_router import get_active_diffusion_engine
progress = 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.py
index 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_cr
from core.inference.model_ids import public_model_id
from hub.dependencies import get_hf_token
from 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.py
index 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 assert
diff --git a/studio/backend/tests/test_diffusion_routes.py b/studio/backend/tests/test_diffusion_routes.py
index 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_module
import core.inference.gpu_arbiter as gpu_arbiter
import core.inference.image_gallery as gallery_module
from auth.authentication import get_current_subject
+import routes.inference as inference_routes
from 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.save
def _probe_save(image, meta):
- seen["during"] = inf._diffusion_persist_active
+ seen["during"] = inference_routes._diffusion_persist_active
return 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 == 0
assert 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.py
index 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] * 3
logs.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"] * 3
def 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.py
new file mode 100644
index 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.0
diff --git a/studio/backend/tests/test_openai_images_generations_route.py b/studio/backend/tests/test_openai_images_generations_route.py
index 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_routes
from routes.inference import router, _parse_openai_image_size
from 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 == 200
diff --git a/studio/backend/tests/test_openai_videos_route.py b/studio/backend/tests/test_openai_videos_route.py
index 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.py
index 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.py
index 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 True
assert 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 start
def 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.py
index 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.py
index 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.py
index 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_routes
from 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 None
client.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 True
assert 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 == 200
body = resp.json()
assert body["active"] is False
assert 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):