620 lines
21 KiB
Python
620 lines
21 KiB
Python
"""Run the three-case V3.8 A2 Audio Only GPU Canary."""
|
|
|
|
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
|
|
from typing import Any, Mapping
|
|
import uuid
|
|
|
|
import numpy as np
|
|
import torch
|
|
from safetensors.torch import load_file
|
|
|
|
|
|
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 submit_and_wait
|
|
from v36_r1_stress_gate_runner import ResourceMonitor
|
|
from v38_easy_gpu_gate_runner import _output_media, _probe_media
|
|
|
|
|
|
class GateFailure(RuntimeError):
|
|
pass
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class GateCase:
|
|
name: str
|
|
chunks: int
|
|
terminal_merge: bool
|
|
expected_physical_groups: int
|
|
boundary_seconds: tuple[float, ...]
|
|
|
|
|
|
CASES = (
|
|
GateCase("g1_1x5_tail6", 1, False, 1, ()),
|
|
GateCase("g2_3x5_balanced22", 3, False, 3, (5.0, 10.0)),
|
|
GateCase("g3_terminal_merge", 3, True, 2, (5.0, 10.0)),
|
|
)
|
|
|
|
|
|
PROMPT = (
|
|
"A continuous cinematic shot follows a woman walking through a modern plaza. "
|
|
"Natural footsteps, clothing movement, wind, and steady city ambience remain "
|
|
"audible throughout without cuts or silence."
|
|
)
|
|
FIRST_PASS_SEED = 3802701
|
|
REFINE_SEED = 3802702
|
|
|
|
|
|
def _sha256_file(path: Path) -> str:
|
|
digest = hashlib.sha256()
|
|
with path.open("rb") as stream:
|
|
for block in iter(lambda: stream.read(1024 * 1024), b""):
|
|
digest.update(block)
|
|
return digest.hexdigest()
|
|
|
|
|
|
def _sha256_tensor(value: torch.Tensor) -> str:
|
|
tensor = value.detach().to(device="cpu").contiguous()
|
|
digest = hashlib.sha256()
|
|
digest.update(str(tuple(int(item) for item in tensor.shape)).encode("ascii"))
|
|
digest.update(str(tensor.dtype).encode("ascii"))
|
|
digest.update(tensor.view(torch.uint8).numpy().tobytes(order="C"))
|
|
return digest.hexdigest()
|
|
|
|
|
|
def _find_one(prompt: Mapping[str, Any], class_type: str) -> tuple[str, dict[str, Any]]:
|
|
matches = [
|
|
(str(node_id), node)
|
|
for node_id, node in prompt.items()
|
|
if str(node.get("class_type")) == class_type
|
|
]
|
|
if len(matches) != 1:
|
|
raise GateFailure(f"expected one {class_type}, found {len(matches)}")
|
|
return matches[0]
|
|
|
|
|
|
def _remove_class(prompt: dict[str, Any], class_type: str) -> None:
|
|
for node_id in [
|
|
str(key)
|
|
for key, node in prompt.items()
|
|
if str(node.get("class_type")) == class_type
|
|
]:
|
|
prompt.pop(node_id, None)
|
|
|
|
|
|
def _configure_prompt(
|
|
template: Mapping[str, Any],
|
|
*,
|
|
case: GateCase,
|
|
output_prefix: str,
|
|
) -> dict[str, Any]:
|
|
prompt = copy.deepcopy(dict(template))
|
|
sampler_id, continuum = _find_one(prompt, "H3ContinuumSamplerV38")
|
|
inputs = continuum["inputs"]
|
|
inputs.update(
|
|
{
|
|
"prompt_mode": "Fixed",
|
|
"chunks": int(case.chunks),
|
|
"chunk_seconds": 5.0,
|
|
"continuity": "Balanced — 22 frames",
|
|
"base_seed": FIRST_PASS_SEED,
|
|
"audio_continuity": True,
|
|
"diagnostics": "Detailed Report",
|
|
"reroll_from_chunk": "Auto",
|
|
"reroll_nonce": 0,
|
|
"strict_compatibility": False,
|
|
"debug": True,
|
|
"show_preview": False,
|
|
"run_storage": "Off",
|
|
"run_name": "",
|
|
"project_id": "",
|
|
"generation_mode": "Full Run",
|
|
"review_action": "Continue / Next",
|
|
"aspect": "Square 1:1",
|
|
"preset": "Custom",
|
|
"custom_mp": 0.331776,
|
|
}
|
|
)
|
|
for name in (
|
|
"reference_video_1",
|
|
"reference_video_2",
|
|
"reference_video_3",
|
|
"driving_audio",
|
|
):
|
|
inputs.pop(name, None)
|
|
if not case.terminal_merge:
|
|
inputs.pop("first_frame", None)
|
|
inputs.pop("last_frame", None)
|
|
_remove_class(prompt, "LoadImage")
|
|
_remove_class(prompt, "H3ContinuumLoadVideo")
|
|
|
|
prompt_id = str(inputs["sequence_prompt"][0])
|
|
prompt[prompt_id]["inputs"]["value"] = PROMPT
|
|
first_scheduler_id = str(inputs["sigmas"][0])
|
|
prompt[first_scheduler_id]["inputs"].update(
|
|
{"scheduler": "simple", "steps": 8, "denoise": 1.0}
|
|
)
|
|
scheduler_matches = [
|
|
(str(node_id), node)
|
|
for node_id, node in prompt.items()
|
|
if str(node.get("class_type")) == "BasicScheduler"
|
|
and str(node_id) != first_scheduler_id
|
|
]
|
|
if len(scheduler_matches) != 1:
|
|
raise GateFailure(
|
|
"expected one refine BasicScheduler, "
|
|
f"found {len(scheduler_matches)}"
|
|
)
|
|
refine_scheduler_id, refine_scheduler = scheduler_matches[0]
|
|
refine_scheduler["inputs"].update(
|
|
{"scheduler": "simple", "steps": 10, "denoise": 0.35}
|
|
)
|
|
|
|
prompt["302"] = {
|
|
"class_type": "H3A2AudioOnlyCanary",
|
|
"inputs": {
|
|
"model": inputs["model"],
|
|
"clip": inputs["clip"],
|
|
"sampler": inputs["sampler"],
|
|
"sigmas": [refine_scheduler_id, 0],
|
|
"video_latents": [sampler_id, 0],
|
|
"audio_latents": [sampler_id, 1],
|
|
"assembly_plan": [sampler_id, 2],
|
|
"refine_context": [sampler_id, 5],
|
|
"video_vae": inputs["video_vae"],
|
|
"refine_seed": REFINE_SEED,
|
|
"schedule_mode": "Tail",
|
|
"tail_evaluations": 6,
|
|
},
|
|
"_meta": {"title": "A2 Audio Only Canary"},
|
|
}
|
|
for node_id in ("900", "901", "902", "903", "904", "905", "906"):
|
|
prompt.pop(node_id, None)
|
|
prompt["900"] = {
|
|
"class_type": "PreviewAny",
|
|
"inputs": {"source": [sampler_id, 3]},
|
|
}
|
|
prompt["901"] = {
|
|
"class_type": "PreviewAny",
|
|
"inputs": {"source": ["302", 3]},
|
|
}
|
|
prompt["902"] = {
|
|
"class_type": "SaveLatent",
|
|
"inputs": {
|
|
"samples": [sampler_id, 0],
|
|
"filename_prefix": f"{output_prefix}_first_video",
|
|
},
|
|
}
|
|
prompt["903"] = {
|
|
"class_type": "SaveLatent",
|
|
"inputs": {
|
|
"samples": [sampler_id, 1],
|
|
"filename_prefix": f"{output_prefix}_first_audio",
|
|
},
|
|
}
|
|
prompt["904"] = {
|
|
"class_type": "SaveLatent",
|
|
"inputs": {
|
|
"samples": ["302", 0],
|
|
"filename_prefix": f"{output_prefix}_refined_video",
|
|
},
|
|
}
|
|
prompt["905"] = {
|
|
"class_type": "SaveLatent",
|
|
"inputs": {
|
|
"samples": ["302", 1],
|
|
"filename_prefix": f"{output_prefix}_refined_audio",
|
|
},
|
|
}
|
|
prompt["906"] = {
|
|
"class_type": "PreviewAny",
|
|
"inputs": {"source": ["302", 2]},
|
|
}
|
|
_save_id, save_video = _find_one(prompt, "SaveVideo")
|
|
save_video["inputs"]["filename_prefix"] = output_prefix
|
|
return prompt
|
|
|
|
|
|
def _history_entry(history: Mapping[str, Any], prompt_id: str) -> Mapping[str, Any]:
|
|
entry = history.get(prompt_id)
|
|
if not isinstance(entry, Mapping):
|
|
raise GateFailure(f"history is missing prompt {prompt_id}")
|
|
return entry
|
|
|
|
|
|
def _output_text(entry: Mapping[str, Any], node_id: str) -> str:
|
|
value = (entry.get("outputs") or {}).get(node_id) or {}
|
|
items = value.get("text")
|
|
if isinstance(items, list):
|
|
return "\n".join(str(item) for item in items)
|
|
if isinstance(items, str):
|
|
return items
|
|
return json.dumps(value, ensure_ascii=False, sort_keys=True)
|
|
|
|
|
|
def _output_latents(
|
|
entry: Mapping[str, Any],
|
|
node_id: str,
|
|
output_root: Path,
|
|
) -> list[dict[str, Any]]:
|
|
output = (entry.get("outputs") or {}).get(node_id) or {}
|
|
records = []
|
|
for value in output.get("latents") or []:
|
|
path = output_root / str(value.get("subfolder") or "") / str(
|
|
value["filename"]
|
|
)
|
|
latent = load_file(str(path), device="cpu")["latent_tensor"]
|
|
records.append(
|
|
{
|
|
"path": str(path),
|
|
"shape": [int(item) for item in latent.shape],
|
|
"dtype": str(latent.dtype),
|
|
"tensor_sha256": _sha256_tensor(latent),
|
|
}
|
|
)
|
|
return records
|
|
|
|
|
|
def _canary_json(status: str) -> dict[str, Any]:
|
|
line = next(
|
|
(item for item in status.splitlines() if item.startswith("A2_CANARY_JSON=")),
|
|
"",
|
|
)
|
|
if not line:
|
|
raise GateFailure("A2 canary status JSON is missing")
|
|
return json.loads(line.split("=", 1)[1])
|
|
|
|
|
|
def _decode_audio(path: Path, ffmpeg: str) -> np.ndarray:
|
|
process = subprocess.run(
|
|
[
|
|
ffmpeg,
|
|
"-v",
|
|
"error",
|
|
"-i",
|
|
str(path),
|
|
"-map",
|
|
"0:a:0",
|
|
"-ac",
|
|
"2",
|
|
"-ar",
|
|
"32000",
|
|
"-c:a",
|
|
"pcm_f32le",
|
|
"-f",
|
|
"f32le",
|
|
"-",
|
|
],
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.PIPE,
|
|
check=False,
|
|
)
|
|
if process.returncode:
|
|
raise GateFailure(
|
|
"ffmpeg audio decode failed: "
|
|
+ process.stderr.decode("utf-8", errors="replace")[-2000:]
|
|
)
|
|
audio = np.frombuffer(process.stdout, dtype="<f4")
|
|
if audio.size == 0 or audio.size % 2:
|
|
raise GateFailure("decoded stereo PCM is empty or malformed")
|
|
return audio.reshape(-1, 2)
|
|
|
|
|
|
def _rms(value: np.ndarray) -> float:
|
|
if value.size == 0:
|
|
return 0.0
|
|
return float(np.sqrt(np.mean(np.square(value.astype(np.float64)))))
|
|
|
|
|
|
def _audio_health(
|
|
media_path: Path,
|
|
*,
|
|
ffmpeg: str,
|
|
expected_seconds: float,
|
|
boundaries: tuple[float, ...],
|
|
) -> dict[str, Any]:
|
|
audio = _decode_audio(media_path, ffmpeg)
|
|
sample_rate = 32000
|
|
global_rms = _rms(audio)
|
|
channel_rms = [_rms(audio[:, channel]) for channel in range(2)]
|
|
window = max(1, int(round(0.5 * sample_rate)))
|
|
window_rms = [
|
|
_rms(audio[start : start + window])
|
|
for start in range(0, len(audio), window)
|
|
if len(audio[start : start + window]) >= window // 2
|
|
]
|
|
boundary_metrics = []
|
|
for seconds in boundaries:
|
|
index = int(round(seconds * sample_rate))
|
|
if not 1 <= index < len(audio):
|
|
raise GateFailure(f"audio boundary {seconds}s is outside decoded PCM")
|
|
radius = int(round(0.1 * sample_rate))
|
|
local = audio[max(0, index - radius) : min(len(audio), index + radius)]
|
|
local_diff = np.abs(np.diff(local, axis=0))
|
|
q999 = float(np.quantile(local_diff, 0.999)) if local_diff.size else 0.0
|
|
sample_jump = float(np.max(np.abs(audio[index] - audio[index - 1])))
|
|
threshold = max(0.25, q999 * 8.0)
|
|
before_rms = _rms(audio[max(0, index - radius) : index])
|
|
after_rms = _rms(audio[index : min(len(audio), index + radius)])
|
|
boundary_metrics.append(
|
|
{
|
|
"seconds": seconds,
|
|
"sample_index": index,
|
|
"sample_jump": sample_jump,
|
|
"local_diff_q999": q999,
|
|
"click_threshold": threshold,
|
|
"no_click_advisory": sample_jump <= threshold,
|
|
"rms_before_100ms": before_rms,
|
|
"rms_after_100ms": after_rms,
|
|
"no_boundary_silence": before_rms > 1e-7 and after_rms > 1e-7,
|
|
}
|
|
)
|
|
expected_samples = int(round(expected_seconds * sample_rate))
|
|
checks = {
|
|
"finite": bool(np.isfinite(audio).all()),
|
|
"not_silent": global_rms > 1e-7,
|
|
"channels_not_collapsed": all(value > 1e-7 for value in channel_rms),
|
|
"windows_not_collapsed": bool(window_rms)
|
|
and min(window_rms) > 1e-8,
|
|
"duration_no_drift": abs(len(audio) - expected_samples) <= 1024,
|
|
"boundaries_no_click": all(
|
|
item["no_click_advisory"] for item in boundary_metrics
|
|
),
|
|
"boundaries_not_silent": all(
|
|
item["no_boundary_silence"] for item in boundary_metrics
|
|
),
|
|
}
|
|
return {
|
|
"sample_rate": sample_rate,
|
|
"channels": 2,
|
|
"samples_per_channel": int(len(audio)),
|
|
"duration_seconds": float(len(audio) / sample_rate),
|
|
"expected_samples_per_channel": expected_samples,
|
|
"global_rms": global_rms,
|
|
"channel_rms": channel_rms,
|
|
"peak": float(np.max(np.abs(audio))),
|
|
"minimum_window_rms": min(window_rms) if window_rms else 0.0,
|
|
"boundaries": boundary_metrics,
|
|
"checks": checks,
|
|
"pass": all(checks.values()),
|
|
}
|
|
|
|
|
|
def _run_case(
|
|
args: argparse.Namespace,
|
|
*,
|
|
case: GateCase,
|
|
template: Mapping[str, Any],
|
|
) -> dict[str, Any]:
|
|
case_root = args.evidence_root / case.name
|
|
case_root.mkdir(parents=True, exist_ok=True)
|
|
output_prefix = f"v38_a2_audio_only/{args.run_tag}/{case.name}"
|
|
prompt = _configure_prompt(template, case=case, output_prefix=output_prefix)
|
|
prompt_path = case_root / "prompt.json"
|
|
prompt_path.write_text(
|
|
json.dumps(prompt, indent=2, ensure_ascii=False),
|
|
encoding="utf-8",
|
|
)
|
|
print(f"A2 GPU Canary start: {case.name}", flush=True)
|
|
with ResourceMonitor(args.backend_pid, interval_seconds=0.5) as monitor:
|
|
prompt_id, history, elapsed = submit_and_wait(
|
|
server=args.server,
|
|
prompt=prompt,
|
|
client_id=f"v38-a2-{uuid.uuid4().hex}",
|
|
timeout_seconds=args.timeout_seconds,
|
|
poll_seconds=2.0,
|
|
)
|
|
history_path = case_root / "history.json"
|
|
history_path.write_text(
|
|
json.dumps(history, indent=2, ensure_ascii=False),
|
|
encoding="utf-8",
|
|
)
|
|
entry = _history_entry(history, prompt_id)
|
|
first_status = _output_text(entry, "900")
|
|
canary_status = _output_text(entry, "901")
|
|
canary = _canary_json(canary_status)
|
|
first_videos = _output_latents(entry, "902", args.output_root)
|
|
first_audios = _output_latents(entry, "903", args.output_root)
|
|
refined_videos = _output_latents(entry, "904", args.output_root)
|
|
refined_audios = _output_latents(entry, "905", args.output_root)
|
|
media_path = _output_media(history, args.output_root)
|
|
media = _probe_media(media_path, args.ffprobe)
|
|
audio_health = _audio_health(
|
|
media_path,
|
|
ffmpeg=args.ffmpeg,
|
|
expected_seconds=case.chunks * 5.0,
|
|
boundaries=case.boundary_seconds,
|
|
)
|
|
first_video_hashes = [item["tensor_sha256"] for item in first_videos]
|
|
refined_video_hashes = [item["tensor_sha256"] for item in refined_videos]
|
|
first_audio_hashes = [item["tensor_sha256"] for item in first_audios]
|
|
refined_audio_hashes = [item["tensor_sha256"] for item in refined_audios]
|
|
groups = canary.get("physical_groups") or []
|
|
terminal_check = True
|
|
if case.terminal_merge:
|
|
terminal_check = (
|
|
len(groups) == 2
|
|
and groups[-1].get("logical_chunks") == [2, 3]
|
|
and groups[-1].get("terminal_merged") is True
|
|
)
|
|
checks = {
|
|
"physical_group_count": len(groups) == case.expected_physical_groups,
|
|
"first_video_count": len(first_videos) == case.expected_physical_groups,
|
|
"refined_video_count": len(refined_videos) == case.expected_physical_groups,
|
|
"first_audio_count": len(first_audios) == case.expected_physical_groups,
|
|
"refined_audio_count": len(refined_audios) == case.expected_physical_groups,
|
|
"video_sha_exact": first_video_hashes == refined_video_hashes,
|
|
"video_object_identity": len(canary.get("video_object_identity") or [])
|
|
== case.expected_physical_groups
|
|
and all(canary.get("video_object_identity") or []),
|
|
"video_tensor_identity": len(canary.get("video_tensor_identity") or [])
|
|
== case.expected_physical_groups
|
|
and all(canary.get("video_tensor_identity") or []),
|
|
"audio_changed": len(first_audio_hashes) == len(refined_audio_hashes)
|
|
and all(
|
|
before != after
|
|
for before, after in zip(
|
|
first_audio_hashes,
|
|
refined_audio_hashes,
|
|
strict=True,
|
|
)
|
|
),
|
|
"audio_shape_preserved": canary.get("audio_input_shapes")
|
|
== canary.get("audio_output_shapes"),
|
|
"audio_seed_namespace": (
|
|
(canary.get("target") or {}).get("seed_namespace")
|
|
== "h3-continuum-refine-audio-v1"
|
|
),
|
|
"tail_6": canary.get("schedule_mode") == "tail"
|
|
and canary.get("schedule_evaluations") == 6,
|
|
"second_pass_contract_v1": canary.get("second_pass_contract_version") == 1,
|
|
"terminal_atomic_group": terminal_check,
|
|
"media_duration": abs(float(media["format_duration"]) - case.chunks * 5.0)
|
|
<= 0.05,
|
|
"media_frames": int(media["frames"]) == case.chunks * 5 * 24,
|
|
"media_audio_contract": int(media["audio_sample_rate"]) == 32000
|
|
and int(media["audio_channels"]) == 2,
|
|
"audio_health": bool(audio_health["pass"]),
|
|
"temporary_video_discarded": (
|
|
canary_status.count("temporary_video_discarded=true")
|
|
== case.expected_physical_groups
|
|
),
|
|
}
|
|
result = {
|
|
"case": asdict(case),
|
|
"prompt_id": prompt_id,
|
|
"api_elapsed_seconds": float(elapsed),
|
|
"prompt": str(prompt_path),
|
|
"history": str(history_path),
|
|
"first_status": first_status,
|
|
"canary_status": canary_status,
|
|
"canary": canary,
|
|
"first_video_latents": first_videos,
|
|
"refined_video_latents": refined_videos,
|
|
"first_audio_latents": first_audios,
|
|
"refined_audio_latents": refined_audios,
|
|
"media_path": str(media_path),
|
|
"media_sha256": _sha256_file(media_path),
|
|
"media": media,
|
|
"audio_health": audio_health,
|
|
"resources": monitor.as_dict(),
|
|
"checks": checks,
|
|
"pass": all(checks.values()),
|
|
}
|
|
(case_root / "result.json").write_text(
|
|
json.dumps(result, indent=2, ensure_ascii=False),
|
|
encoding="utf-8",
|
|
)
|
|
(case_root / "canary_status.txt").write_text(
|
|
canary_status,
|
|
encoding="utf-8",
|
|
)
|
|
print(
|
|
f"A2 GPU Canary end: {case.name}; pass={result['pass']}; "
|
|
f"elapsed={elapsed:.3f}s; video_exact={checks['video_sha_exact']}; "
|
|
f"audio_changed={checks['audio_changed']}",
|
|
flush=True,
|
|
)
|
|
if not result["pass"]:
|
|
failed = [name for name, value in checks.items() if not value]
|
|
raise GateFailure(f"{case.name} failed checks: {failed}")
|
|
return result
|
|
|
|
|
|
def run(args: argparse.Namespace) -> dict[str, Any]:
|
|
args.evidence_root.mkdir(parents=True, exist_ok=True)
|
|
t2_template = json.loads(args.t2_template.read_text(encoding="utf-8"))
|
|
terminal_template = json.loads(
|
|
args.terminal_template.read_text(encoding="utf-8")
|
|
)
|
|
summary = {
|
|
"format": "h3-continuum-v38-a2-audio-only-gpu-canary-v1",
|
|
"server": args.server,
|
|
"backend_pid": args.backend_pid,
|
|
"run_tag": args.run_tag,
|
|
"first_pass_seed": FIRST_PASS_SEED,
|
|
"refine_seed": REFINE_SEED,
|
|
"settings": {
|
|
"resolution": "576x576",
|
|
"first_pass_steps": 8,
|
|
"refine_source_steps": 10,
|
|
"refine_denoise": 0.35,
|
|
"refine_schedule": "Tail 6",
|
|
"continuity": "Balanced — 22 frames",
|
|
"audio_continuity": True,
|
|
"run_storage": "Off",
|
|
"sampler": "res_multistep",
|
|
"scheduler": "simple",
|
|
"sage": True,
|
|
},
|
|
"templates": {
|
|
"t2": str(args.t2_template),
|
|
"terminal": str(args.terminal_template),
|
|
},
|
|
"results": {},
|
|
"pass": False,
|
|
"production_status": "HOLD",
|
|
}
|
|
summary_path = args.evidence_root / "summary.json"
|
|
try:
|
|
for case in CASES:
|
|
template = terminal_template if case.terminal_merge else t2_template
|
|
summary["results"][case.name] = _run_case(
|
|
args,
|
|
case=case,
|
|
template=template,
|
|
)
|
|
summary["pass"] = True
|
|
summary["status"] = "GPU Experimental PASS / Production HOLD"
|
|
return summary
|
|
except Exception as exc:
|
|
summary["failure_type"] = type(exc).__name__
|
|
summary["failure"] = str(exc)
|
|
summary["status"] = "GPU Canary STOP / Production HOLD"
|
|
return summary
|
|
finally:
|
|
summary_path.write_text(
|
|
json.dumps(summary, indent=2, ensure_ascii=False),
|
|
encoding="utf-8",
|
|
)
|
|
|
|
|
|
def main() -> int:
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument("--server", default="http://127.0.0.6:8190")
|
|
parser.add_argument("--backend-pid", type=int, required=True)
|
|
parser.add_argument("--run-tag", required=True)
|
|
parser.add_argument("--evidence-root", type=Path, required=True)
|
|
parser.add_argument("--t2-template", type=Path, required=True)
|
|
parser.add_argument("--terminal-template", type=Path, required=True)
|
|
parser.add_argument(
|
|
"--output-root",
|
|
type=Path,
|
|
default=Path(r"D:\output\video\comfy_video"),
|
|
)
|
|
parser.add_argument("--ffmpeg", default=shutil.which("ffmpeg"))
|
|
parser.add_argument("--ffprobe", default=shutil.which("ffprobe"))
|
|
parser.add_argument("--timeout-seconds", type=float, default=3600.0)
|
|
args = parser.parse_args()
|
|
if not args.ffmpeg or not args.ffprobe:
|
|
raise SystemExit("ffmpeg and ffprobe are required")
|
|
summary = run(args)
|
|
print(json.dumps(summary, indent=2, ensure_ascii=False), flush=True)
|
|
return 0 if summary["pass"] else 2
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|