Files
ComfyUI-H3-Continuum-Tiled/tests/test_audit_boundary_repairs.py
T
ukr8b3g-cmyk 190141e03e fix: stabilize V3.9 and bump package to 3.9.1
Preserve Second Pass audio and scoped Review conditioning, strengthen Take compatibility, and align Review Driving Audio.

Keep v5 history readable, document v6 restart requirements, and describe the fixes at the top of both READMEs. Remove workstation-specific paths and private operational records from public documentation.
2026-10-04 19:05:33 +09:00

228 lines
10 KiB
Python

from collections.abc import Mapping
import copy
import json
import pytest
import torch
from ComfyUI_H3_Continuum_Join.graph_contract import build_upstream_graph_contract
from ComfyUI_H3_Continuum_Join.v2.prompts import make_prompt_plan
from ComfyUI_H3_Continuum_Join.v2.session import make_session
from ComfyUI_H3_Continuum_Join.constants import PROMPT_MODE_LIST
from . import test_v38_review_execution_cap as cap
from .test_v36_masked_video_prefix import _install_nested_tensor
from .test_v35_context_sampler import _capture_sequence
from .test_v31_run_storage import _controller
def test_v3_reference_video_imports_the_shared_temporal_helper():
from ComfyUI_H3_Continuum_Join.temporal import align_frame_count_up as shared
from ComfyUI_H3_Continuum_Join.v3.reference_video import align_frame_count_up
assert align_frame_count_up is shared
def test_reference_bundle_fingerprint_ignores_unused_legacy_vae():
graph = {
"1": {"class_type": "H3ContinuumSamplerV38", "inputs": {
"model": ["2", 0], "clip": ["3", 0], "sampler": ["8", 0],
"audio_references": ["4", 0], "reference_audio_vae": ["5", 0]}},
"2": {"class_type": "UNETLoader", "inputs": {"unet_name": "model"}},
"3": {"class_type": "CLIPLoader", "inputs": {"clip_name": "clip"}},
"4": {"class_type": "H3ContinuumReferenceAudios", "inputs": {
"reference_audio_vae": ["6", 0], "reference_audio_1": ["7", 0]}},
"5": {"class_type": "VAELoader", "inputs": {"vae_name": "unused"}},
"6": {"class_type": "VAELoader", "inputs": {"vae_name": "active"}},
"7": {"class_type": "LoadAudio", "inputs": {"audio": "voice.wav"}},
"8": {"class_type": "KSamplerSelect", "inputs": {"sampler_name": "euler"}},
}
def contract(value):
result, safe, _ = build_upstream_graph_contract(
value, "1", require_video_vae=False, require_reference_audio_vae=True)
assert safe
return result
original = contract(graph)
assert original["routes"]["reference_audio_vae"]["node"]["node_id"] == "4"
active = copy.deepcopy(graph)
active["6"]["inputs"]["vae_name"] = "new-active"
assert contract(active)["sha256"] != original["sha256"]
unused = copy.deepcopy(graph)
unused["5"]["inputs"]["vae_name"] = "new-unused"
assert contract(unused) == original
legacy = copy.deepcopy(graph)
del legacy["1"]["inputs"]["audio_references"]
assert contract(legacy)["routes"]["reference_audio_vae"]["node"]["node_id"] == "5"
# A connected but empty bundle can return None; execution then uses legacy
# audio. Run Storage supplies this resolved route, not just graph priority.
resolved, safe, _ = build_upstream_graph_contract(
graph, "1", require_video_vae=False, require_reference_audio_vae=True,
reference_audio_route="reference_audio_vae")
assert safe
assert resolved["routes"]["reference_audio_vae"]["node"]["node_id"] == "5"
def assert_nested_equal(actual, expected):
if torch.is_tensor(expected):
torch.testing.assert_close(actual, expected, rtol=0, atol=0)
elif isinstance(expected, Mapping):
assert actual.keys() == expected.keys()
for key in expected:
assert_nested_equal(actual[key], expected[key])
elif isinstance(expected, (tuple, list)):
assert len(actual) == len(expected)
for a, b in zip(actual, expected, strict=True):
assert_nested_equal(a, b)
else:
assert actual == expected
@pytest.mark.parametrize("transport", ["reference_context_v1", "masked_av_prefix_22_v1", "masked_video_prefix_v1"])
@pytest.mark.parametrize("anchors", ["none", "first", "first_last"])
@pytest.mark.parametrize("chunks", [1, 3, 6])
def test_review_and_complete_reuse_preserve_full_refine_context(monkeypatch, transport, anchors, chunks):
_install_nested_tensor(monkeypatch)
first = torch.zeros(1, 64, 96, 3) if anchors != "none" else None
last = torch.ones(1, 64, 96, 3) if anchors == "first_last" else None
runtime = cap._install_fake_runtime(monkeypatch, first_frame=first, last_frame=last)
real = cap.sequence.run_sequence
def run(**kwargs):
kwargs["continuation_transport"] = transport
return real(**kwargs)
monkeypatch.setattr(cap.sequence, "run_sequence", run)
options = dict(chunks=chunks, first_frame=first, last_frame=last, capture_refine_context=True)
full = cap._run_sequence(runtime, **options)
assert full[4]["complete"]
expected_sample_count = len(runtime.samples)
runtime.samples.clear()
session = None
for _ in range(chunks):
before = len(runtime.samples)
reviewed = cap._run_sequence(runtime, **options, limit=1, session=session)
session = reviewed[2]
assert len(runtime.samples) - before == 1
if len(reviewed[0]) == chunks:
break
assert not reviewed[4]["complete"]
assert len(runtime.samples) == expected_sample_count
cap._assert_entry_parity(reviewed[0], full[0])
assert reviewed[4]["complete"]
assert_nested_equal(reviewed[4], full[4])
runtime.samples.clear()
reused = cap._run_sequence(runtime, **options, session=session)
assert runtime.samples == []
cap._assert_entry_parity(reused[0], full[0])
assert_nested_equal(reused[4], full[4])
def test_review_does_not_encode_future_prompts(monkeypatch):
runtime = cap._install_fake_runtime(monkeypatch)
real = cap.sequence.run_sequence
encoded = []
encoder = runtime.clip.encode_from_tokens_scheduled
monkeypatch.setattr(runtime.clip, "encode_from_tokens_scheduled",
lambda prompt: (encoded.append(prompt), encoder(prompt))[1])
def run(**kwargs):
kwargs["prompt_plan"] = make_prompt_plan(
mode=PROMPT_MODE_LIST, script=json.dumps([f"action {i}" for i in range(6)]),
chunks=6, chunk_seconds=5.0)
return real(**kwargs)
monkeypatch.setattr(cap.sequence, "run_sequence", run)
cap._run_sequence(runtime, chunks=6, limit=1, capture_refine_context=True)
assert len(runtime.samples) == 1
assert encoded == ["action 0"]
@pytest.mark.parametrize("transport", ["reference_context_v1", "masked_av_prefix_22_v1", "masked_video_prefix_v1"])
@pytest.mark.parametrize("terminal", [False, True])
@pytest.mark.parametrize("image,audio", [(True, False), (False, True), (True, True)])
def test_review_reconstructs_reference_conditions(monkeypatch, transport, terminal, image, audio):
real = cap.sequence.run_sequence
state = {"limit": None, "samples": 0}
def run(**kwargs):
sample = cap.sequence.sample_chunk
def counted(**sample_kwargs):
state["samples"] += 1
return sample(**sample_kwargs)
monkeypatch.setattr(cap.sequence, "sample_chunk", counted)
kwargs["max_new_physical_groups"] = state["limit"]
return real(**kwargs)
monkeypatch.setattr(cap.sequence, "run_sequence", run)
options = dict(terminal=terminal, reference_image=image, reference_audio=audio,
continuation_transport=transport)
full = _capture_sequence(monkeypatch, **options)
assert state["samples"] == 2
state.update(limit=1, samples=0)
first = _capture_sequence(monkeypatch, **options)
assert state["samples"] == 1
assert not first[4]["complete"]
final = _capture_sequence(monkeypatch, **options, session=first[2])
assert state["samples"] == 2
assert_nested_equal(final[4], full[4])
state.update(limit=None, samples=0)
reused = _capture_sequence(monkeypatch, **options, session=final[2])
assert state["samples"] == 0
assert_nested_equal(reused[4], full[4])
def test_full_reuse_without_refine_capture_does_not_encode_or_sample(monkeypatch):
runtime = cap._install_fake_runtime(monkeypatch)
full = cap._run_sequence(runtime, chunks=3)
runtime.samples.clear()
def unexpected(*args, **kwargs):
pytest.fail("Full reuse without refine capture must not encode or sample")
monkeypatch.setattr(cap.sequence, "encode_identity_latents", unexpected)
monkeypatch.setattr(runtime.clip, "encode_from_tokens_scheduled", unexpected)
monkeypatch.setattr(cap.sequence, "sample_chunk", unexpected)
reused = cap._run_sequence(runtime, chunks=3, session=full[2])
assert len(reused) == 4
cap._assert_entry_parity(reused[0], full[0])
@pytest.mark.parametrize("terminal", [False, True])
def test_refine_context_rebuild_after_safetensors_storage_roundtrip(monkeypatch, tmp_path, terminal):
_install_nested_tensor(monkeypatch)
first = torch.zeros(1, 64, 96, 3) if terminal else None
last = torch.ones(1, 64, 96, 3) if terminal else None
runtime = cap._install_fake_runtime(monkeypatch, first_frame=first, last_frame=last)
options = dict(chunks=3, first_frame=first, last_frame=last, capture_refine_context=True)
full = cap._run_sequence(runtime, **options)
writer, hashes = _controller(tmp_path)
writer.prompts = ["continuous shot"] * 3
for index, entry in enumerate(full[0]):
writer.commit_chunk(entry, position=index)
reader, _ = _controller(tmp_path)
reader.prompts = writer.prompts[:]
reader.manifest = json.loads(writer._manifest_path().read_text(encoding="utf-8"))
loaded, records = reader._valid_prefix(reader.manifest, hashes)
assert len(records) == len(loaded) == 3
assert loaded[0]["video"].data_ptr() != full[0][0]["video"].data_ptr()
prior = full[2]
# The normal storage adapter invokes make_session to convert disk positions
# (zero-based) to Session indices (one-based); exercise that owner as well.
session = make_session(
chunks=loaded, width=prior["width"], height=prior["height"],
chunk_seconds=prior["chunk_seconds"], identity_hash=prior["identity_hash"],
model_fingerprint_value=prior["model_fingerprint"],
parent_session_id=prior["session_id"], reroll_from_chunk=0,
settings=prior["settings"])
runtime.samples.clear()
before = {path: path.read_bytes() for path in tmp_path.rglob("*") if path.is_file()}
restored = cap._run_sequence(runtime, **options, session=session)
assert runtime.samples == []
assert_nested_equal(restored[4], full[4])
cap._assert_entry_parity(restored[0], full[0])
assert {path: path.read_bytes() for path in tmp_path.rglob("*") if path.is_file()} == before