Files
ComfyUI-H3-Continuum-Tiled/tests/test_v39_stability_r2.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

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