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.

23.6 KB
Raw Blame
# 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)]"