Add admitted RTX Vulkan Qwen3-TTS whole-session route
This commit is contained in:
1 parent
74d284acba
commit
5bb16af8ee
33 files changed
+3200
-21
No files matched your search
@@ -0,0 +1,163 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Audit complete-WAV RTX hybrid TTS evidence and Radeon route regression."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import hashlib
|
||||
import json
|
||||
import math
|
||||
import wave
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
ARTIFACT_HASHES = {
|
||||
"server_sha256": "999c6af252077195adb723b96da9ee5d3cd291dc7c7a4b32dc493ae148035529",
|
||||
"talker_sha256": "5227dcbc4df7c5533341d111cc469fa491a48e722b23dd10f553181b52dff2d9",
|
||||
"codec_sha256": "70dc95dbfdd9aa5d9d406236ff771d061bf17b0cda02a72513953355606e719b",
|
||||
"punc_sha256": "faf4a43e3135bc307a66194685af00f756e6f4c28c7d9e2dd8f3517cddca5c45",
|
||||
}
|
||||
RTX_PCM = "d3d071531e2574b933c8acf18e2a0344c8961493bd17c63662307270a99d265c"
|
||||
RADEON_PCM = "57f60228e2b456f6dfefc7e49df862c7bff6ba7cf39231ef1824f615948a1539"
|
||||
PREFILL = "qwen3_tts[customvoice]: prefill role="
|
||||
|
||||
|
||||
def sha256(path: Path) -> str:
|
||||
with path.open("rb") as stream:
|
||||
return hashlib.file_digest(stream, "sha256").hexdigest()
|
||||
|
||||
|
||||
def clean_ledger(value: dict, *, rtx: bool) -> bool:
|
||||
empty = {"host_ram": 0, "gpu_vram": 0} if rtx else {"host_ram": 0}
|
||||
return value["reserved"] == empty and value["owners"] == [] and value["quarantined"] == []
|
||||
|
||||
|
||||
def check_wav(path: Path, frames: int, pcm_hash: str) -> None:
|
||||
with wave.open(str(path), "rb") as wav:
|
||||
if (wav.getnchannels(), wav.getsampwidth(), wav.getframerate(), wav.getnframes()) != (1, 2, 24000, frames):
|
||||
raise ValueError(f"{path.name}: unexpected WAV format or frame count")
|
||||
if hashlib.sha256(wav.readframes(frames)).hexdigest() != pcm_hash:
|
||||
raise ValueError(f"{path.name}: PCM differs from the stage output")
|
||||
|
||||
|
||||
def check_log(path: Path, device: str, started: int = 1) -> int:
|
||||
log = path.read_text(encoding="utf-8", errors="replace")
|
||||
if (f"0 = {device}" not in log or "using preferred GPU backend: Vulkan0" not in log
|
||||
or "code_pred CPU-pinned" not in log
|
||||
or "codec: GPU default - loading weights onto Vulkan0" not in log
|
||||
or "falling back to CPU" in log):
|
||||
raise ValueError(f"{path.name}: hybrid device placement not verified")
|
||||
count = log.count(PREFILL)
|
||||
if count < started:
|
||||
raise ValueError(f"{path.name}: expected TTS prefill absent")
|
||||
return count
|
||||
|
||||
|
||||
def audit(root: Path) -> dict:
|
||||
profile = json.loads((root / "tts_rtx_profile20_report.json").read_text(encoding="utf-8"))
|
||||
smoke = json.loads((root / "tts_rtx_smoke_report.json").read_text(encoding="utf-8"))
|
||||
postguard = json.loads((root / "tts_rtx_postguard_report.json").read_text(encoding="utf-8"))
|
||||
radeon = json.loads((root / "tts_radeon_regression_report.json").read_text(encoding="utf-8"))
|
||||
public = json.loads((root / "tts_rtx_public_report.json").read_text(encoding="utf-8"))
|
||||
asr = json.loads((root / "tts_rtx_smoke_asr.json").read_text(encoding="utf-8"))
|
||||
refused = json.loads((root / "tts_rtx_refused_3gib.json").read_text(encoding="utf-8"))
|
||||
hardware = json.loads((root / "hardware.json").read_text(encoding="utf-8"))
|
||||
if any(report["status"] != "passed" for report in (profile, smoke, postguard, radeon, public, refused)):
|
||||
raise ValueError("one of the TTS runs failed")
|
||||
for report, device, gpu, pcm in (
|
||||
(profile, "NVIDIA GeForce RTX 5090 Laptop GPU", True, RTX_PCM),
|
||||
(smoke, "NVIDIA GeForce RTX 5090 Laptop GPU", True, RTX_PCM),
|
||||
(postguard, "NVIDIA GeForce RTX 5090 Laptop GPU", True, RTX_PCM),
|
||||
(radeon, "AMD Radeon(TM) 890M Graphics", False, RADEON_PCM),
|
||||
):
|
||||
plan = report["execution_plan"]
|
||||
if (plan["artifact_sha256"] != ARTIFACT_HASHES or plan["expected_gpu_name"] != device
|
||||
or plan["ggml_vk_visible_devices"] != ("0" if gpu else "1")
|
||||
or ("gpu_vram" in plan["reserved_bytes"]) != gpu):
|
||||
raise ValueError("TTS artifact, GPU identity or memory pools changed")
|
||||
if (report["checks"][0]["pcm_sha256"] != pcm
|
||||
or report["measured"][0]["pcm_sha256"] != pcm
|
||||
or not clean_ledger(report["ledger_after_shutdown"], rtx=gpu)):
|
||||
raise ValueError("TTS complete WAV or release changed")
|
||||
if (profile["warmup_count"] != 1 or profile["measured_count"] != 20
|
||||
or len(profile["measured"]) != 20 or not profile["all_same_pcm_sha256"]
|
||||
or any(row["pcm_sha256"] != RTX_PCM or row["frames"] != 65280
|
||||
for row in profile["measured"])):
|
||||
raise ValueError("RTX serial profile did not return 20 identical complete WAVs")
|
||||
walls = sorted(row["wall_s"] for row in profile["measured"])
|
||||
if (profile["nearest_rank_p50_wall_s"] != walls[math.ceil(20 * .5) - 1]
|
||||
or profile["nearest_rank_p95_wall_s"] != walls[math.ceil(20 * .95) - 1]):
|
||||
raise ValueError("RTX p50/p95 do not match the retained 20 samples")
|
||||
for report, gpu in ((profile, True), (radeon, False)):
|
||||
abort = report["abort_check"]
|
||||
restart = report["restart_check"]
|
||||
old_plan, fresh_plan = report["execution_plan"], restart["fresh_execution_plan"]
|
||||
if (abort["prefills_after_abort_request_start"] <= abort["prefills_before_abort_request"]
|
||||
or abort["stale_output"] or not abort["worker_exited"]
|
||||
or restart["late_output"] or not restart["same_pcm_as_before_abort"]
|
||||
or old_plan["worker_generation"] == fresh_plan["worker_generation"]
|
||||
or fresh_plan["artifact_sha256"] != ARTIFACT_HASHES
|
||||
or fresh_plan["expected_gpu_name"] != old_plan["expected_gpu_name"]
|
||||
or fresh_plan["reserved_bytes"] != old_plan["reserved_bytes"]
|
||||
or restart["fresh_request"]["stage_event"]["worker_generation"] != fresh_plan["worker_generation"]
|
||||
or not all(clean_ledger(value, rtx=gpu) for value in (
|
||||
abort["ledger_after_abort"], restart["first_runtime_ledger_after_shutdown"]
|
||||
))):
|
||||
raise ValueError("in-flight cancellation or fresh-stage recovery failed")
|
||||
if (len(public["outputs"]) != 1 or public["outputs"][0]["pcm_sha256"] != RTX_PCM
|
||||
or public["outputs"][0]["frames"] != 65280 or public["outputs"][0]["sample_rate"] != 24000):
|
||||
raise ValueError("public AsyncOmni audio differs from the RTX stage output")
|
||||
if (asr["word_error_rate"] != 0.0 or asr["transcript"] != "Hello from the local computer."
|
||||
or asr["wav_sha256"] != sha256(root / "tts_rtx_smoke.wav")):
|
||||
raise ValueError("independent ASR proxy or WAV identity failed")
|
||||
if (refused["server_log_created"] or "GPU-VRAM reservation" not in refused["error"]
|
||||
or not clean_ledger(refused["ledger_after_refusal"], rtx=True)
|
||||
or (root / "tts_rtx_refused_should_not_exist.log").exists()):
|
||||
raise ValueError("undersized GPU reservation launched or retained a worker")
|
||||
if not any(gpu["Name"] == "NVIDIA GeForce RTX 5090 Laptop GPU" for gpu in hardware["gpus"]):
|
||||
raise ValueError("RTX hardware identity absent")
|
||||
counts = {
|
||||
"smoke": check_log(root / "tts_rtx_smoke_server.log", "NVIDIA GeForce RTX 5090 Laptop GPU", 3),
|
||||
"postguard": check_log(root / "tts_rtx_postguard_server.log", "NVIDIA GeForce RTX 5090 Laptop GPU", 3),
|
||||
"profile": check_log(root / "tts_rtx_profile20_server.log", "NVIDIA GeForce RTX 5090 Laptop GPU", 24),
|
||||
"restart": check_log(root / "tts_rtx_profile20_server_restart.log", "NVIDIA GeForce RTX 5090 Laptop GPU"),
|
||||
"public": check_log(root / "tts_rtx_public_server.log", "NVIDIA GeForce RTX 5090 Laptop GPU"),
|
||||
"radeon": check_log(root / "tts_radeon_regression_server.log", "AMD Radeon(TM) 890M Graphics"),
|
||||
"radeon_restart": check_log(root / "tts_radeon_regression_server_restart.log", "AMD Radeon(TM) 890M Graphics"),
|
||||
}
|
||||
check_wav(root / "tts_rtx_smoke.wav", 65280, RTX_PCM)
|
||||
check_wav(root / "tts_rtx_postguard.wav", 65280, RTX_PCM)
|
||||
check_wav(root / "tts_rtx_profile20.wav", 65280, RTX_PCM)
|
||||
check_wav(root / "tts_radeon_regression.wav", 61440, RADEON_PCM)
|
||||
files = [path for path in root.iterdir() if path.is_file() and path.name not in ("README.md", "audit_report.json")]
|
||||
return {
|
||||
"status": "passed",
|
||||
"scope": "RTX complete-request TTS, 20 serial outputs, public API, in-flight cancel/restart, GPU admission refusal and Radeon regression",
|
||||
"profile_nearest_rank_p50_wall_s": profile["nearest_rank_p50_wall_s"],
|
||||
"profile_nearest_rank_p95_wall_s": profile["nearest_rank_p95_wall_s"],
|
||||
"rtx_pcm_sha256": RTX_PCM,
|
||||
"radeon_pcm_sha256": RADEON_PCM,
|
||||
"server_prefill_counts": counts,
|
||||
"files": {path.name: {"bytes": path.stat().st_size, "sha256": sha256(path)} for path in files},
|
||||
"limits": [
|
||||
"ASR exact transcription is an intelligibility proxy, not speaker or perceptual quality qualification.",
|
||||
"The backend emits complete WAVs and has no playable chunk stream.",
|
||||
"Declared GPU-VRAM admission is not a measured device-memory loading peak.",
|
||||
"One fresh-stage restart is not same-session continuation or sustained recovery qualification.",
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("--evidence-dir", type=Path, required=True)
|
||||
args = parser.parse_args()
|
||||
result = audit(args.evidence_dir)
|
||||
(args.evidence_dir / "audit_report.json").write_text(
|
||||
json.dumps(result, indent=2) + "\n", encoding="utf-8"
|
||||
)
|
||||
print(json.dumps({"status": result["status"], "profile_p50": result["profile_nearest_rank_p50_wall_s"]}))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,74 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Verify that an undersized discrete-GPU TTS reservation fails before load."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
for name in (
|
||||
"server_bin", "server_sha256", "talker_file", "talker_sha256", "codec_file",
|
||||
"codec_sha256", "punc_file", "punc_sha256", "server_log", "output_report",
|
||||
):
|
||||
parser.add_argument("--" + name.replace("_", "-"), required=True)
|
||||
args = parser.parse_args()
|
||||
|
||||
from vllm_omni.engine.backends.crisp_tts import CrispTTSStageClient
|
||||
from vllm_omni.engine.resource_ledger import ResourceLedger, ResourceUnavailable
|
||||
|
||||
log_path = Path(args.server_log)
|
||||
if log_path.exists():
|
||||
raise FileExistsError("refusal probe needs a fresh server-log path")
|
||||
ledger = ResourceLedger({"host_ram": 16 << 30, "gpu_vram": 16 << 30})
|
||||
reservation = ledger.reserve("undersized-rtx-tts", {"host_ram": 8 << 30, "gpu_vram": 3 << 30})
|
||||
backend = {
|
||||
"server_bin": args.server_bin,
|
||||
"server_sha256": args.server_sha256,
|
||||
"talker_file": args.talker_file,
|
||||
"talker_sha256": args.talker_sha256,
|
||||
"codec_file": args.codec_file,
|
||||
"codec_sha256": args.codec_sha256,
|
||||
"punc_file": args.punc_file,
|
||||
"punc_sha256": args.punc_sha256,
|
||||
"log_file": str(log_path),
|
||||
"expected_gpu_name": "NVIDIA GeForce RTX 5090 Laptop GPU",
|
||||
"ggml_vk_visible_devices": "0",
|
||||
"memory_overhead_bytes": 5 << 30,
|
||||
"gpu_memory_pool": "gpu_vram",
|
||||
"gpu_memory_overhead_bytes": 2 << 30,
|
||||
}
|
||||
error = None
|
||||
try:
|
||||
CrispTTSStageClient(SimpleNamespace(stage_id=0), backend, ledger, reservation)
|
||||
except ResourceUnavailable as exc:
|
||||
error = f"{type(exc).__name__}: {exc}"
|
||||
if error is None:
|
||||
raise RuntimeError("undersized GPU-VRAM reservation was admitted")
|
||||
snapshot = ledger.snapshot()
|
||||
if snapshot["reserved"] != {"host_ram": 0, "gpu_vram": 0} or snapshot["quarantined"] or log_path.exists():
|
||||
raise RuntimeError("GPU-VRAM refusal left a reservation or launched the server")
|
||||
report = {
|
||||
"status": "passed",
|
||||
"scope": "RTX TTS 3 GiB GPU-VRAM demand is refused before server launch",
|
||||
"artifact_sha256": {name: getattr(args, name) for name in (
|
||||
"server_sha256", "talker_sha256", "codec_sha256", "punc_sha256"
|
||||
)},
|
||||
"declared_gpu_reservation_bytes": 3 << 30,
|
||||
"declared_gpu_overhead_bytes": 2 << 30,
|
||||
"error": error,
|
||||
"server_log_created": False,
|
||||
"ledger_after_refusal": snapshot,
|
||||
}
|
||||
destination = Path(args.output_report)
|
||||
destination.parent.mkdir(parents=True, exist_ok=True)
|
||||
destination.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
|
||||
print(json.dumps({"status": report["status"], "error": report["error"]}))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -39,6 +39,7 @@ async def main() -> None:
|
||||
):
|
||||
parser.add_argument("--" + name.replace("_", "-"), required=True)
|
||||
parser.add_argument("--expected-gpu-name", default="AMD Radeon(TM) 890M Graphics")
|
||||
parser.add_argument("--ggml-vk-visible-devices", default="1")
|
||||
parser.add_argument("--warmups", type=int, default=1)
|
||||
parser.add_argument("--repeats", type=int, default=20)
|
||||
parser.add_argument("--abort-check", action="store_true")
|
||||
@@ -46,9 +47,16 @@ async def main() -> None:
|
||||
help="After in-flight cancellation, start a fresh stage and verify audio")
|
||||
parser.add_argument("--capacity-gib", type=int, default=16)
|
||||
parser.add_argument("--reserve-gib", type=int, default=8)
|
||||
parser.add_argument("--gpu-capacity-gib", type=int, default=0)
|
||||
parser.add_argument("--gpu-reserve-gib", type=int, default=0)
|
||||
args = parser.parse_args()
|
||||
if args.warmups < 0 or args.repeats <= 0 or args.reserve_gib <= 0 or args.capacity_gib < args.reserve_gib:
|
||||
parser.error("invalid warmup/repeat count or memory budget")
|
||||
if args.expected_gpu_name == "NVIDIA GeForce RTX 5090 Laptop GPU":
|
||||
if args.ggml_vk_visible_devices != "0" or args.gpu_reserve_gib < 4 or args.gpu_capacity_gib < args.gpu_reserve_gib:
|
||||
parser.error("RTX route requires Vulkan device 0 and at least 4 GiB reserved GPU VRAM")
|
||||
elif args.gpu_capacity_gib or args.gpu_reserve_gib:
|
||||
parser.error("Radeon shared-RAM route must not declare discrete GPU VRAM")
|
||||
if args.restart_check and not args.abort_check:
|
||||
parser.error("--restart-check requires --abort-check")
|
||||
|
||||
@@ -68,7 +76,7 @@ async def main() -> None:
|
||||
"punc_sha256": args.punc_sha256,
|
||||
"log_file": args.server_log,
|
||||
"expected_gpu_name": args.expected_gpu_name,
|
||||
"ggml_vk_visible_devices": "1",
|
||||
"ggml_vk_visible_devices": args.ggml_vk_visible_devices,
|
||||
"memory_overhead_bytes": 5 << 30,
|
||||
"max_text_bytes": 4096,
|
||||
"max_wav_bytes": 4 << 20,
|
||||
@@ -78,14 +86,21 @@ async def main() -> None:
|
||||
"voice": "ryan",
|
||||
"seed": 42,
|
||||
}
|
||||
capacities = {"host_ram": args.capacity_gib << 30}
|
||||
demands = {"host_ram": args.reserve_gib << 30}
|
||||
if args.gpu_reserve_gib:
|
||||
capacities["gpu_vram"] = args.gpu_capacity_gib << 30
|
||||
demands["gpu_vram"] = args.gpu_reserve_gib << 30
|
||||
backend["gpu_memory_pool"] = "gpu_vram"
|
||||
backend["gpu_memory_overhead_bytes"] = 2 << 30
|
||||
deploy = DeployConfig(
|
||||
async_chunk=False,
|
||||
stages=[StageDeployConfig(
|
||||
stage_id=0,
|
||||
backend=backend,
|
||||
resource_budget={
|
||||
"capacities": {"host_ram": args.capacity_gib << 30},
|
||||
"demands": {"host_ram": args.reserve_gib << 30},
|
||||
"capacities": capacities,
|
||||
"demands": demands,
|
||||
},
|
||||
)],
|
||||
)
|
||||
@@ -94,7 +109,7 @@ async def main() -> None:
|
||||
runtime = StageRuntime(configs, "local-qwen-tts-crisp", "", stage_init_timeout=180, async_chunk=False)
|
||||
report = {
|
||||
"scope": "complete resident Qwen3-TTS CustomVoice text-to-WAV through Omni StageRuntime/StagePool",
|
||||
"placement": "Radeon Vulkan talker/codec + CPU FP32 code predictor",
|
||||
"placement": f"{args.expected_gpu_name} Vulkan talker/codec + CPU FP32 code predictor",
|
||||
"warmup_count": args.warmups,
|
||||
"measured_count": args.repeats,
|
||||
"memory_budget": deploy.stages[0].resource_budget,
|
||||
|
||||
@@ -22,7 +22,18 @@ async def main() -> None:
|
||||
"codec_file", "codec_sha256", "punc_file", "punc_sha256", "server_log", "output_report",
|
||||
):
|
||||
parser.add_argument("--" + name.replace("_", "-"), required=True)
|
||||
parser.add_argument("--expected-gpu-name", default="AMD Radeon(TM) 890M Graphics")
|
||||
parser.add_argument("--ggml-vk-visible-devices", default="1")
|
||||
parser.add_argument("--gpu-capacity-gib", type=int, default=0)
|
||||
parser.add_argument("--gpu-reserve-gib", type=int, default=0)
|
||||
parser.add_argument("--expected-frames", type=int, default=61440)
|
||||
parser.add_argument("--expected-pcm-sha256", default="57f60228e2b456f6dfefc7e49df862c7bff6ba7cf39231ef1824f615948a1539")
|
||||
args = parser.parse_args()
|
||||
if args.expected_gpu_name == "NVIDIA GeForce RTX 5090 Laptop GPU":
|
||||
if args.ggml_vk_visible_devices != "0" or args.gpu_reserve_gib < 4 or args.gpu_capacity_gib < args.gpu_reserve_gib:
|
||||
parser.error("RTX route requires Vulkan device 0 and at least 4 GiB reserved GPU VRAM")
|
||||
elif args.gpu_capacity_gib or args.gpu_reserve_gib:
|
||||
parser.error("Radeon shared-RAM route must not declare discrete GPU VRAM")
|
||||
|
||||
from vllm_omni.entrypoints.async_omni import AsyncOmni
|
||||
from vllm_omni.model_executor.models.qwen3_tts.pipeline import QWEN3_TTS_CRISP_HYBRID_PIPELINE
|
||||
@@ -38,8 +49,8 @@ async def main() -> None:
|
||||
"punc_file": args.punc_file,
|
||||
"punc_sha256": args.punc_sha256,
|
||||
"log_file": args.server_log,
|
||||
"expected_gpu_name": "AMD Radeon(TM) 890M Graphics",
|
||||
"ggml_vk_visible_devices": "1",
|
||||
"expected_gpu_name": args.expected_gpu_name,
|
||||
"ggml_vk_visible_devices": args.ggml_vk_visible_devices,
|
||||
"memory_overhead_bytes": 5 << 30,
|
||||
"max_text_bytes": 4096,
|
||||
"max_wav_bytes": 4 << 20,
|
||||
@@ -47,7 +58,15 @@ async def main() -> None:
|
||||
"voice": "ryan",
|
||||
"seed": 42,
|
||||
}
|
||||
capacities = {"host_ram": 16 << 30}
|
||||
demands = {"host_ram": 8 << 30}
|
||||
if args.gpu_reserve_gib:
|
||||
capacities["gpu_vram"] = args.gpu_capacity_gib << 30
|
||||
demands["gpu_vram"] = args.gpu_reserve_gib << 30
|
||||
backend["gpu_memory_pool"] = "gpu_vram"
|
||||
backend["gpu_memory_overhead_bytes"] = 2 << 30
|
||||
report = {"entrypoint": "AsyncOmni.generate", "pipeline": QWEN3_TTS_CRISP_HYBRID_PIPELINE.model_type}
|
||||
report["memory_budget"] = {"capacities": capacities, "demands": demands}
|
||||
engine = None
|
||||
try:
|
||||
with tempfile.TemporaryDirectory(prefix="omni-crisp-tts-") as temporary:
|
||||
@@ -59,8 +78,8 @@ async def main() -> None:
|
||||
"stage_id": 0,
|
||||
"backend": backend,
|
||||
"resource_budget": {
|
||||
"capacities": {"host_ram": 16 << 30},
|
||||
"demands": {"host_ram": 8 << 30},
|
||||
"capacities": capacities,
|
||||
"demands": demands,
|
||||
},
|
||||
}],
|
||||
}), encoding="utf-8")
|
||||
@@ -89,9 +108,11 @@ async def main() -> None:
|
||||
})
|
||||
report["request_wall_s"] = time.perf_counter() - started
|
||||
report["outputs"] = outputs
|
||||
assert len(outputs) == 1 and outputs[0]["request_id"] == "public-tts-1"
|
||||
assert outputs[0]["sample_rate"] == 24000 and outputs[0]["frames"] == 61440
|
||||
assert outputs[0]["pcm_sha256"] == "57f60228e2b456f6dfefc7e49df862c7bff6ba7cf39231ef1824f615948a1539"
|
||||
if (len(outputs) != 1 or outputs[0]["request_id"] != "public-tts-1"
|
||||
or outputs[0]["sample_rate"] != 24000
|
||||
or outputs[0]["frames"] != args.expected_frames
|
||||
or outputs[0]["pcm_sha256"] != args.expected_pcm_sha256):
|
||||
raise RuntimeError("public audio differed from the pinned stage output")
|
||||
report["status"] = "passed"
|
||||
except BaseException as exc:
|
||||
report["status"] = "failed"
|
||||
|
||||
Reference in new issue
Block a user