"""RR-R6 public boundary and read-only Reference Plan contracts.""" from __future__ import annotations from copy import deepcopy import json from pathlib import Path from types import SimpleNamespace from uuid import UUID import zipfile import pytest import torch from ComfyUI_H3_Continuum_Join import nodes as public_nodes from ComfyUI_H3_Continuum_Join.v3 import driving_nodes from ComfyUI_H3_Continuum_Join.v3.reference_images_v39 import ( H3ContinuumReferenceImagesV39, REFERENCE_IMAGES_V39_TYPE, ReferenceImagesV39Bundle, effective_reference_inputs, ) from ComfyUI_H3_Continuum_Join.v3.reference_plan_inspector import ( format_reference_plan, project_reference_plan, ) from ComfyUI_H3_Continuum_Join.v3.reference_routing import ( REFERENCE_SLOT_IDS, compile_reference_routing_schedule, ) from ComfyUI_H3_Continuum_Join.v3.reference_runtime import ( ReferenceInputSet, ReferenceRoutingRuntime, ) from ComfyUI_H3_Continuum_Join.v3.reference_storage_contract import canonical_sha256 from ComfyUI_H3_Continuum_Join.v3.refine_context import ( RefineContextError, make_refine_context, make_refine_group, validate_refine_context, ) from ComfyUI_H3_Continuum_Join.v3.second_pass import run_second_pass_groups def test_v39_has_one_typed_reference_input_and_v38_is_unchanged(): assert public_nodes.NODE_CLASS_MAPPINGS["H3ContinuumSamplerV39"] is ( driving_nodes.H3ContinuumSamplerV39 ) old = driving_nodes.H3ContinuumSamplerV38.INPUT_TYPES() new = driving_nodes.H3ContinuumSamplerV39.INPUT_TYPES() assert new["required"] == old["required"] assert "reference_routing_mode" not in new["required"] assert not any(f"reference_r{index}_chunks" in new["required"] for index in range(1, 10)) assert set(new["optional"]) == (set(old["optional"]) - {"reference_image_1", "reference_image_2", "reference_image_3", "image_references", "reference_image_4", "reference_image_5"} | {"reference_images"}) assert new["optional"]["reference_images"][0] == H3ContinuumReferenceImagesV39.RETURN_TYPES[0] assert public_nodes.NODE_CLASS_MAPPINGS["H3ContinuumReferenceImagesV39"] is H3ContinuumReferenceImagesV39 assert tuple(H3ContinuumReferenceImagesV39.INPUT_TYPES()["optional"]) == tuple( f"reference_image_{index}" for index in range(1, 10) ) def test_all_uses_the_same_routed_engine(monkeypatch): calls = [] plan = {"mode": "Custom", "accepted_chunks": 0, "connected_slots": ["R1"], "groups": []} outputs = (object(), object(), {"reference_routing_v1": plan}, "status", object()) def old_run(_self, **kwargs): calls.append(kwargs) return outputs monkeypatch.setattr(driving_nodes.H3ContinuumSamplerV38, "run", old_run) image = object() bundle = ReferenceImagesV39Bundle((image, *(None for _ in range(8))), "All chunks", ("off",) * 9) result = driving_nodes.H3ContinuumSamplerV39().run(reference_images=bundle, chunks=3, marker=7) assert result["result"] is outputs assert calls[0]["marker"] == 7 assert calls[0]["reference_image_1"] is image assert calls[0]["_reference_routing_settings"] == { "R1": "all", **{f"R{index}": "off" for index in range(2, 10)} } def test_custom_passes_selectors_privately_and_displays_verified_backend_plan(monkeypatch): calls = [] plan = { "mode": "Custom", "accepted_chunks": 1, "connected_slots": ["R1"], "groups": [{ "physical_group": 1, "logical_chunks": [1], "status": "generated", "descriptor": {"references": [{"source_slot_id": "R1", "picture_number": 2}]}, "contract_sha256": "a" * 64, "warnings": [], }], } def old_run(_self, **kwargs): calls.append(kwargs) return ([], [], {"reference_routing_v1": plan}, "status", None) monkeypatch.setattr(driving_nodes.H3ContinuumSamplerV38, "run", old_run) image = object() bundle = ReferenceImagesV39Bundle((image, *(None for _ in range(8))), "Per chunk", ("2-3", *("off" for _ in range(8)))) result = driving_nodes.H3ContinuumSamplerV39().run( reference_images=bundle, chunks=3, marker=7, ) assert calls[0]["marker"] == 7 assert calls[0]["_reference_routing_settings"] == { **{f"R{index}": "off" for index in range(1, 10)}, "R1": "2,3", "R9": "off", } assert result["ui"]["h3_reference_plan"] == [format_reference_plan(plan)] assert "R1=" in result["ui"]["h3_reference_plan"][0] def test_plan_inspector_uses_observed_or_frozen_contract_not_a_frontend_guess(): selectors = {slot: "off" for slot in REFERENCE_SLOT_IDS} selectors.update(R1="1", R4="2") schedule = compile_reference_routing_schedule( total_chunks=3, terminal_merge_enabled=False, mode="Custom", selectors_by_slot=selectors, ) runtime = ReferenceRoutingRuntime( schedule=schedule, inputs=ReferenceInputSet((None,) * 9, 64, 64, "Match Output"), ) first = { "descriptor": {"references": [{"source_slot_id": "R1", "picture_number": 1}]}, "sha256": "a" * 64, } second = { "descriptor": {"references": [{"source_slot_id": "R4", "picture_number": 1}]}, "sha256": "b" * 64, } runtime.storage_plan = SimpleNamespace(group_for=lambda group: {1: first, 2: second}[group]) runtime.observed_group_contracts[2] = deepcopy(second) runtime.group_warnings[2] = ("R9 is disconnected",) runtime.accepted_chunks = 2 runtime.generated_groups = (2,) projected = project_reference_plan(runtime) assert [item["status"] for item in projected["groups"]] == [ "reused", "generated", "pending", ] assert projected["groups"][0]["contract_sha256"] == "a" * 64 assert projected["groups"][1]["warnings"] == ["R9 is disconnected"] assert "descriptor" not in projected["groups"][2] assert "configured no References" in format_reference_plan(projected) assert first["descriptor"]["references"][0]["picture_number"] == 1 def test_invalid_bundle_mode_does_not_call_v38(monkeypatch): monkeypatch.setattr( driving_nodes.H3ContinuumSamplerV38, "run", lambda *_args, **_kwargs: pytest.fail("legacy path was called"), ) bad = ReferenceImagesV39Bundle((None,) * 9, "Other", ("off",) * 9) with pytest.raises(ValueError, match="nine-slot V3.9 bundle"): driving_nodes.H3ContinuumSamplerV39().run(reference_images=bad) def test_inline_helper_keeps_sparse_slot_ids_and_saved_future_chunks(): image1, image4, image9 = object(), object(), object() values = {"reference_use": "Per chunk", "reference_image_1": image1, "reference_image_4": image4, "reference_image_9": image9, "reference_r1_chunks": "1,3,6", "reference_r4_chunks": "2-4", "reference_r9_chunks": "all"} (bundle,) = H3ContinuumReferenceImagesV39().pack(**values) assert bundle.images[3] is image4 and bundle.images[8] is image9 assert bundle.selectors[3] == "2,3,4" first, extra, routes = effective_reference_inputs(bundle, chunks=3) assert first[0] is image1 and extra.images[0] is image4 and extra.images[5] is image9 assert routes["R1"] == "1,3" assert routes["R4"] == "2,3" assert routes["R9"] == "1,2,3" assert effective_reference_inputs(bundle, chunks=6)[2]["R1"] == "1,3,6" assert bundle.selectors[0] == "1,3,6" @pytest.mark.parametrize("saved,expected", [ ("1,2", [("R1",), ("R1",), ()]), ("1,2,3", [("R1",), ("R1",), ("R1",)]), (",".join(str(n) for n in range(1, 17)), [("R1",), ("R1",), ("R1",)]), ("off", [(), (), ()]), ]) def test_external_assignment_range_uses_actual_chunks_without_rewriting_saved_value(saved, expected): bundle, = H3ContinuumReferenceImagesV39().pack( reference_use="Per chunk", reference_r1_chunks=saved, reference_image_1=object(), ) original = bundle.selectors _, _, selectors = effective_reference_inputs(bundle, chunks=3) schedule = compile_reference_routing_schedule( total_chunks=3, terminal_merge_enabled=False, mode="Custom", selectors_by_slot=selectors, ) assert schedule.valid assert [route.reference_slot_ids for route in schedule.logical_routes] == expected assert bundle.selectors == original def test_new_workflow_rewires_all_nine_slots_and_isolates_saved_runs(): directory = Path(__file__).resolve().parents[1] / "examples" / "workflows" old = json.loads((directory / "MiniMax_H3_Continuum_V38X2.json").read_text(encoding="utf-8")) name = "MiniMax_H3_Continuum_V39_Reference_Inline.json" new_bytes = (directory / name).read_bytes() new = json.loads(new_bytes) with zipfile.ZipFile(directory / name.replace(".json", ".zip")) as archive: assert archive.namelist() == [name] assert archive.read(name) == new_bytes assert len(old["nodes"]) == len(new["nodes"]) assert len(old["links"]) == len(new["links"]) old_sampler = next(node for node in old["nodes"] if node["id"] == 312) sampler = next(node for node in new["nodes"] if node["id"] == 312) helper = next(node for node in new["nodes"] if node["id"] == 348) assert sampler["type"] == "H3ContinuumSamplerV39" # The user-supplied V38X2+Decode Cache Helper graph has an appended # Timeline Video mode that the earlier repository template lacked. project_id = sampler["widgets_values_named"]["project_id"] assert UUID(project_id).version == 4 assert project_id != old_sampler["widgets_values_named"]["project_id"] expected_values = old_sampler["widgets_values"].copy() project_index = expected_values.index(old_sampler["widgets_values_named"]["project_id"]) expected_values[project_index] = project_id assert sampler["widgets_values"][:-1] == expected_values assert sampler["widgets_values"][-1] == "Repeat Reference" assert sampler["widgets_values_named"]["video_reference_mode"] == "Repeat Reference" assert "reference_routing_mode" not in sampler["widgets_values_named"] assert not any(item["name"].startswith("reference_image_") for item in sampler["inputs"]) assert helper["type"] == "H3ContinuumReferenceImagesV39" assert helper["widgets_values"] == ["All chunks", *(["off"] * 9)] assert [item["name"] for item in helper["inputs"]] == [ f"reference_image_{index}" for index in range(1, 10) ] links = {item[0]: item for item in new["links"]} for slot, link_id in enumerate((351, 350, 349, 393, 394, 395), start=0): assert links[link_id][3:5] == [348, slot] assert links[392][3:6] == [312, len(sampler["inputs"]) - 1, REFERENCE_IMAGES_V39_TYPE] nodes = {node["id"]: node for node in new["nodes"]} assert nodes[344]["type"] == "H3DecodeCacheHelper" assert nodes[317]["mode"] == 4 # Preserve the supplied image loader bypass. assert nodes[355]["widgets_values"] == ["MiniMax_H3_00001_.mp4", "image"] assert nodes[315]["widgets_values"] == ["prnas_.mp3", None, None] assert sampler["inputs"][8]["name"] == "reference_video_1" assert sampler["inputs"][9]["name"] == "driving_audio" def _routed_refine_fixture(): descriptor = { "physical_group": 1, "logical_chunks": [1], "references": [{"source_slot_id": "R4", "picture_number": 1}], } route = {"descriptor": descriptor, "sha256": canonical_sha256(descriptor)} conditioning = [[torch.zeros((1, 1, 2)), {"minimax_frame_count": 124}]] captured = make_refine_group( conditioning=conditioning, group_id=0, logical_chunks=(1,), physical_frames=124, prompt_policy="single", physical_prompt="@R4 runs", source_video_shape=(1, 24, 37, 2, 3), physical_clip_index=1, context_frames=0, reference_routing_group_contract=route, ) context = make_refine_context( [captured], source_width=48, source_height=32, conditioning_mode="t2va", ) group = { "group_id": 0, "logical_chunks": [1], "physical_frames": 124, "physical_prompt": "@R4 runs", "prompt_policy": "single", "trim_prefix_frames": 0, "terminal_merged": False, "source_width": 48, "source_height": 32, "source_batch": 1, "latent_channels": 24, "source_latent_t": 37, "source_latent_h": 2, "source_latent_w": 3, "source_audio_shape": [1, 8, 148], } plan = { "width": 48, "height": 32, "second_pass_contract": {"version": 1, "physical_groups": [group]}, "reference_routing_v1": {"groups": [{ "contract_sha256": route["sha256"], "descriptor": deepcopy(descriptor), }]}, } return context, plan, route def test_refine_capture_is_bound_to_the_exact_first_pass_route(): context, plan, route = _routed_refine_fixture() assert validate_refine_context(context, assembly_plan=plan) is context assert context["groups"][0]["reference_routing_v1"] == route changed = deepcopy(plan) changed["reference_routing_v1"]["groups"][0]["contract_sha256"] = "0" * 64 with pytest.raises(RefineContextError, match="differs from First Pass Plan"): validate_refine_context(context, assembly_plan=changed) @pytest.mark.parametrize("with_context,status", [ (True, "verified"), (False, "not_inherited"), ]) def test_second_pass_reports_reference_inheritance_only_for_matching_context( with_context, status, ): context, plan, route = _routed_refine_fixture() video = {"samples": torch.zeros((1, 24, 37, 2, 3))} audio = {"samples": torch.zeros((1, 8, 148))} calls = [] def encode_prompt(_clip, prompt, **_kwargs): calls.append(prompt) return [[torch.zeros((1, 1, 2)), {}]] result = run_second_pass_groups( model=object(), clip=object(), sampler=object(), sigmas=torch.tensor([0.2, 0.0]), video_latents=[video], audio_latents=[audio], assembly_plan=plan, refine_seed=123, refine_context=context if with_context else None, encode_prompt_fn=encode_prompt, clone_model_fn=lambda model, **_kwargs: model, adapt_group_conditioning_fn=lambda group, **_kwargs: ( [[item[0], dict(item[1])] for item in group["conditioning"]], {"warnings": ()}, ), latent_builder=lambda v, a: {"video": v, "audio": a}, sample_fn=lambda **kwargs: kwargs["latent"], stream_extractor=lambda sampled: (sampled["video"], sampled["audio"]), ) _refined, output_audio, updated, report = result record = updated["second_pass_contract"]["reference_inheritance"][0] assert record["status"] == status assert record["contract_sha256"] == (route["sha256"] if with_context else None) assert output_audio[0] is audio assert f"reference_inheritance={status}" in report assert calls == ([] if with_context else ["@R4 runs"])