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
"""CPU-only auto-policy tests for footprint estimates, quant candidates and provenance records."""
from __future__ import annotations
import pytest
from types import SimpleNamespace
import core.inference.diffusion_auto_policy as ap
@pytest.fixture(autouse = True)
def _assume_the_restricted_load_is_available(monkeypatch):
"""Policy tests, not a torchao check: unpatched, a broken torchao keeps dense weights for prequants."""
import core.inference.diffusion_prequant as _pq
monkeypatch.setattr(
_pq, "restricted_prequant_load_supported", lambda scheme = None, filename = None: True
)
from core.inference.diffusion_auto_policy import (
DenseQuantEstimate,
build_resolved_record,
estimate_dense_quant,
family_bf16_components_gb,
precision_fallback_allowed,
precision_refusal_message,
resolve_dense_quant_candidate,
)
from core.inference.diffusion_memory import (
OFFLOAD_NONE,
DeviceMemory,
plan_diffusion_memory,
)
def _fam(name = "z-image"):
return SimpleNamespace(name = name)
def test_family_table_covers_the_dit_families():
for name in ("flux.1", "flux.2-klein", "flux.2-dev", "qwen-image", "z-image", "krea-2"):
comps = family_bf16_components_gb(_fam(name))
assert comps is not None, f"{name} missing from the bf16 component table"
transformer, text_encoders, vae = comps
assert transformer > 1.0 and text_encoders > 0.0 and vae > 0.0
def test_family_table_unknown_family_returns_none():
assert family_bf16_components_gb(_fam("not-a-family")) is None
def test_zimage_base_downloads_bf16_while_turbo_downloads_fp32():
# Only the Turbo publishes fp32 shards; the undistilled base ships bf16, so no 2x factor.
assert ap.hub_download_factor(_fam("z-image")) == 2.0
assert ap.hub_download_factor(_fam("z-image"), "Tongyi-MAI/Z-Image-Turbo") == 2.0
assert ap.hub_download_factor(_fam("z-image"), "Tongyi-MAI/Z-Image") == 1.0
assert ap.hub_download_factor(_fam("flux.2-klein"), "black-forest-labs/FLUX.2-klein-4B") == 1.0
assert ap.hub_download_factor(_fam("z-image"), " tongyi-mai/Z-IMAGE ") == 1.0
turbo = estimate_dense_quant(_fam("z-image"), "int8", base_repo = "Tongyi-MAI/Z-Image-Turbo")
base = estimate_dense_quant(_fam("z-image"), "int8", base_repo = "Tongyi-MAI/Z-Image")
assert turbo is not None and base is not None
assert base.steady_transformer_mib == turbo.steady_transformer_mib
assert base.download_transformer_mib * 2 == turbo.download_transformer_mib
def test_base_repo_override_wins_over_the_family_default():
# klein's family default is the 4B; the 9B base's transformer is over twice the size.
default = family_bf16_components_gb(_fam("flux.2-klein"))
nine_b = family_bf16_components_gb(
_fam("flux.2-klein"), base_repo = "black-forest-labs/FLUX.2-klein-9B"
)
assert nine_b is not None and default is not None
assert nine_b[0] > 2 * default[0]
base_nine_b = family_bf16_components_gb(
_fam("flux.2-klein"), base_repo = "unsloth/FLUX.2-klein-base-9B"
)
assert base_nine_b == nine_b
def test_klein_base_9b_is_sized_like_the_9b_not_the_4b():
# klein-base-9B is the undistilled 9B (18.2 GB transformer), so it needs the 9B override too.
default = family_bf16_components_gb(_fam("flux.2-klein"))
nine_b = family_bf16_components_gb(
_fam("flux.2-klein"), base_repo = "black-forest-labs/FLUX.2-klein-9B"
)
base_9b = family_bf16_components_gb(
_fam("flux.2-klein"), base_repo = "black-forest-labs/FLUX.2-klein-base-9B"
)
assert base_9b == nine_b
assert base_9b is not None and default is not None and base_9b[0] > 2 * default[0]
assert (
family_bf16_components_gb(_fam("flux.2-klein"), base_repo = "unsloth/FLUX.2-klein-base-9B")
== base_9b
)
assert (
family_bf16_components_gb(
_fam("flux.2-klein"), base_repo = " BLACK-FOREST-LABS/flux.2-klein-base-9b "
)
== base_9b
)
def test_estimate_int8_steady_is_roughly_half_bf16():
est = estimate_dense_quant(_fam("z-image"), "int8")
assert est is not None
bf16_mib = 12.3 * ap._MIB_PER_GB
assert 0.5 * bf16_mib < est.steady_transformer_mib < 0.6 * bf16_mib
assert est.transient_transformer_mib == int(bf16_mib)
assert est.prequant is False
def test_estimate_prequant_transient_equals_steady():
# A pre-quantized checkpoint loads via the meta device: dense bf16 never lands on the GPU, so the build peak IS the quantised size.
est = estimate_dense_quant(_fam("z-image"), "int8", prequant_available = True)
assert est is not None
assert est.transient_transformer_mib == est.steady_transformer_mib
assert est.prequant is True
def test_estimate_nvfp4_is_smaller_than_int8():
int8 = estimate_dense_quant(_fam("flux.1"), "int8")
nvfp4 = estimate_dense_quant(_fam("flux.1"), "nvfp4")
assert int8 is not None and nvfp4 is not None
assert nvfp4.steady_transformer_mib < int8.steady_transformer_mib
def test_an_nvfp4_policy_base_is_sized_by_the_policy_not_by_whole_model_nvfp4():
from core.inference.diffusion_auto_policy import (
_MIB_PER_GB,
_POLICY_STEADY_FACTOR,
_QUANT_STEADY_FACTOR,
policy_steady_factor,
)
transformer_gb = ap._FAMILY_BF16_GB["z-image"][0]
policy = estimate_dense_quant(_fam("z-image"), "nvfp4", base_repo = "Tongyi-MAI/Z-Image-Turbo")
assert policy is not None
assert policy.steady_transformer_mib == int(
transformer_gb * _POLICY_STEADY_FACTOR["zimg_rg76_v1"] * _MIB_PER_GB
)
whole_model = int(transformer_gb * _QUANT_STEADY_FACTOR["nvfp4"] * _MIB_PER_GB)
assert policy.steady_transformer_mib > whole_model
for base in (None, "some-org/Z-Image-Fork"):
plain = estimate_dense_quant(_fam("z-image"), "nvfp4", base_repo = base)
assert plain is not None and plain.steady_transformer_mib == whole_model, base
kontext = estimate_dense_quant(
_fam("flux.1-kontext"), "nvfp4", base_repo = "black-forest-labs/FLUX.1-Kontext-dev"
)
assert kontext is not None
assert kontext.steady_transformer_mib == int(
ap._FAMILY_BF16_GB["flux.1-kontext"][0] * _QUANT_STEADY_FACTOR["nvfp4"] * _MIB_PER_GB
)
assert policy_steady_factor("flux.1-kontext", "black-forest-labs/FLUX.1-Kontext-dev") is None
fp8 = estimate_dense_quant(_fam("z-image"), "fp8", base_repo = "Tongyi-MAI/Z-Image-Turbo")
assert fp8 is not None
assert fp8.steady_transformer_mib == int(
transformer_gb * _QUANT_STEADY_FACTOR["fp8"] * _MIB_PER_GB
)
def test_estimate_unknown_family_or_scheme_returns_none():
assert estimate_dense_quant(_fam("not-a-family"), "int8") is None
assert estimate_dense_quant(_fam("z-image"), "q4_k") is None
def _patch_selector(
monkeypatch,
*,
supported = True,
scheme = "int8",
prequant = None,
):
import core.inference.diffusion_transformer_quant as tq
monkeypatch.setattr(tq, "dense_transformer_supported", lambda target: supported)
monkeypatch.setattr(
tq,
"select_transformer_quant_scheme",
lambda target, req, family = None, **_kw: scheme,
)
import core.inference.diffusion_prequant as pq
monkeypatch.setattr(
pq,
"resolve_prequant_source",
lambda fam, s, path_override = None, base_repo = None: prequant,
)
# Neutralize the cache-disk gate so tests do not depend on runner free space.
monkeypatch.setattr(ap, "_hf_cache_free_mib", lambda: None)
def test_candidate_resolves_for_a_supported_request(monkeypatch):
_patch_selector(monkeypatch, scheme = "int8")
est = resolve_dense_quant_candidate(fam = _fam("z-image"), target = object(), requested = "auto")
assert isinstance(est, DenseQuantEstimate)
assert est.scheme == "int8"
assert est.transient_transformer_mib > est.steady_transformer_mib
def test_candidate_none_when_request_is_off(monkeypatch):
_patch_selector(monkeypatch)
for off in (None, "", "none", "off"):
assert resolve_dense_quant_candidate(fam = _fam(), target = object(), requested = off) is None
def test_candidate_none_when_device_unsupported(monkeypatch):
_patch_selector(monkeypatch, supported = False)
assert resolve_dense_quant_candidate(fam = _fam(), target = object(), requested = "auto") is None
def test_candidate_none_when_no_scheme_resolves(monkeypatch):
_patch_selector(monkeypatch, scheme = None)
assert resolve_dense_quant_candidate(fam = _fam(), target = object(), requested = "auto") is None
def test_candidate_disk_gate_skips_when_cache_disk_low(monkeypatch):
import core.inference.diffusion_auto_policy as ap
_patch_selector(monkeypatch, scheme = "int8")
monkeypatch.setattr(ap, "_hf_cache_free_mib", lambda: 1024)
assert (
resolve_dense_quant_candidate(fam = _fam("z-image"), target = object(), requested = "auto")
is None
)
def test_candidate_disk_gate_spares_an_already_cached_prequant(monkeypatch):
"""Cached prequants cost no download, so the disk-space gate must spare them, or auto retries fail."""
import core.inference.diffusion_auto_policy as ap
import core.inference.diffusion_prequant as pq
_patch_selector(monkeypatch, scheme = "int8")
monkeypatch.setattr(
pq, "usable_prequant_source", lambda *a, **k: type("S", (), {"kind": "repo"})()
)
monkeypatch.setattr(pq, "prequant_checkpoint_cached", lambda *a, **k: True)
monkeypatch.setattr(ap, "_hf_cache_free_mib", lambda: 1024)
est = resolve_dense_quant_candidate(fam = _fam("z-image"), target = object(), requested = "auto")
assert isinstance(est, DenseQuantEstimate)
assert est.prequant is True
monkeypatch.setattr(pq, "prequant_checkpoint_cached", lambda *a, **k: False)
assert (
resolve_dense_quant_candidate(fam = _fam("z-image"), target = object(), requested = "auto")
is None
)
def test_a_local_override_is_never_gated_on_disk_space(monkeypatch):
"""A local path override costs no download; the disk-space gate must skip it, not re-check the cache."""
import core.inference.diffusion_auto_policy as ap
import core.inference.diffusion_prequant as pq
_patch_selector(monkeypatch, scheme = "int8")
monkeypatch.setattr(
pq, "usable_prequant_source", lambda *a, **k: type("S", (), {"kind": "path"})()
)
monkeypatch.setattr(pq, "prequant_checkpoint_cached", lambda *a, **k: False)
monkeypatch.setattr(ap, "_hf_cache_free_mib", lambda: 1024)
est = resolve_dense_quant_candidate(fam = _fam("z-image"), target = object(), requested = "auto")
assert isinstance(est, DenseQuantEstimate)
def test_the_cached_probe_is_pinned_to_the_active_cache_root(monkeypatch):
"""Pin the cache probe to the live cache root; huggingface_hub's import-time constant goes stale."""
import core.inference.diffusion_auto_policy as ap
import core.inference.diffusion_prequant as pq
import utils.hf_cache_settings as cache_settings
seen: list = []
_patch_selector(monkeypatch, scheme = "int8")
monkeypatch.setattr(
pq, "usable_prequant_source", lambda *a, **k: type("S", (), {"kind": "repo"})()
)
monkeypatch.setattr(cache_settings, "active_hf_hub_cache", lambda: "/live-root")
monkeypatch.setattr(
pq,
"prequant_checkpoint_cached",
lambda _src, **kw: (seen.append(kw.get("cache_dir")), True)[1],
)
monkeypatch.setattr(ap, "_hf_cache_free_mib", lambda: 1024)
resolve_dense_quant_candidate(fam = _fam("z-image"), target = object(), requested = "auto")
assert seen == ["/live-root"], seen
def test_candidate_disk_gate_unprobeable_disk_passes(monkeypatch):
import core.inference.diffusion_auto_policy as ap
_patch_selector(monkeypatch, scheme = "int8")
monkeypatch.setattr(ap, "_hf_cache_free_mib", lambda: None)
est = resolve_dense_quant_candidate(fam = _fam("z-image"), target = object(), requested = "auto")
assert isinstance(est, DenseQuantEstimate)
def test_disk_gate_sizes_fp32_families_by_their_real_download(monkeypatch):
# The disk gate counts HF cache bytes: Z-Image publishes fp32 shards (23,479 vs 11,730 MiB).
import core.inference.diffusion_auto_policy as ap
_patch_selector(monkeypatch, scheme = "int8")
est = ap.estimate_dense_quant(_fam("z-image"), "int8")
assert est.transient_transformer_mib == 11_730
assert est.download_transformer_mib == 23_460
monkeypatch.setattr(ap, "_hf_cache_free_mib", lambda: 11_730 + 10 * 1024 + 512)
assert (
resolve_dense_quant_candidate(fam = _fam("z-image"), target = object(), requested = "auto")
is None
)
monkeypatch.setattr(ap, "_hf_cache_free_mib", lambda: 23_460 + 10 * 1024 + 512)
assert isinstance(
resolve_dense_quant_candidate(fam = _fam("z-image"), target = object(), requested = "auto"),
DenseQuantEstimate,
)
def test_disk_gate_does_not_overcharge_a_family_published_below_bf16(monkeypatch):
# Ideogram 4 ships fp8 (17,718 MiB) and doubles to bf16, so resident size would over-refuse.
import core.inference.diffusion_auto_policy as ap
_patch_selector(monkeypatch, scheme = "int8")
est = ap.estimate_dense_quant(_fam("ideogram-4"), "int8")
assert est.transient_transformer_mib == 35_476
assert est.download_transformer_mib == 17_738
monkeypatch.setattr(ap, "_hf_cache_free_mib", lambda: 17_738 + 10 * 1024 + 512)
assert isinstance(
resolve_dense_quant_candidate(fam = _fam("ideogram-4"), target = object(), requested = "auto"),
DenseQuantEstimate,
)
def test_disk_gate_matches_download_for_bf16_published_families(monkeypatch):
import core.inference.diffusion_auto_policy as ap
for name in ("flux.1", "flux.2-dev", "qwen-image", "krea-2", "hidream-i1"):
est = ap.estimate_dense_quant(_fam(name), "int8")
assert est.download_transformer_mib == est.transient_transformer_mib, name
def test_candidate_none_for_an_unlisted_family(monkeypatch):
_patch_selector(monkeypatch)
assert (
resolve_dense_quant_candidate(fam = _fam("not-a-family"), target = object(), requested = "auto")
is None
)
def test_candidate_uses_prequant_transient_when_available(monkeypatch):
_patch_selector(monkeypatch, prequant = SimpleNamespace(kind = "repo", location = "org/int8"))
est = resolve_dense_quant_candidate(fam = _fam("z-image"), target = object(), requested = "int8")
assert est is not None and est.prequant is True
assert est.transient_transformer_mib == est.steady_transformer_mib
def test_disk_gate_reserves_the_checkpoint_not_the_dense_shards_for_a_hosted_prequant(monkeypatch):
# With a prequant source only the small quantised checkpoint is downloaded.
_patch_selector(
monkeypatch,
scheme = "int8",
prequant = SimpleNamespace(kind = "repo", location = "org/int8"),
)
est = ap.estimate_dense_quant(_fam("z-image"), "int8", prequant_available = True)
assert est.steady_transformer_mib == 6_451
assert est.download_transformer_mib == 23_460
monkeypatch.setattr(ap, "_hf_cache_free_mib", lambda: 6_451 + 10 * 1024 + 512)
gated = resolve_dense_quant_candidate(fam = _fam("z-image"), target = object(), requested = "int8")
assert isinstance(gated, DenseQuantEstimate) and gated.prequant is True
assert (
resolve_dense_quant_candidate(
fam = _fam("z-image"), target = object(), requested = "int8", force_dense = True
)
is None
)
def _cuda_target():
return SimpleNamespace(device = "cuda", supports_model_cpu_offload = True)
def test_quant_candidate_fits_resident_where_gguf_plan_offloads():
memory = DeviceMemory("cuda", "cuda", "discrete_vram", 30000, 32768)
z_bf16_gguf_mib = int(12.3 * ap._MIB_PER_GB * 1.05)
companions_mib = 2600
gguf_plan = plan_diffusion_memory(
target = _cuda_target(),
device_memory = memory,
model_dense_mib = z_bf16_gguf_mib + companions_mib,
companion_dense_mib = companions_mib,
runtime_headroom_mib = 6963,
)
assert gguf_plan.offload_policy != OFFLOAD_NONE
est = estimate_dense_quant(_fam("z-image"), "int8", prequant_available = True)
assert est is not None
assert est.transient_transformer_mib < z_bf16_gguf_mib / 1.8
quant_plan = plan_diffusion_memory(
target = _cuda_target(),
device_memory = memory,
model_dense_mib = est.transient_transformer_mib + companions_mib,
companion_dense_mib = companions_mib,
runtime_headroom_mib = 6963,
)
assert quant_plan.offload_policy == OFFLOAD_NONE
def test_resolved_record_marks_auto_and_explicit():
record = build_resolved_record(
{
"speed_mode": (None, "default", "per-kind default"),
"transformer_quant": ("auto", "fp8", "auto ladder"),
"attention_backend": ("cudnn", "_native_cudnn", "requested"),
"memory_mode": ("", "none", "planned"),
"cpu_offload": (True, True, "legacy flag"),
}
)
assert record["speed_mode"]["source"] == "auto"
assert record["transformer_quant"]["source"] == "auto"
assert record["attention_backend"]["source"] == "explicit"
assert record["memory_mode"]["source"] == "auto"
assert record["cpu_offload"]["source"] == "explicit"
assert record["transformer_quant"]["value"] == "fp8"
assert all("reason" in v for v in record.values())
def test_resolved_record_keeps_the_request_beside_the_engaged_value():
record = build_resolved_record(
{
"transformer_quant": ("fp8", "off", "the dense build did not fit", "fell_back"),
"text_encoder_quant": ("int8", "fp8", "no keep-bf16 schedule"),
"memory_mode": ("low_vram", "sequential", "planned"),
}
)
assert record["transformer_quant"]["requested"] == "fp8"
assert record["transformer_quant"]["value"] == "off"
assert record["transformer_quant"]["status"] == "fell_back"
assert record["text_encoder_quant"]["status"] == "fell_back"
# memory_mode requests a MODE but engages an offload POLICY, so honored is not a fallback.
assert record["memory_mode"]["status"] == "applied"
def test_resolved_record_treats_an_honored_off_request_as_applied():
record = build_resolved_record(
{
"transformer_quant": ("none", "off", "GGUF loaded"),
"text_encoder_quant": ("fp8", "fp8", "cast in place"),
"cpu_offload": (True, True, "legacy flag"),
}
)
assert record["transformer_quant"]["status"] == "applied"
assert record["text_encoder_quant"]["status"] == "applied"
assert record["cpu_offload"]["status"] == "applied"
def test_resolved_record_auto_never_reports_a_fallback():
record = build_resolved_record({"transformer_quant": (None, "off", "no CUDA")})
assert record["transformer_quant"]["source"] == "auto"
assert record["transformer_quant"]["requested"] is None
assert record["transformer_quant"]["status"] == "applied"
def test_precision_fallback_escape_hatch(monkeypatch):
monkeypatch.delenv("UNSLOTH_DIFFUSION_ALLOW_PRECISION_FALLBACK", raising = False)
assert precision_fallback_allowed() is False
monkeypatch.setenv("UNSLOTH_DIFFUSION_ALLOW_PRECISION_FALLBACK", "1")
assert precision_fallback_allowed() is True
monkeypatch.setenv("UNSLOTH_DIFFUSION_ALLOW_PRECISION_FALLBACK", "0")
assert precision_fallback_allowed() is False
def test_the_refusal_only_offers_auto_where_auto_exists():
msg = precision_refusal_message(
"transformer_quant",
"nvfp4",
"this GPU has no fp4 tensor cores",
off_label = "Off to run the checkpoint as-is",
)
assert "Choose Auto" in msg and msg.endswith("or Off to run the checkpoint as-is.")
# text_encoder_quant has no auto mode (fp8/fp8_dynamic/int8/nvfp4), so "Choose Auto" would 422.
te = precision_refusal_message(
"text_encoder_quant",
"int8",
"this device does not have the tensor cores that backend needs",
off_label = "leave it unset to keep the dense bf16 encoder",
auto_available = False,
)
assert "Auto" not in te
assert te.endswith("Leave it unset to keep the dense bf16 encoder.")
def test_every_family_with_a_hosted_prequant_can_be_sized():
"""Every family with a hosted prequant needs a size entry, or the loader downloads dense weights."""
from core.inference.diffusion_auto_policy import _FAMILY_BF16_GB
from core.inference.diffusion_families import _FAMILIES
unsizable = [
f.name
for f in _FAMILIES
if (getattr(f, "prequant_repos", ()) or ()) and f.name not in _FAMILY_BF16_GB
]
assert not unsizable, (
f"these families declare hosted pre-quant checkpoints the auto policy cannot size, so "
f"the seed is never chosen and the dense transformer is downloaded instead: {unsizable}"
)
def test_qwen_image_21_sizes_a_dense_quant_candidate():
"""The concrete case, with the numbers, so a wrong entry is as visible as a missing one."""
from core.inference.diffusion_auto_policy import _FAMILY_BF16_GB, estimate_dense_quant
from core.inference.diffusion_families import detect_family
fam = detect_family("Qwen/Qwen-Image-2.1")
transformer, encoders, vae = _FAMILY_BF16_GB[fam.name]
# From Qwen/Qwen-Image-2.1's own sibling metadata: 14.23 / 17.53 / 1.35 GB, bf16 on disk.
assert 13.5 < transformer < 15.0, transformer
assert 17.0 < encoders < 18.0, encoders
assert 1.0 < vae < 2.0, vae
assert (transformer, encoders, vae) != _FAMILY_BF16_GB["qwen-image"]
assert transformer < _FAMILY_BF16_GB["qwen-image"][0]
assert encoders > _FAMILY_BF16_GB["qwen-image"][1]
est = estimate_dense_quant(fam, "fp8", base_repo = fam.base_repo, prequant_available = True)
assert est is not None, "no estimate means the pipeline seed is never chosen"
assert est.prequant and est.steady_transformer_mib > 0
def test_resolved_log_line_shows_engaged_values_and_their_source():
record = build_resolved_record(
{
"transformer_quant": (None, "int8", "per-kind default"),
"text_encoder_quant": ("nvfp4", "nvfp4", "applied"),
"memory_mode": ("fast", "none", "fits"),
}
)
line = ap.format_resolved_for_log(record)
assert "transformer_quant=int8(auto)" in line
assert "text_encoder_quant=nvfp4(requested nvfp4)" in line
assert "memory_mode=none(requested fast)" in line
def test_resolved_log_line_flags_a_declined_request():
record = build_resolved_record({"text_encoder_quant": ("nvfp4", "off", "no fp8 dtype")})
assert ap.format_resolved_for_log(record) == (
f"text_encoder_quant=off(requested nvfp4, {ap.RESOLVED_FELL_BACK})"
)
assert ap.format_resolved_for_log(None) == ""
def test_generation_log_line_reads_the_recipe_fields():
result = {
"images": [SimpleNamespace(size = (1024, 768)), SimpleNamespace(size = (1024, 768))],
"seed": 7,
"seeds": [7, 8],
"workflow": "inpaint",
"active_loras": [["style", 0.8]],
"reference_resolution": None,
"localized_edit": None,
}
line = ap.format_generation_for_log(result, engine = "diffusers", steps = 30, strength = 0.6)
assert line == (
"engine=diffusers workflow=inpaint images=2 size=1024x768 seeds=[7, 8] steps=30 "
"strength=0.6 loras=[['style', 0.8]]"
)
assert "size" not in ap.format_generation_for_log({"images": []}, engine = "sd_cpp")
def test_generation_log_line_prefers_the_engine_supplied_loras():
result = {"images": [], "seeds": [3], "workflow": "txt2img"}
line = ap.format_generation_for_log(result, engine = "sd_cpp", loras = [("style", 0.8)])
assert line == "engine=sd_cpp workflow=txt2img images=0 seeds=[3] loras=[('style', 0.8)]"