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 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) == []