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.
226 lines
9.9 KiB
Python
226 lines
9.9 KiB
Python
from __future__ import annotations
|
|
|
|
import copy
|
|
import functools
|
|
import hashlib
|
|
import json
|
|
from pathlib import Path
|
|
import shutil
|
|
from types import SimpleNamespace
|
|
|
|
import pytest
|
|
|
|
from ComfyUI_H3_Continuum_Join import run_storage as storage
|
|
from ComfyUI_H3_Continuum_Join.graph_contract import build_upstream_graph_contract
|
|
from ComfyUI_H3_Continuum_Join.v3.review_control import (
|
|
GENERATION_MODE_REVIEW, REVIEW_ACTION_CONTINUE, REVIEW_ACTION_REGENERATE_CURRENT,
|
|
ReviewControlError,
|
|
)
|
|
from . import test_v31_run_storage as signatures
|
|
from . import test_v38_review_run_storage as review
|
|
|
|
|
|
def closure(gain):
|
|
def sample(x=None, **kwargs):
|
|
return x * gain
|
|
return sample
|
|
|
|
|
|
@pytest.mark.parametrize("option", [
|
|
"sampler_cfg_function", "sampler_pre_cfg_function", "sampler_post_cfg_function",
|
|
"model_function_wrapper", "denoise_mask_function",
|
|
])
|
|
def test_model_hook_changes_are_observed(option):
|
|
model = signatures._Model()
|
|
model.model_options[option] = closure(1)
|
|
before, safe = storage._model_signature(model, "base")
|
|
model.model_options[option] = closure(2)
|
|
after, after_safe = storage._model_signature(model, "base")
|
|
assert safe and after_safe
|
|
assert before != after
|
|
|
|
|
|
def test_cfg1_and_internal_join_context():
|
|
model = signatures._Model()
|
|
before, safe = storage._model_signature(model, "base")
|
|
model.model_options["disable_cfg1_optimization"] = True
|
|
after, safe_after = storage._model_signature(model, "base")
|
|
assert safe and safe_after and before != after
|
|
model.model_options["transformer_options"] = {"h3_continuum_join_context": object()}
|
|
join, safe_join = storage._model_signature(model, "base")
|
|
model.model_options["transformer_options"] = {}
|
|
clean, safe_clean = storage._model_signature(model, "base")
|
|
assert safe_join and safe_clean and join == clean
|
|
|
|
|
|
def test_sampler_closure_only_changes_identity_with_graph_unchanged():
|
|
graph, graph_safe, _ = build_upstream_graph_contract(
|
|
signatures._prompt_graph(), "42", require_video_vae=True,
|
|
)
|
|
model, clip, vae = signatures._Model(), signatures._Clip(), signatures._VideoVAE()
|
|
sampler = SimpleNamespace(sampler_function=closure(1), extra_options={}, inpaint_options={})
|
|
kwargs = dict(model=model, clip=clip, video_vae=vae, sampler=sampler,
|
|
upstream_graph_contract=graph, upstream_graph_safe=graph_safe)
|
|
before, safe, _ = signatures._sampling_contract(**kwargs)
|
|
sampler.sampler_function = closure(2)
|
|
after, after_safe, _ = signatures._sampling_contract(**kwargs)
|
|
assert safe and after_safe
|
|
assert before["global"]["upstream_graph"] == after["global"]["upstream_graph"]
|
|
assert storage.revision_identity(before) != storage.revision_identity(after)
|
|
same, same_safe, _ = signatures._sampling_contract(**kwargs)
|
|
assert same_safe and same == after
|
|
|
|
|
|
def test_sampler_graph_only_changes_identity():
|
|
graph = signatures._prompt_graph()
|
|
before, safe, _ = build_upstream_graph_contract(graph, "42", require_video_vae=True)
|
|
graph["40"]["inputs"]["sampler_name"] = "heun"
|
|
after, after_safe, _ = build_upstream_graph_contract(graph, "42", require_video_vae=True)
|
|
assert safe and after_safe and before != after
|
|
assert before["version"] == after["version"] == 4
|
|
assert before["routes"]["model"] == after["routes"]["model"]
|
|
|
|
|
|
def test_partial_and_bound_method_state_are_observed():
|
|
class Bound:
|
|
def __init__(self, gain):
|
|
self.gain = gain
|
|
def sample(self, value):
|
|
return value * self.gain
|
|
first, safe = storage._observe(functools.partial(Bound(1).sample, 2))
|
|
second, safe_second = storage._observe(functools.partial(Bound(3).sample, 2))
|
|
assert safe and safe_second and first != second
|
|
|
|
|
|
@pytest.mark.parametrize("location", ["wrappers", "patches", "model_options"])
|
|
def test_opaque_state_disables_reuse_without_preventing_contract(location):
|
|
class Opaque:
|
|
__slots__ = ("gain",)
|
|
def __init__(self):
|
|
self.gain = 1
|
|
def __call__(self, *args):
|
|
return self.gain
|
|
model = signatures._Model()
|
|
getattr(model, location)["external"] = Opaque()
|
|
contract, safe, reasons = signatures._sampling_contract(model=model)
|
|
assert contract["global"]["sampling_contract_version"] == 6
|
|
assert not safe and reasons
|
|
|
|
|
|
def test_empty_callable_attributes_are_not_complete():
|
|
class Opaque:
|
|
def __call__(self):
|
|
return 1
|
|
_, safe = storage._observe(Opaque())
|
|
assert not safe
|
|
|
|
|
|
def test_observation_bounds_preserve_ordinary_lora_keys_without_weight_traversal():
|
|
_, keys_safe = storage._observe({f"weight.{index}" for index in range(500)})
|
|
_, oversized_safe = storage._observe(list(range(4097)))
|
|
module = signatures._Model().model.diffusion_model
|
|
descriptor, module_safe = storage._observe(module)
|
|
assert keys_safe and not oversized_safe and not module_safe
|
|
assert descriptor["module_state_unobserved"]
|
|
|
|
|
|
def test_signature_failure_is_diagnostic_not_a_generation_stop():
|
|
model = signatures._Model()
|
|
model.model_dtype = lambda: (_ for _ in ()).throw(RuntimeError("custom dtype"))
|
|
contract, safe, reasons = signatures._sampling_contract(model=model)
|
|
assert contract and not safe and reasons
|
|
|
|
|
|
def test_core_euler_sampler_has_an_observable_runtime_signature():
|
|
from comfy.samplers import sampler_object
|
|
_, safe = storage._sampler_signature(sampler_object("euler"))
|
|
assert safe
|
|
|
|
|
|
def reader(tmp_path, contract):
|
|
controller = review._controller(tmp_path, contract)
|
|
controller.configure_review(generation_mode=GENERATION_MODE_REVIEW,
|
|
review_action=REVIEW_ACTION_CONTINUE)
|
|
return controller
|
|
|
|
|
|
@pytest.mark.parametrize("entry_point", ["head", "review", "import", "compatible", "take"])
|
|
def test_safe_false_never_adopts_a_prefix(tmp_path, entry_point):
|
|
contract = review._contract(chunks=3)
|
|
source = review._persist(tmp_path, contract, prefix=2, review_unit=(2, 2),
|
|
updated_utc="2026-10-04T00:00:00+00:00")
|
|
controller = reader(tmp_path, contract)
|
|
original = (source._manifest_path().read_bytes(), (source.run_root / "project.json").read_bytes())
|
|
if entry_point == "head":
|
|
assert controller.find_latest_review_head(contract, resume_safe=False) is None
|
|
elif entry_point == "review":
|
|
assert not controller._load_validated_review_prefix(contract, resume_safe=False).entries
|
|
elif entry_point == "import":
|
|
assert controller._find_plan_import(contract, resume_safe=False) is None
|
|
elif entry_point == "compatible":
|
|
assert controller._compatible_plan_prefix(source.manifest, contract, resume_safe=False) == ([], [])
|
|
else:
|
|
controller.take_group = 2
|
|
controller.take_revision_id = review._project(source)["canonical_head_revision_id"]
|
|
with pytest.raises(storage.RunStorageError, match="unobservable"):
|
|
controller._validated_take_selection(contract, resume_safe=False)
|
|
assert original == (source._manifest_path().read_bytes(), (source.run_root / "project.json").read_bytes())
|
|
|
|
|
|
def test_safe_false_retry_preserves_existing_take(tmp_path):
|
|
contract = review._contract(chunks=3)
|
|
source = review._persist(tmp_path, contract, prefix=2, review_unit=(2, 2),
|
|
updated_utc="2026-10-04T00:00:00+00:00")
|
|
controller = reader(tmp_path, contract)
|
|
controller.review_action = REVIEW_ACTION_REGENERATE_CURRENT
|
|
before = source._manifest_path().read_bytes()
|
|
with pytest.raises(ReviewControlError, match="could not be matched"):
|
|
controller._load_validated_review_prefix(contract, resume_safe=False)
|
|
assert source._manifest_path().read_bytes() == before
|
|
|
|
|
|
def test_identical_v6_review_and_take_still_reuse(tmp_path):
|
|
contract = review._contract(chunks=3)
|
|
source = review._persist(tmp_path, contract, prefix=2, review_unit=(2, 2),
|
|
updated_utc="2026-10-04T00:00:00+00:00")
|
|
controller = reader(tmp_path, contract)
|
|
assert len(controller._load_validated_review_prefix(contract, resume_safe=True).entries) == 2
|
|
controller.take_group = 2
|
|
controller.take_revision_id = review._project(source)["canonical_head_revision_id"]
|
|
assert len(controller._validated_take_selection(contract)["entries"]) == 2
|
|
|
|
|
|
def fixture_hashes(root):
|
|
return {str(file.relative_to(root)): hashlib.sha256(file.read_bytes()).hexdigest()
|
|
for file in root.rglob("*") if file.is_file()}
|
|
|
|
|
|
def test_actual_old_code_v5_fixture_readable_and_immutable(tmp_path):
|
|
fixture = Path(__file__).parent / "fixtures" / "v39_sampling_v5"
|
|
before = fixture_hashes(fixture)
|
|
run = tmp_path / "run"
|
|
shutil.copytree(fixture, run)
|
|
controller = storage.RunStorageController("legacy-read")
|
|
controller.run_root = run
|
|
controller.revisions_root = run / "revisions"
|
|
manifests, catalog, chains = controller._provenance_catalog()
|
|
assert len(manifests) == 1 and len(catalog) == 2 and len(chains) == 1
|
|
manifest = next(iter(manifests.values()))
|
|
assert manifest["sampling_contract_version"] == 5
|
|
assert manifest["contract"]["global"]["sampling_contract_version"] == 5
|
|
storage._manifest_sampling_identity(manifest)
|
|
head = controller._validated_review_head(manifest, for_reuse=False)
|
|
assert head["validated_prefix_count"] == 2
|
|
assert len(head["entries"]) == 2
|
|
contract = review._contract(chunks=manifest["contract"]["chunk_count"])
|
|
controller.prompts = [""] * contract["chunk_count"]
|
|
assert controller.find_latest_review_head(contract) is None
|
|
assert controller._compatible_plan_prefix(manifest, contract) == ([], [])
|
|
assert controller._find_plan_import(contract) is None
|
|
controller.take_group = 2
|
|
controller.take_revision_id = head["manifest"]["branch_provenance"]["active_chain"][-1]
|
|
with pytest.raises(storage.RunStorageError, match="read-only"):
|
|
controller._validated_take_selection(contract, source_lineage=manifest["contract"]["nonce_lineage_sha256"])
|
|
assert fixture_hashes(fixture) == before
|
|
assert fixture_hashes(run) == before
|