Archive fork in favor of upstream and DUMAS nodes
This commit is contained in:
@@ -0,0 +1,328 @@
|
||||
"""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]
|
||||
Reference in New Issue
Block a user