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
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
"""Pre-quantized denoiser route; refusals sit before the diffusers check, so no diffusers needed."""
from __future__ import annotations
import types
import pytest
from core.inference.diffusion_prequant import (
cached_checkpoint_path,
resolve_prequant_source,
)
from core.inference.video import VideoBackend
def _shared_setup_1():
import torch
from core.inference import video as vid
fam = _h3_family()
return fam, torch, vid
@pytest.fixture(autouse = True)
def _assume_the_restricted_load_is_available(monkeypatch):
"""Stubs torchao availability so planning tests do not depend on this host's torchao install."""
import core.inference.diffusion_prequant as _pq
monkeypatch.setattr(
_pq, "restricted_prequant_load_supported", lambda scheme = None, filename = None: True
)
monkeypatch.setattr(_pq, "torchao_group_offload_supported", lambda: True)
from core.inference.video_families import (
VideoFamily,
detect_video_family,
video_family_prequant_available,
video_family_prequant_repo,
video_family_prequant_schemes,
)
def _fam(**kwargs) -> VideoFamily:
base = dict(
name = "test-video",
pipeline_class = "TestPipeline",
transformer_class = "TestTransformer3DModel",
base_repo = "org/test-video",
)
base.update(kwargs)
return VideoFamily(**base)
def test_resolves_the_hosted_repo_for_a_scheme():
fam = _fam(prequant_repos = (("int8", "org/test-INT8"), ("fp8", "org/test-FP8")))
assert video_family_prequant_repo(fam, "int8") == "org/test-INT8"
assert video_family_prequant_repo(fam, "fp8") == "org/test-FP8"
assert video_family_prequant_repo(fam, "nvfp4") is None
def test_a_variant_checkpoint_wins_over_the_family_default():
fam = _fam(
prequant_repos = (("int8", "org/test-INT8"),),
prequant_variant_repos = (("org/test-video-v2", "int8", "org/test-v2-INT8"),),
)
assert video_family_prequant_repo(fam, "int8", "org/test-video-v2") == "org/test-v2-INT8"
assert video_family_prequant_repo(fam, "int8", " ORG/Test-Video-V2 ") == "org/test-v2-INT8"
assert video_family_prequant_repo(fam, "int8", "org/other") == "org/test-INT8"
def test_a_malformed_table_row_is_skipped_rather_than_raised():
fam = _fam(prequant_repos = (("int8",), ("int8", ""), ("int8", "org/good")))
assert video_family_prequant_repo(fam, "int8") == "org/good"
def test_a_family_without_the_fields_simply_has_no_checkpoint():
import types
assert video_family_prequant_repo(types.SimpleNamespace(), "int8") is None
assert video_family_prequant_schemes(types.SimpleNamespace()) == ()
def test_schemes_are_listed_in_table_order():
fam = _fam(prequant_repos = (("int8", "org/a"), ("fp8", "org/b")))
assert video_family_prequant_schemes(fam) == ("int8", "fp8")
def test_minimax_h3_declares_hosted_denoiser_checkpoints():
fam = detect_video_family("MiniMaxAI/MiniMax-H3")
assert fam is not None and fam.name == "minimax-h3"
assert set(video_family_prequant_schemes(fam)) == {"int8", "fp8"}
for scheme in ("int8", "fp8"):
repo = video_family_prequant_repo(fam, scheme)
assert repo and repo.startswith("unsloth/")
def test_both_h3_schemes_resolve_to_one_repo():
fam = detect_video_family("MiniMaxAI/MiniMax-H3")
repos = {s: video_family_prequant_repo(fam, s) for s in ("int8", "fp8")}
assert repos["int8"] == repos["fp8"], repos
@pytest.mark.parametrize(
"scheme, expected",
[("int8", "MiniMax-H3-INT8-ConvRot.safetensors"), ("fp8", "MiniMax-H3-FP8.safetensors")],
)
def test_h3_resolves_the_primary_name_at_the_repo_root(scheme, expected):
fam = detect_video_family("MiniMaxAI/MiniMax-H3")
src = resolve_prequant_source(fam, scheme)
assert src.filename == expected
assert "/" not in src.filename and "\\" not in src.filename
def test_h3_int8_keeps_the_plain_denoiser_as_its_fallback():
# The rotated artifact needs a newer Unsloth, so the plain name stays a fallback.
fam = detect_video_family("MiniMaxAI/MiniMax-H3")
src = resolve_prequant_source(fam, "int8")
assert src.fallback_filenames == (
"MiniMax-H3-INT8-ConvRot.pt",
"MiniMax-H3-INT8.safetensors",
"MiniMax-H3-INT8.pt",
"transformer_int8.pt",
)
assert all("/" not in n and "\\" not in n for n in src.candidate_filenames)
def _h3_with_only_the_pt_cached(monkeypatch):
"""The H3 int8 source with only its declared ConvRot .pt in the HF cache."""
import os
import huggingface_hub
fam = detect_video_family("MiniMaxAI/MiniMax-H3")
src = resolve_prequant_source(fam, "int8")
seen = []
def _fake_try_to_load_from_cache(
repo_id,
filename,
cache_dir = None,
):
seen.append(filename)
return "/cache/blobs/h3" if filename == "MiniMax-H3-INT8-ConvRot.pt" else None
real_isfile = os.path.isfile
monkeypatch.setattr(huggingface_hub, "try_to_load_from_cache", _fake_try_to_load_from_cache)
monkeypatch.setattr(os.path, "isfile", lambda p: p == "/cache/blobs/h3" or real_isfile(p))
return src, seen
def test_the_h3_primary_name_is_what_memory_planning_credits(monkeypatch):
# Offline the load can only use what is on disk, so the cached .pt is what it resolves to.
# Pinned offline: online, the answer depends on whether the Hub has the .safetensors twin.
src, seen = _h3_with_only_the_pt_cached(monkeypatch)
assert cached_checkpoint_path(src, online = False) == "/cache/blobs/h3"
assert "MiniMax-H3-INT8-ConvRot.pt" in seen
@pytest.mark.parametrize("twin_absent", [True, False])
def test_online_the_cached_h3_pt_counts_only_once_its_safetensors_twin_is_known_absent(
monkeypatch, twin_absent
):
# Online, an uncached .safetensors ahead of the .pt is what the load downloads unless the Hub
# is known not to have it, so the cached .pt is credited only then.
from core.inference import diffusion_prequant as pq
src, _ = _h3_with_only_the_pt_cached(monkeypatch)
monkeypatch.setattr(pq, "hub_name_known_absent", lambda repo, name, cache_dir = None: twin_absent)
monkeypatch.setattr(pq, "_first_mirrored", lambda *a, **k: None)
got = cached_checkpoint_path(src, online = True)
assert got == ("/cache/blobs/h3" if twin_absent else None)
def test_the_names_are_built_from_the_repo_and_the_scheme():
fam = _fam(prequant_repos = (("int8", "unsloth/Test-FP8"), ("fp8", "unsloth/Test-FP8")))
assert resolve_prequant_source(fam, "int8").filename == "Test-INT8.safetensors"
assert resolve_prequant_source(fam, "fp8").filename == "Test-FP8.safetensors"
assert resolve_prequant_source(fam, "int8").fallback_filenames == (
"Test-INT8.pt",
"transformer_int8.pt",
)
def test_a_task_specific_row_beats_the_task_agnostic_one():
fam = _fam(
prequant_repos = (("int8", "unsloth/Test-FP8"),),
prequant_filenames = (
("int8", "Test-INT8-ConvRot.pt"),
("int8", "ref2va", "Test-Ref2VA-INT8-ConvRot.pt"),
),
prequant_partition_tasks = ("ref2va",),
)
assert resolve_prequant_source(fam, "int8", task = "ref2va").filename == (
"Test-Ref2VA-INT8-ConvRot.safetensors"
)
assert resolve_prequant_source(fam, "int8", task = " Ref2VA ").candidate_filenames == (
"Test-Ref2VA-INT8-ConvRot.safetensors",
"Test-Ref2VA-INT8-ConvRot.pt",
)
def test_a_task_specific_artifact_gets_no_filename_fallback():
# Another partition's denoiser would be wrong; only this artifact's two containers are tried.
fam = _fam(
prequant_repos = (("int8", "unsloth/Test-FP8"),),
prequant_filenames = (
("int8", "Test-INT8-ConvRot.pt"),
("int8", "ref2va", "Test-Ref2VA-INT8-ConvRot.pt"),
),
prequant_partition_tasks = ("ref2va",),
)
assert resolve_prequant_source(fam, "int8", task = "ref2va").candidate_filenames == (
"Test-Ref2VA-INT8-ConvRot.safetensors",
"Test-Ref2VA-INT8-ConvRot.pt",
)
assert resolve_prequant_source(fam, "int8").candidate_filenames == (
"Test-INT8-ConvRot.safetensors",
"Test-INT8-ConvRot.pt",
"Test-INT8.safetensors",
"Test-INT8.pt",
"transformer_int8.pt",
)
def test_a_scheme_without_a_task_row_resolves_exactly_what_it_did_before():
fam = _fam(
prequant_repos = (("int8", "unsloth/Test-FP8"), ("fp8", "unsloth/Test-FP8")),
prequant_filenames = (("int8", "Test-INT8-ConvRot.pt"),),
)
for scheme in ("int8", "fp8"):
plain = resolve_prequant_source(fam, scheme)
for task in ("fl2va", "t2va", "anything-at-all"):
assert resolve_prequant_source(fam, scheme, task = task) == plain
def test_a_family_predating_the_task_shape_is_unaffected_by_a_task():
import types
fam = _fam(prequant_repos = (("fp8", "unsloth/Test-FP8"),))
assert resolve_prequant_source(fam, "fp8", task = "ref2va") == resolve_prequant_source(fam, "fp8")
assert resolve_prequant_source(types.SimpleNamespace(), "fp8", task = "ref2va") is None
def test_a_partition_task_with_no_artifact_of_its_own_is_unavailable():
fam = _fam(
prequant_repos = (("int8", "unsloth/Test-FP8"), ("fp8", "unsloth/Test-FP8")),
prequant_filenames = (("fp8", "ref2va", "Test-Ref2VA-FP8.pt"),),
prequant_partition_tasks = ("ref2va",),
)
assert video_family_prequant_repo(fam, "int8") == "unsloth/Test-FP8"
assert video_family_prequant_available(fam, "int8", task = "ref2va") is False
assert video_family_prequant_available(fam, "fp8", task = "ref2va") is True
assert video_family_prequant_available(fam, "int8", task = "fl2va") is True
assert video_family_prequant_available(fam, "int8") is True
assert video_family_prequant_schemes(fam, task = "ref2va") == ("fp8",)
assert video_family_prequant_schemes(fam) == ("int8", "fp8")
@pytest.mark.parametrize(
"scheme, expected",
[("int8", "MiniMax-H3-Ref2VA-INT8-ConvRot"), ("fp8", "MiniMax-H3-Ref2VA-FP8")],
)
def test_h3_reference_video_resolves_its_own_hosted_denoiser(scheme, expected):
fam = detect_video_family("MiniMaxAI/MiniMax-H3")
src = resolve_prequant_source(fam, scheme, task = "ref2va")
assert src.candidate_filenames == (expected + ".safetensors", expected + ".pt")
assert "/" not in src.filename and "\\" not in src.filename
@pytest.mark.parametrize("task", [None, "fl2va", "t2va"])
def test_h3_keyframe_and_text_only_resolve_exactly_what_they_resolved_before(task):
fam = detect_video_family("MiniMaxAI/MiniMax-H3")
int8 = resolve_prequant_source(fam, "int8", task = task)
assert int8.filename == "MiniMax-H3-INT8-ConvRot.safetensors"
assert int8.fallback_filenames[0] == "MiniMax-H3-INT8-ConvRot.pt"
assert "MiniMax-H3-INT8.pt" in int8.fallback_filenames
fp8 = resolve_prequant_source(fam, "fp8", task = task)
assert fp8.filename == "MiniMax-H3-FP8.safetensors"
def test_the_h3_partition_task_matches_the_reference_workflow_name():
# The registry spells the task as a literal to stay import-free; pin it to the constant the
# loader and the download planner branch on, so the two cannot drift apart silently.
from core.inference.video_minimax_h3 import H3_TASK_REFERENCES
fam = detect_video_family("MiniMaxAI/MiniMax-H3")
assert fam.prequant_partition_tasks == (H3_TASK_REFERENCES,)
def test_a_reference_load_is_refused_when_its_scheme_has_no_reference_artifact(monkeypatch):
fam = _fam(
name = "partitioned",
modular_workflow = "fl2va",
prequant_repos = (("int8", "unsloth/Test-FP8"), ("fp8", "unsloth/Test-FP8")),
prequant_filenames = (("fp8", "ref2va", "Test-Ref2VA-FP8.pt"),),
prequant_partition_tasks = ("ref2va",),
)
monkeypatch.setattr("core.inference.video._detect_load_family", lambda *a, **k: fam)
monkeypatch.setattr("core.inference.video._is_trusted_video_repo", lambda repo: True)
backend = VideoBackend()
with pytest.raises(ValueError) as excinfo:
backend.validate_load_request(
"org/test-video",
model_kind = "pipeline",
transformer_quant = "int8",
h3_task = "ref2va",
)
message = str(excinfo.value)
assert "int8" in message and "ref2va" in message
assert "fp8" in message
# Asserted on the message: the diffusers probe below may fail for unrelated reasons.
try:
backend.validate_load_request(
"org/test-video",
model_kind = "pipeline",
transformer_quant = "fp8",
h3_task = "ref2va",
)
except Exception as exc: # noqa: BLE001
assert "transformer_quant" not in str(
exc
), f"fp8 ref2va should be loadable but was refused: {exc}"
def test_a_modular_family_refuses_a_single_file_load_before_anything_downloads():
backend = VideoBackend()
with pytest.raises(ValueError) as excinfo:
backend.validate_load_request(
"MiniMaxAI/MiniMax-H3",
# A ComfyUI-quantized denoiser file is the one H3 single file Studio loads; anything else is refused.
gguf_filename = "qwen3vl_32b_minimax_h3_bf16.safetensors",
model_kind = "single_file",
)
message = str(excinfo.value)
assert "MiniMaxAI/MiniMax-H3" in message
assert "unsloth/MiniMax-H3-GGUF" in message
def test_an_unavailable_transformer_quant_is_refused_with_the_workable_schemes():
backend = VideoBackend()
with pytest.raises(ValueError) as excinfo:
backend.validate_load_request("MiniMaxAI/MiniMax-H3", transformer_quant = "nvfp4")
message = str(excinfo.value)
assert "nvfp4" in message
assert "int8" in message and "fp8" in message
@pytest.mark.parametrize("scheme", ["int8", "fp8"])
def test_a_scheme_with_a_hosted_checkpoint_is_not_refused(scheme):
backend = VideoBackend()
try:
backend.validate_load_request("MiniMaxAI/MiniMax-H3", transformer_quant = scheme)
except ValueError as exc: # pragma: no cover - only on a regression
pytest.fail(f"{scheme} should be loadable but was refused: {exc}")
except Exception:
pass
def test_auto_is_never_refused():
backend = VideoBackend()
try:
backend.validate_load_request("MiniMaxAI/MiniMax-H3", transformer_quant = "auto")
except ValueError as exc: # pragma: no cover - only on a regression
pytest.fail(f"auto should never be refused: {exc}")
except Exception:
pass
def _forced_target(device):
"""Forced diffusion target on device so a device-keyed refusal runs without that hardware."""
from core.inference.diffusion_device import DiffusionDeviceTarget
return lambda: DiffusionDeviceTarget(
device = device,
dtype = None,
backend = device,
vendor = None,
supports_model_cpu_offload = False,
supports_default_torch_compile = False,
supports_pinned_transfer = False,
supports_float64 = device != "mps",
)
def test_the_modular_pipeline_is_refused_on_metal(monkeypatch):
# Refuse MPS before the ~145 GB download: auto CPU offload needs mem_get_info, torch.mps lacks it.
monkeypatch.setattr(
"core.inference.video.resolve_diffusion_device_target", _forced_target("mps")
)
backend = VideoBackend()
with pytest.raises(ValueError, match = "cannot run on Apple Silicon"):
backend.validate_load_request("MiniMaxAI/MiniMax-H3")
def test_the_metal_refusal_names_the_artifact_that_does_run_there(monkeypatch):
monkeypatch.setattr(
"core.inference.video.resolve_diffusion_device_target", _forced_target("mps")
)
backend = VideoBackend()
with pytest.raises(ValueError, match = "unsloth/MiniMax-H3-GGUF"):
backend.validate_load_request("MiniMaxAI/MiniMax-H3")
def test_the_metal_refusal_leaves_every_other_device_alone(monkeypatch):
monkeypatch.setattr(
"core.inference.video.resolve_diffusion_device_target", _forced_target("cuda")
)
backend = VideoBackend()
try:
backend.validate_load_request("MiniMaxAI/MiniMax-H3")
except ValueError as exc: # pragma: no cover - only on a regression
pytest.fail(f"a CUDA modular load must not be refused: {exc}")
except Exception:
pass
def test_the_refusals_run_before_the_diffusers_availability_probe():
backend = VideoBackend()
with pytest.raises(ValueError, match = "cannot load from a single .safetensors checkpoint"):
backend.validate_load_request(
"MiniMaxAI/MiniMax-H3",
gguf_filename = "anything.safetensors",
model_kind = "single_file",
)
def test_a_non_modular_video_family_is_unaffected():
backend = VideoBackend()
try:
fam = backend.validate_load_request(
"Lightricks/LTX-2.3",
gguf_filename = "ltx-2.3-22b-distilled.safetensors",
model_kind = "single_file",
)
except ValueError as exc:
pytest.fail(f"a single-file LTX-2.3 load must not be refused: {exc}")
except RuntimeError:
return
assert fam.name == "ltx-2" and "ltx-2.3" in fam.aliases
assert fam.modular_workflow is None
# Torchao-quantized denoisers cannot move under auto CPU offload, so they are placed once.
class _FakeInnerHook:
def __init__(self) -> None:
self.other_hooks: list = []
class _FakeUserHook:
def __init__(self, model) -> None:
self.model = model
self.hook = _FakeInnerHook()
self.removed = False
def remove(self) -> None:
self.removed = True
class _FakeModule:
def __init__(self) -> None:
self.moved_to: list = []
def to(self, device):
self.moved_to.append(device)
return self
class _FakeOffloadManager:
def __init__(self, models) -> None:
self.model_hooks = [_FakeUserHook(model) for model in models]
for hook in self.model_hooks:
hook.hook.other_hooks = [other for other in self.model_hooks if other is not hook]
def test_pinning_unhooks_the_denoiser_and_places_it():
from core.inference.diffusion_prequant import pin_prequantized_module
transformer, encoder, vae = _FakeModule(), _FakeModule(), _FakeModule()
manager = _FakeOffloadManager([transformer, encoder, vae])
denoiser_hook = manager.model_hooks[0]
assert pin_prequantized_module(manager, transformer, "cuda") is True
assert denoiser_hook.removed is True
assert denoiser_hook not in manager.model_hooks
assert [hook.model for hook in manager.model_hooks] == [encoder, vae]
for hook in manager.model_hooks:
assert denoiser_hook not in hook.hook.other_hooks
assert transformer.moved_to == ["cuda"]
assert encoder.moved_to == [] and vae.moved_to == []
def test_pinning_still_places_the_module_when_the_manager_is_unrecognisable():
"""Best-effort on the hook surgery: an unmanaged module must still end up on the device."""
from core.inference.diffusion_prequant import pin_prequantized_module
transformer = _FakeModule()
manager = _FakeOffloadManager([_FakeModule()])
before = list(manager.model_hooks)
assert pin_prequantized_module(manager, transformer, "cuda") is False
assert transformer.moved_to == ["cuda"]
assert manager.model_hooks == before
def _h3_fam():
fam = detect_video_family("MiniMaxAI/MiniMax-H3")
assert fam is not None and fam.modular_workflow
return fam
def test_an_unset_denoiser_request_keeps_the_released_weights():
fam, base = _h3_fam(), "MiniMaxAI/MiniMax-H3"
for unset in (None, "auto"):
assert VideoBackend._denoiser_prequant_covered(fam, unset, base) is False
assert VideoBackend._denoiser_prequant_covered(fam, "int8", base) is True
assert VideoBackend._denoiser_prequant_covered(fam, "fp8", base) is True
def test_the_dense_denoiser_is_pinned_only_when_it_actually_fits():
"""Pin the dense denoiser only when it fits: an optimisation, so the fit check stays conservative."""
import torch
from core.inference.video import _h3_dense_denoiser_resident_bytes
fam = _h3_fam()
class _Denoiser:
def __init__(self, gb):
self._t = torch.empty(0)
self._gb = gb
def parameters(self):
return iter(())
def buffers(self):
return iter([torch.empty(int(self._gb * 1e9), dtype = torch.uint8, device = "meta")])
assert (
_h3_dense_denoiser_resident_bytes(
fam, denoiser = _Denoiser(66.3), te_scheme = "int8", dtype = torch.bfloat16
)
is None
)
assert (
_h3_dense_denoiser_resident_bytes(
fam, denoiser = None, te_scheme = "int8", dtype = torch.bfloat16
)
is None
)
class _Real(_Denoiser):
def buffers(self):
return iter([torch.empty(1024, dtype = torch.uint8)])
sizes = _h3_dense_denoiser_resident_bytes(
fam, denoiser = _Real(0), te_scheme = "int8", dtype = torch.bfloat16
)
assert sizes is not None
denoiser_bytes, others = sizes
assert denoiser_bytes == 1024
dense_sizes = _h3_dense_denoiser_resident_bytes(
fam, denoiser = _Real(0), te_scheme = None, dtype = torch.bfloat16
)
assert dense_sizes is not None and dense_sizes[1] - others > 38 * 1000**3
assert others > (27.2 + fam.bf16_components_gb[2]) * 1000**3
def test_the_pin_decision_itself_refuses_a_card_that_cannot_hold_it():
"""The pin comparison is asserted on its own: getting it wrong is an OOM, not a slow generation."""
from core.inference.video import _h3_dense_denoiser_fits
sizes = (66_300_000_000, 33_000_000_000)
need = sizes[0] + sizes[1]
assert _h3_dense_denoiser_fits(sizes, need) is True
assert _h3_dense_denoiser_fits(sizes, need + 1) is True
assert _h3_dense_denoiser_fits(sizes, need - 1) is False
assert _h3_dense_denoiser_fits(sizes, sizes[0]) is False
assert _h3_dense_denoiser_fits(None, need) is False
assert _h3_dense_denoiser_fits(sizes, None) is False
def test_the_released_conditioner_is_reachable_through_the_load_api():
"""none/off must survive both request gates, or the released bf16 conditioner is unreachable."""
from pydantic import ValidationError
from core.inference.diffusion_precision import normalize_te_quant
from models.inference import VideoLoadRequest
for opt_out in ("none", "off", "None", " OFF "):
assert normalize_te_quant(opt_out) is None
assert normalize_te_quant("auto") is None
with pytest.raises(ValueError):
normalize_te_quant("int3")
def _request(value):
return VideoLoadRequest(model_path = "MiniMaxAI/MiniMax-H3", text_encoder_quant = value)
for accepted in (None, "auto", "none", "off", "fp8", "fp8_dynamic", "int8", "nvfp4"):
assert _request(accepted).text_encoder_quant == accepted
with pytest.raises(ValidationError):
_request("int3")
def test_the_opt_out_spellings_reach_the_h3_tri_state():
"""Reaching the model is only useful if the tri-state then reads them as the dense pin rather
than folding them into the unset branch that takes the hosted checkpoint."""
from core.inference.video import _h3_precision_pinned_dense, _h3_precision_unset
for opt_out in ("none", "off", "OFF", " none "):
assert _h3_precision_pinned_dense(opt_out) is True
assert _h3_precision_unset(opt_out) is False
for unset in (None, "", "auto", "AUTO"):
assert _h3_precision_unset(unset) is True
assert _h3_precision_pinned_dense(unset) is False
def test_speed_off_declines_the_dense_pin_but_never_the_prequantized_one():
"""speed=off declines the dense pin but never the pre-quantized one, which torchao needs."""
import ast
import inspect
import textwrap
from core.inference.diffusion_speed import SPEED_DEFAULT, SPEED_OFF, resolve_speed_mode
assert resolve_speed_mode("off", is_gguf = False, dense_default = SPEED_DEFAULT) == SPEED_OFF
for on in ("default", "max"):
assert resolve_speed_mode(on, is_gguf = False, dense_default = SPEED_DEFAULT) != SPEED_OFF
# Read from source: a modular load cannot be stood up in this network-free suite.
source = textwrap.dedent(inspect.getsource(VideoBackend._load_h3_modular_pipeline))
pins = [
node
for node in ast.walk(ast.parse(source))
if isinstance(node, ast.If)
and "transformer_quant_engaged" == getattr(node.test, "id", None)
and node.orelse
]
assert len(pins) == 1, "the two denoiser placements are no longer one if/elif pair"
prequantized_branch, dense_branch = pins[0], pins[0].orelse[0]
assert isinstance(dense_branch, ast.If)
dense_test = ast.dump(dense_branch.test)
assert "SPEED_OFF" in dense_test, "the dense pin no longer honours an explicit speed=off"
assert "denoiser" in dense_test
assert "SPEED_OFF" not in ast.dump(prequantized_branch.test)
for stmt in prequantized_branch.body:
assert "SPEED_OFF" not in ast.dump(stmt)
def test_the_dense_placement_is_fenced_on_the_load_token():
"""Fence the dense placement on the load token before placing, so a superseded worker stops."""
import ast
import inspect
import textwrap
source = textwrap.dedent(inspect.getsource(VideoBackend._load_h3_modular_pipeline))
tree = ast.parse(source)
def _line(predicate) -> int:
hits = [node.lineno for node in ast.walk(tree) if predicate(node)]
assert hits, "landmark not found in the modular loader"
return min(hits)
load_components = _line(lambda n: isinstance(n, ast.Attribute) and n.attr == "load_components")
fence = _line(
lambda n: isinstance(n, ast.Compare)
and "_load_token" in ast.dump(n)
and n.lineno > load_components
)
placement = _line(
lambda n: isinstance(n, ast.Attribute) and n.attr == "enable_auto_cpu_offload"
)
assert (
load_components < fence < placement
), "the token fence must sit between load_components and the placement it guards"
def _h3_family():
from core.inference.video_families import detect_video_family
return detect_video_family("minimax-h3")
def test_the_planned_sizing_matches_the_measured_one_it_stands_in_for():
"""Pre-load sizing and the post-load pin must agree exactly, except for the denoiser term."""
import torch
from core.inference.video import (
_h3_dense_denoiser_resident_bytes,
_h3_planned_denoiser_bytes,
)
fam = _h3_family()
class _Weight:
"""Fake weight reporting only numel, element_size and is_meta, so no real 66 GB tensor is built."""
is_meta = False
def numel(self):
return int(fam.bf16_components_gb[0] * 1000**3 // 2)
def element_size(self):
return torch.finfo(torch.bfloat16).bits // 8
class _Dense:
def parameters(self):
return [_Weight()]
def buffers(self):
return []
for te_scheme in (None, "int8"):
planned = _h3_planned_denoiser_bytes(fam, te_scheme = te_scheme, dtype = torch.bfloat16)
measured = _h3_dense_denoiser_resident_bytes(
fam, denoiser = _Dense(), te_scheme = te_scheme, dtype = torch.bfloat16
)
assert planned is not None and measured is not None
assert planned[1] == measured[1], f"the others term drifted for te_scheme={te_scheme}"
assert abs(planned[0] - measured[0]) < 1_000_000_000
fp32 = _h3_planned_denoiser_bytes(fam, te_scheme = None, dtype = torch.float32)
bf16 = _h3_planned_denoiser_bytes(fam, te_scheme = None, dtype = torch.bfloat16)
assert fp32 is not None and bf16 is not None and fp32[0] == bf16[0] * 2
def test_auto_takes_the_hosted_denoiser_even_on_a_card_with_room_to_spare(monkeypatch):
"""int8 is the default, not a fallback: spare VRAM is no reason to pick bf16, and int8 alters output."""
fam, torch, vid = _shared_setup_1()
monkeypatch.setattr(vid, "_h3_auto_precision_ok", lambda target = None: True, raising = False)
monkeypatch.setattr(vid, "_h3_free_device_bytes", lambda device: 500 * 1000**3)
assert (
vid._h3_auto_denoiser_scheme(
fam,
target = None,
dtype = torch.bfloat16,
device = "cuda",
te_scheme = "int8",
task = "fl2va",
base_repo = fam.base_repo,
)
== "int8"
)
def test_auto_takes_the_hosted_denoiser_when_the_released_one_cannot_stay_resident(monkeypatch):
"""CPU offload blocks regional compile (194 s vs 23.7 s), so auto takes the hosted denoiser."""
fam, torch, vid = _shared_setup_1()
monkeypatch.setattr(vid, "_h3_auto_precision_ok", lambda target = None: True, raising = False)
monkeypatch.setattr(vid, "_h3_free_device_bytes", lambda device: 80 * 1000**3)
assert (
vid._h3_auto_denoiser_scheme(
fam,
target = None,
dtype = torch.bfloat16,
device = "cuda",
te_scheme = "int8",
task = "fl2va",
base_repo = fam.base_repo,
)
== vid.H3_AUTO_FALLBACK_SCHEME
)
def test_the_auto_fallback_is_declined_when_nothing_can_answer(monkeypatch):
"""Unanswerable questions keep the released weights; a missing reading is not a shortfall."""
fam, torch, vid = _shared_setup_1()
def ask(**over):
kw = dict(
target = None,
dtype = torch.bfloat16,
device = "cuda",
te_scheme = "int8",
task = "fl2va",
base_repo = fam.base_repo,
)
kw.update(over)
return vid._h3_auto_denoiser_scheme(fam, **kw)
monkeypatch.setattr(vid, "_h3_free_device_bytes", lambda device: 80 * 1000**3)
monkeypatch.setattr(vid, "_h3_auto_precision_ok", lambda target = None: False, raising = False)
assert ask() is None
monkeypatch.setattr(vid, "_h3_auto_precision_ok", lambda target = None: True, raising = False)
monkeypatch.setattr(vid, "_h3_free_device_bytes", lambda device: None)
assert ask() == vid.H3_AUTO_FALLBACK_SCHEME
monkeypatch.setattr(vid, "_h3_free_device_bytes", lambda device: 80 * 1000**3)
monkeypatch.setattr(vid, "_h3_planned_denoiser_bytes", lambda *a, **k: None)
assert ask() == vid.H3_AUTO_FALLBACK_SCHEME
import core.inference.diffusion_prequant as pq
monkeypatch.setattr(pq, "torchao_group_offload_supported", lambda: False)
assert ask() is None
monkeypatch.undo()
monkeypatch.setattr(vid, "_h3_auto_precision_ok", lambda target = None: True, raising = False)
monkeypatch.setattr(vid, "_h3_free_device_bytes", lambda device: 80 * 1000**3)
monkeypatch.setattr(
vid, "video_family_prequant_available", lambda *a, **k: False, raising = False
)
assert ask() is None
def test_an_explicit_speed_off_keeps_the_released_denoiser(monkeypatch):
"""speed_mode=off must stay bit-exact; hosted checkpoints re-roll the sample, so decline them."""
fam, torch, vid = _shared_setup_1()
monkeypatch.setattr(vid, "_h3_auto_precision_ok", lambda target = None: True, raising = False)
monkeypatch.setattr(vid, "_h3_free_device_bytes", lambda device: 80 * 1000**3)
def ask(speed_mode):
return vid._h3_auto_denoiser_scheme(
fam,
target = None,
dtype = torch.bfloat16,
device = "cuda",
te_scheme = "int8",
task = "fl2va",
base_repo = fam.base_repo,
speed_mode = speed_mode,
)
assert ask("off") is None
assert ask("OFF ") is None, "the request is read the same way the conventional loader reads it"
assert ask(None) == vid.H3_AUTO_FALLBACK_SCHEME
assert ask("default") == vid.H3_AUTO_FALLBACK_SCHEME
def test_the_automatic_substitution_needs_the_exact_base_model(monkeypatch):
"""Auto substitution requires the exact base repo; a look-alike derivative must not lend weights."""
fam, torch, vid = _shared_setup_1()
monkeypatch.setattr(vid, "_h3_auto_precision_ok", lambda target = None: True, raising = False)
monkeypatch.setattr(vid, "_h3_free_device_bytes", lambda device: 80 * 1000**3)
def ask(base_repo):
return vid._h3_auto_denoiser_scheme(
fam,
target = None,
dtype = torch.bfloat16,
device = "cuda",
te_scheme = "int8",
task = "fl2va",
base_repo = base_repo,
)
assert ask(fam.base_repo) == vid.H3_AUTO_FALLBACK_SCHEME
assert ask("someone/MiniMax-H3") is None, "a derivative keeps its own denoiser"
assert ask("/models/MiniMax-H3") is None, "and so does a local re-save this cannot identify"
assert ask(None) is None
def test_auto_keeps_int8_on_every_card_size_and_lets_the_fit_pick_the_placement(monkeypatch):
"""The fit picks placement, not precision: a small card is no reason to take bf16."""
fam, torch, vid = _shared_setup_1()
monkeypatch.setattr(vid, "_h3_auto_precision_ok", lambda target = None: True, raising = False)
def ask(free_gb, te_scheme):
monkeypatch.setattr(vid, "_h3_free_device_bytes", lambda device: int(free_gb * 1000**3))
return vid._h3_auto_denoiser_scheme(
fam,
target = None,
dtype = torch.bfloat16,
device = "cuda",
te_scheme = te_scheme,
task = "fl2va",
base_repo = fam.base_repo,
)
for free_gb in (24, 32, 48, 80, 141):
for te_scheme in ("int8", None):
assert ask(free_gb, te_scheme) == vid.H3_AUTO_FALLBACK_SCHEME, (free_gb, te_scheme)
def test_without_group_offload_the_hosted_denoiser_still_has_to_fit_pinned(monkeypatch):
"""Without group offload pinning is the only placement; where the pin does not fit, the released
denoiser in the rotation is the configuration that runs."""
import core.inference.diffusion_prequant as pq
fam, torch, vid = _shared_setup_1()
monkeypatch.setattr(vid, "_h3_auto_precision_ok", lambda target = None: True, raising = False)
monkeypatch.setattr(pq, "torchao_group_offload_supported", lambda: False)
def ask(free_gb, te_scheme):
monkeypatch.setattr(vid, "_h3_free_device_bytes", lambda device: int(free_gb * 1000**3))
return vid._h3_auto_denoiser_scheme(
fam,
target = None,
dtype = torch.bfloat16,
device = "cuda",
te_scheme = te_scheme,
task = "fl2va",
base_repo = fam.base_repo,
)
pinned = vid._h3_planned_denoiser_bytes(
fam, te_scheme = "int8", dtype = torch.bfloat16, rotating = True
)
need_gb = (20.3 * 1000**3 + pinned[1]) / 1000**3
assert ask(need_gb + 0.1, "int8") == vid.H3_AUTO_FALLBACK_SCHEME
assert ask(need_gb - 0.1, "int8") is None
assert ask(32, "int8") is None
assert ask(80, None) is None
assert ask(141, None) == vid.H3_AUTO_FALLBACK_SCHEME
def test_a_pinned_denoiser_is_sized_beside_the_larger_rotating_component_not_their_sum():
"""A pinned denoiser sits beside the larger rotating part, not their sum; summing over-counts by
the ~11 GB VAE term and refuses pins that fit; only the whole-set-resident question sums."""
import torch
from core.inference.video import _h3_dense_denoiser_resident_bytes, _h3_planned_denoiser_bytes
fam = _h3_family()
te_gb, vae_gb = 27.2, fam.bf16_components_gb[2]
class _Real:
def parameters(self):
return iter(())
def buffers(self):
return iter([torch.empty(1024, dtype = torch.uint8)])
for sizer in (
lambda **kw: _h3_planned_denoiser_bytes(fam, te_scheme = "int8", dtype = torch.bfloat16, **kw),
lambda **kw: _h3_dense_denoiser_resident_bytes(
fam, denoiser = _Real(), te_scheme = "int8", dtype = torch.bfloat16, **kw
),
):
whole = sizer()[1]
rotating = sizer(rotating = True)[1]
assert whole - rotating == int((te_gb + vae_gb) * 1000**3) - int(
max(te_gb, vae_gb) * 1000**3
)
whole = _h3_planned_denoiser_bytes(fam, te_scheme = None, dtype = torch.bfloat16)[1]
rotating = _h3_planned_denoiser_bytes(fam, te_scheme = None, dtype = torch.bfloat16, rotating = True)[
1
]
assert abs((whole - rotating) - vae_gb * 1000**3) < 1000
def test_the_fallback_is_resolved_before_the_download_is_planned(monkeypatch):
"""Plan the download after resolving the fallback, or the 66.3 GB dense denoiser is staged anyway."""
import inspect
import types
fam, torch, vid = _shared_setup_1()
backend = vid.VideoBackend.__new__(vid.VideoBackend)
monkeypatch.setattr(vid, "_h3_auto_precision_ok", lambda target = None: True, raising = False)
monkeypatch.setattr(
vid,
"resolve_diffusion_device_target",
lambda *a, **k: types.SimpleNamespace(device = "cuda", dtype = torch.bfloat16),
raising = False,
)
monkeypatch.setattr(vid, "_h3_device_capacity_bytes", lambda device: 80 * 1000**3)
monkeypatch.setattr(vid, "_h3_free_device_bytes", lambda device: None)
def plan(**over):
kw = dict(
base = fam.base_repo,
transformer_quant = None,
text_encoder_quant = None,
speed_mode = None,
h3_task = "fl2va",
)
kw.update(over)
return backend._h3_planned_auto_denoiser_scheme(fam, **kw)
assert plan() == vid.H3_AUTO_FALLBACK_SCHEME
assert plan(transformer_quant = "none") is None
assert plan(transformer_quant = "int8") is None
assert plan(speed_mode = "off") is None
assert not vid.VideoBackend._denoiser_prequant_covered(fam, None, fam.base_repo, "fl2va")
assert vid.VideoBackend._denoiser_prequant_covered(
fam, vid.H3_AUTO_FALLBACK_SCHEME, fam.base_repo, "fl2va"
)
# The planner must run before the shard-dropping verification, which precedes the pull.
src = inspect.getsource(vid.VideoBackend._run_load)
planned = src.index("_h3_planned_auto_denoiser_scheme")
verified = src.index("_denoiser_prequant_verified")
predownload = src.index("_predownload_base")
assert planned < verified < predownload
assert "h3_auto_denoiser or video_auto_denoiser or requested_denoiser" in src
def _h3_placement_probe(
monkeypatch,
*,
free_gb,
te_gb,
denoiser_gb,
speed = "default",
):
"""Drive just the placement decision: does this load install the CPU-offload rotation?"""
from core.inference import video as vid
monkeypatch.setattr(
vid,
"_h3_dense_denoiser_resident_bytes",
lambda fam, **kw: (int(denoiser_gb * 1e9), int(te_gb * 1e9)),
)
monkeypatch.setattr(vid, "_h3_free_device_bytes", lambda device: int(free_gb * 1e9))
sizes = vid._h3_dense_denoiser_resident_bytes(None)
free = vid._h3_free_device_bytes("cuda")
return speed != vid.SPEED_OFF and vid._h3_dense_denoiser_fits(sizes, free)
def test_a_card_that_holds_everything_does_not_install_the_offload_rotation(monkeypatch):
"""No offload rotation on a card that holds everything: it only adds host-RAM and bus traffic."""
assert _h3_placement_probe(monkeypatch, free_gb = 183, te_gb = 40, denoiser_gb = 66) is True
def test_a_card_that_cannot_hold_everything_keeps_the_rotation(monkeypatch):
assert _h3_placement_probe(monkeypatch, free_gb = 80, te_gb = 40, denoiser_gb = 66) is False
def test_speed_off_keeps_the_rotation_even_on_a_card_that_could_hold_everything(monkeypatch):
"""Resident sets trade long-clip headroom for speed; only explicit speed_mode=off keeps the rotation."""
from core.inference import video as vid
assert (
_h3_placement_probe(monkeypatch, free_gb = 183, te_gb = 40, denoiser_gb = 66, speed = vid.SPEED_OFF)
is False
)
def test_an_unreadable_card_keeps_the_rotation(monkeypatch):
from core.inference import video as vid
monkeypatch.setattr(vid, "_h3_dense_denoiser_resident_bytes", lambda fam, **kw: (1, 1))
monkeypatch.setattr(vid, "_h3_free_device_bytes", lambda device: None)
assert vid._h3_dense_denoiser_fits(vid._h3_dense_denoiser_resident_bytes(None), None) is False
def _moe_fam(**kwargs):
"""A dual-expert MoE family (Wan2.2-A14B's shape) hosting both experts in one repo."""
return _fam(
is_moe = True,
prequant_repos = (("nvfp4", "org/test-quantized"),),
prequant_filenames = (("nvfp4", "transformer_2", "test-transformer_2-NVFP4.safetensors"),),
**kwargs,
)
def test_the_components_a_family_seeds_are_its_denoisers():
from core.inference.video_denoiser_prequant import denoiser_components
assert denoiser_components(_fam()) == ("transformer",)
assert denoiser_components(_fam(is_moe = True)) == ("transformer", "transformer_2")
def test_the_second_expert_is_addressed_through_the_task_slot():
"""The second expert is addressed through the task slot; nvfp4 resolves no .pt container at all."""
from core.inference.video_denoiser_prequant import denoiser_prequant_sources
sources = denoiser_prequant_sources(_moe_fam(), "nvfp4", "org/test-video")
assert set(sources) == {"transformer", "transformer_2"}
from core.inference.diffusion_prequant import candidate_filenames_of
assert candidate_filenames_of(sources["transformer"]) == ("test-NVFP4.safetensors",)
assert candidate_filenames_of(sources["transformer_2"]) == (
"test-transformer_2-NVFP4.safetensors",
)
def test_every_component_or_none():
"""Partial coverage is not coverage: every component or none."""
from core.inference.video_denoiser_prequant import denoiser_prequant_sources
single = _fam(prequant_repos = (("nvfp4", "org/test-NVFP4"),))
assert set(denoiser_prequant_sources(single, "nvfp4", "org/test-video")) == {"transformer"}
assert (
denoiser_prequant_sources(
_fam(is_moe = True, prequant_repos = (("nvfp4", "org/x"),)), "nvfp4", "org/test-video"
)
is None
)
assert denoiser_prequant_sources(_moe_fam(), "int8", "org/test-video") is None
for scheme in (None, "", "auto", "off", "none"):
assert denoiser_prequant_sources(_moe_fam(), scheme, "org/test-video") is None
def _stub_prequant_loader(monkeypatch, outcomes):
"""Record every ``load_prequantized_transformer`` call and return ``outcomes`` in order."""
import gc
import sys
import types
import core.inference.diffusion_prequant as pq
diffusers = types.ModuleType("diffusers")
diffusers.TestTransformer3DModel = object
monkeypatch.setitem(sys.modules, "diffusers", diffusers)
events: list = []
calls: list = []
def _fake_load(transformer_cls, base, source, **kwargs):
calls.append({"base": base, "source": source, **kwargs})
events.append(("load", kwargs.get("component")))
return outcomes[len(calls) - 1]
monkeypatch.setattr(pq, "load_prequantized_transformer", _fake_load)
monkeypatch.setattr(gc, "collect", lambda *a, **k: events.append(("collect", None)))
return calls, events
def test_seeding_loads_every_expert_into_its_own_component(monkeypatch):
"""Seeding loads every expert into its own component, from its own config."""
from core.inference.video_denoiser_prequant import denoiser_prequant_pipe_kwargs
first, second = object(), object()
calls, events = _stub_prequant_loader(monkeypatch, [first, second])
seeded = denoiser_prequant_pipe_kwargs(
_moe_fam(),
"org/test-video",
scheme = "nvfp4",
dtype = "bfloat16",
device = "cuda:0",
hf_token = "tok",
cache_dir = "/cache",
)
assert seeded == {"transformer": first, "transformer_2": second}
assert [c["config_subfolder"] for c in calls] == ["transformer", "transformer_2"]
assert [c["component"] for c in calls] == ["transformer", "transformer_2"]
assert [c["source"].filename for c in calls] == [
"test-NVFP4.safetensors",
"test-transformer_2-NVFP4.safetensors",
]
from core.inference.diffusion_transformer_quant import DEFAULT_MIN_LINEAR_FEATURES
assert {c["min_features"] for c in calls} == {DEFAULT_MIN_LINEAR_FEATURES}
assert events == [
("load", "transformer"),
("collect", None),
("load", "transformer_2"),
("collect", None),
]
def test_a_second_expert_that_will_not_load_seeds_nothing(monkeypatch):
"""A second expert that will not load seeds nothing and releases what was loaded."""
from core.inference.video_denoiser_prequant import denoiser_prequant_pipe_kwargs
calls, events = _stub_prequant_loader(monkeypatch, [object(), None])
assert (
denoiser_prequant_pipe_kwargs(
_moe_fam(),
"org/test-video",
scheme = "nvfp4",
dtype = "bfloat16",
device = "cuda:0",
)
== {}
)
assert len(calls) == 2
assert events[-1] == ("collect", None)
def test_seeding_declines_a_host_that_cannot_run_the_quant(monkeypatch):
import types
import core.inference.diffusion_transformer_quant as tq
from core.inference.video_denoiser_prequant import denoiser_prequant_pipe_kwargs
calls, _events = _stub_prequant_loader(monkeypatch, [object(), object()])
monkeypatch.setattr(tq, "dense_transformer_supported", lambda target: False)
assert (
denoiser_prequant_pipe_kwargs(
_moe_fam(),
"org/test-video",
scheme = "nvfp4",
dtype = "bfloat16",
device = "cuda:0",
target = types.SimpleNamespace(device = "cpu"),
)
== {}
)
assert calls == []
def _video_auto(
monkeypatch,
*,
scheme,
fam = None,
**over,
):
"""``_video_auto_denoiser_scheme`` with the device selector stubbed to ``scheme``."""
from core.inference import video as vid
def _select(
target,
requested,
family = None,
base_repo = None,
**kw,
):
_video_auto.calls.append(
dict(requested = requested, family = family, base_repo = base_repo, **kw)
)
probe = kw.get("has_prequant")
if scheme is not None and requested == "auto" and probe is not None and not probe(scheme):
return None
return scheme
_video_auto.calls = []
monkeypatch.setattr(vid, "select_transformer_quant_scheme", _select)
kw = dict(
target = None,
requested = "auto",
base_repo = "org/test-video",
speed_mode = None,
)
kw.update(over)
return vid._video_auto_denoiser_scheme(fam if fam is not None else _moe_fam(), **kw)
def test_the_conventional_auto_scheme_needs_an_artifact_for_every_expert(monkeypatch):
assert _video_auto(monkeypatch, scheme = "nvfp4") == "nvfp4"
assert _video_auto(monkeypatch, scheme = "int8") is None
assert (
_video_auto(
monkeypatch, scheme = "nvfp4", fam = _fam(is_moe = True, prequant_repos = (("nvfp4", "org/x"),))
)
is None
)
assert _video_auto(monkeypatch, scheme = None) is None
def test_auto_is_handed_the_probe_that_lets_it_reach_a_prequant_only_scheme(monkeypatch):
"""AUTO offers nvfp4 only where a hosted checkpoint provably covers THIS load."""
assert _video_auto(monkeypatch, scheme = "nvfp4") == "nvfp4"
probe = _video_auto.calls[-1]["has_prequant"]
assert probe("nvfp4") is True
assert probe("int8") is False
half = _fam(is_moe = True, prequant_repos = (("nvfp4", "org/x"),))
assert _video_auto(monkeypatch, scheme = "nvfp4", fam = half) is None
assert _video_auto.calls == []
def test_speed_off_and_the_modular_workflow_are_never_seeded_here(monkeypatch):
assert _video_auto(monkeypatch, scheme = "nvfp4", speed_mode = "off") is None
assert _video_auto(monkeypatch, scheme = "nvfp4", speed_mode = " OFF ") is None
assert _video_auto(monkeypatch, scheme = "nvfp4", speed_mode = "off", requested = None) is None
assert _video_auto(monkeypatch, scheme = "nvfp4", fam = _moe_fam(modular_workflow = "fl2va")) is None
def test_an_explicit_scheme_keeps_its_seed_under_speed_off(monkeypatch):
"""An explicit scheme under Speed="off" is honored, so the plan keeps the hosted checkpoint."""
assert _video_auto(monkeypatch, scheme = "nvfp4", speed_mode = "off", requested = "nvfp4") == "nvfp4"
from core.inference.diffusion_transformer_quant import select_transformer_quant_scheme
assert select_transformer_quant_scheme(object(), "off") is None
def test_an_install_that_cannot_open_a_checkpoint_keeps_the_dense_denoiser(monkeypatch):
import core.inference.diffusion_prequant as pq
monkeypatch.setattr(pq, "restricted_prequant_load_supported", lambda scheme = None: False)
assert _video_auto(monkeypatch, scheme = "nvfp4") is None
def test_the_conventional_coverage_probe_reads_every_component():
from core.inference.video import VideoBackend
fam = _moe_fam()
assert VideoBackend._denoiser_prequant_covered(fam, "nvfp4", "org/test-video")
assert not VideoBackend._denoiser_prequant_covered(fam, "int8", "org/test-video")
assert not VideoBackend._denoiser_prequant_covered(fam, "auto", "org/test-video")
assert not VideoBackend._denoiser_prequant_covered(fam, None, "org/test-video")
assert not VideoBackend._denoiser_prequant_covered(
fam, "nvfp4", "org/test-video", None, kind = "gguf"
)
half = _fam(is_moe = True, prequant_repos = (("nvfp4", "org/x"),))
assert not VideoBackend._denoiser_prequant_covered(half, "nvfp4", "org/test-video")
def _a14b_auto(
monkeypatch,
*,
backend,
fam = None,
allowed = None,
gated = False,
):
import types
import core.inference.diffusion_nvfp4_ops as ops
import core.inference.diffusion_prequant as pq
import core.inference.diffusion_transformer_quant as tq
from core.inference import video as vid
from core.inference.video_denoiser_prequant import denoiser_prequant_sources
from core.inference.video_families import detect_video_family
allowed = allowed or {"nvfp4", "fp8", "mxfp8", "int8"}
monkeypatch.setattr(tq, "dense_transformer_supported", lambda target: True)
monkeypatch.setattr(tq, "_capability", lambda: (10, 0))
monkeypatch.setattr(tq, "_is_consumer_gpu", lambda device: False)
monkeypatch.setattr(tq, "_scheme_supported", lambda scheme, device, **kw: scheme in allowed)
monkeypatch.setattr(ops, "select_nvfp4_backend", lambda device = None: backend)
monkeypatch.setattr(pq, "restricted_prequant_load_supported", lambda scheme = None: True)
if gated:
# What a measured, passing A14B gate record would read as (none ships).
monkeypatch.setattr(tq, "_nvfp4_gate_passed", lambda family, base_repo: True)
monkeypatch.setattr(tq, "_nvfp4_gate_backend_ok", lambda family, base_repo, device: True)
fam = fam if fam is not None else detect_video_family("Wan-AI/Wan2.2-T2V-A14B-Diffusers")
base = fam.base_repo
return (
vid._video_auto_denoiser_scheme(
fam,
target = types.SimpleNamespace(device = "cuda:0", dtype = "bfloat16"),
requested = "auto",
base_repo = base,
speed_mode = None,
),
tq.select_transformer_quant_scheme(
types.SimpleNamespace(device = "cuda:0", dtype = "bfloat16"),
"auto",
family = fam.name,
base_repo = base,
has_prequant = lambda scheme: (denoiser_prequant_sources(fam, scheme, base) is not None),
),
)
def test_the_a14b_auto_plan_never_seeds_ungated_nvfp4(monkeypatch):
"""No accuracy-gate record covers the hosted A14B NVFP4 experts, so auto keeps the ladder even on flashinfer."""
seeded, chosen = _a14b_auto(monkeypatch, backend = "flashinfer")
assert chosen == "int8"
assert seeded == "int8"
def test_the_a14b_auto_plan_seeds_nvfp4_where_a_gate_record_and_flashinfer_serve_the_device(
monkeypatch,
):
seeded, chosen = _a14b_auto(monkeypatch, backend = "flashinfer", gated = True)
assert seeded == "nvfp4"
assert chosen == "nvfp4"
def test_the_a14b_auto_plan_stays_on_the_ladder_on_the_torchao_backend(monkeypatch):
# The ladder's int8 is hosted, so the plan seeds the scheme auto would otherwise quantise at load.
seeded, chosen = _a14b_auto(monkeypatch, backend = "torchao")
assert chosen == "int8"
assert seeded == "int8"
def test_the_a14b_auto_plan_stays_on_the_ladder_with_only_one_expert_hosted(monkeypatch):
"""One expert hosted is uncovered, not partly covered."""
import dataclasses
from core.inference.video_families import detect_video_family
full = detect_video_family("Wan-AI/Wan2.2-T2V-A14B-Diffusers")
half = dataclasses.replace(
full,
prequant_filenames = tuple(row for row in full.prequant_filenames if len(row) == 2),
)
seeded, chosen = _a14b_auto(monkeypatch, backend = "flashinfer", fam = half)
assert seeded is None
assert chosen == "int8"
def test_the_a14b_auto_plan_falls_through_when_the_fp4_kernel_is_missing(monkeypatch):
seeded, chosen = _a14b_auto(monkeypatch, backend = "flashinfer", allowed = {"fp8", "mxfp8", "int8"})
assert seeded == "int8"
assert chosen == "int8"
def _planned_denoiser_request(monkeypatch, fam, **load_kwargs):
"""The scheme the download planner hands ``_denoiser_prequant_verified``; only the Hub probe is stubbed."""
from core.inference import video as vid
backend = vid.VideoBackend()
backend._load_token = 1
backend._loading = vid._VideoLoadingState(repo_id = fam.base_repo, base_repo = fam.base_repo)
monkeypatch.setattr(vid, "_detect_load_family", lambda *a, **k: fam)
monkeypatch.setattr(vid, "_assert_pick_is_not_speech", lambda *a, **k: None)
monkeypatch.setattr(backend, "_h3_planned_auto_denoiser_scheme", lambda *a, **k: None)
monkeypatch.setattr(backend, "_video_planned_auto_denoiser_scheme", lambda *a, **k: None)
monkeypatch.setattr(backend, "load_pipeline", lambda **kwargs: None)
monkeypatch.setattr(backend, "_run_load_h3_native", lambda **kwargs: None)
seen: list = []
def _verified(_fam, transformer_quant, *a, **k):
seen.append(transformer_quant)
return False
monkeypatch.setattr(backend, "_denoiser_prequant_verified", _verified)
backend._run_load(
repo_id = fam.base_repo,
local_files_only = True,
_load_token = 1,
**load_kwargs,
)
assert seen, "the plan never reached the denoiser probe"
return seen[0]
def test_a_conventional_plan_drops_no_shard_the_load_will_not_seed(monkeypatch):
from core.inference.video_families import detect_video_family
wan = detect_video_family("Wan-AI/Wan2.2-TI2V-5B-Diffusers")
assert wan is not None and not wan.modular_workflow
assert (
_planned_denoiser_request(monkeypatch, wan, transformer_quant = "nvfp4", speed_mode = "off")
is None
)
h3 = detect_video_family("MiniMaxAI/MiniMax-H3")
assert h3 is not None and h3.modular_workflow
assert (
_planned_denoiser_request(
monkeypatch, h3, transformer_quant = "int8", speed_mode = "off", h3_task = "fl2va"
)
== "int8"
)
def test_a_seed_the_plan_declined_is_pinned_into_the_load(monkeypatch):
"""The plan runs with the PREVIOUS pipeline resident, so its decline travels as its own value, not None."""
from core.inference import video as vid
from core.inference.video_families import detect_video_family
wan = detect_video_family("Wan-AI/Wan2.2-TI2V-5B-Diffusers")
assert wan is not None and not wan.modular_workflow
backend = vid.VideoBackend()
backend._load_token = 1
backend._loading = vid._VideoLoadingState(repo_id = wan.base_repo, base_repo = wan.base_repo)
monkeypatch.setattr(vid, "_detect_load_family", lambda *a, **k: wan)
monkeypatch.setattr(vid, "_assert_pick_is_not_speech", lambda *a, **k: None)
monkeypatch.setattr(backend, "_h3_planned_auto_denoiser_scheme", lambda *a, **k: None)
monkeypatch.setattr(
backend,
"_video_planned_auto_denoiser_scheme",
lambda *a, **k: vid.DENOISER_SEED_DECLINED,
)
monkeypatch.setattr(backend, "_run_load_h3_native", lambda **kwargs: None)
probed: list = []
def _verified(_fam, transformer_quant, *a, **k):
probed.append(transformer_quant)
return False
monkeypatch.setattr(backend, "_denoiser_prequant_verified", _verified)
loaded: list = []
monkeypatch.setattr(backend, "load_pipeline", lambda **kwargs: loaded.append(kwargs))
backend._run_load(
repo_id = wan.base_repo,
local_files_only = True,
_load_token = 1,
transformer_quant = "nvfp4",
)
assert probed == [None], "a declined seed drops no dense shard from the pull"
assert loaded and loaded[0]["_video_auto_denoiser_planned"] == vid.DENOISER_SEED_DECLINED
def test_the_seeded_denoiser_repo_is_claimed_against_a_concurrent_delete(monkeypatch):
from core.inference import video as vid
from core.inference.video_families import detect_video_family
wan = detect_video_family("Wan-AI/Wan2.2-TI2V-5B-Diffusers")
assert wan is not None and not wan.modular_workflow
backend = vid.VideoBackend()
backend._load_token = 1
backend._loading = vid._VideoLoadingState(repo_id = wan.base_repo, base_repo = wan.base_repo)
monkeypatch.setattr(vid, "_detect_load_family", lambda *a, **k: wan)
monkeypatch.setattr(vid, "_assert_pick_is_not_speech", lambda *a, **k: None)
monkeypatch.setattr(backend, "_h3_planned_auto_denoiser_scheme", lambda *a, **k: None)
monkeypatch.setattr(backend, "_video_planned_auto_denoiser_scheme", lambda *a, **k: "nvfp4")
monkeypatch.setattr(backend, "_denoiser_prequant_verified", lambda *a, **k: True)
monkeypatch.setattr(backend, "_run_load_h3_native", lambda **kwargs: None)
claimed: list = []
monkeypatch.setattr(
backend, "load_pipeline", lambda **kwargs: claimed.extend(backend.loading_repo_ids())
)
backend._run_load(
repo_id = wan.base_repo,
local_files_only = True,
_load_token = 1,
transformer_quant = "nvfp4",
)
assert "unsloth/Wan2.2-TI2V-5B-NVFP4" in claimed
def test_both_experts_of_an_moe_resolve_to_one_claimed_repo():
"""The two A14B experts are two files in ONE repo, so the claim names it once."""
from core.inference.video_families import detect_video_family
a14b = detect_video_family("Wan-AI/Wan2.2-T2V-A14B-Diffusers")
assert a14b is not None and a14b.is_moe
assert VideoBackend._denoiser_prequant_repo_ids(a14b, "nvfp4", a14b.base_repo) == (
"unsloth/Wan2.2-T2V-A14B-NVFP4",
)
assert VideoBackend._denoiser_prequant_repo_ids(a14b, "int8", a14b.base_repo) == (
"unsloth/Wan2.2-T2V-A14B-FP8",
)
assert VideoBackend._denoiser_prequant_repo_ids(a14b, "auto", a14b.base_repo) == ()
def test_the_seeded_denoiser_artifact_is_fetched_under_the_load_cancel_event(monkeypatch):
import threading
from core.inference import video as vid
from core.inference.video_families import detect_video_family
wan = detect_video_family("Wan-AI/Wan2.2-TI2V-5B-Diffusers")
assert wan is not None and not wan.modular_workflow
backend = vid.VideoBackend()
backend._load_token = 1
backend._loading = vid._VideoLoadingState(repo_id = wan.base_repo, base_repo = wan.base_repo)
monkeypatch.setattr(vid, "_detect_load_family", lambda *a, **k: wan)
monkeypatch.setattr(vid, "_assert_pick_is_not_speech", lambda *a, **k: None)
monkeypatch.setattr(backend, "_h3_planned_auto_denoiser_scheme", lambda *a, **k: None)
monkeypatch.setattr(backend, "_video_planned_auto_denoiser_scheme", lambda *a, **k: "nvfp4")
monkeypatch.setattr(backend, "_denoiser_prequant_verified", lambda *a, **k: True)
monkeypatch.setattr(backend, "_run_load_h3_native", lambda **kwargs: None)
monkeypatch.setattr(backend, "load_pipeline", lambda **kwargs: None)
fetched: list = []
import utils.hf_xet_fallback as xet
monkeypatch.setattr(
xet,
"hf_hub_download_with_xet_fallback",
lambda repo, filename, token = None, **kwargs: fetched.append(
(repo, filename, kwargs.get("cancel_event"))
),
)
cancel = threading.Event()
backend._run_load(
repo_id = wan.base_repo,
local_files_only = True,
_load_token = 1,
_cancel_event = cancel,
transformer_quant = "nvfp4",
# pinned: on a CUDA host an unset request also plans the hosted FP8 text encoder, a second fetch
text_encoder_quant = "off",
)
assert [(r, f) for r, f, _ in fetched] == [
("unsloth/Wan2.2-TI2V-5B-NVFP4", "Wan2.2-TI2V-5B-NVFP4.safetensors")
]
assert fetched[0][2] is cancel
def test_the_seed_plan_credits_the_resident_pipelines_memory(monkeypatch):
"""The plan credits the resident pipeline's bytes, not other tenants', capped by the total."""
import core.inference.video as vid
from core.inference.diffusion_memory import DeviceMemory
from core.inference.video_families import detect_video_family
fam = detect_video_family("Wan-AI/Wan2.2-TI2V-5B-Diffusers")
seen: list = []
monkeypatch.setattr(
vid,
"settled_snapshot_device_memory",
lambda _t: DeviceMemory("cuda", "cuda", "discrete_vram", 10_000, 32_000),
)
monkeypatch.setattr(
vid,
"plan_diffusion_memory",
lambda **kw: seen.append(kw["device_memory"].free_mib)
or types.SimpleNamespace(offload_policy = "none"),
)
target = types.SimpleNamespace(device = "cuda", dtype = None)
for credit in (0, 15_000, 40_000):
vid._video_seed_stays_resident(
fam,
target = target,
scheme = "fp8",
memory_mode = None,
text_encoder_quant = None,
base_repo = None,
reclaimable_mib = credit,
)
assert seen == [10_000, 25_000, 32_000]
def test_the_planner_hands_the_resident_pipelines_bytes_to_the_seed_plan(monkeypatch):
import core.inference.video as vid
from core.inference.video_families import detect_video_family
fam = detect_video_family("Wan-AI/Wan2.2-TI2V-5B-Diffusers")
backend = vid.VideoBackend()
resident_pipe = object()
backend._state = types.SimpleNamespace(pipe = resident_pipe)
monkeypatch.setattr(vid, "_video_auto_denoiser_scheme", lambda fam, **kw: "fp8")
monkeypatch.setattr(
vid,
"_pipeline_device_mib",
lambda pipe, ordinal = None: (
captured.setdefault("ordinal", ordinal),
12_345 if pipe is resident_pipe else 0,
)[1],
)
captured: dict = {}
# The artifact-sized plan stays resident; the bf16 one (scheme=None) does not, so auto would quantise.
monkeypatch.setattr(
vid,
"_video_seed_stays_resident",
lambda fam, **kw: captured.update(kw) or kw["scheme"] is not None,
)
monkeypatch.setattr(
vid,
"resolve_diffusion_device_target",
lambda **_k: types.SimpleNamespace(device = "cuda", dtype = None, ordinal = None),
)
assert (
backend._video_planned_auto_denoiser_scheme(
fam, base = None, kind = "pipeline", transformer_quant = "auto", speed_mode = None
)
== "fp8"
)
assert captured["reclaimable_mib"] == 12_345
@pytest.mark.parametrize("requested, expected", [("auto", None), ("fp8", "fp8")])
def test_the_planner_keeps_the_dense_shards_where_auto_keeps_bf16(monkeypatch, requested, expected):
"""bf16 fits resident: auto runs the released bf16 DiT, so neither the artifact nor a shard skip is planned. An
explicit scheme is a request and still seeds."""
import core.inference.video as vid
from core.inference.video_families import detect_video_family
fam = detect_video_family("Wan-AI/Wan2.2-TI2V-5B-Diffusers")
backend = vid.VideoBackend()
backend._state = types.SimpleNamespace(pipe = None)
monkeypatch.setattr(vid, "_video_auto_denoiser_scheme", lambda fam, **kw: "fp8")
monkeypatch.setattr(vid, "_pipeline_device_mib", lambda pipe, ordinal = None: 0)
monkeypatch.setattr(vid, "_video_seed_stays_resident", lambda fam, **kw: True)
monkeypatch.setattr(
vid,
"resolve_diffusion_device_target",
lambda **_k: types.SimpleNamespace(device = "cuda", dtype = None, ordinal = None),
)
assert (
backend._video_planned_auto_denoiser_scheme(
fam, base = None, kind = "pipeline", transformer_quant = requested, speed_mode = None
)
== expected
)
def test_only_the_resident_bytes_on_the_target_card_are_credited():
"""Only bytes on the target card are credited; a storage shared by two tensors counts once."""
import core.inference.video as vid
def tensor(index, ptr, nbytes):
storage = types.SimpleNamespace(data_ptr = lambda: ptr, nbytes = lambda: nbytes)
return types.SimpleNamespace(
device = types.SimpleNamespace(type = "cuda", index = index),
untyped_storage = lambda: storage,
)
tensors = [tensor(0, 1, 3 << 20), tensor(0, 1, 3 << 20), tensor(1, 2, 5 << 20)]
module = types.SimpleNamespace(parameters = lambda: iter(tensors), buffers = lambda: iter(()))
pipe = types.SimpleNamespace(components = {"transformer": module})
assert vid._pipeline_device_mib(pipe) == 8
assert vid._pipeline_device_mib(pipe, ordinal = 0) == 3
assert vid._pipeline_device_mib(pipe, ordinal = 1) == 5
assert vid._pipeline_device_mib(pipe, ordinal = 2) == 0
def test_the_credit_is_read_on_the_card_the_load_targets():
import core.inference.video as vid
assert vid._target_ordinal(types.SimpleNamespace(device = "cuda", ordinal = 3)) == 3
assert vid._target_ordinal(types.SimpleNamespace(device = "mps", ordinal = None)) is None
def test_unreadability_is_reported_only_when_it_is_what_kept_bfloat16(monkeypatch):
try:
import importlib
import importlib.metadata
importlib.metadata.version("torch")
assert hasattr(importlib.import_module("torch"), "Tensor")
except Exception: # noqa: BLE001 - a stand-in torch in sys.modules is not an install
pytest.skip("needs torch installed")
fam, torch, vid = _shared_setup_1()
import core.inference.diffusion_prequant as pq
monkeypatch.setattr(vid, "_h3_auto_precision_ok", lambda target = None: True, raising = False)
monkeypatch.setattr(vid, "_h3_free_device_bytes", lambda device: 80 * 1000**3)
monkeypatch.setattr(pq, "restricted_prequant_load_supported", lambda *a, **k: False)
fired = []
def ask(**over):
kw = dict(
target = None,
dtype = torch.bfloat16,
device = "cuda",
te_scheme = "int8",
task = "fl2va",
base_repo = fam.base_repo,
on_unreadable = lambda: fired.append(True),
)
kw.update(over)
return vid._h3_auto_denoiser_scheme(fam, **kw)
assert ask() is None and fired == [True]
fired.clear()
assert ask(speed_mode = "off") is None and fired == []
assert ask(base_repo = "someone/MiniMax-H3") is None and fired == []
monkeypatch.setattr(vid, "_h3_free_device_bytes", lambda device: 10 * 1000**3)
assert ask() is None and fired == [True]
fired.clear()
monkeypatch.setattr(pq, "torchao_group_offload_supported", lambda: False)
assert ask() is None and fired == []
monkeypatch.setattr(pq, "torchao_group_offload_supported", lambda: True)
monkeypatch.setattr(pq, "restricted_prequant_load_supported", lambda *a, **k: True)
monkeypatch.setattr(vid, "_h3_free_device_bytes", lambda device: 80 * 1000**3)
assert ask() == vid.H3_AUTO_FALLBACK_SCHEME and fired == []
def test_an_explicit_cached_scheme_seeds_even_when_another_scheme_is_hosted(monkeypatch):
"""HunyuanVideo-1.5 hosts nvfp4; an explicit locally cached int8 must still seed."""
from core.inference import video as vid
from core.inference import video_denoiser_prequant as vdp
monkeypatch.setattr(vid, "video_family_prequant_schemes", lambda fam: ("nvfp4",))
sources = {"nvfp4": object(), "int8": object()} # int8 resolves only through the local cache
monkeypatch.setattr(
vdp, "denoiser_prequant_sources", lambda fam, s, base, hf_token = None: sources.get(s)
)
assert _video_auto(monkeypatch, scheme = "int8", requested = "int8") == "int8"
sources.pop("int8")
assert _video_auto(monkeypatch, scheme = "int8", requested = "int8") is None