Files
ComfyUI-H3-Continuum-Tiled/preview_override_signature.py
T
chris.dumas 3716b02a57
tests / test (push) Canceled after 0s
tests / windows-storage (push) Canceled after 0s
Archive fork in favor of upstream and DUMAS nodes
2026-10-20 10:46:16 +00:00

295 lines
15 KiB
Python

"""Bounded KJ Preview Override identity; no provider imports or preview execution.
Only the source profiles shipped with this adapter can omit ``frames``. Other
wrappers keep the ordinary observer, including its existing safety decisions.
"""
from __future__ import annotations
import ast
import hashlib
import json
import marshal
import sys
import types
from functools import lru_cache
from pathlib import Path
_PROFILE = json.loads(Path(__file__).with_name("preview_override_provider_v1.json").read_text(encoding="utf-8"))
def _load_public_profile(path):
# A partial update must not break the old profile or ordinary generation.
try:
profile = json.loads(Path(path).read_text(encoding="utf-8"))
if (type(profile) is not dict or profile.keys() != _PROFILE.keys()
or type(profile["id"]) is not str or type(profile["source_sha256"]) is not str
or profile["id"] == _PROFILE["id"]
or profile["source_sha256"] == _PROFILE["source_sha256"]):
return None
return profile
except (OSError, ValueError):
return None
_PUBLIC_PROFILE = _load_public_profile(Path(__file__).with_name("preview_override_provider_public_v1.json"))
_PROFILES = (_PROFILE,) + ((_PUBLIC_PROFILE,) if _PUBLIC_PROFILE is not None else ())
_FIELDS = frozenset(("max_resolution", "node_id", "jpeg_quality", "suppress_default",
"preview_frames", "preview_fps", "vae", "tiny_vae", "audio_vae", "frames"))
_PREVIEW_REASONS = {
"provider source is outside the audited profile": "KJ/Core preview implementation is outside the audited source profiles",
"VAE preview is outside Phase A": "KJ preview VAE/Audio VAE or Tiny VAE is outside the supported configuration",
"Core approximate VAE is outside Phase A": "Core approximate-VAE preview is outside the supported configuration",
}
_UNKNOWN_PREVIEW_REASON = "KJ preview runtime code or state could not be verified"
PREVIEW_REUSE_REASONS = frozenset((*_PREVIEW_REASONS.values(), _UNKNOWN_PREVIEW_REASON))
def _normalized_code(code):
return code.replace(co_filename="<audited-provider>", co_consts=tuple(
_normalized_code(value) if isinstance(value, types.CodeType) else value
for value in code.co_consts))
def _literal(node):
# The audited source has one literal default expressed as 256 << 20.
if isinstance(node, ast.BinOp) and isinstance(node.op, ast.LShift):
return ast.literal_eval(node.left) << ast.literal_eval(node.right)
return ast.literal_eval(node)
@lru_cache(maxsize=8)
def _compiled(source):
tree = ast.parse(source)
code = compile(source, "<audited-provider>", "exec", dont_inherit=True)
codes = {}
def collect(item):
for child in item.co_consts:
if isinstance(child, types.CodeType):
codes[child.co_qualname] = child
collect(child)
collect(code)
functions = {}
classes = {}
for node in tree.body:
if isinstance(node, ast.FunctionDef):
functions[node.name] = node
elif isinstance(node, ast.ClassDef):
classes[node.name] = node
return codes, functions, classes
def _source(path, expected):
data = Path(path).read_bytes()
# Match the audited file contents across Git's LF/CRLF checkout policies.
data = data.replace(b"\r\n", b"\n")
if hashlib.sha256(data).hexdigest() != expected:
raise ValueError("provider source is outside the audited profile")
return data.decode("utf-8-sig")
def _provider_source(path):
data = Path(path).read_bytes().replace(b"\r\n", b"\n")
digest = hashlib.sha256(data).hexdigest()
matches = [profile for profile in _PROFILES if profile.get("source_sha256") == digest]
if len(matches) != 1:
raise ValueError("provider source is outside the audited profile")
return matches[0], data.decode("utf-8-sig")
def _check_function(fn, node, code, namespace):
if (type(fn) is not types.FunctionType or fn.__globals__ is not namespace
or fn.__closure__ or vars(fn) or fn.__qualname__ != code.co_qualname
or fn.__module__ != namespace["__name__"]):
raise ValueError("unknown loaded callable")
if marshal.dumps(_normalized_code(fn.__code__)) != marshal.dumps(_normalized_code(code)):
raise ValueError("loaded code differs from audited source")
defaults = tuple(_literal(value) for value in node.args.defaults) or None
kwdefaults = {arg.arg: _literal(value) for arg, value in zip(node.args.kwonlyargs, node.args.kw_defaults) if value is not None} or None
if not _same_literal(fn.__defaults__, defaults) or not _same_literal(fn.__kwdefaults__, kwdefaults):
raise ValueError("loaded defaults differ from audited source")
def _same_literal(actual, expected):
if type(actual) is not type(expected):
return False
if type(expected) in (tuple, list):
return len(actual) == len(expected) and all(_same_literal(a, b) for a, b in zip(actual, expected))
if type(expected) is dict:
return actual.keys() == expected.keys() and all(_same_literal(actual[key], value) for key, value in expected.items())
return type(expected) in (type(None), bool, int, float, str) and actual == expected
def _check_plain_class(cls, node, codes, namespace, *, sentinel=False):
if (type(cls) is not type or cls.__bases__ != (object,)
or cls.__module__ != namespace["__name__"]):
raise ValueError("unknown wrapper class")
methods = {item.name: item for item in node.body if isinstance(item, ast.FunctionDef)}
allowed = set(methods) | {"__module__", "__doc__", "__dict__", "__weakref__",
"__firstlineno__", "__static_attributes__"}
if sentinel:
allowed.add("_STOP")
if type(vars(cls).get("_STOP")) is not object:
raise ValueError("unknown encoder sentinel")
if set(vars(cls)) - allowed:
raise ValueError("additional class attributes")
for name, method in methods.items():
_check_function(vars(cls).get(name), method, codes[cls.__name__ + "." + name], namespace)
def _check_selected(module, source, names):
codes, functions, classes = _compiled(source)
for name in names:
value = vars(module).get(name)
if name in functions:
_check_function(value, functions[name], codes[name], vars(module))
continue
node = classes[name]
if not isinstance(value, type) or value.__module__ != module.__name__:
raise ValueError("unknown imported class")
methods = {item.name: item for item in node.body if isinstance(item, ast.FunctionDef)}
allowed = set(methods) | {"__module__", "__doc__", "__dict__", "__weakref__",
"__firstlineno__", "__static_attributes__"}
if set(vars(value)) - allowed:
raise ValueError("unknown imported class attributes")
expected_bases = tuple(vars(module).get(base.id) for base in node.bases if isinstance(base, ast.Name))
if not expected_bases:
expected_bases = (object,)
if value.__bases__ != expected_bases:
raise ValueError("unknown imported class bases")
for member, definition in methods.items():
_check_function(vars(value).get(member), definition, codes[name + "." + member], vars(module))
def _audit_provider(value):
cls = type(value)
module = sys.modules.get(cls.__module__)
if (module is None or vars(module).get("_PreviewOverrideWrapper") is not cls
or cls.__name__ != "_PreviewOverrideWrapper"):
raise ValueError("unrecognized Preview Override provider")
namespace = vars(module)
profile, source = _provider_source(namespace.get("__file__"))
codes, functions, classes = _compiled(source)
for name, node in functions.items():
_check_function(namespace.get(name), node, codes[name], namespace)
for name in ("_PreviewOverrideWrapper", "_AsyncPreviewEncoder"):
_check_plain_class(namespace.get(name), classes[name], codes, namespace,
sentinel=name == "_AsyncPreviewEncoder")
for alias, name in (("torch", "torch"), ("np", "numpy"), ("queue", "queue"),
("threading", "threading"), ("time", "time"), ("Image", "PIL.Image"),
("ImageOps", "PIL.ImageOps")):
if namespace.get(alias) is not sys.modules.get(name) or namespace.get(alias) is None:
raise ValueError("substituted preview module binding")
# Imported KJ bindings are canonical objects from the audited sibling files.
# No importlib/exec is used here; absent or substituted modules fail closed.
package = module.__name__.rsplit(".", 1)[0]
for relative, bindings in profile["siblings"].items():
sibling = sys.modules.get(package + "." + relative)
if sibling is None:
# ltxv_nodes is an explicitly optional import in the audited source.
if relative == "ltxv_nodes" and all(namespace.get(alias) is None for alias in bindings):
continue
raise ValueError("provider dependency not loaded")
dependency_source = _source(vars(sibling).get("__file__"), profile["sibling_sha256"][relative])
_check_selected(sibling, dependency_source, bindings.values())
for alias, original in bindings.items():
if namespace.get(alias) is not vars(sibling).get(original):
raise ValueError("substituted provider dependency")
# KJ reaches Core's preview factory directly. Unknown get_previewer hooks
# and an active Core approximate VAE stay outside this Phase A profile.
core = sys.modules.get("latent_preview")
if namespace.get("latent_preview") is not core or core is None:
raise ValueError("unknown Core preview module")
core_source = _source(vars(core).get("__file__"), profile["core_preview_sha256"])
_check_selected(core, core_source, ("get_previewer", "preview_to_image", "LatentPreviewer", "Latent2RGBPreviewer"))
patcher = sys.modules.get("comfy.patcher_extension")
if patcher is None:
raise ValueError("Core wrapper dispatcher not loaded")
dispatch_source = _source(vars(patcher).get("__file__"), profile["core_dispatch_sha256"])
_check_selected(patcher, dispatch_source, ("get_all_wrappers",))
method = getattr(vars(core).get("args"), "preview_method", None)
if (type(method) is not vars(core).get("LatentPreviewMethod")
or getattr(method, "name", None) not in ("NoPreviews", "Auto", "Latent2RGB")):
raise ValueError("Core approximate VAE is outside Phase A")
size = vars(core).get("MAX_PREVIEW_RESOLUTION")
if type(size) is not int or size <= 0:
raise ValueError("unknown Core preview setting")
return profile, {"method": method.name, "max_resolution": size}
def preview_override_signature(value):
"""Return a finite descriptor, never relaxing an unknown provider's guard."""
try:
profile, core_preview = _audit_provider(value)
state = vars(value)
if set(state) != _FIELDS or type(state["frames"]) is not list:
raise ValueError("unknown wrapper state")
if (state["vae"] is not None or state["audio_vae"] is not None
or type(state["tiny_vae"]) is not str or state["tiny_vae"] != "none"):
raise ValueError("VAE preview is outside Phase A")
for name, low, high in (("max_resolution", 0, 8192), ("jpeg_quality", 30, 100),
("preview_frames", 1, 1024), ("preview_fps", 1, 60)):
if type(state[name]) is not int or not low <= state[name] <= high:
raise ValueError("invalid fixed preview setting")
if (type(state["suppress_default"]) is not bool
or (state["node_id"] is not None and type(state["node_id"]) is not str)):
raise ValueError("invalid fixed preview setting")
settings = {key: state[key] for key in sorted(_FIELDS - {"frames", "vae", "audio_vae"})}
return {"adapter": "kj_preview_override_v1", "profile": profile["id"],
"profile_sha256": hashlib.sha256(json.dumps(profile, sort_keys=True, separators=(",", ":")).encode()).hexdigest(),
"source_sha256": profile["source_sha256"], "settings": settings,
"core_preview": core_preview}, True
except Exception as exc:
return {"adapter": "kj_preview_override_v1", "unsupported": str(exc)}, False
def preview_override_reuse_reasons(observed):
"""Classify the already observed KJ slot; never inspect MODEL a second time."""
wrappers = observed.get("wrappers") if type(observed) is dict else None
outer = wrappers.get("outer_sample") if type(wrappers) is dict else None
items = outer.get("kj_preview_override") if type(outer) is dict else None
if type(items) is not list:
return []
reasons = []
for item in items[:4096]:
if (type(item) is dict and item.get("adapter") == "kj_preview_override_v1"
and "unsupported" in item):
failure = item["unsupported"]
reason = _PREVIEW_REASONS.get(failure, _UNKNOWN_PREVIEW_REASON) if type(failure) is str else _UNKNOWN_PREVIEW_REASON
if reason not in reasons:
reasons.append(reason)
return reasons
def observe_model_wrappers(wrappers, observe):
"""Keep the no-KJ path exact; encode Core's key/list execution order for KJ."""
outer = wrappers.get("outer_sample") if type(wrappers) is dict else None
if not isinstance(outer, dict) or "kj_preview_override" not in outer:
return observe(wrappers)
if type(outer) is not dict or any(type(key) is not str for key in outer):
return {"unsupported": "unknown outer_sample container"}, False
if (len(wrappers) > 4096 or len(outer) > 4096
or any(type(key) is not str for key in wrappers)):
return {"unsupported": "wrapper container exceeds observation bounds"}, False
items = outer["kj_preview_override"]
if type(items) is not list or not items or len(items) > 4096:
return {"unsupported": "unknown kj_preview_override container"}, False
# A local copy holds placeholders while the ordinary observer checks all
# unrelated wrappers at their original nesting depth. Never mutate MODEL.
copied = dict(wrappers)
copied["outer_sample"] = dict(outer)
copied["outer_sample"]["kj_preview_override"] = [None] * len(items)
result, safe = observe(copied)
adapted = []
for value in items:
descriptor, recognized = preview_override_signature(value)
adapted.append(descriptor)
safe = safe and recognized
result["outer_sample"]["kj_preview_override"] = adapted
# Generic dict observation sorts keys. Keep a separate ordered sequence so
# cross-key execution order cannot disappear in canonical JSON hashing.
return {"wrappers": result, "outer_sample_order": list(outer)}, safe