feat: lock Moxie loader to MiniMax H3 and drop model_loader bundle

The Moxie model set is MiniMax H3-only, so no other model choices are
exposed in the editor:

- Moxie Multimedia Loader: removed the clip_type dropdown (which listed
  every CLIPType recipe in ComfyUI). The H3 Qwen3-VL text encoder is now
  always loaded with CLIPType.MINIMAX; older ComfyUI builds raise a
  clear error instead of silently loading the wrong encoder.
- Moxie Multimedia Loader: outputs are now exactly model, clip,
  video_vae, audio_vae - the legacy FAST_MODEL_LOADER (model_loader)
  bundle output is removed. The model output keeps the attention
  backend and LoRA applied.
- Moxie MultiTrack Project: takes model, clip, video_vae and audio_vae
  as required direct inputs instead of a bundled model_loader; the
  fallback plumbing is removed while EasyMultiTrackProject keeps its
  model_loader input for non-Moxie workflows.
- Moxie Preview Override: dropped the model_loader pass-through slots
  and patches the model input directly.
- Moxie-consolidated.json reference workflow updated to the new slots.
- Added tests/test_moxie_nodes.py covering the schema contracts, the
  attention -> LoRA -> output chain, the MINIMAX lock and the project
  loader synthesis.
This commit is contained in:
Z User 2026-09-26 19:06:50 +00:00
parent bec001f6f7
commit e2ae630ec2
7 changed files with 653 additions and 113 deletions

View File

@ -2,6 +2,13 @@
--- ---
## [Unreleased]
### ⚡ Improvements
- **Moxie Multimedia Loader**: Locked the loader to the MiniMax H3 model set. The `clip_type` dropdown (which previously exposed every CLIP recipe in ComfyUI) was removed; the H3 Qwen3-VL text encoder is now always loaded with the `minimax` CLIP recipe. Any older ComfyUI build without `CLIPType.MINIMAX` raises a clear startup error instead of silently loading the wrong encoder.
- **Moxie Multimedia Loader / Moxie MultiTrack Project**: Removed the legacy `FAST_MODEL_LOADER` (`model_loader`) bundle. The loader now outputs exactly `model`, `clip`, `video_vae`, and `audio_vae` (with the attention backend and LoRA already applied to the model), and the Moxie MultiTrack Project takes those four outputs as required direct inputs instead of a bundled loader. `Moxie Preview Override` likewise dropped its `model_loader` pass-through slots and now patches the `model` input directly. The generic `easy multitrackProject` node keeps its `model_loader` input for non-Moxie workflows.
## [1.3.3] - 2026-09-25 ## [1.3.3] - 2026-09-25
### ✨ New Features ### ✨ New Features

View File

@ -47,11 +47,6 @@
"links": [ "links": [
204 204
] ]
},
{
"name": "model_loader",
"type": "FAST_MODEL_LOADER",
"links": []
} }
], ],
"properties": { "properties": {
@ -67,7 +62,6 @@
"minimax_h3_video_vae_int8_convrot.safetensors", "minimax_h3_video_vae_int8_convrot.safetensors",
"minimax_h3_audio_vae_fp32.safetensors", "minimax_h3_audio_vae_fp32.safetensors",
"qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors", "qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors",
"minimax",
"cpu" "cpu"
] ]
}, },
@ -90,11 +84,6 @@
"name": "model", "name": "model",
"type": "MODEL", "type": "MODEL",
"link": 201 "link": 201
},
{
"name": "model_loader",
"type": "FAST_MODEL_LOADER",
"link": null
} }
], ],
"outputs": [ "outputs": [
@ -104,11 +93,6 @@
"links": [ "links": [
205 205
] ]
},
{
"name": "model_loader",
"type": "FAST_MODEL_LOADER",
"links": []
} }
], ],
"properties": { "properties": {
@ -162,11 +146,6 @@
"name": "audio_vae", "name": "audio_vae",
"type": "VAE", "type": "VAE",
"link": 204 "link": 204
},
{
"name": "model_loader",
"type": "FAST_MODEL_LOADER",
"link": null
} }
], ],
"outputs": [ "outputs": [

View File

@ -22,10 +22,10 @@
Moxie Multimedia Suite consolidates multi-node setups into a concise pipeline: Moxie Multimedia Suite consolidates multi-node setups into a concise pipeline:
```text ```text
[Moxie Multimedia Loader] ───────────────┬─────────► [Moxie Preview Override] (live preview) [Moxie Multimedia Loader] ── model ──► [Moxie Preview Override] (live preview)
│ │ │ model, clip, │
▼ ▼ (FAST_MODEL_LOADER) │ video_vae, audio_vae ▼ model
[easy multiTrackEditor] ── (TRACKS_INFO) ──► [Moxie MultiTrack Project] (controls: steps, seed) └──────────────► [easy multiTrackEditor] ── (TRACKS_INFO) ──► [Moxie MultiTrack Project] (controls: steps, seed)
│ (PROJECT_NAME) │ (PROJECT_NAME)
▼ ▼
[Moxie Project Video Combine] [Moxie Project Video Combine]
@ -38,9 +38,9 @@ Moxie Multimedia Suite consolidates multi-node setups into a concise pipeline:
| Node | Description | | Node | Description |
|---|---| |---|---|
| **Moxie Multimedia Loader** (`MoxieMultimediaLoader`) | Self-contained loader reading from local `models/` subdirectories (`diffusion`, `loras`, `vae`, `audio_vae`, `clip`). Chains **Diffusion Model → Attention Backend (`comfy_kitchen_int8`) → LoRA Loader** and outputs individual models as well as the bundled `FAST_MODEL_LOADER` object. | | **Moxie Multimedia Loader** (`MoxieMultimediaLoader`) | Self-contained loader reading from local `models/` subdirectories (`diffusion`, `loras`, `vae`, `audio_vae`, `clip`). Chains **Diffusion Model → Attention Backend (`comfy_kitchen_int8`) → LoRA Loader** and outputs `model`, `clip`, `video_vae`, and `audio_vae` directly. The model set is MiniMax H3-only: the CLIP recipe is locked to the `minimax` (Qwen3-VL) text encoder with no model-type choices exposed. |
| **Moxie Preview Override** (`MoxiePreviewOverride`) | Ported from ComfyUI-KJNodes' Model Preview Override. Intercepts outer-sampling iterations to stream full-resolution animated video/audio preview frames directly to the node canvas widget using `taeh3` / tiny VAE decoders. | | **Moxie Preview Override** (`MoxiePreviewOverride`) | Ported from ComfyUI-KJNodes' Model Preview Override. Intercepts outer-sampling iterations to stream full-resolution animated video/audio preview frames directly to the node canvas widget using `taeh3` / tiny VAE decoders. |
| **Moxie MultiTrack Project** (`MoxieProject`) | Consolidates `easy multitrackProject` + `KSamplerSelect` (euler) + `BasicScheduler` (beta scheduler) + `ManualSigmas`. Hardcodes tested single-pass settings while exposing only **`steps`**, **`seed`**, and **`project_name`**. | | **Moxie MultiTrack Project** (`MoxieProject`) | Consolidates `easy multitrackProject` + `KSamplerSelect` (euler) + `BasicScheduler` (beta scheduler) + `ManualSigmas`. Takes `model`, `clip`, `video_vae`, and `audio_vae` directly from the Moxie Multimedia Loader. Hardcodes tested single-pass settings while exposing only **`steps`**, **`seed`**, and **`project_name`**. |
| **Moxie Project Video Combine** (`MoxieCombine`) | Consolidates `easy multitrackProjectVideoCombine` + `GetVideoComponents`. Assembles rendered segments and outputs `images`, `audio`, `fps`, and `FILENAME_PREFIX` directly into `easy saveVideo`. | | **Moxie Project Video Combine** (`MoxieCombine`) | Consolidates `easy multitrackProjectVideoCombine` + `GetVideoComponents`. Assembles rendered segments and outputs `images`, `audio`, `fps`, and `FILENAME_PREFIX` directly into `easy saveVideo`. |
--- ---

View File

@ -53,21 +53,26 @@ def _resolve(subdir, name):
return path return path
def _clip_type_options(): def _h3_clip_type():
"""All CLIPType members from the running ComfyUI, lowercased like native CLIPLoader.""" """MiniMax H3 CLIP recipe. The Moxie model set is H3-only, so the text
try: encoder type is intentionally NOT a user-facing choice."""
return sorted( clip_type_enum = getattr(comfy.sd.CLIPType, "MINIMAX", None)
m.lower() if clip_type_enum is None:
for m in dir(comfy.sd.CLIPType) raise RuntimeError(
if not m.startswith("_") and isinstance(getattr(comfy.sd.CLIPType, m), comfy.sd.CLIPType) "Moxie Multimedia Loader: this ComfyUI build does not expose "
"CLIPType.MINIMAX (required for MiniMax H3 Qwen3-VL text encoders). "
"Please update ComfyUI."
) )
except Exception: return clip_type_enum
return ["stable_diffusion"]
class MoxieMultimediaLoader(io.ComfyNode): class MoxieMultimediaLoader(io.ComfyNode):
"""All-in-one loader: diffusion model -> attention backend -> LoRA, plus """All-in-one loader: diffusion model -> attention backend -> LoRA, plus
video VAE, audio VAE and CLIP, all read from the node pack's models/ folder.""" video VAE, audio VAE and CLIP, all read from the node pack's models/ folder.
The model set is MiniMax H3-only: the CLIP recipe is locked to
CLIPType.MINIMAX and outputs are exactly (model, clip, video_vae, audio_vae)
with the attention backend and LoRA already applied to the model."""
_loaded_lora = None # (path, sd, metadata) cache, mirrors native LoraLoader _loaded_lora = None # (path, sd, metadata) cache, mirrors native LoraLoader
@ -78,8 +83,9 @@ class MoxieMultimediaLoader(io.ComfyNode):
node_id="MoxieMultimediaLoader", node_id="MoxieMultimediaLoader",
display_name="Moxie Multimedia Loader", display_name="Moxie Multimedia Loader",
category="loaders/moxie", category="loaders/moxie",
description="Loads the diffusion model, applies the attention backend and a LoRA, and loads a video VAE, " description="Loads the MiniMax H3 diffusion model, applies the attention backend and a LoRA, and loads "
"an audio VAE and CLIP - all from the models folder bundled with this custom node.", "a video VAE, an audio VAE and the H3 Qwen3-VL CLIP - all from the models folder bundled "
"with this custom node. Outputs model, clip, video_vae and audio_vae.",
inputs=[ inputs=[
io.Combo.Input( io.Combo.Input(
"diffusion_model", "diffusion_model",
@ -123,13 +129,8 @@ class MoxieMultimediaLoader(io.ComfyNode):
io.Combo.Input( io.Combo.Input(
"clip", "clip",
options=_list_files("clip"), options=_list_files("clip"),
tooltip="Text encoder file (inside models/clip).", tooltip="MiniMax H3 text encoder file (inside models/clip). Loaded with the locked "
), "minimax CLIP recipe (Qwen3-VL).",
io.Combo.Input(
"clip_type",
options=_clip_type_options(),
default="stable_diffusion",
tooltip="CLIP model type/recipe. E.g. wan: umt5 xxl, ltxv: t5 xxl, minimax: MiniMax H3 Qwen3-VL.",
), ),
io.Combo.Input( io.Combo.Input(
"clip_device", "clip_device",
@ -144,10 +145,6 @@ class MoxieMultimediaLoader(io.ComfyNode):
io.Clip.Output(display_name="clip", tooltip="CLIP text encoder (with LoRA applied if present)."), io.Clip.Output(display_name="clip", tooltip="CLIP text encoder (with LoRA applied if present)."),
io.Vae.Output(display_name="video_vae", tooltip="Loaded video/image VAE."), io.Vae.Output(display_name="video_vae", tooltip="Loaded video/image VAE."),
io.Vae.Output(display_name="audio_vae", tooltip="Loaded audio VAE."), io.Vae.Output(display_name="audio_vae", tooltip="Loaded audio VAE."),
io.Custom(io_type="FAST_MODEL_LOADER").Output(
display_name="model_loader",
tooltip="Optional bundled {model, clip, vae, audio_vae} for legacy/subgraph nodes.",
),
], ],
) )
@ -223,8 +220,8 @@ class MoxieMultimediaLoader(io.ComfyNode):
return vae return vae
@classmethod @classmethod
def _load_clip(cls, clip_name, clip_type, device): def _load_clip(cls, clip_name, device):
clip_type_enum = getattr(comfy.sd.CLIPType, clip_type.upper(), comfy.sd.CLIPType.STABLE_DIFFUSION) clip_type_enum = _h3_clip_type()
clip_path = _resolve("clip", clip_name) clip_path = _resolve("clip", clip_name)
model_options = {} model_options = {}
@ -251,19 +248,17 @@ class MoxieMultimediaLoader(io.ComfyNode):
video_vae, video_vae,
audio_vae, audio_vae,
clip, clip,
clip_type,
clip_device, clip_device,
) -> io.NodeOutput: ) -> io.NodeOutput:
# Chain: Load Diffusion Model -> Model Attention Backend -> Lora Loader (needs both model and clip) # Chain: Load Diffusion Model -> Model Attention Backend -> Lora Loader (needs both model and clip)
model = cls._load_diffusion_model(diffusion_model, weight_dtype) model = cls._load_diffusion_model(diffusion_model, weight_dtype)
model = cls._apply_attention_backend(model, attention_backend) model = cls._apply_attention_backend(model, attention_backend)
clip_obj = cls._load_clip(clip, clip_type, clip_device) clip_obj = cls._load_clip(clip, clip_device)
model, clip_obj = cls._apply_lora(model, clip_obj, lora_name, lora_strength_model, lora_strength_clip) model, clip_obj = cls._apply_lora(model, clip_obj, lora_name, lora_strength_model, lora_strength_clip)
video_vae_obj = cls._load_vae(video_vae, "vae") video_vae_obj = cls._load_vae(video_vae, "vae")
audio_vae_obj = cls._load_vae(audio_vae, "audio_vae") audio_vae_obj = cls._load_vae(audio_vae, "audio_vae")
bundle = {"model": model, "clip": clip_obj, "vae": video_vae_obj, "audio_vae": audio_vae_obj} return io.NodeOutput(model, clip_obj, video_vae_obj, audio_vae_obj)
return io.NodeOutput(model, clip_obj, video_vae_obj, audio_vae_obj, bundle)

View File

@ -978,8 +978,8 @@ class ModelPreviewOverrideKJ(io.ComfyNode):
display_name="Moxie Preview Override", display_name="Moxie Preview Override",
category="sampling/moxie", category="sampling/moxie",
description=( description=(
"Attaches the live-preview wrapper to the model inside a " "Attaches the live-preview wrapper to the model produced by the "
"FAST_MODEL_LOADER bundle produced by the Moxie Multimedia Loader. " "Moxie Multimedia Loader. "
"Sends high-res preview frames (and audio) to the node while sampling." "Sends high-res preview frames (and audio) to the node while sampling."
), ),
inputs=[ inputs=[
@ -987,11 +987,6 @@ class ModelPreviewOverrideKJ(io.ComfyNode):
"model", "model",
tooltip="Diffusion model (with attention backend and LoRA already applied).", tooltip="Diffusion model (with attention backend and LoRA already applied).",
), ),
io.Custom(io_type="FAST_MODEL_LOADER").Input(
"model_loader",
optional=True,
tooltip="Optional FAST_MODEL_LOADER bundle from Moxie Multimedia Loader.",
),
io.Int.Input( io.Int.Input(
"max_resolution", "max_resolution",
default=1024, default=1024,
@ -1046,10 +1041,6 @@ class ModelPreviewOverrideKJ(io.ComfyNode):
"model", "model",
tooltip="Model with preview wrapper attached.", tooltip="Model with preview wrapper attached.",
), ),
io.Custom(io_type="FAST_MODEL_LOADER").Output(
"model_loader",
tooltip="Bundle with preview wrapper attached to model (only when a bundle was passed in).",
),
], ],
hidden=[io.Hidden.unique_id], hidden=[io.Hidden.unique_id],
is_experimental=True, is_experimental=True,
@ -1059,7 +1050,6 @@ class ModelPreviewOverrideKJ(io.ComfyNode):
def execute( def execute(
cls, cls,
model=None, model=None,
model_loader=None,
max_resolution=1024, max_resolution=1024,
jpeg_quality=80, jpeg_quality=80,
suppress_default_preview=True, suppress_default_preview=True,
@ -1067,18 +1057,10 @@ class ModelPreviewOverrideKJ(io.ComfyNode):
preview_fps=24, preview_fps=24,
tiny_vae="taeh3.safetensors", tiny_vae="taeh3.safetensors",
) -> io.NodeOutput: ) -> io.NodeOutput:
target_model = None if model is None:
if model is not None: raise TypeError("Moxie Preview Override: 'model' input is required.")
target_model = model
elif isinstance(model_loader, dict) and model_loader.get("model") is not None:
target_model = model_loader.get("model")
if target_model is None: patched_model = model.clone()
raise TypeError(
"Moxie Preview Override: Either 'model' or 'model_loader' must be provided."
)
patched_model = target_model.clone()
patched_model.add_wrapper_with_key( patched_model.add_wrapper_with_key(
comfy.patcher_extension.WrappersMP.OUTER_SAMPLE, comfy.patcher_extension.WrappersMP.OUTER_SAMPLE,
"moxie_preview_override", "moxie_preview_override",
@ -1088,12 +1070,7 @@ class ModelPreviewOverrideKJ(io.ComfyNode):
), ),
) )
out_loader = None return io.NodeOutput(patched_model)
if isinstance(model_loader, dict):
out_loader = dict(model_loader)
out_loader["model"] = patched_model
return io.NodeOutput(patched_model, out_loader)
class GetPreviewOverrideFramesKJ(io.ComfyNode): class GetPreviewOverrideFramesKJ(io.ComfyNode):

View File

@ -8,7 +8,6 @@ from .nodes.project import (
TYPE_TRACKS_INFO, TYPE_TRACKS_INFO,
_first_input, _first_input,
) )
from .nodes.common import TYPE_FAST_MODEL_LOADER
# Values baked from the reference workflow (Moxie-clean.json). End users only # Values baked from the reference workflow (Moxie-clean.json). End users only
# control project_name, steps and seed on this node. # control project_name, steps and seed on this node.
@ -45,7 +44,7 @@ class MoxieProject(EasyMultiTrackProject):
category="EasyUse/MultiTrackEditor", category="EasyUse/MultiTrackEditor",
description=( description=(
"Build and execute a multi-track MiniMax H3 project. " "Build and execute a multi-track MiniMax H3 project. "
"Takes direct model, clip, video_vae, and audio_vae inputs (or a bundled model_loader). " "Takes model, clip, video_vae and audio_vae directly from the Moxie Multimedia Loader. "
"Sampling is baked to a single pass with euler + beta sigmas; set only steps and seed." "Sampling is baked to a single pass with euler + beta sigmas; set only steps and seed."
), ),
is_input_list=True, is_input_list=True,
@ -53,11 +52,10 @@ class MoxieProject(EasyMultiTrackProject):
not_idempotent=True, not_idempotent=True,
inputs=[ inputs=[
TYPE_TRACKS_INFO.Input("tracks_info"), TYPE_TRACKS_INFO.Input("tracks_info"),
io.Model.Input("model", tooltip="Diffusion model (with attention backend and LoRA already applied).", optional=True), io.Model.Input("model", tooltip="Diffusion model from Moxie Multimedia Loader (attention backend and LoRA already applied)."),
io.Clip.Input("clip", tooltip="CLIP text encoder (from Moxie Multimedia Loader).", optional=True), io.Clip.Input("clip", tooltip="CLIP text encoder from Moxie Multimedia Loader."),
io.Vae.Input("video_vae", tooltip="Video VAE (from Moxie Multimedia Loader).", optional=True), io.Vae.Input("video_vae", tooltip="Video VAE from Moxie Multimedia Loader."),
io.Vae.Input("audio_vae", tooltip="Audio VAE (from Moxie Multimedia Loader).", optional=True), io.Vae.Input("audio_vae", tooltip="Audio VAE from Moxie Multimedia Loader (required to decode MiniMax H3 audio)."),
TYPE_FAST_MODEL_LOADER.Input("model_loader", optional=True, tooltip="Optional bundled FAST_MODEL_LOADER from Moxie Multimedia Loader."),
io.String.Input("project_name", default="", io.String.Input("project_name", default="",
tooltip="Name of the project; used for output folders."), tooltip="Name of the project; used for output folders."),
io.Int.Input( io.Int.Input(
@ -88,31 +86,20 @@ class MoxieProject(EasyMultiTrackProject):
def execute(cls, **kwargs) -> io.NodeOutput: def execute(cls, **kwargs) -> io.NodeOutput:
steps = int(_first_input(kwargs.get("steps"), 3)) steps = int(_first_input(kwargs.get("steps"), 3))
# Support both direct individual inputs and bundled model_loader
model = _first_input(kwargs.get("model")) model = _first_input(kwargs.get("model"))
clip = _first_input(kwargs.get("clip")) clip = _first_input(kwargs.get("clip"))
video_vae = _first_input(kwargs.get("video_vae")) video_vae = _first_input(kwargs.get("video_vae"))
audio_vae = _first_input(kwargs.get("audio_vae")) audio_vae = _first_input(kwargs.get("audio_vae"))
loader = _first_input(kwargs.get("model_loader"))
if isinstance(loader, dict):
if model is None:
model = loader.get("model")
if clip is None:
clip = loader.get("clip")
if video_vae is None:
video_vae = loader.get("vae")
if audio_vae is None:
audio_vae = loader.get("audio_vae")
if model is None or clip is None or video_vae is None or audio_vae is None: if model is None or clip is None or video_vae is None or audio_vae is None:
missing = [k for k, v in [("model", model), ("clip", clip), ("video_vae", video_vae), ("audio_vae", audio_vae)] if v is None] missing = [k for k, v in [("model", model), ("clip", clip), ("video_vae", video_vae), ("audio_vae", audio_vae)] if v is None]
raise ValueError( raise ValueError(
"MoxieProject: Missing required model components: " + ", ".join(missing) + "MoxieProject: Missing required model components: " + ", ".join(missing) +
". Wire model, clip, video_vae, and audio_vae directly from Moxie Multimedia Loader, or provide model_loader." ". Wire model, clip, video_vae, and audio_vae from Moxie Multimedia Loader."
) )
# Build bundled loader dict for EasyMultiTrackProject.execute # Pack the direct inputs into the loader dict consumed by
# EasyMultiTrackProject.execute (internal plumbing only).
synthesized_loader = { synthesized_loader = {
"model": model, "model": model,
"clip": clip, "clip": clip,

595
tests/test_moxie_nodes.py Normal file
View File

@ -0,0 +1,595 @@
"""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 and LoRA applied.
- 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()
self.lora_model = None
self.lora_clip = None
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):
state.calls.append(("load_lora_for_models", strength_model, strength_clip))
state.lora_model = model
state.lora_clip = clip
return model, clip
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
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
assert "clip_device" in inputs
assert inputs.index("clip") == len(inputs) - 2 # clip, then clip_device
def test_loader_execute_applies_attention_then_lora(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)
monkeypatch.setattr(moxie.loader.MoxieMultimediaLoader, "_loaded_lora", None)
state.calls.clear()
result = moxie.loader.MoxieMultimediaLoader.execute(
diffusion_model="h3.safetensors",
weight_dtype="default",
attention_backend="comfy_kitchen_attention",
lora_name="turbo.safetensors",
lora_strength_model=1.0,
lora_strength_clip=1.0,
video_vae="video.safetensors",
audio_vae="audio.safetensors",
clip="qwen.safetensors",
clip_device="default",
)
sequence = [call[0] for call in state.calls]
assert sequence == [
"load_diffusion_model",
"get_attention_function",
"load_clip",
"load_torch_file",
"load_lora_for_models",
"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)]
# LoRA applied on top of the attention-patched model, after the CLIP load.
assert state.calls.index(("get_attention_function", "comfy_kitchen_int8")) < state.calls.index(
("load_clip", state.CLIPType.MINIMAX)
) < state.calls.index(("load_lora_for_models", 1.0, 1.0))
# Exactly four direct outputs, model carrying attention + LoRA.
assert isinstance(result, _NodeOutput)
assert len(result.values) == 4
model_out, clip_out, video_vae_out, audio_vae_out = result.values
assert model_out is state.lora_model
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_execute_without_lora_skips_lora_loading(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"):
subdir = {
"h3.safetensors": "diffusion",
"video.safetensors": "vae",
"audio.safetensors": "audio_vae",
"qwen.safetensors": "clip",
}[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="pytorch_attention",
lora_name="<no files found in models/loras>",
lora_strength_model=1.0,
lora_strength_clip=1.0,
video_vae="video.safetensors",
audio_vae="audio.safetensors",
clip="qwen.safetensors",
clip_device="default",
)
assert "load_lora_for_models" not in [call[0] for call in state.calls]
assert result.values[0] is not state.clip # model output remains a model
assert result.values[0].attention_fn is state.attention_fn
assert result.values[1] is state.clip
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)
with pytest.raises(RuntimeError, match="CLIPType.MINIMAX"):
moxie.loader.MoxieMultimediaLoader.execute(
diffusion_model="h3.safetensors",
weight_dtype="default",
attention_backend="pytorch_attention",
lora_name="<no files found in models/loras>",
lora_strength_model=1.0,
lora_strength_clip=1.0,
video_vae="video.safetensors",
audio_vae="audio.safetensors",
clip="qwen.safetensors",
clip_device="default",
)
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)