MMnode/tests/test_ltx_nodes.py
turtle89431 4ea8431cd0
Some checks are pending
Publish to Comfy registry / Publish Custom Node to registry (push) Waiting to run
init
2026-09-26 11:11:23 -07:00

602 lines
21 KiB
Python

import importlib.util
import inspect
import json
import sys
import types
from pathlib import Path
import pytest
import torch
class _Port:
def __init__(self, name=None, **kwargs):
self.name = name
self.kwargs = kwargs
class _PortType:
Type = object
@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
def __getitem__(self, index):
return self.values[index]
class _Schema:
def __init__(self, **kwargs):
self.__dict__.update(kwargs)
def _load_ltx_module(monkeypatch):
calls = []
io = types.SimpleNamespace(
Audio=_PortType,
Boolean=_PortType,
Clip=_PortType,
Combo=_PortType,
ComfyNode=object,
Conditioning=_PortType,
Float=_PortType,
Image=_PortType,
Int=_PortType,
Latent=_PortType,
LatentUpscaleModel=_PortType,
Model=_PortType,
NodeOutput=_NodeOutput,
NumberDisplay=types.SimpleNamespace(number="number"),
Schema=_Schema,
Sigmas=_PortType,
String=_PortType,
Vae=_PortType,
)
comfy_api = types.ModuleType("comfy_api")
comfy_api_latest = types.ModuleType("comfy_api.latest")
comfy_api_latest.io = io
comfy_api.latest = comfy_api_latest
class _CFGGuider:
def __init__(self, model):
self.model = model
calls.append(("guider", model))
def set_conds(self, positive, negative):
calls.append(("conds", positive, negative))
def set_cfg(self, cfg):
calls.append(("cfg", cfg))
comfy = types.ModuleType("comfy")
comfy.__path__ = []
comfy_samplers = types.ModuleType("comfy.samplers")
comfy_samplers.SAMPLER_NAMES = ["euler_ancestral", "euler_cfg_pp"]
comfy_samplers.CFGGuider = _CFGGuider
comfy_samplers.sampler_object = lambda name: calls.append(("sampler", name)) or f"sampler:{name}"
comfy.samplers = comfy_samplers
core_nodes = types.ModuleType("nodes")
class _ConditioningZeroOut:
def zero_out(self, conditioning):
calls.append(("zero", conditioning))
return ("negative",)
class _SetLatentNoiseMask:
def set_mask(self, samples, mask):
calls.append(("set_mask", samples, mask))
return ({**samples, "noise_mask": mask},)
core_nodes.ConditioningZeroOut = _ConditioningZeroOut
core_nodes.SetLatentNoiseMask = _SetLatentNoiseMask
extras = types.ModuleType("comfy_extras")
extras.__path__ = []
custom_sampler = types.ModuleType("comfy_extras.nodes_custom_sampler")
lt = types.ModuleType("comfy_extras.nodes_lt")
lt_audio = types.ModuleType("comfy_extras.nodes_lt_audio")
lt_upsampler = types.ModuleType("comfy_extras.nodes_lt_upsampler")
mask = types.ModuleType("comfy_extras.nodes_mask")
class _NoiseRandom:
def __init__(self, seed):
self.seed = seed
calls.append(("noise", seed))
class _SamplerCustomAdvanced:
@classmethod
def execute(cls, noise, guider, sampler, sigmas, latent_image):
calls.append(("sample", noise, guider, sampler, sigmas, latent_image))
return _NodeOutput({"samples": "sampled-av"}, {"samples": "denoised-av"})
class _EmptyVideo:
@classmethod
def execute(cls, width, height, length, batch_size=1):
calls.append(("empty_video", width, height, length, batch_size))
return _NodeOutput({"samples": "empty-video"})
class _Preprocess:
@classmethod
def execute(cls, image, img_compression):
calls.append(("preprocess", image.clone(), img_compression))
return _NodeOutput(image + 10)
class _Inplace:
@classmethod
def execute(cls, vae, image, latent, strength, bypass=False):
calls.append(("inplace", vae, image.clone(), latent, strength, bypass))
return _NodeOutput({"samples": "i2v-video"})
class _Upsampler:
@classmethod
def execute(cls, samples, upscale_model, vae):
calls.append(("upsample", samples, upscale_model, vae))
return _NodeOutput({"samples": f"{samples['samples']}->{upscale_model}"})
class _Conditioning:
@classmethod
def execute(cls, positive, negative, frame_rate):
calls.append(("conditioning", positive, negative, frame_rate))
return _NodeOutput(f"conditioned:{positive}", f"conditioned:{negative}")
class _Concat:
@classmethod
def execute(cls, video_latent, audio_latent):
calls.append(("concat", video_latent, audio_latent))
return _NodeOutput({"samples": "av"})
class _Separate:
@classmethod
def execute(cls, av_latent):
calls.append(("separate", av_latent))
return _NodeOutput({"samples": "video"}, {"samples": "audio"})
class _Crop:
@classmethod
def execute(cls, positive, negative, latent):
calls.append(("crop", positive, negative, latent))
return _NodeOutput("cropped-positive", "cropped-negative", {"samples": "cropped-video"})
class _AudioEncode:
@classmethod
def execute(cls, audio, audio_vae):
calls.append(("audio_encode", audio, audio_vae))
return _NodeOutput({"samples": "encoded-audio"})
class _EmptyAudio:
@classmethod
def execute(cls, frames_number, frame_rate, batch_size, audio_vae):
calls.append(("empty_audio", frames_number, frame_rate, batch_size, audio_vae))
return _NodeOutput({"samples": "empty-audio"})
class _SolidMask:
@classmethod
def execute(cls, value, width, height):
calls.append(("solid_mask", value, width, height))
return _NodeOutput({"mask": (value, width, height)})
custom_sampler.Noise_RandomNoise = _NoiseRandom
custom_sampler.SamplerCustomAdvanced = _SamplerCustomAdvanced
lt.EmptyLTXVLatentVideo = _EmptyVideo
lt.LTXVConditioning = _Conditioning
lt.LTXVConcatAVLatent = _Concat
lt.LTXVCropGuides = _Crop
lt.LTXVImgToVideoInplace = _Inplace
lt.LTXVPreprocess = _Preprocess
lt.LTXVSeparateAVLatent = _Separate
lt_audio.LTXVAudioVAEEncode = _AudioEncode
lt_audio.LTXVEmptyLatentAudio = _EmptyAudio
lt_upsampler.LTXVLatentUpsampler = _Upsampler
mask.SolidMask = _SolidMask
package = types.ModuleType("easy_media")
package.__path__ = []
nodes_package = types.ModuleType("easy_media.nodes")
nodes_package.__path__ = []
utils = types.ModuleType("easy_media.utils")
def iter_valid_audio_inputs(*values):
result = []
for value in values:
if isinstance(value, dict) and "waveform" in value:
result.append(value)
elif isinstance(value, list):
result.extend(iter_valid_audio_inputs(*value))
return result
def merge_audio_inputs(audios, method):
calls.append(("merge_audio", audios, method))
return {"waveform": "merged", "sample_rate": 44100} if audios else None
def audio_is_silent(audio):
waveform = audio["waveform"]
return waveform.numel() == 0 or torch.count_nonzero(waveform).item() == 0
utils.audio_is_silent = audio_is_silent
utils.iter_valid_audio_inputs = iter_valid_audio_inputs
utils.merge_audio_inputs = merge_audio_inputs
modules = types.ModuleType("easy_media.modules")
modules.__path__ = []
prompt_relay = types.ModuleType("easy_media.modules.prompt_relay")
prompt_relay.__path__ = []
prompt_encode = types.ModuleType("easy_media.modules.prompt_relay.encode")
def encode_relay(*args, **kwargs):
calls.append(("encode_relay", args, kwargs))
return "patched-model", "positive"
prompt_encode._encode_relay = encode_relay
modules_to_patch = {
"comfy_api": comfy_api,
"comfy_api.latest": comfy_api_latest,
"comfy": comfy,
"comfy.samplers": comfy_samplers,
"nodes": core_nodes,
"comfy_extras": extras,
"comfy_extras.nodes_custom_sampler": custom_sampler,
"comfy_extras.nodes_lt": lt,
"comfy_extras.nodes_lt_audio": lt_audio,
"comfy_extras.nodes_lt_upsampler": lt_upsampler,
"comfy_extras.nodes_mask": mask,
"easy_media": package,
"easy_media.nodes": nodes_package,
"easy_media.utils": utils,
"easy_media.modules": modules,
"easy_media.modules.prompt_relay": prompt_relay,
"easy_media.modules.prompt_relay.encode": prompt_encode,
}
for name, module in modules_to_patch.items():
monkeypatch.setitem(sys.modules, name, module)
path = Path(__file__).parents[1] / "nodes" / "ltx.py"
assert path.exists(), "nodes/ltx.py must define the new LTX nodes"
spec = importlib.util.spec_from_file_location("easy_media.nodes.ltx", path)
module = importlib.util.module_from_spec(spec)
monkeypatch.setitem(sys.modules, spec.name, module)
spec.loader.exec_module(module)
return module, calls
def _audio(value):
return {"waveform": torch.tensor([[[value]]]), "sample_rate": 44100}
def _execute_encode(module, **overrides):
values = {
"model": ["model"],
"clip": ["clip"],
"audio_vae": ["audio-vae"],
"audio": [[_audio(1), _audio(2)]],
"local_prompt": ["first | second"],
"global_prompt": ["global"],
"epsilon": [0.25],
"width": [1280],
"height": [720],
"frame_rate": [24.0],
"video_length": [121],
"half_latent_size": [True],
}
values.update(overrides)
return module.LTXMultiTrackEncode.execute(**values)
def test_ltx_multitrack_encode_schema_matches_confirmed_interface(monkeypatch):
module, _ = _load_ltx_module(monkeypatch)
schema = module.LTXMultiTrackEncode.define_schema()
assert schema.node_id == "easy ltxMultiTrackEncode"
assert schema.is_input_list is True
assert [item.name for item in schema.inputs] == [
"model", "clip", "audio_vae", "audio",
"local_prompt", "global_prompt", "epsilon", "width", "height", "frame_rate",
"video_length", "half_latent_size",
]
assert schema.inputs[3].kwargs["optional"] is True
assert [item.name for item in schema.outputs] == [
"model", "positive", "negative", "video_latent", "audio_latent",
]
def test_encode_builds_prompt_audio_video_and_frame_rate_conditioning(monkeypatch):
module, calls = _load_ltx_module(monkeypatch)
result = _execute_encode(module)
assert result.values == (
"patched-model",
"conditioned:positive",
"conditioned:negative",
{"samples": "empty-video"},
{"samples": "encoded-audio", "noise_mask": {"mask": (0.0, 1280, 720)}},
)
assert ("empty_video", 640, 384, 121, 1) in calls
assert not any(call[0] in {"preprocess", "inplace"} for call in calls)
assert any(call[:2] == ("merge_audio", [_audio(1), _audio(2)]) and call[2] == "add" for call in calls)
assert ("solid_mask", 0.0, 1280, 720) in calls
relay = next(call for call in calls if call[0] == "encode_relay")
assert relay[1] == (
"model", "clip", 121, 384, 640, "global", "first | second", "", 0.25,
)
assert ("conditioning", "positive", "negative", 24.0) in calls
@pytest.mark.parametrize(
"audio",
[None, []],
)
def test_encode_uses_empty_audio_when_input_is_missing(monkeypatch, audio):
module, calls = _load_ltx_module(monkeypatch)
result = _execute_encode(
module,
audio=audio,
width=[768],
height=[512],
frame_rate=[25.0],
half_latent_size=[False],
video_length=[97],
)
assert result.values[-1] == {"samples": "empty-audio"}
assert ("empty_audio", 97, 25, 1, "audio-vae") in calls
assert not any(call[0] == "audio_encode" for call in calls)
assert ("empty_video", 768, 512, 97, 1) in calls
def test_encode_uses_empty_audio_when_all_fragments_are_silent(monkeypatch):
module, calls = _load_ltx_module(monkeypatch)
result = _execute_encode(module, audio=[[_audio(0), _audio(0)]])
assert result.values[-1] == {"samples": "empty-audio"}
assert ("empty_audio", 121, 24.0, 1, "audio-vae") in calls
assert not any(
call[0] in {"merge_audio", "audio_encode", "solid_mask", "set_mask"}
for call in calls
)
def test_encode_ignores_silent_fragments_when_audio_is_present(monkeypatch):
module, calls = _load_ltx_module(monkeypatch)
silent_audio = _audio(0)
audible_audio = _audio(2)
result = _execute_encode(module, audio=[[silent_audio, audible_audio]])
assert result.values[-1] == {
"samples": "encoded-audio",
"noise_mask": {"mask": (0.0, 1280, 720)},
}
assert ("merge_audio", [audible_audio], "add") in calls
assert any(call[0] == "audio_encode" for call in calls)
def test_encode_preserves_fractional_frame_rate_for_empty_audio(monkeypatch):
module, calls = _load_ltx_module(monkeypatch)
_execute_encode(
module,
audio=None,
frame_rate=[23.976],
half_latent_size=[False],
)
assert ("empty_audio", 121, 23.976, 1, "audio-vae") in calls
def test_ltx_i2v_inplace_and_upsample_schema_matches_split_interface(monkeypatch):
module, _ = _load_ltx_module(monkeypatch)
schema = module.LTXI2VInplaceAndUpsample.define_schema()
assert schema.node_id == "easy ltxI2VInplaceAndUpsample"
assert schema.is_input_list is True
assert [item.name for item in schema.inputs] == [
"vae", "image", "video_latent", "upscale_models", "img_index", "img_compression", "strength", "bypass",
]
assert schema.inputs[1].kwargs["optional"] is True
assert schema.inputs[3].kwargs["optional"] is True
assert schema.inputs[4].kwargs["default"] == 0
assert schema.inputs[5].kwargs["default"] == 18
assert schema.inputs[6].kwargs["default"] == 0.7
assert schema.inputs[7].kwargs["default"] is False
assert [item.name for item in schema.outputs] == ["video_latent"]
def test_ltx_i2v_inplace_and_upsample_preprocesses_selected_image(monkeypatch):
module, calls = _load_ltx_module(monkeypatch)
image_batch = torch.stack([torch.zeros(2, 2, 3), torch.ones(2, 2, 3)])
result = module.LTXI2VInplaceAndUpsample.execute(
vae=["vae"],
image=[image_batch],
video_latent=[{"samples": "base"}],
upscale_models=[["upscale-1", "upscale-2"]],
strength=[0.8],
img_index=[1],
img_compression=[18],
bypass=[False],
)
assert result.values == ({"samples": "i2v-video"},)
upsample_calls = [call for call in calls if call[0] == "upsample"]
assert upsample_calls == [
("upsample", {"samples": "base"}, "upscale-1", "vae"),
("upsample", {"samples": "base->upscale-1"}, "upscale-2", "vae"),
]
inplace = next(call for call in calls if call[0] == "inplace")
preprocess = next(call for call in calls if call[0] == "preprocess")
assert torch.equal(preprocess[1], torch.ones(1, 2, 2, 3))
assert preprocess[2] == 18
assert inplace[1] == "vae"
assert torch.equal(inplace[2], torch.ones(1, 2, 2, 3) + 10)
assert inplace[3:] == ({"samples": "base->upscale-1->upscale-2"}, 0.8, False)
assert calls.index(preprocess) < calls.index(inplace)
def test_ltx_i2v_inplace_and_upsample_rejects_an_out_of_range_image_index(monkeypatch):
module, _ = _load_ltx_module(monkeypatch)
with pytest.raises(ValueError, match="image_index"):
module.LTXI2VInplaceAndUpsample.execute(
vae=["vae"],
image=[torch.zeros(1, 2, 2, 3)],
video_latent=[{"samples": "base"}],
img_index=[3],
)
def test_ltx_i2v_inplace_and_upsample_defaults_to_enabled_conditioning(monkeypatch):
module, calls = _load_ltx_module(monkeypatch)
signature = inspect.signature(module.LTXI2VInplaceAndUpsample.execute)
module.LTXI2VInplaceAndUpsample.execute(
vae=["vae"],
image=[torch.zeros(1, 2, 2, 3)],
video_latent=[{"samples": "base"}],
)
assert signature.parameters["bypass"].default is False
inplace = next(call for call in calls if call[0] == "inplace")
assert inplace[-1] is False
def test_ltx_i2v_inplace_and_upsample_bypass_keeps_only_upsampling(monkeypatch):
module, calls = _load_ltx_module(monkeypatch)
result = module.LTXI2VInplaceAndUpsample.execute(
vae=["vae"],
image=[torch.zeros(1, 2, 2, 3)],
video_latent=[{"samples": "base"}],
upscale_models=[["upscale-1"]],
img_index=[99],
bypass=[True],
)
assert result.values == ({"samples": "base->upscale-1"},)
assert ("upsample", {"samples": "base"}, "upscale-1", "vae") in calls
assert not any(call[0] in {"preprocess", "inplace"} for call in calls)
def test_ltx_i2v_inplace_and_upsample_missing_image_auto_bypasses(monkeypatch):
module, calls = _load_ltx_module(monkeypatch)
signature = inspect.signature(module.LTXI2VInplaceAndUpsample.execute)
result = module.LTXI2VInplaceAndUpsample.execute(
vae=["vae"],
image=None,
video_latent=[{"samples": "base"}],
upscale_models=[["upscale-1"]],
bypass=[False],
)
assert signature.parameters["image"].default is None
assert result.values == ({"samples": "base->upscale-1"},)
assert ("upsample", {"samples": "base"}, "upscale-1", "vae") in calls
assert not any(call[0] in {"preprocess", "inplace"} for call in calls)
def test_ltx_sampler_simple_schema_and_sampling_pipeline(monkeypatch):
module, calls = _load_ltx_module(monkeypatch)
schema = module.LTXSamplerSimple.define_schema()
assert schema.node_id == "easy ltxSamplerSimple"
assert [item.name for item in schema.inputs] == [
"model", "positive", "negative", "video_latent", "audio_latent",
"sampler_name", "sigmas", "cfg", "seed",
]
assert [item.name for item in schema.outputs] == [
"positive", "negative", "video_latent", "audio_latent",
]
result = module.LTXSamplerSimple.execute(
"model", "positive", "negative", {"samples": "video-in"}, {"samples": "audio-in"},
"euler_cfg_pp", torch.tensor([1.0, 0.5, 0.0]), 1.5, 42,
)
assert result.values == (
"cropped-positive", "cropped-negative", {"samples": "cropped-video"}, {"samples": "audio"},
)
assert ("concat", {"samples": "video-in"}, {"samples": "audio-in"}) in calls
sample = next(call for call in calls if call[0] == "sample")
assert torch.equal(sample[4], torch.tensor([1.0, 0.5, 0.0]))
assert sample[5] == {"samples": "av"}
assert ("crop", "positive", "negative", {"samples": "video"}) in calls
def test_ltx_encode_execute_defaults_match_schema_defaults(monkeypatch):
module, _ = _load_ltx_module(monkeypatch)
signature = inspect.signature(module.LTXMultiTrackEncode.execute)
assert signature.parameters["epsilon"].default == 0.001
assert signature.parameters["width"].default == 512
assert signature.parameters["height"].default == 512
assert signature.parameters["video_length"].default == 73
assert signature.parameters["half_latent_size"].default is True
def test_ltx_nodes_are_exported_and_registered():
root = Path(__file__).parents[1]
nodes_init = (root / "nodes" / "__init__.py").read_text(encoding="utf-8")
extension_init = (root / "__init__.py").read_text(encoding="utf-8")
assert "from .ltx import *" in nodes_init
assert "LTXMultiTrackEncode," in extension_init
assert "LTXI2VInplaceAndUpsample," in extension_init
assert "LTXSamplerSimple," in extension_init
def test_ltx_nodes_have_complete_chinese_localization():
locale_path = Path(__file__).parents[1] / "locales" / "zh" / "nodeDefs.json"
node_defs = json.loads(locale_path.read_text(encoding="utf-8"))
expected = {
"easy ltxMultiTrackEncode": {
"inputs": {
"model", "clip", "audio_vae", "audio", "local_prompt", "global_prompt", "epsilon",
"width", "height", "frame_rate", "video_length", "half_latent_size",
},
"outputs": 5,
},
"easy ltxI2VInplaceAndUpsample": {
"inputs": {
"vae", "image", "video_latent", "upscale_models", "img_index", "strength",
"img_compression", "bypass",
},
"outputs": 1,
},
"easy ltxSamplerSimple": {
"inputs": {
"model", "positive", "negative", "video_latent", "audio_latent", "sampler_name",
"sigmas", "cfg", "seed",
},
"outputs": 4,
},
}
for node_id, localization in expected.items():
translation = node_defs[node_id]
assert translation["display_name"]
assert translation["description"]
assert set(translation["inputs"]) == localization["inputs"]
assert set(translation["outputs"]) == {str(index) for index in range(localization["outputs"])}
assert "未连接" in node_defs["easy ltxI2VInplaceAndUpsample"]["inputs"]["image"]["tooltip"]
def test_ltx_nodes_use_the_real_node_output_indexing_api():
source = (Path(__file__).parents[1] / "nodes" / "ltx.py").read_text(encoding="utf-8")
assert ".values" not in source