699 lines
25 KiB
Python
699 lines
25 KiB
Python
"""Run the A6 Temporal Window Refine GPU Matrix against the public node."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import copy
|
|
from dataclasses import asdict, dataclass
|
|
import importlib.util
|
|
import json
|
|
from pathlib import Path
|
|
import shutil
|
|
import sys
|
|
import types
|
|
from typing import Any, Mapping, Sequence
|
|
|
|
from safetensors.torch import load_file
|
|
import torch
|
|
|
|
|
|
TOOLS_ROOT = Path(__file__).resolve().parent
|
|
SOURCE_ROOT = TOOLS_ROOT.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,
|
|
MatrixCase,
|
|
_configure_g1,
|
|
_configure_selective,
|
|
_execute,
|
|
_marker_json,
|
|
)
|
|
from v38_a4_chunk_scoped_refine_gpu_matrix import (
|
|
_cross_run_plan_identity,
|
|
_key_paths,
|
|
_load_a3c_baseline,
|
|
)
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class WindowCase:
|
|
name: str
|
|
target: str
|
|
chunks: int
|
|
terminal_merge: bool
|
|
start_sec: float
|
|
end_sec: float
|
|
selected_group_indices: tuple[int, ...]
|
|
boundary_seconds: tuple[float, ...]
|
|
|
|
|
|
WINDOW_CASES = (
|
|
WindowCase(
|
|
"g2_video_only_partial",
|
|
"Video Only",
|
|
1,
|
|
False,
|
|
1.0,
|
|
3.0,
|
|
(0,),
|
|
(),
|
|
),
|
|
WindowCase(
|
|
"g3_video_audio_partial",
|
|
"Video + Audio",
|
|
1,
|
|
False,
|
|
1.0,
|
|
3.0,
|
|
(0,),
|
|
(),
|
|
),
|
|
WindowCase(
|
|
"g4_video_audio_cross_group",
|
|
"Video + Audio",
|
|
3,
|
|
False,
|
|
4.0,
|
|
6.0,
|
|
(0, 1),
|
|
(5.0, 10.0),
|
|
),
|
|
WindowCase(
|
|
"g5_terminal_one_logical_side",
|
|
"Video + Audio",
|
|
3,
|
|
True,
|
|
5.5,
|
|
8.0,
|
|
(1,),
|
|
(5.0, 10.0),
|
|
),
|
|
)
|
|
|
|
VIDEO_ONLY_CONTRACT_FIELDS = {
|
|
"audio_output",
|
|
"audio_sampling",
|
|
"conditioning_sources",
|
|
"execution",
|
|
"physical_groups",
|
|
"refine_execution_contract",
|
|
"refine_group_seeds",
|
|
"refine_schedule",
|
|
"refine_schedule_identity",
|
|
"refine_seed_base",
|
|
"refine_target_contract",
|
|
"target_height",
|
|
"target_width",
|
|
"version",
|
|
}
|
|
|
|
|
|
def _load_source_contract():
|
|
"""Load only constants/temporal/refine_window under an isolated package."""
|
|
|
|
package_name = "h3_a6_gate_source"
|
|
package = types.ModuleType(package_name)
|
|
package.__path__ = [str(SOURCE_ROOT)]
|
|
sys.modules[package_name] = package
|
|
v3_package = types.ModuleType(f"{package_name}.v3")
|
|
v3_package.__path__ = [str(SOURCE_ROOT / "v3")]
|
|
sys.modules[f"{package_name}.v3"] = v3_package
|
|
|
|
def load(name: str, path: Path):
|
|
spec = importlib.util.spec_from_file_location(name, path)
|
|
if spec is None or spec.loader is None:
|
|
raise GateFailure(f"cannot load source module {path}")
|
|
module = importlib.util.module_from_spec(spec)
|
|
sys.modules[name] = module
|
|
spec.loader.exec_module(module)
|
|
return module
|
|
|
|
load(f"{package_name}.constants", SOURCE_ROOT / "constants.py")
|
|
temporal = load(f"{package_name}.temporal", SOURCE_ROOT / "temporal.py")
|
|
refine_window = load(
|
|
f"{package_name}.v3.refine_window",
|
|
SOURCE_ROOT / "v3" / "refine_window.py",
|
|
)
|
|
return temporal, refine_window
|
|
|
|
|
|
TEMPORAL, REFINE_WINDOW = _load_source_contract()
|
|
|
|
|
|
def _load_tensor(record: Mapping[str, Any]) -> torch.Tensor:
|
|
return load_file(str(record["path"]), device="cpu")["latent_tensor"]
|
|
|
|
|
|
def _temporal_selection(
|
|
tensor: torch.Tensor,
|
|
ranges: Sequence[Sequence[int]],
|
|
*,
|
|
time_dim: int,
|
|
) -> tuple[torch.Tensor, torch.Tensor]:
|
|
dimension = int(time_dim)
|
|
if dimension < 0:
|
|
dimension += tensor.ndim
|
|
mask = torch.zeros(int(tensor.shape[dimension]), dtype=torch.bool)
|
|
for start, stop in ranges:
|
|
mask[int(start) : int(stop)] = True
|
|
moved = tensor.movedim(dimension, 0)
|
|
return moved[mask], moved[~mask]
|
|
|
|
|
|
def _temporal_checks(
|
|
before: torch.Tensor,
|
|
after: torch.Tensor,
|
|
ranges: Sequence[Sequence[int]],
|
|
*,
|
|
time_dim: int,
|
|
expect_inside_change: bool,
|
|
) -> dict[str, bool]:
|
|
if tuple(before.shape) != tuple(after.shape) or before.dtype != after.dtype:
|
|
return {
|
|
"shape_dtype": False,
|
|
"inside_expected": False,
|
|
"outside_exact": False,
|
|
}
|
|
before_inside, before_outside = _temporal_selection(
|
|
before,
|
|
ranges,
|
|
time_dim=time_dim,
|
|
)
|
|
after_inside, after_outside = _temporal_selection(
|
|
after,
|
|
ranges,
|
|
time_dim=time_dim,
|
|
)
|
|
inside_equal = torch.equal(before_inside, after_inside)
|
|
return {
|
|
"shape_dtype": True,
|
|
"inside_expected": (not inside_equal) if expect_inside_change else inside_equal,
|
|
"outside_exact": torch.equal(before_outside, after_outside),
|
|
}
|
|
|
|
|
|
def _field_set(value: Any) -> set[str]:
|
|
return set(_key_paths(value))
|
|
|
|
|
|
def _contains_window_key(value: Any) -> bool:
|
|
if isinstance(value, Mapping):
|
|
return any(
|
|
"window" in str(key).lower() or _contains_window_key(item)
|
|
for key, item in value.items()
|
|
)
|
|
if isinstance(value, list):
|
|
return any(_contains_window_key(item) for item in value)
|
|
return False
|
|
|
|
|
|
def _configure_parity(template: Mapping[str, Any], *, output_prefix: str) -> dict[str, Any]:
|
|
prompt = _configure_g1(template, output_prefix=output_prefix)
|
|
prompt["303"]["inputs"].update(
|
|
{
|
|
"refine_scope": "All",
|
|
"refine_scope_index": 1,
|
|
"window_start_sec": 0.0,
|
|
"window_end_sec": 5.0,
|
|
}
|
|
)
|
|
return prompt
|
|
|
|
|
|
def _configure_window(
|
|
template: Mapping[str, Any],
|
|
*,
|
|
case: WindowCase,
|
|
output_prefix: str,
|
|
) -> dict[str, Any]:
|
|
matrix_case = MatrixCase(
|
|
name=case.name,
|
|
target=case.target,
|
|
chunks=case.chunks,
|
|
terminal_merge=case.terminal_merge,
|
|
expected_physical_groups=2 if case.terminal_merge else case.chunks,
|
|
boundary_seconds=case.boundary_seconds,
|
|
)
|
|
prompt = _configure_selective(
|
|
template,
|
|
case=matrix_case,
|
|
output_prefix=output_prefix,
|
|
)
|
|
prompt["302"]["inputs"].update(
|
|
{
|
|
"refine_scope": "Time Window",
|
|
"refine_scope_index": 1,
|
|
"window_start_sec": float(case.start_sec),
|
|
"window_end_sec": float(case.end_sec),
|
|
}
|
|
)
|
|
prompt["302"]["_meta"]["title"] = (
|
|
f"Selective {case.target} / Time Window "
|
|
f"[{case.start_sec:g}, {case.end_sec:g})"
|
|
)
|
|
return prompt
|
|
|
|
|
|
def _run_g1(args: argparse.Namespace, template: Mapping[str, Any]) -> dict[str, Any]:
|
|
output_prefix = f"v38_a6/{args.run_tag}/g1_no_window_all_video_only"
|
|
prompt = _configure_parity(template, output_prefix=output_prefix)
|
|
result, entry = _execute(
|
|
args,
|
|
name="g1_no_window_all_video_only",
|
|
prompt=prompt,
|
|
expected_seconds=5.0,
|
|
boundaries=(),
|
|
)
|
|
parity_status = _output_text(entry, "908")
|
|
parity = _marker_json(parity_status, "A3C_PARITY_JSON=")
|
|
checks = {
|
|
"one_physical_group": parity.get("physical_group_count") == 1,
|
|
"video_latent_sha_parity": parity.get("legacy_video_sha256")
|
|
== parity.get("selective_video_sha256"),
|
|
"audio_latent_sha_parity": parity.get("legacy_audio_sha256")
|
|
== parity.get("selective_audio_sha256"),
|
|
"audio_object_passthrough": all(
|
|
parity.get("legacy_audio_object_identity") or []
|
|
)
|
|
and all(parity.get("selective_audio_object_identity") or []),
|
|
"audio_tensor_passthrough": all(
|
|
parity.get("legacy_audio_tensor_identity") or []
|
|
)
|
|
and all(parity.get("selective_audio_tensor_identity") or []),
|
|
"seed_parity": parity.get("legacy_refine_group_seeds")
|
|
== parity.get("selective_refine_group_seeds"),
|
|
"sigmas_parity": parity.get("legacy_schedule_sigma_hash")
|
|
== parity.get("selective_schedule_sigma_hash"),
|
|
"sampling_parity": parity.get("legacy_sampling_passes_reported")
|
|
== parity.get("selective_sampling_passes_reported")
|
|
== 1,
|
|
"assembly_plan_parity": parity.get("legacy_plan_without_target_identity")
|
|
== parity.get("selective_plan_without_target_identity"),
|
|
"target_contract": parity.get("selective_target_mode") == "video_only",
|
|
"finite": all(parity.get("legacy_video_finite") or [])
|
|
and all(parity.get("selective_video_finite") or [])
|
|
and all(parity.get("legacy_audio_finite") or [])
|
|
and all(parity.get("selective_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"]),
|
|
}
|
|
result.update(
|
|
{
|
|
"parity_status": parity_status,
|
|
"parity": parity,
|
|
"checks": checks,
|
|
"pass": all(checks.values()),
|
|
}
|
|
)
|
|
case_root = args.evidence_root / "g1_no_window_all_video_only"
|
|
(case_root / "result.json").write_text(
|
|
json.dumps(result, indent=2, ensure_ascii=False),
|
|
encoding="utf-8",
|
|
)
|
|
if not result["pass"]:
|
|
failed = [name for name, passed in checks.items() if not passed]
|
|
raise GateFailure(f"A6 G1 parity failed: {failed}")
|
|
return result
|
|
|
|
|
|
def _run_window_case(
|
|
args: argparse.Namespace,
|
|
*,
|
|
case: WindowCase,
|
|
template: Mapping[str, Any],
|
|
baseline_probe: Mapping[str, Any],
|
|
expected_seeds: Sequence[int],
|
|
expected_contract_fields: set[str],
|
|
) -> dict[str, Any]:
|
|
output_prefix = f"v38_a6/{args.run_tag}/{case.name}"
|
|
prompt = _configure_window(template, case=case, output_prefix=output_prefix)
|
|
result, entry = _execute(
|
|
args,
|
|
name=case.name,
|
|
prompt=prompt,
|
|
expected_seconds=case.chunks * 5.0,
|
|
boundaries=case.boundary_seconds,
|
|
)
|
|
status = _output_text(entry, "908")
|
|
probe = _marker_json(status, "A3C_PROBE_JSON=")
|
|
input_video_records = _output_latents(entry, "902", args.output_root)
|
|
input_audio_records = _output_latents(entry, "903", args.output_root)
|
|
output_video_records = _output_latents(entry, "904", args.output_root)
|
|
output_audio_records = _output_latents(entry, "905", args.output_root)
|
|
input_videos = [_load_tensor(record) for record in input_video_records]
|
|
input_audios = [_load_tensor(record) for record in input_audio_records]
|
|
output_videos = [_load_tensor(record) for record in output_video_records]
|
|
output_audios = [_load_tensor(record) for record in output_audio_records]
|
|
normalized_plan = (probe.get("output_plan") or {}).get("normalized") or {}
|
|
window = REFINE_WINDOW.resolve_refine_window(
|
|
case.start_sec,
|
|
case.end_sec,
|
|
normalized_plan,
|
|
)
|
|
selected = tuple(window.selected_group_indices)
|
|
expected_selected = tuple(case.selected_group_indices)
|
|
contract = normalized_plan.get("second_pass_contract") or {}
|
|
baseline_plan = (baseline_probe.get("output_plan") or {}).get("normalized") or {}
|
|
baseline_contract = baseline_plan.get("second_pass_contract") or {}
|
|
checks: dict[str, bool] = {
|
|
"selected_groups": selected == expected_selected,
|
|
"physical_group_count": len(input_videos)
|
|
== len(input_audios)
|
|
== len(output_videos)
|
|
== len(output_audios)
|
|
== (2 if case.terminal_merge else case.chunks),
|
|
"sampling_count": probe.get("sampling_passes_reported")
|
|
== len(expected_selected),
|
|
"absolute_seed_parity": probe.get("refine_group_seeds")
|
|
== list(expected_seeds),
|
|
"sigmas_parity": probe.get("schedule_sigma_hash")
|
|
== baseline_probe.get("schedule_sigma_hash"),
|
|
"contract_version": probe.get("second_pass_contract_version") == 1,
|
|
"window_status": "scope=Time Window" in status
|
|
and "timeline=final_visible_output" in status
|
|
and "continuation_prefix=protected" in status,
|
|
"window_not_in_plan": not _contains_window_key(contract),
|
|
"assembly_field_set": set(contract) == set(expected_contract_fields),
|
|
"refine_schedule_v1_unchanged": contract.get("refine_schedule")
|
|
== baseline_contract.get("refine_schedule"),
|
|
"media": int(result["media"]["frames"]) == case.chunks * 120
|
|
and abs(
|
|
float(result["media"]["format_duration"]) - case.chunks * 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"]),
|
|
"finite": all(probe.get("output_video_finite") or [])
|
|
and all(probe.get("output_audio_finite") or []),
|
|
}
|
|
group_checks: dict[str, dict[str, bool]] = {}
|
|
for group_index, (before_v, before_a, after_v, after_a) in enumerate(
|
|
zip(input_videos, input_audios, output_videos, output_audios, strict=True)
|
|
):
|
|
group_window = window.group(group_index)
|
|
selected_group = group_index in expected_selected
|
|
current: dict[str, bool] = {}
|
|
if not selected_group:
|
|
current.update(
|
|
{
|
|
"video_whole_exact": torch.equal(before_v, after_v),
|
|
"audio_whole_exact": torch.equal(before_a, after_a),
|
|
"video_object_passthrough": bool(
|
|
(probe.get("input_video_object_identity") or [])[group_index]
|
|
),
|
|
"video_tensor_passthrough": bool(
|
|
(probe.get("input_video_tensor_identity") or [])[group_index]
|
|
),
|
|
"audio_object_passthrough": bool(
|
|
(probe.get("input_audio_object_identity") or [])[group_index]
|
|
),
|
|
"audio_tensor_passthrough": bool(
|
|
(probe.get("input_audio_tensor_identity") or [])[group_index]
|
|
),
|
|
}
|
|
)
|
|
else:
|
|
if group_window is None:
|
|
raise GateFailure(f"selected group {group_index + 1} has no window")
|
|
video_expect_change = case.target in ("Video Only", "Video + Audio")
|
|
audio_expect_change = case.target in ("Audio Only", "Video + Audio")
|
|
for name, passed in _temporal_checks(
|
|
before_v,
|
|
after_v,
|
|
group_window.video_slot_ranges,
|
|
time_dim=2,
|
|
expect_inside_change=video_expect_change,
|
|
).items():
|
|
current[f"video_{name}"] = passed
|
|
for name, passed in _temporal_checks(
|
|
before_a,
|
|
after_a,
|
|
group_window.audio_tick_ranges,
|
|
time_dim=-1,
|
|
expect_inside_change=audio_expect_change,
|
|
).items():
|
|
current[f"audio_{name}"] = passed
|
|
physical_group = contract["physical_groups"][group_index]
|
|
trim_frames = int(physical_group.get("trim_prefix_frames", 0))
|
|
offsets = TEMPORAL.latent_slot_offsets(int(before_v.shape[2]))
|
|
first_video_slot = int(group_window.video_slot_ranges[0][0])
|
|
first_audio_tick = int(group_window.audio_tick_ranges[0][0])
|
|
current["video_prefix_excluded"] = offsets[first_video_slot] >= trim_frames
|
|
current["audio_prefix_excluded"] = (
|
|
first_audio_tick >= TEMPORAL.audio_latent_t(trim_frames)
|
|
)
|
|
group_checks[str(group_index + 1)] = current
|
|
checks[f"group_{group_index + 1}"] = all(current.values())
|
|
if case.terminal_merge:
|
|
terminal = list(probe.get("physical_groups") or [])[-1]
|
|
checks["terminal_atomic"] = (
|
|
terminal.get("logical_chunks") == [2, 3]
|
|
and terminal.get("terminal_merged") is True
|
|
and probe.get("sampling_passes_reported") == 1
|
|
and selected == (1,)
|
|
)
|
|
result.update(
|
|
{
|
|
"case": asdict(case),
|
|
"probe_status": status,
|
|
"probe": probe,
|
|
"window_contract": REFINE_WINDOW.serializable_window_contract(window),
|
|
"input_video_latents": input_video_records,
|
|
"input_audio_latents": input_audio_records,
|
|
"output_video_latents": output_video_records,
|
|
"output_audio_latents": output_audio_records,
|
|
"group_checks": group_checks,
|
|
"checks": checks,
|
|
"pass": all(checks.values()),
|
|
}
|
|
)
|
|
case_root = args.evidence_root / case.name
|
|
(case_root / "result.json").write_text(
|
|
json.dumps(result, indent=2, ensure_ascii=False),
|
|
encoding="utf-8",
|
|
)
|
|
if not result["pass"]:
|
|
failed = [name for name, passed in checks.items() if not passed]
|
|
raise GateFailure(f"{case.name} failed: {failed}")
|
|
return result
|
|
|
|
|
|
def _load_resumed_g1(path: Path) -> dict[str, Any]:
|
|
result = json.loads(path.read_text(encoding="utf-8"))
|
|
if not bool(result.get("pass")) or not all((result.get("checks") or {}).values()):
|
|
raise GateFailure(f"resumed G1 is not PASS: {path}")
|
|
result["resumed_without_resampling"] = True
|
|
path.with_name("result.revalidated.json").write_text(
|
|
json.dumps(result, indent=2, ensure_ascii=False),
|
|
encoding="utf-8",
|
|
)
|
|
return result
|
|
|
|
|
|
def _load_resumed_window_result(
|
|
path: Path,
|
|
*,
|
|
expected_seeds: Sequence[int],
|
|
expected_contract_fields: set[str],
|
|
) -> dict[str, Any]:
|
|
result = json.loads(path.read_text(encoding="utf-8"))
|
|
probe = result.get("probe") or {}
|
|
contract = (
|
|
((probe.get("output_plan") or {}).get("normalized") or {}).get(
|
|
"second_pass_contract"
|
|
)
|
|
or {}
|
|
)
|
|
checks = dict(result.get("checks") or {})
|
|
checks["absolute_seed_parity"] = probe.get("refine_group_seeds") == list(
|
|
expected_seeds
|
|
)
|
|
checks["assembly_field_set"] = set(contract) == set(expected_contract_fields)
|
|
result["checks"] = checks
|
|
result["pass"] = all(checks.values())
|
|
result["resumed_without_resampling"] = True
|
|
if not result["pass"]:
|
|
failed = [name for name, passed in checks.items() if not passed]
|
|
raise GateFailure(f"resumed window validation failed: {failed}")
|
|
path.with_name("result.revalidated.json").write_text(
|
|
json.dumps(result, indent=2, ensure_ascii=False),
|
|
encoding="utf-8",
|
|
)
|
|
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"))
|
|
baseline_summary = json.loads(args.a3c_baseline.read_text(encoding="utf-8"))
|
|
nonterminal_baseline = _load_a3c_baseline(
|
|
args.a3c_baseline,
|
|
"g4_video_audio_3x5",
|
|
)["probe"]
|
|
one_group_av_baseline = _load_a3c_baseline(
|
|
args.a3c_baseline,
|
|
"g3_video_audio_1x5",
|
|
)["probe"]
|
|
terminal_baseline = _load_a3c_baseline(
|
|
args.a3c_baseline,
|
|
"g5_video_audio_terminal",
|
|
)["probe"]
|
|
summary: dict[str, Any] = {
|
|
"format": "h3-continuum-v38-a6-temporal-window-refine-gpu-matrix-v1",
|
|
"server": args.server,
|
|
"backend_pid": args.backend_pid,
|
|
"run_tag": args.run_tag,
|
|
"a3c_baseline": str(args.a3c_baseline),
|
|
"settings": {
|
|
"resolution": "576x576",
|
|
"first_pass_steps": 8,
|
|
"refine_steps": 10,
|
|
"refine_denoise": 0.35,
|
|
"continuity": "Balanced — 22 frames",
|
|
"audio_continuity": True,
|
|
"run_storage": "Off",
|
|
"sampler": "res_multistep",
|
|
"scheduler": "simple",
|
|
"sage": True,
|
|
},
|
|
"results": {},
|
|
"pass": False,
|
|
"production_status": "Experimental; audio-targeted modes remain HOLD",
|
|
}
|
|
summary_path = args.evidence_root / "summary.json"
|
|
try:
|
|
if args.resume_g1 is not None:
|
|
summary["results"]["g1_no_window_all_video_only"] = _load_resumed_g1(
|
|
args.resume_g1
|
|
)
|
|
else:
|
|
summary["results"]["g1_no_window_all_video_only"] = _run_g1(
|
|
args,
|
|
t2_template,
|
|
)
|
|
video_only_seeds = list(
|
|
(((baseline_summary.get("results") or {}).get("g1_video_only_parity") or {})
|
|
.get("parity", {})
|
|
.get("selective_refine_group_seeds")
|
|
or [])
|
|
)
|
|
resume_results: dict[str, Path] = {}
|
|
for path in args.resume_result or ():
|
|
payload = json.loads(path.read_text(encoding="utf-8"))
|
|
name = str((payload.get("case") or {}).get("name") or "")
|
|
if not name or name in resume_results:
|
|
raise GateFailure(f"invalid or duplicate resumed result: {path}")
|
|
resume_results[name] = path
|
|
for case in WINDOW_CASES:
|
|
template = terminal_template if case.terminal_merge else t2_template
|
|
if case.target == "Video Only":
|
|
baseline = one_group_av_baseline
|
|
expected_seeds = video_only_seeds
|
|
expected_fields = VIDEO_ONLY_CONTRACT_FIELDS
|
|
elif case.terminal_merge:
|
|
baseline = terminal_baseline
|
|
expected_seeds = [
|
|
list(terminal_baseline.get("refine_group_seeds") or [])[index]
|
|
for index in case.selected_group_indices
|
|
]
|
|
expected_fields = set(
|
|
(
|
|
(terminal_baseline.get("output_plan") or {})
|
|
.get("normalized", {})
|
|
.get("second_pass_contract", {})
|
|
)
|
|
)
|
|
elif case.chunks == 1:
|
|
baseline = one_group_av_baseline
|
|
expected_seeds = list(
|
|
one_group_av_baseline.get("refine_group_seeds") or []
|
|
)
|
|
expected_fields = set(
|
|
(
|
|
(one_group_av_baseline.get("output_plan") or {})
|
|
.get("normalized", {})
|
|
.get("second_pass_contract", {})
|
|
)
|
|
)
|
|
else:
|
|
baseline = nonterminal_baseline
|
|
expected_seeds = [
|
|
list(nonterminal_baseline.get("refine_group_seeds") or [])[index]
|
|
for index in case.selected_group_indices
|
|
]
|
|
expected_fields = set(
|
|
(
|
|
(nonterminal_baseline.get("output_plan") or {})
|
|
.get("normalized", {})
|
|
.get("second_pass_contract", {})
|
|
)
|
|
)
|
|
if case.name in resume_results:
|
|
result = _load_resumed_window_result(
|
|
resume_results[case.name],
|
|
expected_seeds=expected_seeds,
|
|
expected_contract_fields=expected_fields,
|
|
)
|
|
else:
|
|
result = _run_window_case(
|
|
args,
|
|
case=case,
|
|
template=template,
|
|
baseline_probe=baseline,
|
|
expected_seeds=expected_seeds,
|
|
expected_contract_fields=expected_fields,
|
|
)
|
|
summary["results"][case.name] = result
|
|
summary["pass"] = True
|
|
summary["status"] = "A6 Temporal Window Refine GPU Experimental PASS"
|
|
return summary
|
|
except Exception as exc:
|
|
summary["failure_type"] = type(exc).__name__
|
|
summary["failure"] = str(exc)
|
|
summary["status"] = "A6 STOP / Production unchanged"
|
|
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("--a3c-baseline", type=Path, required=True)
|
|
parser.add_argument("--resume-g1", type=Path)
|
|
parser.add_argument("--resume-result", type=Path, action="append")
|
|
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())
|