Files
ComfyUI-H3-Continuum-Tiled/tests/test_v38_chunk_scoped_refine.py

438 lines
14 KiB
Python

from __future__ import annotations
import copy
import pytest
import torch
from ComfyUI_H3_Continuum_Join.v3 import second_pass, second_pass_nodes
from ComfyUI_H3_Continuum_Join.v3 import targeted_second_pass
from ComfyUI_H3_Continuum_Join.v3.refine_scope import (
MAGIC,
MODE_ALL,
MODE_LOGICAL_CHUNK,
MODE_PHYSICAL_GROUP,
RefineScopeError,
resolve_refine_scope,
serializable_scope_contract,
)
from ComfyUI_H3_Continuum_Join.v3.refine_target import (
MODE_AUDIO_ONLY,
MODE_VIDEO_AUDIO,
MODE_VIDEO_ONLY,
derive_target_refine_seed,
)
from ComfyUI_H3_Continuum_Join.v3.second_pass_nodes import (
H3ContinuumSelectiveSecondPassExperimental,
REFINE_SCOPE_ALL,
REFINE_SCOPE_LOGICAL_CHUNK,
REFINE_SCOPE_PHYSICAL_GROUP,
REFINE_TARGET_VIDEO_ONLY,
)
from ComfyUI_H3_Continuum_Join.v3.targeted_second_pass import (
run_targeted_second_pass_groups,
)
def _group(
group_id: int,
logical_chunks: list[int],
*,
temporal: int,
audio_t: int,
terminal: bool = False,
) -> dict:
return {
"group_id": group_id,
"logical_chunks": logical_chunks,
"physical_prompt": f"group {group_id + 1}",
"prompt_policy": "paired_timeline_v1" if terminal else "single",
"physical_frames": 260 if terminal else 124,
"trim_prefix_frames": 22 if group_id else 0,
"terminal_merged": terminal,
"source_width": 128,
"source_height": 128,
"source_batch": 1,
"latent_channels": 24,
"source_latent_t": temporal,
"source_latent_h": 8,
"source_latent_w": 8,
"source_audio_shape": [1, 32, 2, audio_t],
}
def _fixture(*, terminal: bool = False):
if terminal:
groups = [
_group(0, [1], temporal=31, audio_t=207),
_group(1, [2, 3], temporal=65, audio_t=433, terminal=True),
]
else:
groups = [
_group(0, [1], temporal=31, audio_t=207),
_group(1, [2], temporal=36, audio_t=235),
_group(2, [3], temporal=36, audio_t=235),
]
videos = [
{
"samples": torch.full(
(1, 24, group["source_latent_t"], 8, 8),
float(index + 1),
)
}
for index, group in enumerate(groups)
]
audios = [
{
"samples": torch.full(
tuple(group["source_audio_shape"]),
float(index + 11),
)
}
for index, group in enumerate(groups)
]
plan = {
"width": 128,
"height": 128,
"existing_top_level": {"preserved": True},
"second_pass_contract": {
"version": 1,
"existing_contract_field": "preserved",
"physical_groups": groups,
},
}
return groups, videos, audios, plan
def _run(
target: str,
*,
scope: str = MODE_ALL,
scope_index: int = 1,
terminal: bool = False,
observers: dict | None = None,
):
groups, videos, audios, plan = _fixture(terminal=terminal)
calls = observers if observers is not None else {}
calls.setdefault("encode", [])
calls.setdefault("clone", [])
calls.setdefault("sample", [])
sigmas = torch.tensor([0.6, 0.3, 0.0], dtype=torch.float32)
def encode(_clip, prompt, **_kwargs):
calls["encode"].append(prompt)
return [prompt]
def clone(model, **kwargs):
calls["clone"].append(kwargs)
return model
def sample(**kwargs):
calls["sample"].append(kwargs)
return {
"video": kwargs["latent"]["video"] + 100.0,
"audio": kwargs["latent"]["audio"] + 200.0,
}
result = run_targeted_second_pass_groups(
model="model",
clip="clip",
sampler="sampler",
sigmas=sigmas,
video_latents=videos,
audio_latents=audios,
assembly_plan=plan,
refine_seed=91,
refine_target=target,
refine_scope=scope,
refine_scope_index=scope_index,
encode_prompt_fn=encode,
latent_builder=lambda video, audio: {"video": video, "audio": audio},
sample_fn=sample,
stream_extractor=lambda value: (value["video"], value["audio"]),
clone_model_fn=clone,
enable_preview=False,
)
return groups, videos, audios, plan, sigmas, calls, result
def test_scope_resolver_is_pure_and_terminal_logical_selection_is_atomic():
groups, _videos, _audios, plan = _fixture(terminal=True)
plan_before = copy.deepcopy(plan)
all_scope = resolve_refine_scope(MODE_ALL, 99, plan)
physical = resolve_refine_scope(MODE_PHYSICAL_GROUP, 2, plan)
logical = resolve_refine_scope(MODE_LOGICAL_CHUNK, 3, plan)
assert plan == plan_before
assert all_scope.selected_group_indices == (0, 1)
assert all_scope.contract["requested_index"] is None
assert physical.selected_group_indices == (1,)
assert physical.contract["selected_logical_chunks"] == (2, 3)
assert physical.contract["terminal_expanded"] is False
assert logical.selected_group_indices == (1,)
assert logical.contract["selected_logical_chunks"] == (2, 3)
assert logical.contract["terminal_expanded"] is True
assert logical.contract["magic"] == MAGIC
serialized = serializable_scope_contract(logical)
serialized["selected_logical_chunks"].append(99)
assert logical.contract["selected_logical_chunks"] == (2, 3)
assert groups[1]["logical_chunks"] == [2, 3]
@pytest.mark.parametrize(
("mode", "index", "match"),
(
("unknown", 1, "unsupported refine scope"),
(1, 1, "unsupported refine scope"),
(MODE_PHYSICAL_GROUP, 0, "positive integer"),
(MODE_PHYSICAL_GROUP, 1.5, "positive integer"),
(MODE_PHYSICAL_GROUP, 3, "outside"),
(MODE_LOGICAL_CHUNK, 4, "not present"),
),
)
def test_invalid_scope_fails_before_any_execution(mode, index, match):
_groups, _videos, _audios, plan = _fixture(terminal=True)
with pytest.raises(RefineScopeError, match=match):
resolve_refine_scope(mode, index, plan)
@pytest.mark.parametrize(
("target", "video_changed", "audio_changed"),
(
(MODE_VIDEO_ONLY, True, False),
(MODE_AUDIO_ONLY, False, True),
(MODE_VIDEO_AUDIO, True, True),
),
)
def test_physical_group_scope_does_no_work_for_unselected_groups(
monkeypatch,
target,
video_changed,
audio_changed,
):
derived_indices = []
if target == MODE_VIDEO_ONLY:
original = second_pass.derive_refine_seed
def derive(seed, index):
derived_indices.append(index)
return original(seed, index)
monkeypatch.setattr(second_pass, "derive_refine_seed", derive)
else:
original = targeted_second_pass.derive_target_refine_seed
def derive(seed, index, resolved_target):
derived_indices.append(index)
return original(seed, index, resolved_target)
monkeypatch.setattr(targeted_second_pass, "derive_target_refine_seed", derive)
groups, videos, audios, plan, sigmas, calls, result = _run(
target,
scope=MODE_PHYSICAL_GROUP,
scope_index=2,
)
output_videos, output_audios, updated_plan, status = result
assert len(groups) == 3
assert calls["encode"] == ["group 2"]
assert len(calls["clone"]) == len(calls["sample"]) == 1
assert derived_indices == [1]
assert calls["sample"][0]["sigmas"] is sigmas
assert calls["sample"][0]["seed"] == derive_target_refine_seed(91, 1, target)
for index in (0, 2):
assert output_videos[index] is videos[index]
assert output_audios[index] is audios[index]
assert (output_videos[1] is not videos[1]) is video_changed
assert (output_audios[1] is not audios[1]) is audio_changed
assert plan["existing_top_level"] == {"preserved": True}
assert plan["second_pass_contract"]["existing_contract_field"] == "preserved"
contract = updated_plan["second_pass_contract"]
assert contract["version"] == 1
assert contract["existing_contract_field"] == "preserved"
assert contract["physical_groups"][:3] != []
assert contract["refine_group_seeds"] == [calls["sample"][0]["seed"]]
assert "refine_scope_contract" not in contract
assert "no conditioning, MODEL clone, Sampling, or seed derivation" in status
def test_non_selected_refine_context_conditioning_is_not_adapted_or_cloned():
groups, videos, _audios, plan = _fixture()
calls = {"adapt": [], "clone": [], "consume": []}
def validate(_context, *, assembly_plan):
assert assembly_plan is plan
return {"complete": True, "groups": groups}
def adapt(group, **_kwargs):
calls["adapt"].append(group["group_id"])
return [[f"conditioning-{group['group_id']}", {}]], None
def clone(model, **kwargs):
calls["clone"].append(kwargs["chunk_index"])
return model
prepared = second_pass.prepare_physical_refine_groups(
model="model",
clip="clip",
video_latents=videos,
assembly_plan=plan,
refine_context=object(),
validate_refine_context_fn=validate,
adapt_group_conditioning_fn=adapt,
clone_model_fn=clone,
group_consumer_fn=lambda group_index, *_args: calls["consume"].append(
group_index
),
retain_group_outputs=False,
selected_group_indices=(1,),
)
assert calls == {"adapt": [1], "clone": [2], "consume": [1]}
assert prepared["selected_group_indices"] == [1]
assert prepared["selected_group_count"] == 1
def test_selected_group_seed_matches_all_mode_and_all_mode_has_a3c_plan_contract():
*_prefix, all_calls, all_result = _run(MODE_VIDEO_AUDIO)
*_scoped_prefix, scoped_calls, scoped_result = _run(
MODE_VIDEO_AUDIO,
scope=MODE_PHYSICAL_GROUP,
scope_index=2,
)
all_plan = all_result[2]
scoped_plan = scoped_result[2]
assert scoped_calls["sample"][0]["seed"] == all_calls["sample"][1]["seed"]
assert "refine_scope_contract" not in all_plan["second_pass_contract"]
assert set(scoped_plan["second_pass_contract"]) == set(
all_plan["second_pass_contract"]
)
assert "Refine Scope:" not in all_result[3]
assert scoped_plan["second_pass_contract"]["version"] == 1
@pytest.mark.parametrize("logical_chunk", (2, 3))
def test_terminal_logical_chunk_scope_expands_to_one_atomic_physical_pair(
logical_chunk,
):
groups, videos, audios, _plan, _sigmas, calls, result = _run(
MODE_VIDEO_AUDIO,
scope=MODE_LOGICAL_CHUNK,
scope_index=logical_chunk,
terminal=True,
)
output_videos, output_audios, updated_plan, status = result
assert groups[1]["logical_chunks"] == [2, 3]
assert groups[1]["terminal_merged"] is True
assert len(calls["encode"]) == len(calls["clone"]) == len(calls["sample"]) == 1
assert output_videos[0] is videos[0]
assert output_audios[0] is audios[0]
assert output_videos[1] is not videos[1]
assert output_audios[1] is not audios[1]
assert "refine_scope_contract" not in updated_plan["second_pass_contract"]
assert "selected_physical_groups=[2]" in status
assert "selected_logical_chunks=[2, 3]" in status
assert "terminal_expanded=true" in status
def test_public_scope_labels_forward_without_frontend_or_silent_fallback(monkeypatch):
calls = []
def fake_run(**kwargs):
calls.append(kwargs)
return kwargs["video_latents"], kwargs["audio_latents"], kwargs[
"assembly_plan"
], "ok"
monkeypatch.setattr(second_pass_nodes, "run_targeted_second_pass_groups", fake_run)
node = H3ContinuumSelectiveSecondPassExperimental()
common = {
"model": [object()],
"clip": [object()],
"sampler": [object()],
"sigmas": [object()],
"video_latents": [{"samples": object()}],
"audio_latents": [{"samples": object()}],
"assembly_plan": [{"second_pass_contract": {"version": 1}}],
"refine_seed": [7],
"refine_target": [REFINE_TARGET_VIDEO_ONLY],
}
node.refine(
**common,
refine_scope=[REFINE_SCOPE_PHYSICAL_GROUP],
refine_scope_index=[2],
)
node.refine(
**common,
refine_scope=[REFINE_SCOPE_LOGICAL_CHUNK],
refine_scope_index=[3],
)
node.refine(**common)
assert [(call["refine_scope"], call["refine_scope_index"]) for call in calls] == [
(MODE_PHYSICAL_GROUP, 2),
(MODE_LOGICAL_CHUNK, 3),
(MODE_ALL, 1),
]
with pytest.raises(ValueError, match="unsupported selective refine scope"):
node.refine(
**common,
refine_scope=["unknown"],
refine_scope_index=[1],
)
assert len(calls) == 3
def test_invalid_public_scope_fails_before_any_execution():
calls = {"encode": [], "clone": [], "sample": []}
with pytest.raises(RefineScopeError, match="not present"):
_run(
MODE_VIDEO_AUDIO,
scope=MODE_LOGICAL_CHUNK,
scope_index=99,
observers=calls,
)
assert calls == {"encode": [], "clone": [], "sample": []}
def test_terminal_logical_halves_resolve_to_the_same_group_seed():
*_, chunk_2_calls, _chunk_2_result = _run(
MODE_VIDEO_AUDIO,
scope=MODE_LOGICAL_CHUNK,
scope_index=2,
terminal=True,
)
*_, chunk_3_calls, _chunk_3_result = _run(
MODE_VIDEO_AUDIO,
scope=MODE_LOGICAL_CHUNK,
scope_index=3,
terminal=True,
)
assert len(chunk_2_calls["sample"]) == len(chunk_3_calls["sample"]) == 1
assert chunk_2_calls["sample"][0]["seed"] == chunk_3_calls["sample"][0][
"seed"
]
def test_scope_does_not_extend_assembly_plan_or_run_storage_contract():
*_all_prefix, all_result = _run(MODE_VIDEO_AUDIO)
*_scope_prefix, scoped_result = _run(
MODE_VIDEO_AUDIO,
scope=MODE_LOGICAL_CHUNK,
scope_index=2,
)
all_contract = all_result[2]["second_pass_contract"]
scoped_contract = scoped_result[2]["second_pass_contract"]
assert all_result[2].keys() == scoped_result[2].keys()
assert all_contract.keys() == scoped_contract.keys()
assert "refine_scope_contract" not in scoped_contract
assert "run_storage" not in targeted_second_pass.__dict__