329 lines
15 KiB
Python
329 lines
15 KiB
Python
"""Phase A: real audited KJ wrapper, CPU-only observation and Run Storage gates."""
|
|
from __future__ import annotations
|
|
|
|
import importlib
|
|
import json
|
|
import os
|
|
import sys
|
|
import types
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
import torch
|
|
from PIL import Image
|
|
|
|
from ComfyUI_H3_Continuum_Join import preview_override_signature as adapter
|
|
from ComfyUI_H3_Continuum_Join import run_storage as storage
|
|
from . import test_v31_run_storage as signatures
|
|
from . import test_v38_review_run_storage as review
|
|
from . import test_issue31_attention_signature as attention
|
|
from .test_issue31_attention_signature import core_attention
|
|
from .test_issue31_spectrum_signature import spectrum, binding
|
|
|
|
|
|
@pytest.fixture(params=["local", "public"])
|
|
def kj(require_comfy_core, request):
|
|
root = os.environ.get("H3_KJ_PREVIEW_TEST_ROOT" if request.param == "local" else "H3_KJ_PREVIEW_PUBLIC_TEST_ROOT")
|
|
if not root:
|
|
pytest.skip("real audited KJ Preview Override provider is not configured")
|
|
package = types.ModuleType("issue31_kj_preview_tests_" + request.param)
|
|
package.__path__ = [str(Path(root) / "nodes")]
|
|
sys.modules[package.__name__] = package
|
|
return importlib.import_module(package.__name__ + ".preview_override_node")
|
|
|
|
|
|
def wrapper(kj, **settings):
|
|
values = dict(max_resolution=512, node_id="100", jpeg_quality=90,
|
|
suppress_default=True, preview_frames=1, preview_fps=12)
|
|
values.update(settings)
|
|
return kj._PreviewOverrideWrapper(**values)
|
|
|
|
|
|
def model_with(item):
|
|
model = signatures._Model()
|
|
model.wrappers = {"outer_sample": {"kj_preview_override": [item]}}
|
|
return model
|
|
|
|
|
|
def observe(model):
|
|
return storage._model_signature(model, "fixture")
|
|
|
|
|
|
def test_no_kj_observer_and_full_sampling_contract_are_exact(monkeypatch):
|
|
model = signatures._Model()
|
|
model.wrappers = {"outer_sample": {"other": [lambda executor: executor()]}}
|
|
current = observe(model)
|
|
torch.manual_seed(31016)
|
|
clip, vae = signatures._Clip(), signatures._VideoVAE()
|
|
contract = signatures._sampling_contract(model=model, clip=clip, video_vae=vae, reroll_from_chunk=0)
|
|
with monkeypatch.context() as ctx:
|
|
ctx.setattr(storage, "observe_model_wrappers", lambda value, observer: observer(value))
|
|
assert observe(model) == current
|
|
old = signatures._sampling_contract(model=model, clip=clip, video_vae=vae, reroll_from_chunk=0)
|
|
assert storage._canonical(contract) == storage._canonical(old)
|
|
assert storage.revision_identity(contract[0]) == storage.revision_identity(old[0])
|
|
|
|
|
|
def test_real_provider_frames_and_recreated_wrapper_keep_contract(kj):
|
|
item = wrapper(kj)
|
|
model = model_with(item)
|
|
before = observe(model)
|
|
assert before[1], before[0]
|
|
clip, vae = signatures._Clip(), signatures._VideoVAE()
|
|
original = signatures._sampling_contract(model=model, clip=clip, video_vae=vae, reroll_from_chunk=0)
|
|
assert original[1]
|
|
for count in (1, 3, 0):
|
|
item.frames[:] = [Image.new("RGB", (2, 2)) for _ in range(count)]
|
|
frames = item.frames
|
|
state = dict(vars(item))
|
|
assert observe(model) == before
|
|
current = signatures._sampling_contract(model=model, clip=clip, video_vae=vae, reroll_from_chunk=0)
|
|
assert current == original
|
|
assert vars(item) == state and item.frames is frames
|
|
model.wrappers["outer_sample"]["kj_preview_override"] = [wrapper(kj)]
|
|
assert observe(model) == before
|
|
|
|
|
|
@pytest.mark.parametrize("setting,value", [("max_resolution", 768), ("node_id", "101"),
|
|
("jpeg_quality", 80), ("suppress_default", False), ("preview_frames", 4), ("preview_fps", 24)])
|
|
def test_every_fixed_setting_changes_identity(kj, setting, value):
|
|
item = wrapper(kj)
|
|
before, safe = adapter.preview_override_signature(item)
|
|
assert safe, before
|
|
setattr(item, setting, value)
|
|
after, safe = adapter.preview_override_signature(item)
|
|
assert safe and after != before
|
|
|
|
|
|
def test_full_audit_profile_is_part_of_identity(kj, monkeypatch):
|
|
item = wrapper(kj)
|
|
before, safe = adapter.preview_override_signature(item)
|
|
assert safe
|
|
# An audit revision must change identity even with the same display ID and
|
|
# wrapper source, so dependency-profile upgrades cannot reuse old Takes.
|
|
profile, _ = adapter._provider_source(kj.__file__)
|
|
monkeypatch.setitem(profile, "audit_revision", 2)
|
|
after, safe = adapter.preview_override_signature(item)
|
|
assert safe and before["profile"] == after["profile"]
|
|
assert before["profile_sha256"] != after["profile_sha256"]
|
|
|
|
|
|
def other_wrapper(executor, *args, **kwargs):
|
|
return executor(*args, **kwargs)
|
|
|
|
|
|
def test_key_and_list_execution_order_change_identity(kj):
|
|
a, b = wrapper(kj), wrapper(kj, jpeg_quality=80)
|
|
model = model_with(a)
|
|
model.wrappers["outer_sample"] = {"other": [other_wrapper], "kj_preview_override": [a, b]}
|
|
before, safe = observe(model)
|
|
assert safe
|
|
model.wrappers["outer_sample"] = {"kj_preview_override": [a, b], "other": [other_wrapper]}
|
|
after, safe = observe(model)
|
|
assert safe and after != before
|
|
model.wrappers["outer_sample"]["kj_preview_override"] = [b, a]
|
|
reordered, safe = observe(model)
|
|
assert safe and reordered != after
|
|
|
|
|
|
@pytest.mark.parametrize("change", ["source", "call_code", "helper_code", "defaults", "class_attribute",
|
|
"instance_attribute", "frames_tuple", "frames_subclass", "vae", "audio_vae", "tiny_vae",
|
|
"foreign", "subclass", "invalid_setting", "core_factory", "imported_helper_code",
|
|
"core_preview_code", "dispatcher_code", "core_tiny_vae"])
|
|
def test_unknown_implementations_and_out_of_scope_state_reject_reuse(kj, monkeypatch, change):
|
|
item = wrapper(kj)
|
|
if change == "source":
|
|
profile, _ = adapter._provider_source(kj.__file__)
|
|
monkeypatch.setitem(profile, "source_sha256", "f" * 64)
|
|
elif change in ("call_code", "helper_code"):
|
|
fn = type(item).__call__ if change == "call_code" else kj._normalize_packed_x0
|
|
monkeypatch.setattr(fn, "__code__", fn.__code__.replace(co_consts=fn.__code__.co_consts + ("changed",)))
|
|
elif change == "defaults":
|
|
monkeypatch.setattr(type(item).__init__, "__defaults__", (2, 12, None, "none", None))
|
|
elif change == "class_attribute":
|
|
monkeypatch.setattr(type(item), "unrecognized", True, raising=False)
|
|
elif change == "instance_attribute":
|
|
item.unrecognized = True
|
|
elif change == "frames_tuple":
|
|
item.frames = ()
|
|
elif change == "frames_subclass":
|
|
class Frames(list):
|
|
pass
|
|
item.frames = Frames()
|
|
elif change in ("vae", "audio_vae"):
|
|
setattr(item, change, object())
|
|
elif change == "tiny_vae":
|
|
item.tiny_vae = "taeh3"
|
|
elif change == "foreign":
|
|
item = types.SimpleNamespace(**vars(item))
|
|
elif change == "subclass":
|
|
class Extra(type(item)):
|
|
pass
|
|
item = Extra(512, "100", 90, True)
|
|
elif change == "invalid_setting":
|
|
item.preview_frames = True
|
|
elif change == "core_factory":
|
|
monkeypatch.setattr(kj.latent_preview, "get_previewer", lambda *a: None)
|
|
elif change == "core_tiny_vae":
|
|
import latent_preview
|
|
monkeypatch.setattr(latent_preview.args, "preview_method", latent_preview.LatentPreviewMethod.TAESD)
|
|
else:
|
|
if change == "imported_helper_code":
|
|
fn = kj.load_tiny_vae_decoder
|
|
elif change == "core_preview_code":
|
|
fn = kj.latent_preview.Latent2RGBPreviewer.decode_latent_to_preview
|
|
else:
|
|
fn = sys.modules["comfy.patcher_extension"].get_all_wrappers
|
|
monkeypatch.setattr(fn, "__code__", fn.__code__.replace(co_consts=fn.__code__.co_consts + ("changed",)))
|
|
assert not observe(model_with(item))[1]
|
|
|
|
|
|
def test_unknown_other_wrapper_is_not_promoted(kj):
|
|
model = model_with(wrapper(kj))
|
|
model.wrappers["outer_sample"]["unknown"] = [torch.nn.Linear(2, 2)]
|
|
assert not observe(model)[1]
|
|
|
|
|
|
@pytest.mark.parametrize("items", [None, (), [], object()])
|
|
def test_unknown_target_container_is_not_promoted(items):
|
|
assert not adapter.observe_model_wrappers({"outer_sample": {"kj_preview_override": items}}, storage._observe)[1]
|
|
|
|
|
|
@pytest.mark.parametrize("container", ["root", "outer", "items"])
|
|
def test_observation_limit_rejects_reuse_without_interrupting_generation(container):
|
|
wrappers = {"outer_sample": {"kj_preview_override": [object()]}}
|
|
if container == "items":
|
|
wrappers["outer_sample"]["kj_preview_override"] *= 4097
|
|
else:
|
|
target = wrappers if container == "root" else wrappers["outer_sample"]
|
|
target.update({str(i): [] for i in range(4097)})
|
|
result, safe = adapter.observe_model_wrappers(wrappers, storage._observe)
|
|
assert not safe and result["unsupported"]
|
|
|
|
|
|
def test_observation_never_executes_provider_or_initializes_cuda(kj, monkeypatch):
|
|
item = wrapper(kj)
|
|
# Even frame objects whose representation or data cannot be inspected are
|
|
# ignored. The exact builtin list is the only permitted transient container.
|
|
class UnreadableFrame:
|
|
def __repr__(self):
|
|
raise AssertionError("frame inspected")
|
|
item.frames.append(UnreadableFrame())
|
|
def forbidden(*args, **kwargs):
|
|
raise AssertionError("signature tried to execute GPU/preview code")
|
|
monkeypatch.setattr(torch.cuda, "_lazy_init", forbidden)
|
|
# Trace calls instead of patching the audited callable (which must reject).
|
|
called = []
|
|
watched = {kj._PreviewOverrideWrapper.__call__.__code__, kj._get_core_previewer.__code__,
|
|
kj._frame_to_pil.__code__, kj.load_tiny_vae_decoder.__code__}
|
|
def trace(frame, event, arg):
|
|
if event == "call" and frame.f_code in watched:
|
|
called.append(frame.f_code.co_name)
|
|
return trace
|
|
previous = sys.gettrace()
|
|
try:
|
|
sys.settrace(trace)
|
|
result, safe = observe(model_with(item))
|
|
finally:
|
|
sys.settrace(previous)
|
|
assert safe, result
|
|
assert called == [] and not torch.cuda.is_initialized()
|
|
|
|
|
|
@pytest.mark.parametrize("backend", ["pytorch", "comfy_kitchen_int8"])
|
|
def test_attention_and_spectrum_combination_is_stable(kj, core_attention, spectrum, backend):
|
|
model = attention.model_with(core_attention, backend)
|
|
model.model_options["spectrum_h3_binding"] = binding(spectrum)
|
|
base, safe = observe(model)
|
|
assert safe
|
|
item = wrapper(kj)
|
|
model.wrappers = {"outer_sample": {"kj_preview_override": [item]}}
|
|
before, safe = observe(model)
|
|
assert safe
|
|
assert before["model_options"] == base["model_options"]
|
|
item.frames.append(Image.new("RGB", (2, 2)))
|
|
assert observe(model) == (before, safe)
|
|
|
|
|
|
def test_saved_prefix_is_reusable_after_preview_only_change(kj, tmp_path):
|
|
item = wrapper(kj)
|
|
model = model_with(item)
|
|
clip, vae = signatures._Clip(), signatures._VideoVAE()
|
|
contract, safe, _ = signatures._sampling_contract(model=model, clip=clip, video_vae=vae, reroll_from_chunk=0)
|
|
assert safe
|
|
saved = signatures._persist_contract_prefix(tmp_path, contract, count=1)
|
|
before = {str(p): p.read_bytes() for p in tmp_path.rglob("*") if p.is_file()}
|
|
item.frames.append(Image.new("RGB", (2, 2)))
|
|
current, safe, _ = signatures._sampling_contract(model=model, clip=clip, video_vae=vae, reroll_from_chunk=0)
|
|
assert safe and storage.revision_identity(current) == storage.revision_identity(contract)
|
|
_, entries, records = signatures._load_compatible_prefix(tmp_path, saved, current)
|
|
assert len(entries) == len(records) == 1
|
|
assert before == {str(p): p.read_bytes() for p in tmp_path.rglob("*") if p.is_file()}
|
|
|
|
|
|
@pytest.mark.parametrize("entry_point", ["review", "head", "import", "compatible", "take"])
|
|
def test_old_unsafe_preview_history_is_never_promoted(kj, tmp_path, monkeypatch, entry_point):
|
|
item = wrapper(kj)
|
|
item.frames.append(Image.new("RGB", (2, 2)))
|
|
model = model_with(item)
|
|
with monkeypatch.context() as ctx:
|
|
ctx.setattr(storage, "observe_model_wrappers", lambda value, observer: observer(value))
|
|
old, safe, reasons = signatures._sampling_contract(model=model, reroll_from_chunk=0)
|
|
assert not safe
|
|
source = review._persist(tmp_path, old, prefix=1, review_unit=(1, 1), updated_utc="2026-10-16T00:00:00+00:00")
|
|
source.manifest["resume_safe"] = False
|
|
source.manifest["resume_disabled_reasons"] = reasons
|
|
source._write_manifest()
|
|
before = {str(p): p.read_bytes() for p in source.run_root.rglob("*") if p.is_file()}
|
|
reader = review._controller(tmp_path, old)
|
|
reader.configure_review(generation_mode=review.GENERATION_MODE_REVIEW, review_action=review.REVIEW_ACTION_CONTINUE)
|
|
assert not storage._reusable_manifest(source.manifest)
|
|
if entry_point == "review": assert not reader._load_validated_review_prefix(old, resume_safe=True).entries
|
|
elif entry_point == "head": assert reader.find_latest_review_head(old, resume_safe=True) is None
|
|
elif entry_point == "import": assert reader._find_plan_import(old, resume_safe=True) is None
|
|
elif entry_point == "compatible": assert reader._compatible_plan_prefix(source.manifest, old, resume_safe=True) == ([], [])
|
|
else:
|
|
reader.take_group = 1
|
|
reader.take_revision_id = review._project(source)["canonical_head_revision_id"]
|
|
with pytest.raises(storage.RunStorageError, match="read-only"):
|
|
reader._validated_take_selection(old, resume_safe=True)
|
|
assert before == {str(p): p.read_bytes() for p in source.run_root.rglob("*") if p.is_file()}
|
|
|
|
|
|
def test_other_profile_registration_does_not_change_identity(kj, monkeypatch):
|
|
item = wrapper(kj)
|
|
before, safe = adapter.preview_override_signature(item)
|
|
assert safe
|
|
active, _ = adapter._provider_source(kj.__file__)
|
|
monkeypatch.setattr(adapter, "_PROFILES", (active,))
|
|
assert adapter.preview_override_signature(item) == (before, True)
|
|
monkeypatch.setattr(adapter, "_PROFILES", (active, dict(active, source_sha256="e" * 64)))
|
|
assert adapter.preview_override_signature(item) == (before, True)
|
|
monkeypatch.setattr(adapter, "_PROFILES", (active, active))
|
|
assert not adapter.preview_override_signature(item)[1]
|
|
|
|
|
|
@pytest.mark.parametrize("contents", [None, "invalid json", "null", "[]", "{}"])
|
|
def test_missing_or_malformed_optional_profile_does_not_break_existing_paths(tmp_path, contents):
|
|
path = tmp_path / "public.json"
|
|
if contents is not None:
|
|
path.write_text(contents, encoding="utf-8")
|
|
assert adapter._load_public_profile(path) is None
|
|
model = signatures._Model()
|
|
assert observe(model)[1]
|
|
|
|
|
|
@pytest.mark.parametrize("field", ["id", "source_sha256"])
|
|
def test_optional_profile_collision_cannot_disable_original_profile(kj, tmp_path, monkeypatch, field):
|
|
candidate = dict(adapter._PUBLIC_PROFILE)
|
|
candidate[field] = adapter._PROFILE[field]
|
|
path = tmp_path / "public.json"
|
|
path.write_text(json.dumps(candidate), encoding="utf-8")
|
|
loaded = adapter._load_public_profile(path)
|
|
assert loaded is None
|
|
monkeypatch.setattr(adapter, "_PROFILES", (adapter._PROFILE,))
|
|
item = wrapper(kj)
|
|
expected = "_local." in kj.__name__
|
|
assert adapter.preview_override_signature(item)[1] is expected
|
|
assert observe(signatures._Model())[1]
|