"""Run the Easy Load Audio + Driving Audio GPU acceptance gate.""" from __future__ import annotations import argparse import copy from dataclasses import asdict, dataclass import hashlib import json from pathlib import Path import shutil import subprocess import sys import time from typing import Any, Mapping import uuid import numpy as np TOOLS_ROOT = Path(__file__).resolve().parent if str(TOOLS_ROOT) not in sys.path: sys.path.insert(0, str(TOOLS_ROOT)) from p32_api_runner import _json_request, submit_and_wait from p32_gpu_profile_probe import configure_profile from v36_r1_stress_gate_runner import ResourceMonitor from v38_easy_gpu_gate_runner import _ensure_profile_route class GateFailure(RuntimeError): pass @dataclass(frozen=True) class GateCase: name: str duration: int enabled: bool sequence: str CASES = ( GateCase("g0_10s_off", 10, False, "G0"), GateCase("g1_10s_on", 10, True, "G1"), GateCase("g2_20s_on", 20, True, "G2"), GateCase("g3_10s_on_1", 10, True, "G3 ON-1"), GateCase("g3_10s_off", 10, False, "G3 OFF"), GateCase("g3_10s_on_2", 10, True, "G3 ON-2"), ) def _find_nodes(prompt: Mapping[str, Any], class_type: str) -> list[str]: return [ str(node_id) for node_id, node in prompt.items() if str(node.get("class_type")) == class_type ] def _one_node(prompt: Mapping[str, Any], class_type: str) -> str: values = _find_nodes(prompt, class_type) if len(values) != 1: raise GateFailure(f"expected one {class_type}, found {len(values)}") return values[0] def _next_node_id(prompt: Mapping[str, Any]) -> str: return str(max(int(value) for value in prompt if str(value).isdigit()) + 1) def configure_case( source: Mapping[str, Any], *, case: GateCase, audio_file: str, seed: int, ) -> dict[str, Any]: prompt = copy.deepcopy(dict(source)) easy_id = _one_node(prompt, "H3ContinuumEasyV38") easy_inputs = prompt[easy_id].setdefault("inputs", {}) easy_inputs.update( { "duration": int(case.duration), "seed": int(seed), "seed_mode": "Fixed", "preset": "Draft — 0.30 MP", "custom_mp": 0.30, "run_storage": "Off", } ) helper_id = _one_node(prompt, "H3ContinuumEasyReferences") prompt[helper_id].setdefault("inputs", {}).clear() audio_vae_id = None for candidate in _find_nodes(prompt, "VAELoader"): vae_name = str(prompt[candidate].get("inputs", {}).get("vae_name", "")) if "audio" in vae_name.lower(): audio_vae_id = candidate break if audio_vae_id is None: raise GateFailure("source prompt has no Audio VAE loader") easy_inputs["audio_vae"] = [audio_vae_id, 0] if case.enabled: loader_id = _next_node_id(prompt) prompt[loader_id] = { "inputs": {"audio": audio_file}, "class_type": "H3EasyLoadAudio", "_meta": {"title": "H3 Easy Load Audio"}, } easy_inputs["driving_audio"] = [loader_id, 0] save_audio_id = str(int(loader_id) + 1) prompt[save_audio_id] = { "inputs": { "audio": [easy_id, 4], "filename_prefix": f"audio/V38_Easy_Driving/{case.name}", }, "class_type": "SaveAudio", "_meta": {"title": "Save Audio (FLAC) (DEPRECATED)"}, } else: easy_inputs.pop("driving_audio", None) scheduler_id = _one_node(prompt, "BasicScheduler") prompt[scheduler_id].setdefault("inputs", {}).update( {"scheduler": "simple", "steps": 8, "denoise": 1.0} ) assembly_id = _one_node(prompt, "H3ContinuumAssembleSeamV35") prompt[assembly_id].setdefault("inputs", {}).update( { "exact_total_duration": True, "audio_seam": "Auto", "video_seam": "Auto", "buffer_backend": "Auto", "diagnostics": "Detailed Report", } ) for save_id in _find_nodes(prompt, "SaveVideo"): prompt[save_id].setdefault("inputs", {})["filename_prefix"] = ( f"video/V38_Easy_Driving/{case.name}" ) _ensure_profile_route(prompt) return configure_profile(prompt, "sage") def _history_media( history: Mapping[str, Any], output_root: Path, suffix: str ) -> Path: for entry in history.values(): outputs = entry.get("outputs", {}) if isinstance(entry, Mapping) else {} for output in outputs.values(): if not isinstance(output, Mapping): continue for field in ("audio", "videos", "gifs", "images"): for media in output.get(field, []) or []: filename = str(media.get("filename", "")) if Path(filename).suffix.lower() != suffix: continue path = output_root / str(media.get("subfolder") or "") / filename if path.is_file(): return path raise GateFailure(f"history returned no existing {suffix} output") def _ffprobe(path: Path, ffprobe: str) -> dict[str, Any]: result = subprocess.run( [ ffprobe, "-v", "error", "-count_frames", "-show_entries", "stream=codec_type,width,height,r_frame_rate,nb_read_frames,sample_rate,channels,duration:format=duration,size", "-of", "json", str(path), ], check=True, capture_output=True, text=True, ) return json.loads(result.stdout) def _media_contract(path: Path, ffprobe: str) -> dict[str, Any]: payload = _ffprobe(path, ffprobe) streams = list(payload.get("streams") or []) video = next((x for x in streams if x.get("codec_type") == "video"), {}) audio = next((x for x in streams if x.get("codec_type") == "audio"), {}) return { "path": str(path), "sha256": hashlib.sha256(path.read_bytes()).hexdigest(), "size_bytes": int(path.stat().st_size), "width": int(video.get("width", 0)), "height": int(video.get("height", 0)), "frames": int(video.get("nb_read_frames", 0)), "fps": str(video.get("r_frame_rate", "")), "video_duration": float(video.get("duration", 0.0)), "audio_duration": float(audio.get("duration", 0.0)), "format_duration": float(payload.get("format", {}).get("duration", 0.0)), "audio_sample_rate": int(audio.get("sample_rate", 0)), "audio_channels": int(audio.get("channels", 0)), } def _decode_pcm(path: Path, ffmpeg: str, duration: int | None = None) -> np.ndarray: command = [ffmpeg, "-v", "error", "-i", str(path)] if duration is not None: command += ["-t", str(int(duration))] command += ["-ar", "32000", "-ac", "2", "-f", "f32le", "pipe:1"] result = subprocess.run(command, check=True, capture_output=True) return np.frombuffer(result.stdout, dtype=" dict[str, Any]: source = _decode_pcm(input_path, ffmpeg, duration) saved = _decode_pcm(saved_path, ffmpeg) final = _decode_pcm(video_path, ffmpeg) count = min(len(source), len(saved)) source_bytes = source[:count].astype(" 10 and len(final) > boundary: boundary_delta = float(np.max(np.abs(final[boundary] - final[boundary - 1]))) diffs = np.abs(np.diff(final, axis=0)) if len(final) > 1 else np.zeros((0, 2)) return { "source_frames": int(len(source)), "saved_frames": int(len(saved)), "final_frames": int(len(final)), "source_prefix_pcm_sha256": hashlib.sha256(source_bytes).hexdigest(), "saved_pcm_sha256": hashlib.sha256(saved_bytes).hexdigest(), "saved_pcm_bit_exact": source_bytes == saved_bytes, "finite": bool(np.isfinite(final).all()), "max_abs": float(np.max(np.abs(final))) if final.size else 0.0, "max_adjacent_delta": float(np.max(diffs)) if diffs.size else 0.0, "p999_adjacent_delta": float(np.quantile(diffs, 0.999)) if diffs.size else 0.0, "ten_second_boundary_delta": boundary_delta, } def _find_backend_pid() -> int | None: try: import psutil except Exception: return None candidates = [] for process in psutil.process_iter(["pid", "cmdline", "memory_info"]): try: command = " ".join(process.info.get("cmdline") or []) if "ComfyUI_W" in command and "main.py" in command: candidates.append((int(process.info["memory_info"].rss), process.pid)) except Exception: continue return max(candidates)[1] if candidates else None def run(args) -> dict[str, Any]: source = json.loads(args.source_prompt.read_text(encoding="utf-8")) args.output_root.mkdir(parents=True, exist_ok=True) (args.output_root / "source_prompt.json").write_text( json.dumps(source, indent=2, ensure_ascii=False), encoding="utf-8" ) ffmpeg = shutil.which("ffmpeg") ffprobe = shutil.which("ffprobe") if not args.dry_run and (ffmpeg is None or ffprobe is None): raise GateFailure("ffmpeg and ffprobe are required") backend_pid = _find_backend_pid() results = [] for case in CASES: case_root = args.output_root / case.name case_root.mkdir(parents=True, exist_ok=True) prompt = configure_case( source, case=case, audio_file=args.audio_file, seed=args.seed, ) prompt_path = case_root / "prompt.json" prompt_path.write_text( json.dumps(prompt, indent=2, ensure_ascii=False), encoding="utf-8" ) record: dict[str, Any] = { "case": asdict(case), "prompt": str(prompt_path), "seed": int(args.seed), } if args.dry_run: record["status"] = "DRY_RUN" results.append(record) continue queue = _json_request(f"{args.server.rstrip('/')}/queue") if queue.get("queue_running") or queue.get("queue_pending"): raise GateFailure("ComfyUI queue is not empty") print(f"START {case.name}", flush=True) started = time.perf_counter() with ResourceMonitor(backend_pid, args.monitor_interval) as monitor: prompt_id, history, elapsed = submit_and_wait( server=args.server, prompt=prompt, client_id=f"v38-easy-driving-{uuid.uuid4().hex}", timeout_seconds=args.timeout_seconds, poll_seconds=args.poll_seconds, ) history_path = case_root / "history.json" history_path.write_text( json.dumps(history, indent=2, ensure_ascii=False), encoding="utf-8" ) video_path = _history_media(history, args.media_root, ".mp4") media = _media_contract(video_path, ffprobe) expected_frames = int(case.duration * 24) checks = { "frames": media["frames"] == expected_frames, "fps": media["fps"] == "24/1", "duration": abs(media["format_duration"] - case.duration) <= 0.02, "audio_rate": media["audio_sample_rate"] == 32000, "audio_channels": media["audio_channels"] == 2, } if not all(checks.values()): raise GateFailure(f"media contract failed for {case.name}: {checks}") audio = None if case.enabled: saved_path = _history_media(history, args.media_root, ".flac") audio = _audio_evidence( input_path=args.input_root / args.audio_file, saved_path=saved_path, video_path=video_path, duration=case.duration, ffmpeg=ffmpeg, ) if not audio["finite"]: raise GateFailure(f"non-finite final audio in {case.name}") record.update( { "prompt_id": prompt_id, "api_elapsed_seconds": float(elapsed), "wall_elapsed_seconds": float(time.perf_counter() - started), "history": str(history_path), "resources": monitor.as_dict(), "media": media, "audio": audio, "checks": checks, "status": "PASS", } ) (case_root / "summary.json").write_text( json.dumps(record, indent=2, ensure_ascii=False), encoding="utf-8" ) results.append(record) print(f"PASS {case.name} elapsed={elapsed:.3f}s", flush=True) summary = { "format": "h3-continuum-v38-easy-driving-audio-gpu-gate-v1", "server": args.server, "source_prompt": str(args.source_prompt), "audio_file": args.audio_file, "seed": int(args.seed), "backend_pid": backend_pid, "dry_run": bool(args.dry_run), "results": results, "status": "DRY_RUN" if args.dry_run else "PASS", } (args.output_root / "gate_summary.json").write_text( json.dumps(summary, indent=2, ensure_ascii=False), encoding="utf-8" ) return summary def _parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--server", default="http://127.0.0.6:8188") parser.add_argument("--source-prompt", type=Path, required=True) parser.add_argument("--output-root", type=Path, required=True) parser.add_argument("--media-root", type=Path, default=Path(r"D:\output\video\comfy_video")) parser.add_argument("--input-root", type=Path, default=Path(r"D:\StabilityMatrix\Data\Packages\ComfyUI_W\input")) parser.add_argument("--audio-file", required=True) parser.add_argument("--seed", type=int, default=927966463230733) parser.add_argument("--timeout-seconds", type=float, default=3600.0) parser.add_argument("--poll-seconds", type=float, default=2.0) parser.add_argument("--monitor-interval", type=float, default=0.25) parser.add_argument("--dry-run", action="store_true") return parser def main() -> int: args = _parser().parse_args() print(json.dumps(run(args), ensure_ascii=False)) return 0 if __name__ == "__main__": raise SystemExit(main())