MMnode/tests/test_slot_input_containers.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

204 lines
6.8 KiB
Python

"""Slot media inputs (@imageN/@audioN/@videoN) must survive the container shapes that
``is_input_list=True`` (and lazy inputs) can produce at runtime: a plain list, a tuple,
and single-element list/tuple-wrapped nested containers.
Regression: under the V3 input system an unevaluated lazy slot arrives as ``(None,)``
rather than ``None`` and, once materialised, slot media can arrive as a tuple. The slot
indexing helpers only handled ``list``, so the referenced media was silently dropped
(images fell back to ``t2v``; video indexing returned the wrapper tuple).
"""
import importlib.util
import sys
from pathlib import Path
import pytest
import torch
def _load_harness():
# Load the shared stub harness by path so this works under any pytest import
# mode and regardless of whether the tests directory is on sys.path.
harness_path = Path(__file__).with_name("test_multitrack_info_output.py")
spec = importlib.util.spec_from_file_location("_em_multitrack_harness", harness_path)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
return module
_load_basic_module = _load_harness()._load_basic_module
@pytest.fixture(scope="module")
def basic():
_load_basic_module()
return sys.modules["easy_media.utils.multitrack"]
def _containers(first, second=None):
"""Every container shape the input plumbing can hand to a slot indexer."""
single = {
"list": [first],
"tuple": (first,),
"nested-list": [[first]],
"nested-tuple": ([first],),
}
if second is None:
return single
multi = {
"list": [first, second],
"tuple": (first, second),
"nested-list": [[first, second]],
"nested-tuple": ([first, second],),
}
return single, multi
def _is_real_image(basic, tensor):
return (
isinstance(tensor, torch.Tensor)
and not basic._is_empty_slot_image(basic._normalize_image_tensor(tensor))
)
def test_index_slot_image_single(basic):
image = torch.rand(1, 480, 832, 3)
for label, value in _containers(image).items():
result = basic._index_slot_image(value, "image1")
assert _is_real_image(basic, result), f"image1 via {label} was dropped"
def test_index_slot_image_multi(basic):
first, second = torch.rand(1, 480, 832, 3), torch.rand(1, 480, 832, 3)
_, multi = _containers(first, second)
for label, value in multi.items():
result = basic._index_slot_image(value, "image2")
assert isinstance(result, torch.Tensor), f"image2 via {label} was dropped"
assert result.shape[0] == 1
def test_index_slot_image_skips_empty_placeholder(basic):
# makeImageList(skip_empty=False) pads unused slots with 1x1 placeholders
real = torch.rand(1, 480, 832, 3)
empty = torch.zeros(1, 1, 4)
result = basic._index_slot_image([real, empty, empty], "image1")
assert _is_real_image(basic, result)
def test_index_slot_audio_single(basic):
audio = {"waveform": torch.zeros(1, 2, 100), "sample_rate": 44100}
for label, value in _containers(audio).items():
result = basic._index_slot_audio(value, "audio1")
assert isinstance(result, dict) and "waveform" in result, f"audio1 via {label}"
def test_index_slot_audio_multi(basic):
first = {"waveform": torch.zeros(1, 2, 100), "sample_rate": 44100}
second = {"waveform": torch.zeros(1, 2, 200), "sample_rate": 44100}
_, multi = _containers(first, second)
for label, value in multi.items():
result = basic._index_slot_audio(value, "audio2")
assert result is second, f"audio2 via {label} did not select the second clip"
def test_index_slot_video_single(basic):
video = object()
for label, value in _containers(video).items():
result = basic._index_slot_video(value, "video1")
assert result is video, f"video1 via {label} returned {type(result).__name__}"
def test_index_slot_video_multi(basic):
first, second = object(), object()
_, multi = _containers(first, second)
for label, value in multi.items():
result = basic._index_slot_video(value, "video2")
assert result is second, f"video2 via {label} did not select the second clip"
@pytest.mark.parametrize(
"slot_name,expected_index",
[
("image1", 0),
("audio2", 1),
("video3", 2),
],
)
def test_slot_index_supports_one_based_names(basic, slot_name, expected_index):
assert basic._slot_index(slot_name) == expected_index
def test_encoded_slot_paths_are_detected_for_all_multitrack_media_types(basic):
data = {
"tracks": [
{
"type": "task",
"segments": [{"content": {"images": [{"file_path": "__slot__:image2"}]}}],
},
{
"type": "audio",
"segments": [{"content": {"media_type": "audio", "file_path": "__slot__:audio2"}}],
},
{
"type": "video",
"segments": [{"content": {"media_type": "video", "file_path": "__slot__:video2"}}],
},
],
}
assert basic.multitrack_slot_media_types(data) == {"image", "audio", "video"}
def test_encoded_slot_paths_resolve_connected_media(basic):
images = [torch.zeros(1, 4, 4, 3), torch.ones(1, 4, 4, 3)]
audios = [
{"waveform": torch.zeros(1, 1, 4), "sample_rate": 2},
{"waveform": torch.ones(1, 1, 4), "sample_rate": 2},
]
videos = [object(), object()]
image = basic._resolve_timeline_image_item({"file_path": "__slot__:image2"}, images)
audio = basic._resolve_multitrack_audio({"file_path": "__slot__:audio2"}, audios)
video = basic._resolve_multitrack_video({"file_path": "__slot__:video2"}, videos)
assert image is not None and torch.equal(image, images[1])
assert audio is audios[1]
assert video is videos[1]
def test_canonicalize_encoded_slot_path_for_tracks_info(basic):
normalized = basic.canonicalize_multitrack_slot_content({
"media_type": "video",
"source_type": "input",
"file_path": "__slot__:video2",
})
assert normalized == {
"media_type": "video",
"source_type": "slot",
"slot_name": "video2",
"file_name": "video2",
}
@pytest.mark.parametrize(
"value,expected_len",
[
((object(),), 1),
(([object(), object()],), 2),
([object()], 1),
([[object(), object()]], 2),
(None, 0),
],
)
def test_as_list_input_normalises_tuples(basic, value, expected_len):
result = basic._as_list_input(value)
assert isinstance(result, list)
assert len(result) == expected_len
def test_unwrap_slot_input_normalises_tuples(basic):
item = object()
assert basic._unwrap_slot_input((item,)) == [item]
assert basic._unwrap_slot_input(([item],)) == [item]
assert basic._unwrap_slot_input([item]) == [item]