677 lines
23 KiB
Python
677 lines
23 KiB
Python
"""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())
|