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.8 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 tests for the LoRA trainer's pure helpers; the training loop needs a GPU and weights."""

from __future__ import annotations

import json

import pytest

from core.training.diffusion_lora_trainer import (
    DEFAULT_LORA_TARGETS,
    DiffusionLoraConfig,
    _coerce_gradient_checkpointing,
    _config_from_dict,
    compute_sdxl_add_time_ids,
    discover_image_caption_pairs,
    resolve_train_steps,
)


def _touch(p):
    p.write_bytes(b"")


def test_discover_prefers_sidecar_then_metadata_then_instance(tmp_path):
    _touch(tmp_path / "a.png")
    _touch(tmp_path / "b.jpg")
    _touch(tmp_path / "c.webp")
    (tmp_path / "metadata.jsonl").write_text(
        json.dumps({"file_name": "a.png", "text": "from metadata"}) + "\n", encoding = "utf-8"
    )
    (tmp_path / "b.txt").write_text("from sidecar", encoding = "utf-8")
    pairs = dict(discover_image_caption_pairs(tmp_path, instance_prompt = "from instance"))
    assert pairs[str(tmp_path / "a.png")] == "from metadata"
    assert pairs[str(tmp_path / "b.jpg")] == "from sidecar"
    assert pairs[str(tmp_path / "c.webp")] == "from instance"


def test_discover_sidecar_overrides_metadata_row(tmp_path):
    _touch(tmp_path / "a.png")
    (tmp_path / "metadata.jsonl").write_text(
        json.dumps({"file_name": "a.png", "text": "from metadata"}) + "\n", encoding = "utf-8"
    )
    (tmp_path / "a.txt").write_text("edited sidecar", encoding = "utf-8")
    pairs = dict(discover_image_caption_pairs(tmp_path))
    assert pairs[str(tmp_path / "a.png")] == "edited sidecar"


def test_discover_empty_sidecar_suppresses_metadata_but_uses_instance_prompt(tmp_path):
    # An empty sidecar suppresses the metadata caption but leaves instance_prompt applicable.
    _touch(tmp_path / "cat.png")
    (tmp_path / "metadata.jsonl").write_text(
        json.dumps({"file_name": "cat.png", "text": "old metadata caption"}) + "\n",
        encoding = "utf-8",
    )
    (tmp_path / "cat.txt").write_text("", encoding = "utf-8")
    pairs = discover_image_caption_pairs(tmp_path, instance_prompt = "a photo of sks cat")
    assert pairs == [(str(tmp_path / "cat.png"), "a photo of sks cat")]


def test_discover_empty_sidecar_without_instance_prompt_skips_image(tmp_path):
    _touch(tmp_path / "cat.png")
    _touch(tmp_path / "cap.png")
    (tmp_path / "metadata.jsonl").write_text(
        json.dumps({"file_name": "cat.png", "text": "old"})
        + "\n"
        + json.dumps({"file_name": "cap.png", "text": "kept"})
        + "\n",
        encoding = "utf-8",
    )
    (tmp_path / "cat.txt").write_text("", encoding = "utf-8")
    pairs = dict(discover_image_caption_pairs(tmp_path))
    assert pairs == {str(tmp_path / "cap.png"): "kept"}


def test_discover_reads_invalid_utf8_sidecar_as_tombstone(tmp_path):
    _touch(tmp_path / "cat.png")
    (tmp_path / "cat.txt").write_bytes(b"\xff\xfe not utf-8")
    pairs = discover_image_caption_pairs(tmp_path, instance_prompt = "a photo of sks cat")
    assert pairs == [(str(tmp_path / "cat.png"), "a photo of sks cat")]


def test_discover_null_metadata_caption_is_not_the_string_none(tmp_path):
    _touch(tmp_path / "cat.png")
    (tmp_path / "metadata.jsonl").write_text(
        json.dumps({"file_name": "cat.png", "text": None}) + "\n", encoding = "utf-8"
    )
    pairs = discover_image_caption_pairs(tmp_path, instance_prompt = "a photo of sks cat")
    assert pairs == [(str(tmp_path / "cat.png"), "a photo of sks cat")]


def test_discover_skips_uncaptioned_without_instance_prompt(tmp_path):
    _touch(tmp_path / "cap.png")
    _touch(tmp_path / "nocap.png")
    (tmp_path / "cap.caption").write_text("a caption", encoding = "utf-8")
    pairs = discover_image_caption_pairs(tmp_path)
    assert pairs == [(str(tmp_path / "cap.png"), "a caption")]


def test_discover_captions_jsonl_and_image_key(tmp_path):
    _touch(tmp_path / "x.png")
    (tmp_path / "captions.jsonl").write_text(
        json.dumps({"image": "x.png", "text": "hi"}) + "\n", encoding = "utf-8"
    )
    assert discover_image_caption_pairs(tmp_path) == [(str(tmp_path / "x.png"), "hi")]


def test_discover_tolerates_non_object_and_invalid_utf8_jsonl(tmp_path):
    _touch(tmp_path / "x.png")
    (tmp_path / "metadata.jsonl").write_text(
        '[]\nnull\n"str"\n123\n{not json\n'
        + json.dumps({"file_name": "x.png", "text": "hi"})
        + "\n",
        encoding = "utf-8",
    )
    assert discover_image_caption_pairs(tmp_path) == [(str(tmp_path / "x.png"), "hi")]
    _touch(tmp_path / "y.png")
    (tmp_path / "captions.jsonl").write_bytes(b"\xff\xfe not utf-8\n")
    pairs = dict(discover_image_caption_pairs(tmp_path, instance_prompt = "fallback"))
    assert pairs[str(tmp_path / "y.png")] == "fallback"


def test_discover_custom_caption_column(tmp_path):
    _touch(tmp_path / "x.png")
    (tmp_path / "metadata.jsonl").write_text(
        json.dumps({"file_name": "x.png", "caption": "col"}) + "\n", encoding = "utf-8"
    )
    assert discover_image_caption_pairs(tmp_path, caption_column = "caption")[0][1] == "col"


def test_discover_verify_images_rejects_undecodable(tmp_path):
    # verify_images must reject before the route frees resident GPU models; trainers leave it off.
    from PIL import Image

    good = tmp_path / "good.png"
    Image.new("RGB", (8, 8), "white").save(good)
    (tmp_path / "good.txt").write_text("ok", encoding = "utf-8")
    # A zero-byte file with an image extension passes filename-only discovery.
    bad = tmp_path / "bad.png"
    bad.write_bytes(b"")
    (tmp_path / "bad.txt").write_text("broken", encoding = "utf-8")

    pairs = dict(discover_image_caption_pairs(tmp_path))
    assert str(bad) in pairs and str(good) in pairs

    with pytest.raises(ValueError, match = "cannot be decoded"):
        discover_image_caption_pairs(tmp_path, verify_images = True)

    bad.unlink()
    (tmp_path / "bad.txt").unlink()
    assert discover_image_caption_pairs(tmp_path, verify_images = True) == [(str(good), "ok")]


def test_discover_empty_raises(tmp_path):
    _touch(tmp_path / "x.png")
    with pytest.raises(ValueError, match = "No captioned images"):
        discover_image_caption_pairs(tmp_path)


def test_discover_missing_dir_raises(tmp_path):
    with pytest.raises(FileNotFoundError):
        discover_image_caption_pairs(tmp_path / "nope")


def test_config_normalized_defaults():
    cfg = DiffusionLoraConfig(base_model = "b", data_dir = "d", output_dir = "o").normalized()
    assert cfg.lora_alpha == cfg.lora_rank
    assert cfg.lora_target_modules == DEFAULT_LORA_TARGETS


@pytest.mark.parametrize(
    "kw",
    [
        {"train_steps": 0},
        {"train_batch_size": 0},
        {"gradient_accumulation_steps": 0},
        {"lora_rank": 0},
        {"resolution": 100},
        {"resolution": 32},
        {"mixed_precision": "int4"},
    ],
)
def test_config_normalized_validation(kw):
    with pytest.raises(ValueError):
        DiffusionLoraConfig(base_model = "b", data_dir = "d", output_dir = "o", **kw).normalized()


def test_config_normalized_accepts_mxfp8_dense_base():
    cfg = DiffusionLoraConfig(
        base_model = "black-forest-labs/FLUX.1-dev",
        data_dir = "d",
        output_dir = "o",
        base_precision = "mxfp8",
    ).normalized()
    assert cfg.base_precision == "mxfp8"


def test_config_normalized_mxfp8_rejects_prequant_base():
    with pytest.raises(ValueError, match = "mxfp8"):
        DiffusionLoraConfig(
            base_model = "unsloth/Qwen-Image-2512-unsloth-bnb-4bit",
            data_dir = "d",
            output_dir = "o",
            base_precision = "mxfp8",
        ).normalized()


def test_config_normalized_mxfp8_requires_bf16_compute():
    with pytest.raises(ValueError, match = "mxfp8"):
        DiffusionLoraConfig(
            base_model = "black-forest-labs/FLUX.1-dev",
            data_dir = "d",
            output_dir = "o",
            base_precision = "mxfp8",
            mixed_precision = "fp16",
        ).normalized()


def test_config_normalized_lists_mxfp8_in_invalid_mode_error():
    with pytest.raises(ValueError, match = "mxfp8"):
        DiffusionLoraConfig(
            base_model = "b", data_dir = "d", output_dir = "o", base_precision = "bogus"
        ).normalized()


def test_config_normalized_krea2_requires_bf16_compute():
    # krea-2 has fp32 RoPE/embedder internals that overflow fp16; refuse before evicting GPU models.
    with pytest.raises(ValueError, match = "bf16"):
        DiffusionLoraConfig(
            base_model = "b",
            data_dir = "d",
            output_dir = "o",
            model_family = "krea-2",
            mixed_precision = "fp16",
        ).normalized()


def test_force_bf16_families_matches_trainer_specs():
    # Must list every family whose trainer refuses fp16, else fp16 passes preflight and evicts residents.
    # MiniMax-H3 declares it on its own trainer, so the set is a union, not just _SPECS.
    from core.training.diffusion_dit_trainer import _SPECS
    from core.training.diffusion_train_common import _FORCE_BF16_FAMILIES

    dit_bf16_only = {fam for fam, spec in _SPECS.items() if spec.force_bf16}
    assert dit_bf16_only <= _FORCE_BF16_FAMILIES
    assert _FORCE_BF16_FAMILIES - dit_bf16_only == {"minimax-h3"}


def _cfg(**kw):
    return DiffusionLoraConfig(base_model = "b", data_dir = "d", output_dir = "o", **kw)


def test_resolve_train_steps_uses_train_steps_when_epochs_disabled():
    cfg = _cfg(train_steps = 300, num_epochs = 0)
    assert resolve_train_steps(cfg, 20) == 300
    assert resolve_train_steps(cfg, 1) == 300


def test_resolve_train_steps_epochs_ceil_over_batch_and_grad_accum():
    # One epoch = ceil(N / (batch x grad_accum)) optimizer steps.
    assert resolve_train_steps(_cfg(num_epochs = 1, train_batch_size = 4), 10) == 3
    assert resolve_train_steps(_cfg(num_epochs = 5, train_batch_size = 4), 10) == 15
    cfg = _cfg(num_epochs = 2, train_batch_size = 2, gradient_accumulation_steps = 3)
    assert resolve_train_steps(cfg, 100) == 34
    assert resolve_train_steps(_cfg(num_epochs = 3, train_batch_size = 4), 8) == 6


def test_resolve_train_steps_single_image_dataset():
    assert resolve_train_steps(_cfg(num_epochs = 7, train_batch_size = 4), 1) == 7


def test_resolve_train_steps_caps_at_100000():
    cfg = _cfg(num_epochs = 1000, train_batch_size = 1)
    assert resolve_train_steps(cfg, 10_000) == 100000


def test_config_normalized_num_epochs_bounds():
    assert _cfg(num_epochs = 0).normalized().num_epochs == 0
    assert _cfg(num_epochs = 1000).normalized().num_epochs == 1000
    with pytest.raises(ValueError, match = "num_epochs"):
        _cfg(num_epochs = -1).normalized()
    with pytest.raises(ValueError, match = "num_epochs"):
        _cfg(num_epochs = 1001).normalized()


def test_config_from_dict_threads_num_epochs():
    cfg = _config_from_dict(
        {"base_model": "b", "data_dir": "d", "output_dir": "o", "num_epochs": 12}
    )
    assert cfg.num_epochs == 12


def test_normalized_rejects_piecewise_constant():
    # piecewise_constant needs step_rules the trainers never supply; it would crash after the GPU is freed.
    with pytest.raises(ValueError, match = "lr_scheduler"):
        DiffusionLoraConfig(
            base_model = "b", data_dir = "d", output_dir = "o", lr_scheduler = "piecewise_constant"
        ).normalized()


def test_normalized_accepts_supported_schedulers():
    for sched in (
        "linear",
        "cosine",
        "cosine_with_restarts",
        "polynomial",
        "constant",
        "constant_with_warmup",
    ):
        cfg = DiffusionLoraConfig(
            base_model = "b", data_dir = "d", output_dir = "o", lr_scheduler = sched
        ).normalized()
        assert cfg.lr_scheduler == sched


def test_api_scheduler_enum_never_advertises_a_rejected_scheduler():
    import typing

    from core.training.diffusion_train_common import _LR_SCHEDULERS
    from models.training import DiffusionTrainingStartRequest

    api_options = set(
        typing.get_args(DiffusionTrainingStartRequest.model_fields["lr_scheduler"].annotation)
    )
    assert api_options and api_options <= _LR_SCHEDULERS, api_options - _LR_SCHEDULERS
    assert "piecewise_constant" not in api_options


def test_compute_sdxl_add_time_ids():
    assert compute_sdxl_add_time_ids(1024) == (1024, 1024, 0, 0, 1024, 1024)


def test_config_from_dict_ignores_unknown_and_tuples_targets():
    cfg = _config_from_dict(
        {
            "base_model": "b",
            "data_dir": "d",
            "output_dir": "o",
            "lora_target_modules": ["to_q", "to_v"],
            "unknown_field": 123,
        }
    )
    assert cfg.lora_target_modules == ("to_q", "to_v")
    assert not hasattr(cfg, "unknown_field")


def test_config_rejects_zero_lora_alpha():
    with pytest.raises(ValueError, match = "lora_alpha"):
        DiffusionLoraConfig(base_model = "b", data_dir = "d", output_dir = "o", lora_alpha = 0).normalized()


def test_config_rejects_nonpositive_snr_gamma():
    with pytest.raises(ValueError, match = "snr_gamma"):
        DiffusionLoraConfig(base_model = "b", data_dir = "d", output_dir = "o", snr_gamma = 0).normalized()
    cfg = DiffusionLoraConfig(
        base_model = "b", data_dir = "d", output_dir = "o", snr_gamma = None
    ).normalized()
    assert cfg.snr_gamma is None


def test_config_coerces_string_learning_rate():
    cfg = DiffusionLoraConfig(
        base_model = "b", data_dir = "d", output_dir = "o", learning_rate = "1e-4"
    ).normalized()
    assert cfg.learning_rate == 1e-4
    with pytest.raises(ValueError, match = "learning_rate"):
        DiffusionLoraConfig(
            base_model = "b", data_dir = "d", output_dir = "o", learning_rate = "abc"
        ).normalized()


def test_config_blank_hf_token_is_anonymous():
    cfg = DiffusionLoraConfig(
        base_model = "b", data_dir = "d", output_dir = "o", hf_token = "   "
    ).normalized()
    assert cfg.hf_token is None


def test_config_from_dict_aliases_generic_studio_keys():
    cfg = _config_from_dict(
        {
            "model_name": "b",
            "data_dir": "d",
            "output_dir": "o",
            "max_steps": 25,
            "batch_size": 3,
            "lora_r": 8,
            "lr_scheduler_type": "cosine",
            "random_seed": 7,
        }
    )
    assert cfg.base_model == "b"
    assert cfg.train_steps == 25
    assert cfg.train_batch_size == 3
    assert cfg.lora_rank == 8
    assert cfg.lr_scheduler == "cosine"
    assert cfg.seed == 7


def test_config_from_dict_canonical_key_beats_alias():
    cfg = _config_from_dict(
        {"base_model": "canon", "model_name": "alias", "data_dir": "d", "output_dir": "o"}
    )
    assert cfg.base_model == "canon"


def test_gradient_checkpointing_string_coercion():
    for off in ("none", "None", "false", "0", "no", "off", ""):
        assert _coerce_gradient_checkpointing(off) is False
    for on in ("true", "unsloth", "yes"):
        assert _coerce_gradient_checkpointing(on) is True
    assert _coerce_gradient_checkpointing(True) is True
    assert _coerce_gradient_checkpointing(False) is False
    cfg = _config_from_dict(
        {"base_model": "b", "data_dir": "d", "output_dir": "o", "gradient_checkpointing": "none"}
    )
    assert cfg.gradient_checkpointing is False


def test_config_rejects_nonpositive_learning_rate():
    with pytest.raises(ValueError, match = "learning_rate"):
        DiffusionLoraConfig(
            base_model = "b", data_dir = "d", output_dir = "o", learning_rate = 0
        ).normalized()


def test_config_rejects_untrainable_base_models():
    for bad in (
        "unsloth/FLUX.1-dev-GGUF",
        "z-image-turbo-Q4_K_M.gguf",
        "stabilityai/stable-diffusion-3-medium",
        "unsloth/FLUX.1-Kontext-dev",
    ):
        with pytest.raises(ValueError):
            DiffusionLoraConfig(base_model = bad, data_dir = "d", output_dir = "o").normalized()


def test_config_resolves_dit_families():
    for base, fam in (
        ("black-forest-labs/FLUX.1-dev", "flux.1"),
        ("black-forest-labs/FLUX.1-schnell", "flux.1"),
        ("unsloth/Qwen-Image-2512-unsloth-bnb-4bit", "qwen-image"),
        ("Tongyi-MAI/Z-Image-Turbo", "z-image"),
    ):
        cfg = DiffusionLoraConfig(base_model = base, data_dir = "d", output_dir = "o").normalized()
        assert cfg.resolved_family == fam


def test_config_accepts_sdxl_and_unknown_base_models():
    # Unclassifiable custom names must pass; a wrong custom pick still fails cleanly later.
    for ok in (
        "stabilityai/stable-diffusion-xl-base-1.0",
        "stabilityai/sdxl-turbo",
        "/data/checkpoints/my-custom-sdxl",
        "my-finetune",
    ):
        cfg = DiffusionLoraConfig(base_model = ok, data_dir = "d", output_dir = "o").normalized()
        assert cfg.base_model == ok


def test_get_trainer_resolves_sdxl():
    from core.training.diffusion_lora_trainer import get_trainer, run_diffusion_lora_training
    assert get_trainer("sdxl") is run_diffusion_lora_training
    assert get_trainer("SDXL") is run_diffusion_lora_training


def test_get_trainer_unknown_family_raises():
    from core.training.diffusion_lora_trainer import get_trainer
    with pytest.raises(ValueError, match = "No trainer"):
        get_trainer("flux.1-kontext")


def test_get_trainer_resolves_dit_families():
    from core.training.diffusion_dit_trainer import run_dit_lora_training
    from core.training.diffusion_lora_trainer import get_trainer
    for fam in ("flux.1", "qwen-image", "z-image", "flux.2-klein", "flux.2-dev"):
        assert get_trainer(fam) is run_dit_lora_training


def test_normalized_sets_resolved_family():
    cfg = DiffusionLoraConfig(
        base_model = "stabilityai/stable-diffusion-xl-base-1.0", data_dir = "d", output_dir = "o"
    ).normalized()
    assert cfg.resolved_family == "sdxl"
    cfg2 = DiffusionLoraConfig(
        base_model = "my-custom-thing", data_dir = "d", output_dir = "o"
    ).normalized()
    assert cfg2.resolved_family == "sdxl"


def test_explicit_model_family_validated():
    from core.training.diffusion_lora_trainer import DiffusionLoraConfig as C

    with pytest.raises(ValueError, match = "Unknown model_family"):
        C(base_model = "b", data_dir = "d", output_dir = "o", model_family = "not-a-family").normalized()
    with pytest.raises(ValueError):
        C(base_model = "b", data_dir = "d", output_dir = "o", model_family = "flux.1-kontext").normalized()
    assert (
        C(base_model = "b", data_dir = "d", output_dir = "o", model_family = "flux.1")
        .normalized()
        .resolved_family
        == "flux.1"
    )
    assert (
        C(base_model = "b", data_dir = "d", output_dir = "o", model_family = "sdxl")
        .normalized()
        .resolved_family
        == "sdxl"
    )


def test_publish_writes_metadata_sidecar(tmp_path, monkeypatch):
    import json as _json
    from pathlib import Path

    from core.inference import diffusion_lora
    from core.training.diffusion_lora_trainer import _publish_to_lora_catalog

    loras = tmp_path / "loras"
    loras.mkdir()
    monkeypatch.setattr(diffusion_lora, "loras_dir", lambda: loras)

    src = tmp_path / "run" / "pytorch_lora_weights.safetensors"
    src.parent.mkdir(parents = True)
    src.write_bytes(b"fake-adapter")
    cfg = DiffusionLoraConfig(
        base_model = "stabilityai/sdxl-turbo",
        data_dir = "d",
        output_dir = str(tmp_path / "run"),
        adapter_name = "my.style",
        instance_prompt = "a photo in sks style",
        lora_rank = 8,
    ).normalized()

    dest = _publish_to_lora_catalog(str(src), cfg)
    assert dest is not None
    sidecar = Path(dest).with_suffix(".json")
    assert sidecar.is_file()
    meta = _json.loads(sidecar.read_text())
    assert meta["family"] == "sdxl"
    assert meta["families"] == ["sdxl"]
    assert meta["base_model"] == "stabilityai/sdxl-turbo"
    assert meta["lora_rank"] == 8
    assert meta["trigger_prompt"] == "a photo in sks style"
    assert meta["source"] == "studio-trained"
    assert meta["kind"] == "diffusion-lora"


def test_publish_does_not_clobber_same_name_adapter(tmp_path, monkeypatch):
    from pathlib import Path

    from core.inference import diffusion_lora
    from core.training.diffusion_lora_trainer import _publish_to_lora_catalog

    loras = tmp_path / "loras"
    loras.mkdir()
    monkeypatch.setattr(diffusion_lora, "loras_dir", lambda: loras)

    def _publish(payload: bytes) -> str:
        src = tmp_path / "run" / "pytorch_lora_weights.safetensors"
        src.parent.mkdir(parents = True, exist_ok = True)
        src.write_bytes(payload)
        cfg = DiffusionLoraConfig(
            base_model = "stabilityai/sdxl-turbo",
            data_dir = "d",
            output_dir = str(tmp_path / "run"),
            adapter_name = "my-style",
        ).normalized()
        return _publish_to_lora_catalog(str(src), cfg)

    first = _publish(b"adapter-v1")
    second = _publish(b"adapter-v2")
    assert Path(first).name == "my-style.safetensors"
    assert Path(second).name == "my-style-2.safetensors"
    assert Path(first).read_bytes() == b"adapter-v1"
    assert Path(second).read_bytes() == b"adapter-v2"
    assert Path(second).with_suffix(".json").is_file()


def test_config_rejects_bad_lr_scheduler():
    with pytest.raises(ValueError, match = "lr_scheduler"):
        DiffusionLoraConfig(
            base_model = "b", data_dir = "d", output_dir = "o", lr_scheduler = "constnat"
        ).normalized()
    cfg = DiffusionLoraConfig(
        base_model = "b", data_dir = "d", output_dir = "o", lr_scheduler = "cosine"
    ).normalized()
    assert cfg.lr_scheduler == "cosine"


def test_config_rejects_fp16_on_bf16_only_family():
    for base in ("Tongyi-MAI/Z-Image-Turbo", "unsloth/Qwen-Image-2512-unsloth-bnb-4bit"):
        with pytest.raises(ValueError, match = "bf16"):
            DiffusionLoraConfig(
                base_model = base, data_dir = "d", output_dir = "o", mixed_precision = "fp16"
            ).normalized()
    cfg = DiffusionLoraConfig(
        base_model = "black-forest-labs/FLUX.1-dev",
        data_dir = "d",
        output_dir = "o",
        mixed_precision = "fp16",
    ).normalized()
    assert cfg.mixed_precision == "fp16"


def test_gguf_substring_does_not_reject_local_diffusers_dir(tmp_path):
    # A local path merely containing 'gguf' is a valid base; the substring check must not reject it.
    from core.training.diffusion_train_common import resolve_trainable_family

    local = tmp_path / "my-gguf-experiments" / "sdxl-finetune"
    local.mkdir(parents = True)
    (local / "model_index.json").write_text("{}", encoding = "utf-8")
    assert resolve_trainable_family(str(local)) == "sdxl"
    with pytest.raises(ValueError, match = "GGUF"):
        resolve_trainable_family(str(local / "weights.gguf"))
    with pytest.raises(ValueError, match = "GGUF"):
        resolve_trainable_family("unsloth/FLUX.1-dev-GGUF")


def test_sdxl_warns_when_an_unused_accelerator_leaves_it_on_the_cpu(monkeypatch, tmp_path):
    pytest.importorskip("diffusers")
    import torch
    from PIL import Image

    import core.training.diffusion_lora_trainer as sdxl

    data = tmp_path / "data"
    data.mkdir()
    Image.new("RGB", (64, 64)).save(data / "a.png")
    monkeypatch.setattr(sdxl, "_assert_trusted_base_model", lambda *_a, **_k: None)
    monkeypatch.setattr(torch.cuda, "is_available", lambda: False)
    monkeypatch.setattr(torch.xpu, "is_available", lambda: False)
    cfg = DiffusionLoraConfig(
        base_model = "stabilityai/stable-diffusion-xl-base-1.0",
        data_dir = str(data),
        output_dir = str(tmp_path / "out"),
        instance_prompt = "a photo",
    )

    def warnings_for(mps):
        monkeypatch.setattr(torch.backends.mps, "is_available", lambda: mps)
        events = []
        sdxl.run_diffusion_lora_training(cfg, on_event = events.append, should_stop = lambda: True)
        return [e for e in events if e.get("type") == "warning" and "CPU" in e.get("message", "")]

    # A Mac (MPS present, SDXL trains on the CPU) is told why the run is slow; a CPU-only host is not.
    assert len(warnings_for(True)) == 1
    assert warnings_for(False) == []