103 lines
4.0 KiB
Python
103 lines
4.0 KiB
Python
import importlib.util
|
|
import sys
|
|
import types
|
|
import unittest
|
|
|
|
|
|
class DumasMiniMaxNodeTests(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
comfy = types.ModuleType("comfy")
|
|
samplers = types.ModuleType("comfy.samplers")
|
|
samplers.KSampler = types.SimpleNamespace(
|
|
SAMPLERS=["euler", "euler_ancestral"],
|
|
SCHEDULERS=["simple", "beta"],
|
|
)
|
|
comfy.samplers = samplers
|
|
sys.modules.setdefault("comfy", comfy)
|
|
sys.modules.setdefault("comfy.samplers", samplers)
|
|
spec = importlib.util.spec_from_file_location("dumas_minimax_nodes", "dumas_minimax_nodes.py")
|
|
cls.module = importlib.util.module_from_spec(spec)
|
|
spec.loader.exec_module(cls.module)
|
|
|
|
def test_registers_tiled_upscale_node(self):
|
|
self.assertEqual(set(self.module.NODE_CLASS_MAPPINGS), {"DumasMMH3TiledLatentUpscale"})
|
|
|
|
def test_exposes_independent_upscale_controls_and_param_inputs(self):
|
|
inputs = self.module.DumasMMH3TiledLatentUpscale.INPUT_TYPES()
|
|
required = inputs["required"]
|
|
self.assertEqual(required["latent_upscale_param"][0], "H3_UPSCALE_PARAM")
|
|
self.assertEqual(required["spatial_split_param"][0], "H3_SPATIAL_PARAM")
|
|
self.assertEqual(required["upscale_steps"][1]["default"], 3)
|
|
self.assertIn("upscale_noise_seed", required)
|
|
self.assertEqual(inputs["optional"]["temporal_split_param"][0], "H3_TEMPORAL_PARAM")
|
|
self.assertIn("upscale_sigmas", inputs["optional"])
|
|
|
|
def test_missing_native_node_is_reported(self):
|
|
original = self.module._native_node
|
|
self.module._native_node = lambda name: None
|
|
try:
|
|
with self.assertRaisesRegex(RuntimeError, "MMH3UltimateUpscale"):
|
|
self.module.DumasMMH3TiledLatentUpscale().upscale(
|
|
object(), object(), {"samples": object()}, {}, {},
|
|
"euler_ancestral", "simple", 3, 0.2, 1.0, 1,
|
|
)
|
|
finally:
|
|
self.module._native_node = original
|
|
|
|
def test_calls_native_upscale_with_tiled_params_and_own_schedule(self):
|
|
calls = {}
|
|
|
|
class Noise:
|
|
def get_noise(self, seed):
|
|
calls["seed"] = seed
|
|
return "noise"
|
|
|
|
class Sampler:
|
|
def get_sampler(self, name):
|
|
calls["sampler"] = name
|
|
return "sampler"
|
|
|
|
class Scheduler:
|
|
def get_sigmas(self, model, name, steps, denoise):
|
|
calls["schedule"] = (name, steps, denoise)
|
|
return "sigmas"
|
|
|
|
class Native:
|
|
def upscale(self, **kwargs):
|
|
calls["kwargs"] = kwargs
|
|
return ({"samples": FakeTensor((1, 24, 9, 48, 72))}, {}, {})
|
|
|
|
class FakeTensor:
|
|
def __init__(self, shape):
|
|
self.shape = shape
|
|
self.ndim = len(shape)
|
|
|
|
original = self.module._native_node
|
|
mapping = {
|
|
"MMH3UltimateUpscale": Native,
|
|
"RandomNoise": Noise,
|
|
"KSamplerSelect": Sampler,
|
|
"BasicScheduler": Scheduler,
|
|
}
|
|
self.module._native_node = lambda name: mapping[name]
|
|
try:
|
|
latent = {"samples": FakeTensor((1, 24, 9, 24, 36))}
|
|
result, info = self.module.DumasMMH3TiledLatentUpscale().upscale(
|
|
"model", "conditioning", latent, "upscale", "spatial",
|
|
"euler_ancestral", "simple", 3, 0.2, 1.0, 123,
|
|
temporal_split_param="temporal",
|
|
)
|
|
self.assertEqual(result["samples"].shape[2], 9)
|
|
self.assertEqual(calls["seed"], 123)
|
|
self.assertEqual(calls["schedule"], ("simple", 3, 0.2))
|
|
self.assertEqual(calls["kwargs"]["spatial_split_param"], "spatial")
|
|
self.assertEqual(calls["kwargs"]["temporal_split_param"], "temporal")
|
|
self.assertIn("Dumas tiled MiniMax-H3", info)
|
|
finally:
|
|
self.module._native_node = original
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|