MMnode/tests/test_moxie_nodes.py
Z User 88849ced65 refactor: remove the LoRA pipeline; distill weights ship baked into the model
The 3-step distill (speedup) LoRA is now baked into the diffusion model
itself, so the Moxie Multimedia Loader no longer applies any LoRA:

- moxie_loader.py: drop the models/loras scan, _auto_lora(), the module
  level LoRA cache and _apply_lora(); the load chain is now
  diffusion model -> attention backend -> CLIP -> VAEs. A leftover file
  in models/loras is silently ignored and the folder can be deleted.
- moxie_project.py / moxie_preview.py: tooltips reference the baked-in
  distill instead of the LoRA.
- tests + standalone loader script: assert no load_lora_for_models call
  happens (the comfy.sd stub now raises if the loader tries), and fix
  the pre-existing MMnode.tiny_vae stub gap (missing pack_vae_approx_files)
  that broke the whole test module at fixture setup.
- README: models table drops the Turbo LoRA row; CHANGELOG entry added.

Node schema, outputs and sampling behavior are unchanged; workflows
saved before this change keep working.
2026-10-13 03:34:47 +00:00

563 lines
19 KiB
Python

"""Regression tests for the consolidated Moxie node contracts.
These tests follow the self-contained stubbing pattern of
test_common_nodes.py so they run without a full ComfyUI installation.
Verified contracts:
- MoxieMultimediaLoader: outputs exactly (model, clip, video_vae, audio_vae);
no legacy FAST_MODEL_LOADER bundle output; no clip_type choice (the CLIP
recipe is locked to CLIPType.MINIMAX); the model output has the attention
backend applied, and any leftover file in models/loras is ignored (the
distill weights ship baked into the diffusion model).
- MoxieProject: takes model/clip/video_vae/audio_vae as required direct
inputs instead of a bundled model_loader, and packs them into the loader
dict consumed internally by EasyMultiTrackProject.
- MoxiePreviewOverride (ModelPreviewOverrideKJ): patches the model input
directly; no model_loader pass-through slots.
"""
import enum
import importlib.util
import sys
import types
from pathlib import Path
import pytest
REPO = Path(__file__).resolve().parents[1]
class _Port:
def __init__(self, name=None, **kwargs):
self.name = name
self.kwargs = kwargs
class _PortType:
@staticmethod
def Input(name, **kwargs):
return _Port(name, **kwargs)
@staticmethod
def Output(name=None, **kwargs):
return _Port(name, **kwargs)
class _NodeOutput:
def __init__(self, *values):
self.values = values
class _Schema:
def __init__(self, **kwargs):
self.__dict__.update(kwargs)
def _build_io():
io = types.SimpleNamespace()
io.AnyType = _PortType
io.Audio = _PortType
io.Boolean = _PortType
io.Clip = _PortType
io.Combo = _PortType
io.Float = _PortType
io.Image = _PortType
io.Int = _PortType
io.Model = _PortType
io.Sampler = _PortType
io.Sigmas = _PortType
io.String = _PortType
io.Vae = _PortType
io.Video = _PortType
io.Custom = lambda **kwargs: _PortType
io.NodeOutput = _NodeOutput
io.Schema = _Schema
io.Hidden = types.SimpleNamespace(prompt="prompt", unique_id="unique_id")
io.ControlAfterGenerate = types.SimpleNamespace(randomize="randomize")
io.InputImpl = type("InputImpl", (), {})
class _ComfyNode:
hidden = types.SimpleNamespace(unique_id="0", prompt={})
io.ComfyNode = _ComfyNode
return io
class _FakeModel:
"""Minimal model stand-in recording attention/clone/wrapper calls."""
def __init__(self, label="model"):
self.label = label
self.attention_fn = None
self.wrappers = []
def clone(self):
clone = _FakeModel(self.label + ".clone")
clone.attention_fn = self.attention_fn
return clone
def set_model_optimized_attention(self, attention_fn):
self.attention_fn = attention_fn
def add_wrapper_with_key(self, key, *args):
self.wrappers.append((key,) + tuple(args))
def get_model_object(self, name):
return name
class _FakeVAE:
def __init__(self, sd=None, metadata=None):
self.sd = sd
self.metadata = metadata
def throw_exception_if_invalid(self):
pass
class _StubState:
"""Shared recorders/sentinels for the comfy.* stubs."""
def __init__(self):
self.calls = []
self.attention_fn = lambda pixels, *a, **k: pixels
self.clip = object()
def _register(state, io, monkeypatch=None):
"""Build the ComfyUI stub modules and return {name: module} to install."""
modules = {}
comfy_api = types.ModuleType("comfy_api")
comfy_api_latest = types.ModuleType("comfy_api.latest")
comfy_api_latest.io = io
comfy_api_latest.InputImpl = io.InputImpl
comfy_api.latest = comfy_api_latest
modules["comfy_api"] = comfy_api
modules["comfy_api.latest"] = comfy_api_latest
comfy = types.ModuleType("comfy")
comfy_sd = types.ModuleType("comfy.sd")
class CLIPType(enum.Enum):
STABLE_DIFFUSION = "stable_diffusion"
WAN = "wan"
LTXV = "ltxv"
MINIMAX = "minimax"
state.CLIPType = CLIPType
def load_diffusion_model(path, model_options=None):
state.calls.append(("load_diffusion_model", path))
return _FakeModel("diffusion")
def load_clip(ckpt_paths, embedding_directory=None, clip_type=None, model_options=None):
state.calls.append(("load_clip", clip_type))
return state.clip
def load_lora_for_models(model, clip, lora_sd, strength_model, strength_clip, lora_metadata=None):
raise AssertionError("MoxieMultimediaLoader must not load LoRAs anymore")
comfy_sd.CLIPType = CLIPType
comfy_sd.load_diffusion_model = load_diffusion_model
comfy_sd.load_clip = load_clip
comfy_sd.load_lora_for_models = load_lora_for_models
comfy_sd.VAE = _FakeVAE
modules["comfy.sd"] = comfy_sd
comfy_utils = types.ModuleType("comfy.utils")
def load_torch_file(path, safe_load=False, return_metadata=False, device=None):
state.calls.append(("load_torch_file", str(path)))
if return_metadata:
return {}, {"source": str(path)}
return {}
comfy_utils.load_torch_file = load_torch_file
comfy_utils.state_dict_prefix_replace = lambda sd, mapping, filter_keys=False: sd
comfy_utils.ProgressBar = type("ProgressBar", (), {"update_absolute": lambda *a, **k: None})
modules["comfy.utils"] = comfy_utils
comfy_ldm = types.ModuleType("comfy.ldm")
comfy_ldm_modules = types.ModuleType("comfy.ldm.modules")
comfy_attention = types.ModuleType("comfy.ldm.modules.attention")
def get_attention_function(attention_name, extra_options=None):
state.calls.append(("get_attention_function", attention_name))
return state.attention_fn
comfy_attention.get_attention_function = get_attention_function
modules["comfy.ldm"] = comfy_ldm
modules["comfy.ldm.modules"] = comfy_ldm_modules
modules["comfy.ldm.modules.attention"] = comfy_attention
comfy_samplers = types.ModuleType("comfy.samplers")
def calculate_sigmas(model_sampling, scheduler, steps):
import torch
state.calls.append(("calculate_sigmas", scheduler, steps))
return torch.linspace(1.0, 0.0, steps + 1)
comfy_samplers.calculate_sigmas = calculate_sigmas
comfy_samplers.sampler_object = lambda name: ("sampler", name)
modules["comfy.samplers"] = comfy_samplers
comfy_patcher = types.ModuleType("comfy.patcher_extension")
comfy_patcher.WrappersMP = types.SimpleNamespace(OUTER_SAMPLE="OUTER_SAMPLE")
modules["comfy.patcher_extension"] = comfy_patcher
modules["comfy.model_base"] = types.ModuleType("comfy.model_base")
modules["comfy.model_management"] = types.ModuleType("comfy.model_management")
comfy_execution = types.ModuleType("comfy_execution")
graph_utils = types.ModuleType("comfy_execution.graph_utils")
graph_utils.GraphBuilder = type("GraphBuilder", (), {})
graph_utils.ExecutionBlocker = type("ExecutionBlocker", (), {})
graph_utils.is_link = lambda value: False
modules["comfy_execution"] = comfy_execution
modules["comfy_execution.graph_utils"] = graph_utils
modules["latent_preview"] = types.ModuleType("latent_preview")
folder_paths = types.ModuleType("folder_paths")
folder_paths.models_dir = ""
folder_paths.get_folder_paths = lambda *a, **k: []
folder_paths.get_filename_list = lambda *a, **k: []
modules["folder_paths"] = folder_paths
nodes_stub = types.ModuleType("nodes")
nodes_stub.EXTENSION_WEB_DIRS = {}
modules["nodes"] = nodes_stub
# Wire the comfy package attribute chain for `import comfy.x.y` statements.
comfy.sd = comfy_sd
comfy.utils = comfy_utils
comfy.samplers = comfy_samplers
comfy.patcher_extension = comfy_patcher
comfy.model_base = modules["comfy.model_base"]
comfy.model_management = modules["comfy.model_management"]
comfy_ldm.modules = comfy_ldm_modules
comfy_ldm_modules.attention = comfy_attention
comfy.ldm = comfy_ldm
modules["comfy"] = comfy
return modules
def _load(spec_name, path):
spec = importlib.util.spec_from_file_location(spec_name, path)
assert spec is not None and spec.loader is not None
module = importlib.util.module_from_spec(spec)
sys.modules[spec_name] = module
spec.loader.exec_module(module)
return module
def _build_moxie():
"""Load the real Moxie modules against the stubbed ComfyUI runtime.
Written as a plain generator (setup / yield / teardown) so it can back
the pytest fixture below and also be driven by a standalone runner in
environments where pytest's package-aware collection cannot be used.
"""
state = _StubState()
io = _build_io()
stubs = _register(state, io)
added = {}
for name, module in stubs.items():
added[name] = sys.modules.get(name)
sys.modules[name] = module
mm_pkg = types.ModuleType("MMnode")
mm_pkg.__path__ = [str(REPO)]
added["MMnode"] = sys.modules.get("MMnode")
sys.modules["MMnode"] = mm_pkg
try:
# Real utils package (torch/folder_paths only externals).
utils_spec = importlib.util.spec_from_file_location(
"MMnode.utils",
REPO / "utils" / "__init__.py",
submodule_search_locations=[str(REPO / "utils")],
)
utils_pkg = importlib.util.module_from_spec(utils_spec)
added["MMnode.utils"] = sys.modules.get("MMnode.utils")
sys.modules["MMnode.utils"] = utils_pkg
utils_spec.loader.exec_module(utils_pkg)
# nodes package without executing the full nodes/__init__ chain.
nodes_pkg = types.ModuleType("MMnode.nodes")
nodes_pkg.__path__ = [str(REPO / "nodes")]
added["MMnode.nodes"] = sys.modules.get("MMnode.nodes")
sys.modules["MMnode.nodes"] = nodes_pkg
common = _load("MMnode.nodes.common", REPO / "nodes" / "common.py")
nodes_pkg.common = common
project = _load("MMnode.nodes.project", REPO / "nodes" / "project.py")
nodes_pkg.project = project
tiny_vae = types.ModuleType("MMnode.tiny_vae")
tiny_vae.load_tiny_vae_decoder = lambda *a, **k: None
tiny_vae.pack_vae_approx_files = lambda *a, **k: []
added["MMnode.tiny_vae"] = sys.modules.get("MMnode.tiny_vae")
sys.modules["MMnode.tiny_vae"] = tiny_vae
loader = _load("MMnode.moxie_loader", REPO / "moxie_loader.py")
preview = _load("MMnode.moxie_preview", REPO / "moxie_preview.py")
project_node = _load("MMnode.moxie_project", REPO / "moxie_project.py")
yield types.SimpleNamespace(
state=state,
loader=loader,
preview=preview,
project_node=project_node,
base_project=project.EasyMultiTrackProject,
)
finally:
for name, previous in added.items():
if previous is None:
sys.modules.pop(name, None)
else:
sys.modules[name] = previous
@pytest.fixture(scope="module")
def moxie():
yield from _build_moxie()
def _input_names(schema):
return [port.name for port in schema.inputs]
def _output_names(schema):
# V3 outputs may pass the label positionally or via display_name=.
return [port.name or port.kwargs.get("display_name") for port in schema.outputs]
def test_loader_schema_outputs_are_direct(moxie):
schema = moxie.loader.MoxieMultimediaLoader.define_schema()
assert _output_names(schema) == ["model", "clip", "video_vae", "audio_vae"]
assert "model_loader" not in _output_names(schema)
assert "model_loader" not in _input_names(schema)
def test_loader_schema_locks_h3_clip_recipe(moxie):
schema = moxie.loader.MoxieMultimediaLoader.define_schema()
inputs = _input_names(schema)
# The model set is MiniMax H3-only: no CLIP recipe choices are exposed.
assert "clip_type" not in inputs
def test_loader_schema_shows_a_single_model(moxie):
schema = moxie.loader.MoxieMultimediaLoader.define_schema()
inputs = _input_names(schema)
# End users see one model picker plus the attention backend; every
# auxiliary model (video/audio VAE, CLIP) is auto-selected.
assert inputs == ["diffusion_model", "weight_dtype", "attention_backend"]
for hidden in (
"lora_name",
"lora_strength_model",
"lora_strength_clip",
"video_vae",
"audio_vae",
"clip",
"clip_device",
):
assert hidden not in inputs
def test_loader_execute_applies_attention_and_ignores_loras(moxie, monkeypatch, tmp_path):
state = moxie.state
models = tmp_path / "models"
for subdir in ("diffusion", "vae", "audio_vae", "clip", "loras"):
(models / subdir).mkdir(parents=True, exist_ok=True)
for name in ("h3.safetensors", "video.safetensors", "audio.safetensors", "qwen.safetensors", "turbo.safetensors"):
subdir = {
"h3.safetensors": "diffusion",
"video.safetensors": "vae",
"audio.safetensors": "audio_vae",
"qwen.safetensors": "clip",
"turbo.safetensors": "loras",
}[name]
(models / subdir / name).write_bytes(b"stub")
monkeypatch.setattr(moxie.loader, "MODELS_DIR", models)
state.calls.clear()
result = moxie.loader.MoxieMultimediaLoader.execute(
diffusion_model="h3.safetensors",
weight_dtype="default",
attention_backend="comfy_kitchen_attention",
)
# The distill weights ship baked into the diffusion model: a leftover
# file in models/loras must be ignored entirely. The comfy.sd stub keeps
# a raising load_lora_for_models, so an accidental LoRA call fails loudly.
sequence = [call[0] for call in state.calls]
assert sequence == [
"load_diffusion_model",
"get_attention_function",
"load_clip",
"load_torch_file",
"load_torch_file",
]
# CLIP recipe is locked to MiniMax.
clip_calls = [call for call in state.calls if call[0] == "load_clip"]
assert clip_calls == [("load_clip", state.CLIPType.MINIMAX)]
# Attention backend applied before the CLIP load.
assert state.calls.index(("get_attention_function", "comfy_kitchen_int8")) < state.calls.index(
("load_clip", state.CLIPType.MINIMAX)
)
# Exactly four direct outputs, model carrying the attention backend.
assert isinstance(result, _NodeOutput)
assert len(result.values) == 4
model_out, clip_out, video_vae_out, audio_vae_out = result.values
assert model_out.label == "diffusion.clone"
assert model_out.attention_fn is state.attention_fn
assert clip_out is state.clip
assert isinstance(video_vae_out, _FakeVAE)
assert isinstance(audio_vae_out, _FakeVAE)
def test_loader_requires_minimax_cliptype(moxie, monkeypatch, tmp_path):
state = moxie.state
models = tmp_path / "models"
for subdir in ("diffusion", "clip"):
(models / subdir).mkdir(parents=True, exist_ok=True)
(models / "diffusion" / "h3.safetensors").write_bytes(b"stub")
(models / "clip" / "qwen.safetensors").write_bytes(b"stub")
monkeypatch.setattr(moxie.loader, "MODELS_DIR", models)
class CLIPTypeNoMinimax(enum.Enum):
STABLE_DIFFUSION = "stable_diffusion"
monkeypatch.setattr(moxie.loader.comfy.sd, "CLIPType", CLIPTypeNoMinimax)
# The error message deliberately avoids naming the underlying enum/recipe
# so end users cannot identify the model family from console output.
with pytest.raises(RuntimeError, match="Please update ComfyUI"):
moxie.loader.MoxieMultimediaLoader.execute(
diffusion_model="h3.safetensors",
weight_dtype="default",
attention_backend="pytorch_attention",
)
def test_project_schema_takes_direct_model_inputs(moxie):
schema = moxie.project_node.MoxieProject.define_schema()
inputs = {port.name: port for port in schema.inputs}
assert list(inputs) == [
"tracks_info",
"model",
"clip",
"video_vae",
"audio_vae",
"project_name",
"steps",
"seed",
]
assert "model_loader" not in inputs
# The four model components are required direct connections.
for name in ("model", "clip", "video_vae", "audio_vae"):
assert inputs[name].kwargs.get("optional") is not True
def test_project_execute_builds_loader_bundle_for_base_node(moxie, monkeypatch):
captured = {}
def fake_base_execute(cls, **kwargs):
captured.update(kwargs)
return _NodeOutput("PROJECT", None)
monkeypatch.setattr(
moxie.base_project,
"execute",
classmethod(fake_base_execute),
)
model = _FakeModel("h3")
clip = object()
video_vae = object()
audio_vae = object()
moxie.project_node.MoxieProject.execute(
tracks_info=[{"width": 960, "height": 544, "frame_rate": 24, "tracks": []}],
model=[model],
clip=[clip],
video_vae=[video_vae],
audio_vae=[audio_vae],
project_name=["girl1-test"],
steps=[3],
seed=[42],
)
assert captured["model_loader"] == {
"model": model,
"clip": clip,
"vae": video_vae,
"audio_vae": audio_vae,
}
# Baked single-pass sampling settings survive the delegation.
assert captured["sampling_mode"] == "single"
assert captured["project_save"] == "override"
assert captured["sampler"] == ("sampler", "euler")
import torch
assert captured["sigmas"].shape == (4,) # steps + 1
assert captured["sigmas"].dtype == torch.float32
def test_project_execute_missing_component_raises(moxie, monkeypatch):
def fake_base_execute(cls, **kwargs): # pragma: no cover - must not be reached
raise AssertionError("base execute must not run with missing components")
monkeypatch.setattr(moxie.base_project, "execute", classmethod(fake_base_execute))
with pytest.raises(ValueError, match="MoxieProject: Missing required model components: clip"):
moxie.project_node.MoxieProject.execute(
tracks_info=[{}],
model=[_FakeModel("h3")],
clip=[None],
video_vae=[object()],
audio_vae=[object()],
project_name=["girl1-test"],
steps=[3],
seed=[42],
)
def test_preview_override_has_no_model_loader_slots(moxie):
schema = moxie.preview.ModelPreviewOverrideKJ.define_schema()
assert "model_loader" not in _input_names(schema)
assert _output_names(schema) == ["model"]
def test_preview_override_patches_model_directly(moxie):
model = _FakeModel("h3")
result = moxie.preview.ModelPreviewOverrideKJ.execute(model=model)
assert isinstance(result, _NodeOutput)
assert len(result.values) == 1
patched = result.values[0]
assert patched is not model
assert any(
wrapper[0] == "OUTER_SAMPLE" and wrapper[1] == "moxie_preview_override"
for wrapper in patched.wrappers
)
def test_preview_override_requires_model(moxie):
with pytest.raises(TypeError, match="'model' input is required"):
moxie.preview.ModelPreviewOverrideKJ.execute(model=None)