206 lines
8.0 KiB
Python
206 lines
8.0 KiB
Python
from __future__ import annotations
|
|
|
|
import importlib.util
|
|
import pathlib
|
|
import sys
|
|
import types
|
|
import unittest
|
|
from dataclasses import dataclass
|
|
|
|
|
|
ROOT = pathlib.Path(__file__).parents[1]
|
|
|
|
|
|
def load_module(name, path):
|
|
spec = importlib.util.spec_from_file_location(name, ROOT / path)
|
|
module = importlib.util.module_from_spec(spec)
|
|
assert spec.loader is not None
|
|
spec.loader.exec_module(module)
|
|
return module
|
|
|
|
|
|
PROMPT = load_module("dumas_h3_prompt_test", "dumas_h3_prompt_nodes.py")
|
|
UPSCALE = load_module("dumas_h3_upscale_test", "dumas_h3_upscale_nodes.py")
|
|
|
|
|
|
class FakeSamples:
|
|
def __init__(self, shape):
|
|
self.shape = shape
|
|
self.ndim = len(shape)
|
|
|
|
|
|
class FakeNoise:
|
|
def get_noise(self, seed):
|
|
return ("noise", seed)
|
|
|
|
|
|
class FakeSampler:
|
|
def get_sampler(self, name):
|
|
return ("sampler", name)
|
|
|
|
|
|
class FakeScheduler:
|
|
def get_sigmas(self, model, scheduler, steps, denoise):
|
|
return ("sigmas", scheduler, steps, denoise)
|
|
|
|
|
|
class FakeUpscale:
|
|
FUNCTION = "execute"
|
|
calls = []
|
|
|
|
def execute(self, **kwargs):
|
|
self.calls.append(kwargs)
|
|
source = kwargs["latent"]["samples"]
|
|
_, _, frames, height, width = source.shape
|
|
return ({"samples": FakeSamples((1, 16, frames, height * 2, width * 2))},)
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class FakeReferenceBundle:
|
|
images: tuple
|
|
reference_use: str
|
|
selectors: tuple
|
|
|
|
|
|
class FakeRefMod:
|
|
kind = "video"
|
|
path = ""
|
|
|
|
def __init__(self, name):
|
|
self.name = name
|
|
|
|
|
|
class H3NodeTests(unittest.TestCase):
|
|
def test_prompt_schema_and_full_chunk_reference_routing(self):
|
|
self.assertEqual(
|
|
PROMPT.DumasH3SequencePromptBuilder.CATEGORY,
|
|
"Dumas/MiniMax H3/Prompt",
|
|
)
|
|
optional = PROMPT.DumasH3SequencePromptBuilder.INPUT_TYPES()["optional"]
|
|
self.assertEqual(optional["reference_image_1"][0], "IMAGE")
|
|
self.assertEqual(optional["reference_image_9"][0], "IMAGE")
|
|
reference_module = types.ModuleType("upstream.v3.reference_images_v39")
|
|
reference_module.ReferenceImagesV39Bundle = FakeReferenceBundle
|
|
sys.modules[reference_module.__name__] = reference_module
|
|
try:
|
|
node = PROMPT.DumasH3SequencePromptBuilder()
|
|
result = node.build(
|
|
2, 4, "Keep @R1 present.",
|
|
'{"clips":[{"slots":[{"start":0,"end":4,"text":"Walk."}]},'
|
|
'{"slots":[{"start":0,"end":4,"text":"Turn."}]}]}',
|
|
"Use @R2 ambience.", "Music.",
|
|
reference_image_1="environment",
|
|
reference_image_2="hero",
|
|
)
|
|
self.assertEqual(result[1], 2)
|
|
self.assertEqual(result[2], 4.0)
|
|
self.assertEqual(result[3].selectors, ("1,2", "1,2") + ("off",) * 7)
|
|
self.assertIn("[0-4s]", result[0])
|
|
self.assertIn("[4-8s]", result[0])
|
|
finally:
|
|
sys.modules.pop(reference_module.__name__, None)
|
|
|
|
def test_prompt_builder_emits_connected_images(self):
|
|
reference_module = types.ModuleType("upstream.v3.reference_images_v39")
|
|
reference_module.ReferenceImagesV39Bundle = FakeReferenceBundle
|
|
sys.modules[reference_module.__name__] = reference_module
|
|
try:
|
|
result = PROMPT.DumasH3SequencePromptBuilder().build(
|
|
2, 4, "", '{"clips":[{"slots":[{"start":0,"end":4,"text":"Use @R1."}]},'
|
|
'{"slots":[{"start":0,"end":4,"text":"Continue with @R1."}]}]}',
|
|
"", "", reference_image_1="hero_ref",
|
|
)
|
|
self.assertEqual(result[3].images[0], "hero_ref")
|
|
self.assertEqual(result[3].selectors[0], "1,2")
|
|
finally:
|
|
sys.modules.pop(reference_module.__name__, None)
|
|
|
|
def test_disabled_chunks_are_removed_from_prompt_and_routing_outputs(self):
|
|
reference_module = types.ModuleType("upstream.v3.reference_images_v39")
|
|
reference_module.ReferenceImagesV39Bundle = FakeReferenceBundle
|
|
sys.modules[reference_module.__name__] = reference_module
|
|
try:
|
|
result = PROMPT.DumasH3SequencePromptBuilder().build(
|
|
3, 4, "", '{"clips":['
|
|
'{"enabled":true,"slots":[{"start":0,"end":4,"text":"Use @R1."}]},'
|
|
'{"enabled":false,"slots":[{"start":0,"end":4,"text":"Do not emit @R1."}]},'
|
|
'{"enabled":true,"slots":[{"start":0,"end":4,"text":"Continue @R1."}]}]}',
|
|
"", "", reference_image_1="hero",
|
|
)
|
|
self.assertEqual(result[1], 2)
|
|
self.assertEqual(result[3].selectors[0], "1,2")
|
|
self.assertNotIn("Do not emit", result[0])
|
|
self.assertIn("[0-4s]", result[0])
|
|
self.assertIn("[4-8s]", result[0])
|
|
self.assertNotIn("[8-12s]", result[0])
|
|
finally:
|
|
sys.modules.pop(reference_module.__name__, None)
|
|
|
|
def test_image_slots_are_preserved_even_when_not_referenced(self):
|
|
reference_module = types.ModuleType("upstream.v3.reference_images_v39")
|
|
reference_module.ReferenceImagesV39Bundle = FakeReferenceBundle
|
|
sys.modules[reference_module.__name__] = reference_module
|
|
try:
|
|
result = PROMPT.DumasH3SequencePromptBuilder().build(
|
|
2, 4, "", '{"clips":['
|
|
'{"slots":[{"start":0,"end":4,"text":"Use @R2."}]},'
|
|
'{"slots":[{"start":0,"end":4,"text":"No extra reference."}]}]}',
|
|
"", "", reference_image_1="unused",
|
|
reference_image_2="used",
|
|
reference_image_3="also_unused",
|
|
)
|
|
self.assertEqual(result[3].images[1], "used")
|
|
self.assertEqual(result[3].images[0], "unused")
|
|
self.assertEqual(result[3].images[2], "also_unused")
|
|
finally:
|
|
sys.modules.pop(reference_module.__name__, None)
|
|
|
|
def test_per_clip_upscale_uses_connected_sigmas(self):
|
|
original = UPSCALE._native_node
|
|
original_helper = UPSCALE._continuum_helper
|
|
FakeUpscale.calls = []
|
|
UPSCALE._native_node = lambda name: {
|
|
"MMH3UltimateUpscale": FakeUpscale,
|
|
"RandomNoise": FakeNoise,
|
|
"KSamplerSelect": FakeSampler,
|
|
"BasicScheduler": FakeScheduler,
|
|
}.get(name)
|
|
geometry_inputs = []
|
|
def fake_helper(name):
|
|
if name == "latent_from_cpu":
|
|
return lambda video, audio: {"samples": video}
|
|
if name == "extract_av_streams":
|
|
return lambda latent: (latent["samples"], None)
|
|
def update_geometry(plan, latents):
|
|
geometry_inputs.append(latents)
|
|
return {**plan, "updated": True}
|
|
return update_geometry
|
|
UPSCALE._continuum_helper = fake_helper
|
|
try:
|
|
node = UPSCALE.DumasH3ContinuumTiledLatentUpscalePerClip()
|
|
outputs, audio, plan, report = node.upscale(
|
|
model=["model"], clip=["clip"],
|
|
video_latents=[{"samples": FakeSamples((1, 16, 85, 48, 84))}],
|
|
audio_latents=[{"samples": "first-pass"}],
|
|
assembly_plan=[{"plan": True}], refine_context=["context"],
|
|
latent_upscale_param=["upscale"], spatial_split_param=["spatial"],
|
|
upscale_sampler=["euler"], upscale_scheduler=["simple"],
|
|
upscale_steps=[3], upscale_denoise=[0.2], upscale_cfg=[1.0],
|
|
upscale_noise_seed=[100], conditioning=["conditioning"],
|
|
upscale_sigmas=["connected-sigmas"],
|
|
)
|
|
self.assertEqual(len(outputs), 1)
|
|
self.assertEqual(audio, [{"samples": "first-pass"}])
|
|
self.assertTrue(plan["updated"])
|
|
self.assertEqual(FakeUpscale.calls[0]["sigmas"], "connected-sigmas")
|
|
self.assertEqual(len(geometry_inputs), 1)
|
|
self.assertIsInstance(geometry_inputs[0][0]["samples"], FakeSamples)
|
|
self.assertIn("clips=1", report)
|
|
finally:
|
|
UPSCALE._native_node = original
|
|
UPSCALE._continuum_helper = original_helper
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|