Squashed 'vendor/dumas_h3_continuum/' content from commit d07ed31
git-subtree-dir: vendor/dumas_h3_continuum git-subtree-split: d07ed31b442d283d6a1740f875a843b9feda4c91
This commit is contained in:
@@ -0,0 +1,676 @@
|
||||
"""Phase 2A P2-4 probe against the installed ComfyUI execution/cache stack.
|
||||
|
||||
The probe uses deterministic decoded CPU IMAGE/AUDIO fixtures. It does not
|
||||
load a model, run a VAE, or use CUDA. Its purpose is to exercise the real
|
||||
ComfyUI cache, Core Preview/Save nodes, installed VHS Video Combine, Core ESC
|
||||
interrupt propagation, and restart-style stale cleanup around the V3.5
|
||||
Disk-backed assembler.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import gc
|
||||
import importlib
|
||||
import importlib.util
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
from types import SimpleNamespace
|
||||
from typing import Any
|
||||
|
||||
import torch
|
||||
|
||||
|
||||
class ProbeFailure(RuntimeError):
|
||||
pass
|
||||
|
||||
|
||||
class _Server:
|
||||
def __init__(self):
|
||||
self.client_id = None
|
||||
self.last_node_id = None
|
||||
self.messages: list[tuple[str, dict[str, Any], Any]] = []
|
||||
|
||||
def send_sync(self, event, data, client_id):
|
||||
self.messages.append((event, data, client_id))
|
||||
|
||||
|
||||
def _load_package(package_root: Path):
|
||||
name = "h3_continuum_p24_probe"
|
||||
spec = importlib.util.spec_from_file_location(
|
||||
name,
|
||||
package_root / "__init__.py",
|
||||
submodule_search_locations=[str(package_root)],
|
||||
)
|
||||
if spec is None or spec.loader is None:
|
||||
raise ProbeFailure("cannot create Continuum package import specification")
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
sys.modules[name] = module
|
||||
spec.loader.exec_module(module)
|
||||
return module
|
||||
|
||||
|
||||
def _install_paths(comfy_root: Path) -> None:
|
||||
for value in (
|
||||
comfy_root,
|
||||
comfy_root / "custom_nodes" / "comfyui-videohelpersuite",
|
||||
):
|
||||
text = str(value)
|
||||
if text not in sys.path:
|
||||
sys.path.insert(0, text)
|
||||
|
||||
|
||||
def _single_plan(package_name: str) -> dict[str, Any]:
|
||||
hardening = importlib.import_module(f"{package_name}.hardening")
|
||||
temporal = importlib.import_module(f"{package_name}.temporal")
|
||||
plan_module = importlib.import_module(f"{package_name}.v3.plan")
|
||||
total_frames = 124
|
||||
chunk = {
|
||||
"sequence_index": 1,
|
||||
"chunk_index": 1,
|
||||
"total_frames": total_frames,
|
||||
"trim_frames": 0,
|
||||
"net_frames": total_frames,
|
||||
"context_frames": 0,
|
||||
"expected_video_latent_t": temporal.video_latent_t(total_frames),
|
||||
"expected_audio_latent_t": temporal.audio_latent_t(total_frames),
|
||||
}
|
||||
return hardening.enrich_assembly_plan(
|
||||
{
|
||||
"magic": plan_module.ASSEMBLY_PLAN_MAGIC,
|
||||
"schema_version": 1,
|
||||
"fps": 24,
|
||||
"width": 16,
|
||||
"height": 16,
|
||||
"chunk_seconds": 5.0,
|
||||
"target_frames": 120,
|
||||
"preserve_final_frame": True,
|
||||
"chunks": [chunk],
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
def _register_probe_nodes(core_nodes, package_module, video_combine):
|
||||
package_name = package_module.__name__
|
||||
|
||||
class P24DecodedFixture:
|
||||
@classmethod
|
||||
def INPUT_TYPES(cls):
|
||||
return {
|
||||
"required": {
|
||||
"nonce": ("INT", {"default": 0}),
|
||||
"interrupt_before_assembly": (
|
||||
"BOOLEAN",
|
||||
{"default": False},
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
RETURN_TYPES = (
|
||||
"IMAGE",
|
||||
"AUDIO",
|
||||
"H3_CONTINUUM_ASSEMBLY_PLAN",
|
||||
)
|
||||
RETURN_NAMES = ("images", "audio", "assembly_plan")
|
||||
FUNCTION = "build"
|
||||
CATEGORY = "P2-4 Probe"
|
||||
|
||||
def build(self, nonce, interrupt_before_assembly):
|
||||
total_frames = 124
|
||||
values = (
|
||||
torch.arange(total_frames, dtype=torch.float32)
|
||||
+ float(int(nonce) % 7)
|
||||
) / float(total_frames + 7)
|
||||
images = values.reshape(-1, 1, 1, 1).expand(
|
||||
-1,
|
||||
16,
|
||||
16,
|
||||
3,
|
||||
)
|
||||
sample_rate = 32_000
|
||||
samples = int(round(total_frames / 24 * sample_rate))
|
||||
audio = {
|
||||
"waveform": torch.linspace(
|
||||
-0.05,
|
||||
0.05,
|
||||
samples,
|
||||
dtype=torch.float32,
|
||||
).reshape(1, 1, -1),
|
||||
"sample_rate": sample_rate,
|
||||
}
|
||||
plan = _single_plan(package_name)
|
||||
if bool(interrupt_before_assembly):
|
||||
core_nodes.interrupt_processing(True)
|
||||
return images, audio, plan
|
||||
|
||||
class P24FailOrPass:
|
||||
@classmethod
|
||||
def INPUT_TYPES(cls):
|
||||
return {
|
||||
"required": {
|
||||
"images": ("IMAGE",),
|
||||
"fail": ("BOOLEAN", {"default": True}),
|
||||
}
|
||||
}
|
||||
|
||||
RETURN_TYPES = ("IMAGE",)
|
||||
FUNCTION = "consume"
|
||||
OUTPUT_NODE = True
|
||||
CATEGORY = "P2-4 Probe"
|
||||
|
||||
def consume(self, images, fail):
|
||||
if bool(fail):
|
||||
raise RuntimeError("P2-4 intentional downstream failure")
|
||||
return {
|
||||
"ui": {"p24": ["downstream pass"]},
|
||||
"result": (images,),
|
||||
}
|
||||
|
||||
class P24ClearCacheOutput:
|
||||
@classmethod
|
||||
def INPUT_TYPES(cls):
|
||||
return {"required": {"token": ("INT", {"default": 0})}}
|
||||
|
||||
RETURN_TYPES = ("STRING",)
|
||||
FUNCTION = "finish"
|
||||
OUTPUT_NODE = True
|
||||
CATEGORY = "P2-4 Probe"
|
||||
|
||||
def finish(self, token):
|
||||
return (f"clear-{int(token)}",)
|
||||
|
||||
core_nodes.NODE_CLASS_MAPPINGS.update(package_module.NODE_CLASS_MAPPINGS)
|
||||
core_nodes.NODE_CLASS_MAPPINGS.update(
|
||||
{
|
||||
"P24DecodedFixture": P24DecodedFixture,
|
||||
"P24FailOrPass": P24FailOrPass,
|
||||
"P24ClearCacheOutput": P24ClearCacheOutput,
|
||||
"P24VHSVideoCombine": video_combine,
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
def _base_prompt(*, nonce: int, interrupt_before_assembly: bool) -> dict[str, Any]:
|
||||
return {
|
||||
"1": {
|
||||
"class_type": "P24DecodedFixture",
|
||||
"inputs": {
|
||||
"nonce": int(nonce),
|
||||
"interrupt_before_assembly": bool(interrupt_before_assembly),
|
||||
},
|
||||
},
|
||||
"2": {
|
||||
"class_type": "H3ContinuumAssembleSeamV35",
|
||||
"inputs": {
|
||||
"images": ["1", 0],
|
||||
"audio": ["1", 1],
|
||||
"assembly_plan": ["1", 2],
|
||||
"exact_total_duration": True,
|
||||
"audio_seam": "Off",
|
||||
"video_seam": "Off",
|
||||
"buffer_backend": "Disk-backed",
|
||||
"diagnostics": "Basic",
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
def _failure_prompt(*, fail: bool, nonce: int = 0) -> dict[str, Any]:
|
||||
prompt = _base_prompt(nonce=nonce, interrupt_before_assembly=False)
|
||||
prompt["3"] = {
|
||||
"class_type": "P24FailOrPass",
|
||||
"inputs": {"images": ["2", 0], "fail": bool(fail)},
|
||||
}
|
||||
return prompt
|
||||
|
||||
|
||||
def _compatibility_prompt() -> dict[str, Any]:
|
||||
prompt = _base_prompt(nonce=0, interrupt_before_assembly=False)
|
||||
prompt.update(
|
||||
{
|
||||
"4": {
|
||||
"class_type": "SaveImage",
|
||||
"inputs": {
|
||||
"images": ["2", 0],
|
||||
"filename_prefix": "P24/Save",
|
||||
},
|
||||
},
|
||||
"5": {
|
||||
"class_type": "PreviewImage",
|
||||
"inputs": {"images": ["2", 0]},
|
||||
},
|
||||
"6": {
|
||||
"class_type": "P24VHSVideoCombine",
|
||||
"inputs": {
|
||||
"images": ["2", 0],
|
||||
"audio": ["2", 1],
|
||||
"frame_rate": 24,
|
||||
"loop_count": 0,
|
||||
"filename_prefix": "P24/VHS",
|
||||
"format": "video/h264-mp4",
|
||||
"pingpong": False,
|
||||
"save_output": True,
|
||||
},
|
||||
},
|
||||
}
|
||||
)
|
||||
return prompt
|
||||
|
||||
|
||||
def _interrupt_prompt() -> dict[str, Any]:
|
||||
prompt = _base_prompt(nonce=99, interrupt_before_assembly=True)
|
||||
prompt["3"] = {
|
||||
"class_type": "P24FailOrPass",
|
||||
"inputs": {"images": ["2", 0], "fail": False},
|
||||
}
|
||||
return prompt
|
||||
|
||||
|
||||
def _clear_prompt(token: int) -> dict[str, Any]:
|
||||
return {
|
||||
"9": {
|
||||
"class_type": "P24ClearCacheOutput",
|
||||
"inputs": {"token": int(token)},
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
def _cached_nodes(executor) -> set[str]:
|
||||
for event, data in executor.status_messages:
|
||||
if event == "execution_cached":
|
||||
return {str(value) for value in data.get("nodes", [])}
|
||||
return set()
|
||||
|
||||
|
||||
def _has_event(executor, wanted: str) -> bool:
|
||||
return any(event == wanted for event, _ in executor.status_messages)
|
||||
|
||||
|
||||
def _execute(executor, prompt, prompt_id: str, outputs: list[str]) -> None:
|
||||
executor.execute(
|
||||
prompt,
|
||||
prompt_id,
|
||||
extra_data={},
|
||||
execute_outputs=outputs,
|
||||
)
|
||||
|
||||
|
||||
def _managed_files(backing_root: Path, suffix: str) -> list[Path]:
|
||||
return sorted(backing_root.glob(f"h3c-p20-*.{suffix}"))
|
||||
|
||||
|
||||
def _all_output_files(root: Path) -> set[str]:
|
||||
if not root.exists():
|
||||
return set()
|
||||
return {
|
||||
str(path.relative_to(root))
|
||||
for path in root.rglob("*")
|
||||
if path.is_file()
|
||||
}
|
||||
|
||||
|
||||
def _assert_output_paths(output_root: Path, temp_root: Path, history: dict) -> dict:
|
||||
outputs = history.get("outputs", {})
|
||||
save_items = outputs.get("4", {}).get("images", [])
|
||||
preview_items = outputs.get("5", {}).get("images", [])
|
||||
gifs = outputs.get("6", {}).get("gifs", [])
|
||||
if len(save_items) != 120:
|
||||
raise ProbeFailure(f"Core SaveImage wrote {len(save_items)} frames, expected 120")
|
||||
if len(preview_items) != 120:
|
||||
raise ProbeFailure(
|
||||
f"Core PreviewImage wrote {len(preview_items)} frames, expected 120"
|
||||
)
|
||||
if len(gifs) != 1:
|
||||
raise ProbeFailure(f"VHS returned {len(gifs)} previews, expected 1")
|
||||
|
||||
for item in save_items:
|
||||
path = output_root / item.get("subfolder", "") / item["filename"]
|
||||
if not path.is_file() or path.stat().st_size <= 0:
|
||||
raise ProbeFailure(f"Core SaveImage output missing: {path}")
|
||||
for item in preview_items:
|
||||
path = temp_root / item.get("subfolder", "") / item["filename"]
|
||||
if not path.is_file() or path.stat().st_size <= 0:
|
||||
raise ProbeFailure(f"Core PreviewImage output missing: {path}")
|
||||
video_path = Path(gifs[0]["fullpath"])
|
||||
if not video_path.is_file() or video_path.stat().st_size <= 0:
|
||||
raise ProbeFailure(f"VHS output missing: {video_path}")
|
||||
ffprobe = shutil.which("ffprobe")
|
||||
if ffprobe is None:
|
||||
raise ProbeFailure("ffprobe is required for P2-4 VHS acceptance")
|
||||
inspected = subprocess.run(
|
||||
[
|
||||
ffprobe,
|
||||
"-v",
|
||||
"error",
|
||||
"-count_frames",
|
||||
"-show_entries",
|
||||
(
|
||||
"stream=codec_type,codec_name,width,height,r_frame_rate,"
|
||||
"nb_read_frames,sample_rate,channels,duration:"
|
||||
"format=duration,size"
|
||||
),
|
||||
"-of",
|
||||
"json",
|
||||
str(video_path),
|
||||
],
|
||||
check=True,
|
||||
capture_output=True,
|
||||
text=True,
|
||||
)
|
||||
media = json.loads(inspected.stdout)
|
||||
video_stream = next(
|
||||
(item for item in media.get("streams", []) if item.get("codec_type") == "video"),
|
||||
None,
|
||||
)
|
||||
audio_stream = next(
|
||||
(item for item in media.get("streams", []) if item.get("codec_type") == "audio"),
|
||||
None,
|
||||
)
|
||||
if video_stream is None or audio_stream is None:
|
||||
raise ProbeFailure("VHS output does not contain both video and audio")
|
||||
if (
|
||||
video_stream.get("codec_name") != "h264"
|
||||
or int(video_stream.get("nb_read_frames", 0)) != 120
|
||||
or video_stream.get("r_frame_rate") != "24/1"
|
||||
or int(video_stream.get("width", 0)) != 16
|
||||
or int(video_stream.get("height", 0)) != 16
|
||||
or int(audio_stream.get("sample_rate", 0)) != 32_000
|
||||
):
|
||||
raise ProbeFailure(f"unexpected VHS media contract: {media}")
|
||||
return {
|
||||
"save_frames": len(save_items),
|
||||
"preview_frames": len(preview_items),
|
||||
"vhs_file": str(video_path),
|
||||
"vhs_bytes": int(video_path.stat().st_size),
|
||||
"vhs_video_frames": int(video_stream["nb_read_frames"]),
|
||||
"vhs_video_fps": video_stream["r_frame_rate"],
|
||||
"vhs_video_duration": float(video_stream["duration"]),
|
||||
"vhs_audio_sample_rate": int(audio_stream["sample_rate"]),
|
||||
"vhs_container_duration": float(media["format"]["duration"]),
|
||||
}
|
||||
|
||||
|
||||
def _collect_until_empty(manager, backing_root: Path) -> None:
|
||||
for _ in range(8):
|
||||
gc.collect()
|
||||
manager.collect_ready()
|
||||
if not _managed_files(backing_root, "bin") and not _managed_files(
|
||||
backing_root,
|
||||
"json",
|
||||
):
|
||||
return
|
||||
time.sleep(0.05)
|
||||
raise ProbeFailure("released cache storage did not become reclaimable")
|
||||
|
||||
|
||||
def _run_child_mode(args, package_root: Path) -> int:
|
||||
_install_paths(args.comfy_root)
|
||||
package = _load_package(package_root)
|
||||
buffers = importlib.import_module(f"{package.__name__}.v3.file_backed_buffer")
|
||||
root = args.backing_root.resolve()
|
||||
if args.child_mode == "create-stale":
|
||||
manager = buffers.get_file_backed_image_manager(root)
|
||||
allocation = manager.allocate((2, 8, 8, 3), dtype=torch.float32)
|
||||
tensor = allocation.publish()
|
||||
tensor.fill_(0.25)
|
||||
os._exit(0)
|
||||
if args.child_mode == "clean-stale":
|
||||
buffers.get_file_backed_image_manager(root)
|
||||
payload = {
|
||||
"bin": len(_managed_files(root, "bin")),
|
||||
"json": len(_managed_files(root, "json")),
|
||||
}
|
||||
print(json.dumps(payload, sort_keys=True))
|
||||
return 0
|
||||
raise ProbeFailure(f"unknown child mode: {args.child_mode}")
|
||||
|
||||
|
||||
def _restart_stale_probe(args, package_root: Path, stale_root: Path) -> dict:
|
||||
common = [
|
||||
sys.executable,
|
||||
str(Path(__file__).resolve()),
|
||||
"--comfy-root",
|
||||
str(args.comfy_root),
|
||||
"--package-root",
|
||||
str(package_root),
|
||||
"--backing-root",
|
||||
str(stale_root),
|
||||
]
|
||||
subprocess.run(
|
||||
[*common, "--child-mode", "create-stale"],
|
||||
check=True,
|
||||
capture_output=True,
|
||||
text=True,
|
||||
)
|
||||
created = (
|
||||
len(_managed_files(stale_root, "bin")),
|
||||
len(_managed_files(stale_root, "json")),
|
||||
)
|
||||
if created != (1, 1):
|
||||
raise ProbeFailure(f"crash child left unexpected files: {created}")
|
||||
cleaned = subprocess.run(
|
||||
[*common, "--child-mode", "clean-stale"],
|
||||
check=True,
|
||||
capture_output=True,
|
||||
text=True,
|
||||
)
|
||||
line = next(
|
||||
(value for value in reversed(cleaned.stdout.splitlines()) if value.startswith("{")),
|
||||
"",
|
||||
)
|
||||
payload = json.loads(line)
|
||||
if payload != {"bin": 0, "json": 0}:
|
||||
raise ProbeFailure(f"restart stale cleanup failed: {payload}")
|
||||
return {"created_pairs": 1, "remaining_pairs_after_restart": 0}
|
||||
|
||||
|
||||
def run_probe(args, package_root: Path) -> dict:
|
||||
_install_paths(args.comfy_root)
|
||||
import folder_paths
|
||||
import nodes as core_nodes
|
||||
import server as comfy_server
|
||||
from execution import CacheType, PromptExecutor
|
||||
|
||||
# A normal ComfyUI process installs this singleton before loading custom
|
||||
# nodes. The headless probe supplies only the queue fields VHS imports;
|
||||
# Video Combine itself does not use them without a meta-batch.
|
||||
if not hasattr(comfy_server.PromptServer, "instance"):
|
||||
comfy_server.PromptServer.instance = SimpleNamespace(
|
||||
prompt_queue=SimpleNamespace(
|
||||
currently_running={},
|
||||
put=lambda _item: None,
|
||||
),
|
||||
number=0,
|
||||
)
|
||||
from videohelpersuite.nodes import VideoCombine
|
||||
|
||||
package = _load_package(package_root)
|
||||
_register_probe_nodes(core_nodes, package, VideoCombine)
|
||||
buffers = importlib.import_module(f"{package.__name__}.v3.file_backed_buffer")
|
||||
|
||||
work_root = args.work_root.resolve()
|
||||
output_root = work_root / "output"
|
||||
temp_root = work_root / "temp"
|
||||
backing_root = temp_root / "h3-continuum-v35-file-backed"
|
||||
stale_root = work_root / "restart-stale"
|
||||
for path in (output_root, temp_root, backing_root, stale_root):
|
||||
path.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
old_output = folder_paths.get_output_directory()
|
||||
old_temp = folder_paths.get_temp_directory()
|
||||
folder_paths.set_output_directory(str(output_root))
|
||||
folder_paths.set_temp_directory(str(temp_root))
|
||||
prompt_graphs = {
|
||||
"downstream_error": _failure_prompt(fail=True),
|
||||
"recovery": _failure_prompt(fail=False),
|
||||
"compatibility": _compatibility_prompt(),
|
||||
"interrupt": _interrupt_prompt(),
|
||||
"clear": _clear_prompt(1),
|
||||
}
|
||||
(work_root / "p24_prompt_graphs.json").write_text(
|
||||
json.dumps(prompt_graphs, indent=2, sort_keys=True),
|
||||
encoding="utf-8",
|
||||
)
|
||||
|
||||
server = _Server()
|
||||
executor = PromptExecutor(
|
||||
server,
|
||||
cache_type=CacheType.CLASSIC,
|
||||
cache_args={"ram": 16.0, "ram_inactive": 0.0},
|
||||
)
|
||||
manager = buffers.get_file_backed_image_manager(backing_root)
|
||||
started = time.perf_counter()
|
||||
try:
|
||||
_execute(executor, prompt_graphs["downstream_error"], "p24-error", ["3"])
|
||||
if executor.success or not _has_event(executor, "execution_error"):
|
||||
raise ProbeFailure("intentional downstream error was not reported")
|
||||
if (len(_managed_files(backing_root, "bin")), len(_managed_files(backing_root, "json"))) != (1, 1):
|
||||
raise ProbeFailure("completed assembler output was not retained by Core cache")
|
||||
retained = manager.collect_ready()
|
||||
if retained.deferred < 1:
|
||||
raise ProbeFailure("Core cache did not keep mapped storage alive after error")
|
||||
|
||||
_execute(executor, prompt_graphs["recovery"], "p24-recovery", ["3"])
|
||||
recovery_cached = _cached_nodes(executor)
|
||||
if not executor.success or "2" not in recovery_cached:
|
||||
raise ProbeFailure("requeue did not reuse cached V3.5 assembler output")
|
||||
if len(_managed_files(backing_root, "bin")) != 1:
|
||||
raise ProbeFailure("same-input requeue created another backing file")
|
||||
|
||||
_execute(
|
||||
executor,
|
||||
prompt_graphs["compatibility"],
|
||||
"p24-compatibility",
|
||||
["4", "5", "6"],
|
||||
)
|
||||
if not executor.success or "2" not in _cached_nodes(executor):
|
||||
raise ProbeFailure("downstream compatibility run did not reuse assembler cache")
|
||||
downstream = _assert_output_paths(
|
||||
output_root,
|
||||
temp_root,
|
||||
executor.history_result,
|
||||
)
|
||||
output_files_before = _all_output_files(output_root)
|
||||
temp_files_before = _all_output_files(temp_root)
|
||||
|
||||
_execute(
|
||||
executor,
|
||||
prompt_graphs["compatibility"],
|
||||
"p24-compatibility-requeue",
|
||||
["4", "5", "6"],
|
||||
)
|
||||
second_cached = _cached_nodes(executor)
|
||||
if not {"2", "4", "5", "6"}.issubset(second_cached):
|
||||
raise ProbeFailure(
|
||||
f"compatibility requeue cache miss: {sorted(second_cached)}"
|
||||
)
|
||||
if output_files_before != _all_output_files(output_root):
|
||||
raise ProbeFailure("cached requeue unexpectedly rewrote output files")
|
||||
if temp_files_before != _all_output_files(temp_root):
|
||||
raise ProbeFailure("cached requeue unexpectedly rewrote temp files")
|
||||
|
||||
_execute(executor, prompt_graphs["clear"], "p24-clear", ["9"])
|
||||
gc.collect()
|
||||
if manager.tracked_count() != 1:
|
||||
raise ProbeFailure("cache eviction lost lifetime-manager tracking state")
|
||||
|
||||
replacement = _failure_prompt(fail=False, nonce=2)
|
||||
_execute(executor, replacement, "p24-replacement", ["3"])
|
||||
if not executor.success or len(_managed_files(backing_root, "bin")) != 1:
|
||||
raise ProbeFailure("post-eviction allocation did not keep backing pairs bounded")
|
||||
_execute(executor, _clear_prompt(2), "p24-final-clear", ["9"])
|
||||
_collect_until_empty(manager, backing_root)
|
||||
|
||||
_execute(executor, prompt_graphs["interrupt"], "p24-interrupt", ["3"])
|
||||
if executor.success or not _has_event(executor, "execution_interrupted"):
|
||||
raise ProbeFailure("Core interrupt was not propagated as execution_interrupted")
|
||||
if _managed_files(backing_root, "bin") or _managed_files(backing_root, "json"):
|
||||
raise ProbeFailure("interrupted unpublished allocation left backing files")
|
||||
_execute(executor, _clear_prompt(3), "p24-interrupt-clear", ["9"])
|
||||
_collect_until_empty(manager, backing_root)
|
||||
|
||||
stale = _restart_stale_probe(args, package_root, stale_root)
|
||||
elapsed = time.perf_counter() - started
|
||||
result = {
|
||||
"phase": "P2-4",
|
||||
"status": "PASS",
|
||||
"gpu_used": False,
|
||||
"fixture": {
|
||||
"source": "deterministic decoded CPU IMAGE/AUDIO",
|
||||
"frames": 124,
|
||||
"assembled_frames": 120,
|
||||
"width": 16,
|
||||
"height": 16,
|
||||
"fps": 24,
|
||||
"audio_sample_rate": 32_000,
|
||||
"model": "not applicable",
|
||||
"lora": "not applicable",
|
||||
"sampler": "not applicable",
|
||||
"prompt": "not applicable",
|
||||
"media_inputs": "none",
|
||||
},
|
||||
"cache": {
|
||||
"implementation": "ComfyUI PromptExecutor CLASSIC / HierarchicalCache",
|
||||
"downstream_error_retained": True,
|
||||
"same_input_requeue_cached": True,
|
||||
"recovery_cached_nodes": sorted(recovery_cached),
|
||||
"compatibility_requeue_cached_nodes": sorted(second_cached),
|
||||
"post_eviction_pair_count_bounded": True,
|
||||
"final_pairs": 0,
|
||||
},
|
||||
"downstream": downstream,
|
||||
"interrupt": {
|
||||
"core_execution_interrupted": True,
|
||||
"unpublished_pairs_remaining": 0,
|
||||
},
|
||||
"restart_stale_cleanup": stale,
|
||||
"elapsed_seconds": round(elapsed, 3),
|
||||
"work_root": str(work_root),
|
||||
}
|
||||
(work_root / "p24_result.json").write_text(
|
||||
json.dumps(result, indent=2, sort_keys=True),
|
||||
encoding="utf-8",
|
||||
)
|
||||
return result
|
||||
finally:
|
||||
core_nodes.interrupt_processing(False)
|
||||
folder_paths.set_output_directory(old_output)
|
||||
folder_paths.set_temp_directory(old_temp)
|
||||
|
||||
|
||||
def _parse_args():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--comfy-root", type=Path, required=True)
|
||||
parser.add_argument("--package-root", type=Path)
|
||||
parser.add_argument("--work-root", type=Path)
|
||||
parser.add_argument("--child-mode", choices=("create-stale", "clean-stale"))
|
||||
parser.add_argument("--backing-root", type=Path)
|
||||
return parser.parse_args()
|
||||
|
||||
|
||||
def main() -> int:
|
||||
args = _parse_args()
|
||||
args.comfy_root = args.comfy_root.resolve()
|
||||
package_root = (
|
||||
args.package_root.resolve()
|
||||
if args.package_root is not None
|
||||
else Path(__file__).resolve().parents[1]
|
||||
)
|
||||
if args.child_mode is not None:
|
||||
if args.backing_root is None:
|
||||
raise ProbeFailure("--backing-root is required in child mode")
|
||||
return _run_child_mode(args, package_root)
|
||||
if args.work_root is None:
|
||||
raise ProbeFailure("--work-root is required")
|
||||
result = run_probe(args, package_root)
|
||||
print(json.dumps(result, indent=2, sort_keys=True))
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
Reference in New Issue
Block a user