290 lines
11 KiB
Python
290 lines
11 KiB
Python
"""RR-R3 CPU contracts for Reference slot and Core Picture correspondence."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from dataclasses import replace
|
|
import hashlib
|
|
|
|
import pytest
|
|
import torch
|
|
|
|
from ComfyUI_H3_Continuum_Join.reference import (
|
|
REFERENCE_SIZE_MATCH_OUTPUT,
|
|
build_hybrid_presentation_items,
|
|
prepare_reference_assets,
|
|
)
|
|
from ComfyUI_H3_Continuum_Join.v3.reference_effective_plan import (
|
|
compile_effective_reference_plan,
|
|
)
|
|
from ComfyUI_H3_Continuum_Join.v3.reference_routing import (
|
|
REFERENCE_SLOT_IDS,
|
|
compile_reference_routing_schedule,
|
|
)
|
|
|
|
|
|
def _selectors(**overrides: str) -> dict[str, str]:
|
|
result = {slot_id: "off" for slot_id in REFERENCE_SLOT_IDS}
|
|
result.update(overrides)
|
|
return result
|
|
|
|
|
|
def _schedule(*, chunks: int = 4, terminal: bool = False, mode=None, selectors=None):
|
|
return compile_reference_routing_schedule(
|
|
total_chunks=chunks,
|
|
terminal_merge_enabled=terminal,
|
|
mode=mode,
|
|
selectors_by_slot=selectors,
|
|
)
|
|
|
|
|
|
def _hash(slot_id: str) -> str:
|
|
return hashlib.sha256(slot_id.encode("ascii")).hexdigest()
|
|
|
|
|
|
def _plan(schedule, slots=("R1", "R4", "R9"), *, first=False, last=False):
|
|
return compile_effective_reference_plan(
|
|
routing_schedule=schedule,
|
|
source_slot_ids=slots,
|
|
reference_image_hashes=tuple(_hash(slot_id) for slot_id in slots),
|
|
reference_asset_count=len(slots),
|
|
has_first_image=first,
|
|
has_last_image=last,
|
|
)
|
|
|
|
|
|
def test_unset_routing_preserves_sparse_legacy_reference_order():
|
|
schedule = _schedule(chunks=3)
|
|
plan = _plan(schedule)
|
|
|
|
assert plan.valid and plan.legacy_fallback
|
|
assert plan.connected_source_slot_ids == ("R1", "R4", "R9")
|
|
assert tuple(route.logical_chunk for route in plan.logical_routes) == (1, 2, 3)
|
|
for route in plan.logical_routes:
|
|
assert route.requested_source_slot_ids == REFERENCE_SLOT_IDS
|
|
assert [item.source_slot_id for item in route.picture_map.references] == ["R1", "R4", "R9"]
|
|
assert [item.asset_index for item in route.picture_map.references] == [0, 1, 2]
|
|
assert [item.image_sha256 for item in route.picture_map.references] == [
|
|
_hash(slot_id) for slot_id in ("R1", "R4", "R9")
|
|
]
|
|
assert [item.picture_number for item in route.picture_map.references] == [1, 2, 3]
|
|
assert all(group.status == "active" for group in plan.physical_routes)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("has_first", "has_last", "first_number", "last_number", "ref_numbers"),
|
|
[
|
|
(False, False, None, None, (1, 2)),
|
|
(True, False, 1, None, (2, 3)),
|
|
(False, True, None, 1, (2, 3)),
|
|
(True, True, 1, 2, (3, 4)),
|
|
],
|
|
)
|
|
def test_anchor_offsets_match_existing_core_presentation_order(
|
|
has_first, has_last, first_number, last_number, ref_numbers
|
|
):
|
|
plan = _plan(_schedule(chunks=1), slots=("R4", "R9"), first=has_first, last=has_last)
|
|
picture_map = plan.logical_routes[0].picture_map
|
|
first = object() if has_first else None
|
|
last = object() if has_last else None
|
|
images = (object(), object())
|
|
presentation = build_hybrid_presentation_items(
|
|
[{"type": "image", "data": image} for image in images],
|
|
first_image=first,
|
|
last_image=last,
|
|
)
|
|
|
|
assert plan.valid
|
|
assert picture_map.first_picture_number == first_number
|
|
assert picture_map.last_picture_number == last_number
|
|
assert tuple(item.picture_number for item in picture_map.references) == ref_numbers
|
|
assert tuple(item.asset_index for item in picture_map.references) == (0, 1)
|
|
for item in picture_map.references:
|
|
assert presentation[item.picture_number - 1]["data"] is images[item.asset_index]
|
|
assert item.picture_tag == f"<Picture {item.picture_number}>"
|
|
if first_number is not None:
|
|
assert presentation[first_number - 1]["data"] is first
|
|
if last_number is not None:
|
|
assert presentation[last_number - 1]["data"] is last
|
|
|
|
|
|
def test_custom_routes_recompact_pictures_without_losing_fixed_slot_identity():
|
|
schedule = _schedule(
|
|
mode="Custom",
|
|
selectors=_selectors(R4="1,3", R9="2-3"),
|
|
)
|
|
plan = _plan(schedule, first=True)
|
|
|
|
assert plan.valid
|
|
assert tuple(route.logical_chunk for route in plan.logical_routes) == (1, 2, 3, 4)
|
|
assert [
|
|
tuple((item.source_slot_id, item.asset_index, item.picture_number)
|
|
for item in route.picture_map.references)
|
|
for route in plan.logical_routes
|
|
] == [
|
|
(("R4", 1, 2),),
|
|
(("R9", 2, 2),),
|
|
(("R4", 1, 2), ("R9", 2, 3)),
|
|
(),
|
|
]
|
|
assert plan.physical_routes[-1].status == "empty"
|
|
assert plan.physical_routes[-1].picture_map.first_picture_number == 1
|
|
|
|
|
|
def test_requested_but_disconnected_slot_stays_visible_as_an_empty_effective_route():
|
|
schedule = _schedule(chunks=2, mode="Custom", selectors=_selectors(R5="1"))
|
|
plan = _plan(schedule, slots=("R4", "R9"))
|
|
|
|
assert plan.valid
|
|
assert plan.logical_routes[0].requested_source_slot_ids == ("R5",)
|
|
assert plan.logical_routes[0].picture_map.references == ()
|
|
assert plan.physical_routes[0].routing_status == "consistent"
|
|
assert plan.physical_routes[0].status == "empty"
|
|
assert plan.physical_routes[0].requested_source_slot_ids == ("R5",)
|
|
|
|
|
|
def test_terminal_conflict_has_no_group_picture_map_but_retains_both_logical_maps():
|
|
schedule = _schedule(
|
|
chunks=3,
|
|
terminal=True,
|
|
mode="Custom",
|
|
selectors=_selectors(R4="2", R9="3"),
|
|
)
|
|
plan = _plan(schedule, slots=("R4", "R9"), first=True, last=True)
|
|
|
|
assert plan.valid and plan.has_route_conflicts
|
|
assert [item.source_slot_id for item in plan.logical_routes[1].picture_map.references] == ["R4"]
|
|
assert [item.source_slot_id for item in plan.logical_routes[2].picture_map.references] == ["R9"]
|
|
terminal = plan.physical_routes[-1]
|
|
assert terminal.logical_chunks == (2, 3)
|
|
assert terminal.terminal_atomic
|
|
assert terminal.status == terminal.routing_status == "conflict"
|
|
assert terminal.requested_source_slot_ids is None
|
|
assert terminal.picture_map is None
|
|
|
|
|
|
def test_consistent_terminal_route_has_one_shared_group_picture_map():
|
|
schedule = _schedule(
|
|
chunks=3, terminal=True, mode="Custom", selectors=_selectors(R4="2-3")
|
|
)
|
|
plan = _plan(schedule, slots=("R4", "R9"), first=True, last=True)
|
|
|
|
assert plan.valid and not plan.has_route_conflicts
|
|
terminal = plan.physical_routes[-1]
|
|
assert terminal.logical_chunks == (2, 3)
|
|
assert terminal.status == "active"
|
|
assert terminal.picture_map.first_picture_number == 1
|
|
assert terminal.picture_map.last_picture_number == 2
|
|
assert tuple((item.source_slot_id, item.asset_index, item.picture_number)
|
|
for item in terminal.picture_map.references) == (("R4", 0, 3),)
|
|
|
|
|
|
def test_explicit_custom_all_off_keeps_first_last_without_reference_pictures():
|
|
schedule = _schedule(chunks=3, terminal=True, mode="Custom", selectors=_selectors())
|
|
plan = _plan(schedule, slots=("R1",), first=True, last=True)
|
|
|
|
assert plan.valid and not plan.legacy_fallback
|
|
assert all(route.picture_map.references == () for route in plan.logical_routes)
|
|
assert all(group.status == "empty" for group in plan.physical_routes)
|
|
assert plan.physical_routes[-1].picture_map.first_picture_number == 1
|
|
assert plan.physical_routes[-1].picture_map.last_picture_number == 2
|
|
|
|
|
|
def test_same_image_content_in_two_slots_retains_two_picture_identities():
|
|
image = torch.full((1, 32, 32, 3), 0.5)
|
|
assets = prepare_reference_assets(
|
|
reference_image_1=image,
|
|
reference_image_2=None,
|
|
reference_image_4=image,
|
|
output_width=32,
|
|
output_height=32,
|
|
size_mode=REFERENCE_SIZE_MATCH_OUTPUT,
|
|
)
|
|
assert assets is not None
|
|
assert assets.image_hashes[0] == assets.image_hashes[1]
|
|
plan = compile_effective_reference_plan(
|
|
routing_schedule=_schedule(chunks=1),
|
|
source_slot_ids=assets.source_slot_ids,
|
|
reference_image_hashes=assets.image_hashes,
|
|
reference_asset_count=assets.count,
|
|
has_first_image=False,
|
|
has_last_image=False,
|
|
)
|
|
assert plan.valid
|
|
assert tuple((item.source_slot_id, item.asset_index, item.picture_number)
|
|
for item in plan.logical_routes[0].picture_map.references) == (
|
|
("R1", 0, 1), ("R4", 1, 2)
|
|
)
|
|
assert tuple(item.image_sha256 for item in plan.logical_routes[0].picture_map.references) == assets.image_hashes
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("slots", "count", "expected_issue"),
|
|
[
|
|
((), 1, "missing_source_slots"),
|
|
(("R1",), 2, "asset_count_mismatch"),
|
|
(("R1", "R1"), 2, "duplicate_source_slot"),
|
|
(("R9", "R4"), 2, "source_slot_order"),
|
|
(("R10",), 1, "unknown_source_slot"),
|
|
],
|
|
)
|
|
def test_broken_source_metadata_is_classified_without_a_partial_plan(slots, count, expected_issue):
|
|
plan = compile_effective_reference_plan(
|
|
routing_schedule=_schedule(chunks=2),
|
|
source_slot_ids=slots,
|
|
reference_image_hashes=tuple(_hash(slot_id) for slot_id in slots),
|
|
reference_asset_count=count,
|
|
has_first_image=False,
|
|
has_last_image=False,
|
|
)
|
|
assert not plan.valid
|
|
assert plan.logical_routes == plan.physical_routes == ()
|
|
assert expected_issue in {issue.code for issue in plan.issues}
|
|
|
|
|
|
def test_invalid_r2_schedule_and_malformed_logical_route_are_classified():
|
|
invalid = _schedule(chunks=2, mode="Custom", selectors=_selectors(R1="3"))
|
|
result = _plan(invalid)
|
|
assert not result.valid
|
|
assert any(issue.code == "routing_chunk_out_of_range" for issue in result.issues)
|
|
|
|
good = _schedule(chunks=2)
|
|
bad_logical = replace(good.logical_routes[0], reference_slot_ids=("R10",))
|
|
bad = replace(good, logical_routes=(bad_logical, *good.logical_routes[1:]))
|
|
malformed = _plan(bad)
|
|
assert not malformed.valid
|
|
assert any(issue.code == "invalid_routing_schedule" for issue in malformed.issues)
|
|
|
|
|
|
def test_anchor_flags_require_explicit_boolean_presence():
|
|
result = compile_effective_reference_plan(
|
|
routing_schedule=_schedule(chunks=1),
|
|
source_slot_ids=(),
|
|
reference_image_hashes=(),
|
|
reference_asset_count=0,
|
|
has_first_image=1,
|
|
has_last_image=False,
|
|
)
|
|
assert not result.valid
|
|
assert result.issues[0].code == "invalid_anchor_flags"
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("hashes", "issue_code"),
|
|
[
|
|
((), "hash_count_mismatch"),
|
|
(("not-a-sha",), "invalid_image_hash"),
|
|
],
|
|
)
|
|
def test_invalid_reference_content_identity_does_not_create_a_partial_plan(hashes, issue_code):
|
|
result = compile_effective_reference_plan(
|
|
routing_schedule=_schedule(chunks=1),
|
|
source_slot_ids=("R4",),
|
|
reference_image_hashes=hashes,
|
|
reference_asset_count=1,
|
|
has_first_image=False,
|
|
has_last_image=False,
|
|
)
|
|
assert not result.valid
|
|
assert result.logical_routes == result.physical_routes == ()
|
|
assert issue_code in {issue.code for issue in result.issues}
|