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,571 @@
|
||||
"""Run the A7b explicit Reference downgrade GPU Matrix."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import copy
|
||||
from dataclasses import dataclass
|
||||
import hashlib
|
||||
import json
|
||||
from pathlib import Path
|
||||
import re
|
||||
import shutil
|
||||
import sys
|
||||
from typing import Any, Mapping
|
||||
|
||||
|
||||
TOOLS_ROOT = Path(__file__).resolve().parent
|
||||
if str(TOOLS_ROOT) not in sys.path:
|
||||
sys.path.insert(0, str(TOOLS_ROOT))
|
||||
|
||||
from v38_a2_audio_only_gpu_canary import _output_latents, _output_text
|
||||
from v38_a3c_selective_refine_gpu_matrix import (
|
||||
GateFailure,
|
||||
PROMPT,
|
||||
_execute,
|
||||
_find_one,
|
||||
_marker_json,
|
||||
)
|
||||
from v38_a7a_packed_row_gpu_matrix import (
|
||||
_cross_run_plan_identity,
|
||||
_parse_packed_rows,
|
||||
)
|
||||
|
||||
|
||||
ACTION_DISABLED = "Disabled"
|
||||
ACTION_REDUCE = "Reduce References One Step"
|
||||
IMAGE_MAX = "Max Identity"
|
||||
IMAGE_MATCH = "Match Output"
|
||||
VIDEO_BALANCED = "Balanced - 0.6 MP"
|
||||
VIDEO_EFFICIENT = "Efficient - 0.4 MP"
|
||||
POLICY_STATUS = "Memory Action Policy [Experimental A7b v1]"
|
||||
SEED_PATTERN = re.compile(r"chunk 1/1: seed=(\d+)")
|
||||
IMAGE_GEOMETRY_PATTERN = re.compile(r"Ref1=(\d+)x(\d+)")
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class A7bCase:
|
||||
name: str
|
||||
conditioning: str
|
||||
reference_count: int = 0
|
||||
video_file: str = ""
|
||||
|
||||
@property
|
||||
def is_image(self) -> bool:
|
||||
return self.conditioning == "image"
|
||||
|
||||
@property
|
||||
def is_video(self) -> bool:
|
||||
return self.conditioning == "video"
|
||||
|
||||
|
||||
def _sha256_json(value: Any) -> str:
|
||||
payload = json.dumps(
|
||||
value,
|
||||
sort_keys=True,
|
||||
separators=(",", ":"),
|
||||
ensure_ascii=True,
|
||||
).encode("utf-8")
|
||||
return hashlib.sha256(payload).hexdigest()
|
||||
|
||||
|
||||
def _configure_prompt(
|
||||
template: Mapping[str, Any],
|
||||
*,
|
||||
case: A7bCase,
|
||||
action: str,
|
||||
output_prefix: str,
|
||||
run_name: str,
|
||||
reference_image: str,
|
||||
) -> dict[str, Any]:
|
||||
prompt = copy.deepcopy(dict(template))
|
||||
sampler_id, sampler = _find_one(prompt, "H3ContinuumSamplerV38")
|
||||
sampler["class_type"] = "H3ContinuumSamplerV38MemoryPolicyExperimental"
|
||||
inputs = sampler["inputs"]
|
||||
inputs["diagnostics"] = "Detailed Report"
|
||||
inputs["run_storage"] = "Save + Auto Resume"
|
||||
inputs["run_name"] = run_name
|
||||
inputs["project_id"] = ""
|
||||
inputs["reference_size"] = IMAGE_MAX
|
||||
inputs["video_reference_size"] = VIDEO_BALANCED
|
||||
for name in (
|
||||
"reference_image_1",
|
||||
"reference_image_2",
|
||||
"reference_image_3",
|
||||
"reference_video_1",
|
||||
):
|
||||
inputs.pop(name, None)
|
||||
|
||||
prompt["949"] = {
|
||||
"class_type": "H3ContinuumMemoryActionPolicyExperimental",
|
||||
"inputs": {"reference_action": action},
|
||||
"_meta": {"title": "A7b Explicit Memory Action Policy"},
|
||||
}
|
||||
inputs["memory_action_policy"] = ["949", 0]
|
||||
prompt_id = str(inputs["sequence_prompt"][0])
|
||||
prompt[prompt_id]["inputs"]["value"] = PROMPT
|
||||
|
||||
if case.is_image:
|
||||
labels = []
|
||||
for index in range(1, case.reference_count + 1):
|
||||
node_id = str(949 + index)
|
||||
input_name = f"reference_image_{index}"
|
||||
prompt[node_id] = {
|
||||
"class_type": "LoadImage",
|
||||
"inputs": {"image": reference_image},
|
||||
"_meta": {"title": f"A7b Reference Image {index}"},
|
||||
}
|
||||
inputs[input_name] = [node_id, 0]
|
||||
labels.append(f"<Picture {index}>")
|
||||
prompt[prompt_id]["inputs"]["value"] = (
|
||||
PROMPT
|
||||
+ " Preserve the identity and natural appearance from "
|
||||
+ ", ".join(labels)
|
||||
+ "."
|
||||
)
|
||||
elif case.is_video:
|
||||
prompt["950"] = {
|
||||
"class_type": "H3ContinuumLoadVideo",
|
||||
"inputs": {
|
||||
"enable_video": True,
|
||||
"file": case.video_file,
|
||||
"force_rate": 24.0,
|
||||
},
|
||||
"_meta": {"title": "A7b Video Guide"},
|
||||
}
|
||||
inputs["reference_video_1"] = ["950", 0]
|
||||
prompt[prompt_id]["inputs"]["value"] = (
|
||||
PROMPT
|
||||
+ " Follow the appearance and motion guidance from <Video 1> while "
|
||||
"preserving continuity."
|
||||
)
|
||||
|
||||
_save_video_id, save_video = _find_one(prompt, "SaveVideo")
|
||||
save_video["inputs"]["filename_prefix"] = output_prefix
|
||||
prompt["902"]["inputs"]["filename_prefix"] = output_prefix + "_video"
|
||||
prompt["903"]["inputs"]["filename_prefix"] = output_prefix + "_audio"
|
||||
# The accepted A7a template already routes sampler outputs through Core
|
||||
# decode, assemble, SaveLatent, and the read-only A3c evidence probe.
|
||||
for node_id in ("900", "902", "903", "907", "908"):
|
||||
if node_id not in prompt:
|
||||
raise GateFailure(f"accepted A7a evidence node {node_id} is missing")
|
||||
prompt["900"]["inputs"]["source"] = [sampler_id, 3]
|
||||
prompt["902"]["inputs"]["samples"] = [sampler_id, 0]
|
||||
prompt["903"]["inputs"]["samples"] = [sampler_id, 1]
|
||||
for name, slot in (
|
||||
("input_video_latents", 0),
|
||||
("output_video_latents", 0),
|
||||
("input_audio_latents", 1),
|
||||
("output_audio_latents", 1),
|
||||
("input_assembly_plan", 2),
|
||||
("output_assembly_plan", 2),
|
||||
("refine_status", 3),
|
||||
):
|
||||
prompt["907"]["inputs"][name] = [sampler_id, slot]
|
||||
return prompt
|
||||
|
||||
|
||||
def _latest_manifest(output_root: Path, run_name: str) -> dict[str, Any]:
|
||||
revision_root = output_root / "h3_continuum" / "runs" / run_name / "revisions"
|
||||
manifests = sorted(
|
||||
revision_root.glob("*/manifest.json"),
|
||||
key=lambda path: path.stat().st_mtime_ns,
|
||||
)
|
||||
if not manifests:
|
||||
raise GateFailure(f"Run Storage manifest is missing for {run_name}")
|
||||
path = manifests[-1]
|
||||
manifest = json.loads(path.read_text(encoding="utf-8"))
|
||||
return {"path": str(path), "manifest": manifest}
|
||||
|
||||
|
||||
def _one_seed(status: str) -> int:
|
||||
match = SEED_PATTERN.search(status)
|
||||
if match is None:
|
||||
raise GateFailure("effective chunk seed is missing from sampler status")
|
||||
return int(match.group(1))
|
||||
|
||||
|
||||
def _image_geometry(status: str) -> tuple[int, int] | None:
|
||||
match = IMAGE_GEOMETRY_PATTERN.search(status)
|
||||
return None if match is None else (int(match.group(1)), int(match.group(2)))
|
||||
|
||||
|
||||
def _run_variant(
|
||||
args: argparse.Namespace,
|
||||
*,
|
||||
template: Mapping[str, Any],
|
||||
case: A7bCase,
|
||||
action: str,
|
||||
) -> dict[str, Any]:
|
||||
variant = "disabled" if action == ACTION_DISABLED else "reduce"
|
||||
name = f"{case.name}_{variant}"
|
||||
run_name = f"v38_a7b_{args.run_tag}_{name}"[:96]
|
||||
output_prefix = f"v38_a7b/{args.run_tag}/{name}"
|
||||
prompt = _configure_prompt(
|
||||
template,
|
||||
case=case,
|
||||
action=action,
|
||||
output_prefix=output_prefix,
|
||||
run_name=run_name,
|
||||
reference_image=args.reference_image,
|
||||
)
|
||||
result, entry = _execute(
|
||||
args,
|
||||
name=name,
|
||||
prompt=prompt,
|
||||
expected_seconds=5.0,
|
||||
boundaries=(),
|
||||
)
|
||||
status = _output_text(entry, "900")
|
||||
probe = _marker_json(_output_text(entry, "908"), "A3C_PROBE_JSON=")
|
||||
video_records = _output_latents(entry, "902", args.output_root)
|
||||
audio_records = _output_latents(entry, "903", args.output_root)
|
||||
packed_rows = _parse_packed_rows(status)
|
||||
storage = _latest_manifest(args.output_root, run_name)
|
||||
manifest = storage["manifest"]
|
||||
contract = manifest.get("contract") or {}
|
||||
global_contract = contract.get("global") or {}
|
||||
chunk_contracts = contract.get("chunk_contracts") or []
|
||||
sampler_id, sampler = _find_one(prompt, "H3ContinuumSamplerV38MemoryPolicyExperimental")
|
||||
checks = {
|
||||
"one_physical_group": len(video_records) == len(audio_records) == 1,
|
||||
"saved_video_sha_matches_probe": [item["tensor_sha256"] for item in video_records]
|
||||
== list(probe.get("input_video_sha256") or []),
|
||||
"saved_audio_sha_matches_probe": [item["tensor_sha256"] for item in audio_records]
|
||||
== list(probe.get("input_audio_sha256") or []),
|
||||
"finite": all(probe.get("output_video_finite") or [])
|
||||
and all(probe.get("output_audio_finite") or []),
|
||||
"media": int(result["media"]["frames"]) == 120
|
||||
and abs(float(result["media"]["format_duration"]) - 5.0) <= 0.05
|
||||
and int(result["media"]["audio_sample_rate"]) == 32000
|
||||
and int(result["media"]["audio_channels"]) == 2,
|
||||
"audio_health": bool(result["audio_health"]["pass"]),
|
||||
"storage_complete": manifest.get("status") == "complete",
|
||||
"one_chunk_contract": len(chunk_contracts) == 1,
|
||||
"packed_rows_valid": packed_rows["observed_groups"] == 1
|
||||
and len(packed_rows["groups"]) == 1
|
||||
and packed_rows["groups"][0]["component_sum"]
|
||||
== packed_rows["groups"][0]["total"],
|
||||
"experimental_sampler_only": sampler["class_type"]
|
||||
== "H3ContinuumSamplerV38MemoryPolicyExperimental",
|
||||
"policy_status": (
|
||||
POLICY_STATUS not in status
|
||||
if action == ACTION_DISABLED
|
||||
else POLICY_STATUS in status
|
||||
and "automatic MODEL unload was not executed" in status
|
||||
and "automatic attention/backend switching was not executed" in status
|
||||
and "external MODEL wrapper was preserved" in status
|
||||
),
|
||||
}
|
||||
result.update(
|
||||
{
|
||||
"action": action,
|
||||
"run_name": run_name,
|
||||
"sampler_id": sampler_id,
|
||||
"status": status,
|
||||
"seed": _one_seed(status),
|
||||
"image_geometry": _image_geometry(status),
|
||||
"probe": probe,
|
||||
"video_latents": video_records,
|
||||
"audio_latents": audio_records,
|
||||
"packed_rows": packed_rows,
|
||||
"run_storage": storage,
|
||||
"global_hash": (
|
||||
str(chunk_contracts[0].get("global_hash"))
|
||||
if chunk_contracts
|
||||
else ""
|
||||
),
|
||||
"sigmas_hash": str(
|
||||
(global_contract.get("sigmas") or {}).get("exact_sha256") or ""
|
||||
),
|
||||
"model_contract_hash": _sha256_json(global_contract.get("model")),
|
||||
"reference_contract": copy.deepcopy(global_contract.get("reference")),
|
||||
"reference_video_contract": copy.deepcopy(
|
||||
global_contract.get("reference_video")
|
||||
),
|
||||
"assembly_normalized": copy.deepcopy(
|
||||
(probe.get("input_plan") or {}).get("normalized")
|
||||
),
|
||||
"checks": checks,
|
||||
"pass": all(checks.values()),
|
||||
}
|
||||
)
|
||||
result_path = args.evidence_root / name / "result.json"
|
||||
result_path.write_text(
|
||||
json.dumps(result, indent=2, ensure_ascii=False), encoding="utf-8"
|
||||
)
|
||||
if not result["pass"]:
|
||||
failed = [key for key, value in checks.items() if not value]
|
||||
raise GateFailure(f"{name} failed: {failed}")
|
||||
return result
|
||||
|
||||
|
||||
def _latent_hashes(result: Mapping[str, Any], stream: str) -> list[str]:
|
||||
return list((result.get("probe") or {}).get(f"input_{stream}_sha256") or [])
|
||||
|
||||
|
||||
def _plan_without_runtime(value: Any) -> Any:
|
||||
return _cross_run_plan_identity(value)
|
||||
|
||||
|
||||
def _effective_contract_checks(
|
||||
case: A7bCase,
|
||||
disabled: Mapping[str, Any],
|
||||
reduced: Mapping[str, Any],
|
||||
) -> dict[str, bool]:
|
||||
base_rows = disabled["packed_rows"]["groups"][0]
|
||||
reduced_rows = reduced["packed_rows"]["groups"][0]
|
||||
checks = {
|
||||
"global_identity_changed": disabled["global_hash"]
|
||||
and reduced["global_hash"]
|
||||
and disabled["global_hash"] != reduced["global_hash"],
|
||||
"actual_total_rows_decreased": reduced_rows["total"] < base_rows["total"],
|
||||
"condition_video_rows_decreased": reduced_rows["condition_video"]
|
||||
< base_rows["condition_video"],
|
||||
"output_variation_expected": _latent_hashes(disabled, "video")
|
||||
!= _latent_hashes(reduced, "video")
|
||||
or _latent_hashes(disabled, "audio") != _latent_hashes(reduced, "audio"),
|
||||
"assembly_semantics_unchanged": _plan_without_runtime(
|
||||
disabled["assembly_normalized"]
|
||||
)
|
||||
== _plan_without_runtime(reduced["assembly_normalized"]),
|
||||
"seed_unchanged": disabled["seed"] == reduced["seed"],
|
||||
"sigmas_unchanged": disabled["sigmas_hash"]
|
||||
and disabled["sigmas_hash"] == reduced["sigmas_hash"],
|
||||
"external_model_wrapper_unchanged": disabled["model_contract_hash"]
|
||||
== reduced["model_contract_hash"],
|
||||
}
|
||||
if case.is_image:
|
||||
base_contract = disabled.get("reference_contract") or {}
|
||||
reduced_contract = reduced.get("reference_contract") or {}
|
||||
base_geometry = disabled.get("image_geometry")
|
||||
reduced_geometry = reduced.get("image_geometry")
|
||||
checks.update(
|
||||
{
|
||||
"image_mode_one_step": base_contract.get("size_mode") == IMAGE_MAX
|
||||
and reduced_contract.get("size_mode") == IMAGE_MATCH,
|
||||
"image_contract_hash_changed": base_contract.get("combined_hash")
|
||||
!= reduced_contract.get("combined_hash"),
|
||||
"image_geometry_decreased": base_geometry is not None
|
||||
and reduced_geometry is not None
|
||||
and reduced_geometry[0] * reduced_geometry[1]
|
||||
< base_geometry[0] * base_geometry[1],
|
||||
}
|
||||
)
|
||||
elif case.is_video:
|
||||
base_contract = disabled.get("reference_video_contract") or {}
|
||||
reduced_contract = reduced.get("reference_video_contract") or {}
|
||||
checks.update(
|
||||
{
|
||||
"video_mode_one_step": base_contract.get("size_mode")
|
||||
== VIDEO_BALANCED
|
||||
and reduced_contract.get("size_mode") == VIDEO_EFFICIENT,
|
||||
"video_contract_hash_changed": base_contract.get("combined_hash")
|
||||
!= reduced_contract.get("combined_hash"),
|
||||
"video_geometry_decreased": int(reduced_contract.get("target_width", 0))
|
||||
* int(reduced_contract.get("target_height", 0))
|
||||
< int(base_contract.get("target_width", 0))
|
||||
* int(base_contract.get("target_height", 0)),
|
||||
"video_frame_count_unchanged": base_contract.get("frame_count")
|
||||
== reduced_contract.get("frame_count"),
|
||||
}
|
||||
)
|
||||
return checks
|
||||
|
||||
|
||||
def _g1_checks(
|
||||
result: Mapping[str, Any],
|
||||
*,
|
||||
baseline_result: Mapping[str, Any],
|
||||
baseline_prompt: Mapping[str, Any],
|
||||
) -> dict[str, bool]:
|
||||
baseline_probe = baseline_result.get("probe") or {}
|
||||
current_probe = result.get("probe") or {}
|
||||
_baseline_sampler_id, baseline_sampler = _find_one(
|
||||
baseline_prompt, "H3ContinuumSamplerV38"
|
||||
)
|
||||
current_prompt = json.loads(Path(result["prompt"]).read_text(encoding="utf-8"))
|
||||
_current_sampler_id, current_sampler = _find_one(
|
||||
current_prompt, "H3ContinuumSamplerV38MemoryPolicyExperimental"
|
||||
)
|
||||
return {
|
||||
"video_latent_bit_exact": list(current_probe.get("input_video_sha256") or [])
|
||||
== list(baseline_probe.get("input_video_sha256") or []),
|
||||
"audio_latent_bit_exact": list(current_probe.get("input_audio_sha256") or [])
|
||||
== list(baseline_probe.get("input_audio_sha256") or []),
|
||||
"assembly_semantics_bit_exact": _plan_without_runtime(
|
||||
(current_probe.get("input_plan") or {}).get("normalized")
|
||||
)
|
||||
== _plan_without_runtime(
|
||||
(baseline_probe.get("input_plan") or {}).get("normalized")
|
||||
),
|
||||
"decoded_video_bit_exact": (result.get("decoded") or {}).get("video_sha256")
|
||||
== (baseline_result.get("decoded") or {}).get("video_sha256"),
|
||||
"decoded_audio_bit_exact": (result.get("decoded") or {}).get(
|
||||
"audio_pcm_sha256"
|
||||
)
|
||||
== (baseline_result.get("decoded") or {}).get("audio_pcm_sha256"),
|
||||
"seed_input_unchanged": current_sampler["inputs"].get("base_seed")
|
||||
== baseline_sampler["inputs"].get("base_seed"),
|
||||
"sampler_link_unchanged": current_sampler["inputs"].get("sampler")
|
||||
== baseline_sampler["inputs"].get("sampler"),
|
||||
"sigmas_link_unchanged": current_sampler["inputs"].get("sigmas")
|
||||
== baseline_sampler["inputs"].get("sigmas"),
|
||||
"no_reference_contract": result.get("reference_contract") is None
|
||||
and result.get("reference_video_contract") is None,
|
||||
"disabled_status_no_action": POLICY_STATUS not in str(result.get("status")),
|
||||
}
|
||||
|
||||
|
||||
def run(args: argparse.Namespace) -> dict[str, Any]:
|
||||
args.evidence_root.mkdir(parents=True, exist_ok=True)
|
||||
template = json.loads(args.template.read_text(encoding="utf-8"))
|
||||
baseline_result = json.loads(args.a7a_g1_result.read_text(encoding="utf-8"))
|
||||
baseline_prompt = json.loads(
|
||||
Path(baseline_result["prompt"]).read_text(encoding="utf-8")
|
||||
)
|
||||
cases = (
|
||||
A7bCase("g2_image_1", "image", reference_count=1),
|
||||
A7bCase("g3_video_short", "video", video_file=args.short_video),
|
||||
A7bCase("g4_images_3", "image", reference_count=3),
|
||||
A7bCase("g5_video_high_row", "video", video_file=args.high_video),
|
||||
)
|
||||
summary: dict[str, Any] = {
|
||||
"format": "h3-continuum-v38-a7b-memory-action-gpu-matrix-v1",
|
||||
"server": args.server,
|
||||
"backend_pid": args.backend_pid,
|
||||
"run_tag": args.run_tag,
|
||||
"settings": {
|
||||
"resolution": "576x576",
|
||||
"steps": 8,
|
||||
"fixed_seed": True,
|
||||
"run_storage": "Save + Auto Resume with unique run names",
|
||||
"policy": "explicit opt-in one-step Reference downgrade",
|
||||
"auto_unload": "not executed; advisory-only",
|
||||
"backend_switch": "not executed; advisory-only",
|
||||
},
|
||||
"results": {},
|
||||
"pass": False,
|
||||
"production_status": "unchanged; Experimental path only; A5 HOLD",
|
||||
}
|
||||
summary_path = args.evidence_root / "summary.json"
|
||||
try:
|
||||
g1_case = A7bCase("g1_disabled", "none")
|
||||
g1 = _run_variant(
|
||||
args,
|
||||
template=template,
|
||||
case=g1_case,
|
||||
action=ACTION_DISABLED,
|
||||
)
|
||||
g1_parity = _g1_checks(
|
||||
g1,
|
||||
baseline_result=baseline_result,
|
||||
baseline_prompt=baseline_prompt,
|
||||
)
|
||||
summary["results"][g1_case.name] = {
|
||||
"baseline": str(args.a7a_g1_result),
|
||||
"disabled": g1,
|
||||
"checks": g1_parity,
|
||||
"pass": all(g1_parity.values()),
|
||||
}
|
||||
summary_path.write_text(
|
||||
json.dumps(summary, indent=2, ensure_ascii=False), encoding="utf-8"
|
||||
)
|
||||
if not all(g1_parity.values()):
|
||||
failed = [key for key, value in g1_parity.items() if not value]
|
||||
raise GateFailure(f"G1 Disabled parity failed: {failed}")
|
||||
print("A7b G1 Disabled parity PASS", flush=True)
|
||||
|
||||
for case in cases:
|
||||
disabled = _run_variant(
|
||||
args,
|
||||
template=template,
|
||||
case=case,
|
||||
action=ACTION_DISABLED,
|
||||
)
|
||||
reduced = _run_variant(
|
||||
args,
|
||||
template=template,
|
||||
case=case,
|
||||
action=ACTION_REDUCE,
|
||||
)
|
||||
checks = _effective_contract_checks(case, disabled, reduced)
|
||||
case_result = {
|
||||
"case": {
|
||||
"name": case.name,
|
||||
"conditioning": case.conditioning,
|
||||
"reference_count": case.reference_count,
|
||||
"video_file": case.video_file,
|
||||
},
|
||||
"disabled": disabled,
|
||||
"reduced": reduced,
|
||||
"checks": checks,
|
||||
"pass": all(checks.values()),
|
||||
}
|
||||
summary["results"][case.name] = case_result
|
||||
summary_path.write_text(
|
||||
json.dumps(summary, indent=2, ensure_ascii=False), encoding="utf-8"
|
||||
)
|
||||
print(
|
||||
f"A7b {case.name}: pass={case_result['pass']} "
|
||||
f"rows={disabled['packed_rows']['peak_total_rows']}->"
|
||||
f"{reduced['packed_rows']['peak_total_rows']}",
|
||||
flush=True,
|
||||
)
|
||||
if not case_result["pass"]:
|
||||
failed = [key for key, value in checks.items() if not value]
|
||||
raise GateFailure(f"{case.name} failed: {failed}")
|
||||
summary["pass"] = True
|
||||
summary["status"] = "A7b v1 Memory Action Policy GPU Experimental PASS"
|
||||
return summary
|
||||
except Exception as exc:
|
||||
summary["failure_type"] = type(exc).__name__
|
||||
summary["failure"] = str(exc)
|
||||
summary["status"] = "A7b STOP / Production unchanged / A5 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("--template", type=Path, required=True)
|
||||
parser.add_argument("--a7a-g1-result", type=Path, required=True)
|
||||
parser.add_argument("--reference-image", required=True)
|
||||
parser.add_argument("--short-video", required=True)
|
||||
parser.add_argument("--high-video", 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(
|
||||
{
|
||||
"status": summary.get("status"),
|
||||
"pass": summary.get("pass"),
|
||||
"failure": summary.get("failure"),
|
||||
"summary": str(args.evidence_root / "summary.json"),
|
||||
},
|
||||
ensure_ascii=False,
|
||||
),
|
||||
flush=True,
|
||||
)
|
||||
return 0 if summary["pass"] else 2
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
Reference in New Issue
Block a user