diff --git a/tests/test_tiled_latent_upscale_nodes.py b/tests/test_tiled_latent_upscale_nodes.py index a131572..170c168 100644 --- a/tests/test_tiled_latent_upscale_nodes.py +++ b/tests/test_tiled_latent_upscale_nodes.py @@ -31,6 +31,11 @@ class FakeScheduler: return ("sigmas", scheduler, steps, denoise) +class FakeNodeOutput: + def __init__(self, *args): + self.result = args + + class FakeUpscale: FUNCTION = "execute" calls = [] @@ -81,6 +86,16 @@ class TiledUpscaleTests(unittest.TestCase): result = MODULE._call_native(FakeUpscale, {"value": 7}) self.assertEqual(result[0]["samples"].shape, (1, 16, 7, 1, 1)) + def test_node_output_wrapper_is_unwrapped_for_single_values(self): + self.assertEqual( + MODULE._unwrap_single_output(FakeNodeOutput("tensor"), "schedule"), + "tensor", + ) + self.assertEqual( + MODULE._unwrap_single_output(("legacy", "tuple"), "legacy"), + ("legacy", "tuple"), + ) + def test_rejects_temporal_resize(self): class BadUpscale(FakeUpscale): def execute(self, **kwargs): diff --git a/v3/second_pass.py b/v3/second_pass.py index 8c12039..dcea669 100644 --- a/v3/second_pass.py +++ b/v3/second_pass.py @@ -29,7 +29,7 @@ from .refine_schedule import ( serializable_schedule_contract, ) from .refine_sampling import sample_refine_chunk -from .tiled_latent_upscale_nodes import _call_native +from .tiled_latent_upscale_nodes import _call_native, _unwrap_single_output class SecondPassContractError(ValueError): @@ -541,15 +541,20 @@ def run_second_pass_groups( upscale_seed = derive_refine_seed( int(config.get("seed_base", physical_seed)), group_index ) - noise = config["random_noise"]().get_noise(upscale_seed) + noise = _unwrap_single_output( + config["random_noise"]().get_noise(upscale_seed), "RandomNoise" + ) upscale_sampler = config["sampler"] upscale_sigmas = config.get("sigmas") if upscale_sigmas is None: - upscale_sigmas = config["scheduler"]().get_sigmas( - chunk_model, - config["scheduler_name"], - config["steps"], - config["denoise"], + upscale_sigmas = _unwrap_single_output( + config["scheduler"]().get_sigmas( + chunk_model, + config["scheduler_name"], + config["steps"], + config["denoise"], + ), + "BasicScheduler", ) native_kwargs = { "model": chunk_model, diff --git a/v3/second_pass_nodes.py b/v3/second_pass_nodes.py index b19cb84..dd84d39 100644 --- a/v3/second_pass_nodes.py +++ b/v3/second_pass_nodes.py @@ -9,6 +9,7 @@ from .refine_scope import MODE_ALL, MODE_LOGICAL_CHUNK, MODE_PHYSICAL_GROUP from .refine_window import MODE_TIME_WINDOW from .second_pass import run_second_pass_groups from .targeted_second_pass import run_targeted_second_pass_groups +from .tiled_latent_upscale_nodes import _native_node, _unwrap_single_output REFINE_TARGET_VIDEO_ONLY = "Video Only" @@ -164,8 +165,6 @@ class H3ContinuumSecondPassV35: ): tiled_config = None if bool(_single_list_input("tiled_upscale", tiled_upscale)): - from .tiled_latent_upscale_nodes import _native_node - required_native = { name: _native_node(name) for name in ( @@ -185,8 +184,11 @@ class H3ContinuumSecondPassV35: tiled_config = { "native": required_native["MMH3UltimateUpscale"], "random_noise": required_native["RandomNoise"], - "sampler": required_native["KSamplerSelect"]().get_sampler( - str(_single_list_input("upscale_sampler", upscale_sampler)) + "sampler": _unwrap_single_output( + required_native["KSamplerSelect"]().get_sampler( + str(_single_list_input("upscale_sampler", upscale_sampler)) + ), + "KSamplerSelect", ), "scheduler": required_native["BasicScheduler"], "scheduler_name": str(_single_list_input("upscale_scheduler", upscale_scheduler)), diff --git a/v3/tiled_latent_upscale_nodes.py b/v3/tiled_latent_upscale_nodes.py index c8cf331..0dc87c4 100644 --- a/v3/tiled_latent_upscale_nodes.py +++ b/v3/tiled_latent_upscale_nodes.py @@ -38,6 +38,35 @@ def _native_node(name: str): return None +def _unwrap_node_output(value: Any) -> Any: + """Extract values returned by ComfyUI's newer NodeOutput API. + + The v3 API wraps node results in ``NodeOutput`` while legacy nodes expect + the underlying tensor/object directly. Keep this adapter compatible with + both APIs without importing ComfyUI internals. + """ + + result = getattr(value, "result", None) + if result is None and not hasattr(value, "result"): + return value + return result + + +def _unwrap_single_output(value: Any, name: str) -> Any: + marker = object() + result = getattr(value, "result", marker) + # Ordinary tuples are valid values for the lightweight test doubles and + # for some legacy ComfyUI helpers. Only unwrap an actual NodeOutput-like + # object, identified by its result property. + if result is marker: + return value + if isinstance(result, (tuple, list)): + if len(result) != 1: + raise ValueError(f"{name} returned {len(result)} outputs; expected one") + return result[0] + return result + + def _call_native(node_class, kwargs: dict[str, Any]): """Invoke a ComfyUI node through its declared FUNCTION contract. @@ -59,7 +88,7 @@ def _call_native(node_class, kwargs: dict[str, Any]): seen.add(name) method = getattr(instance, name, None) if callable(method): - return method(**kwargs) + return _unwrap_node_output(method(**kwargs)) raise RuntimeError( "MMH3UltimateUpscale exposes no callable ComfyUI FUNCTION method " f"(declared={declared!r})" @@ -266,12 +295,19 @@ class H3ContinuumTiledLatentUpscalePerClip: samples = clip_latent.get("samples") if isinstance(clip_latent, dict) else None if samples is None or getattr(samples, "ndim", None) != 5: raise ValueError(f"clip {index} is not a 5-D H3 LATENT") - noise = random_noise().get_noise(seed + index - 1) - sampler = sampler_select().get_sampler(sampler_name) + noise = _unwrap_single_output( + random_noise().get_noise(seed + index - 1), "RandomNoise" + ) + sampler = _unwrap_single_output( + sampler_select().get_sampler(sampler_name), "KSamplerSelect" + ) sigmas = sigma_values[index - 1] if sigmas is None: - sigmas = scheduler().get_sigmas( - clip_model, scheduler_name, steps, denoise + sigmas = _unwrap_single_output( + scheduler().get_sigmas( + clip_model, scheduler_name, steps, denoise + ), + "BasicScheduler", ) kwargs = { "model": clip_model,