TurboScribe 教程：录音转文字、SRT 字幕导出与校对

1
00:00:00,000 --> 00:00:02,000
这是一段教学字幕。

2
00:00:02,000 --> 00:00:04,000
金额、人名和否定表达需要回听。

"""A conservative single-track delivery check, not a speech accuracy test."""
import argparse
import json
import math
import re
from pathlib import Path

STAMP = r"\d{2,}:\d{2}:\d{2},\d{3}"
TIMELINE = re.compile(rf"^({STAMP})\s+-->\s+({STAMP})$")


def milliseconds(value):
    hour, minute, rest = value.split(":")
    second, fraction = rest.split(",")
    if not (0 <= int(minute) < 60 and 0 <= int(second) < 60):
        raise ValueError("minute or second is outside 00-59")
    return ((int(hour) * 60 + int(minute)) * 60 + int(second)) * 1000 + int(fraction)


def check_srt(text, duration_ms=None):
    if duration_ms is not None and (type(duration_ms) is not int or duration_ms < 0):
        raise ValueError("duration_ms must be a nonnegative integer")
    text = text.lstrip("\ufeff").replace("\r\n", "\n").replace("\r", "\n").strip()
    errors, cues = [], []
    if not text:
        return {"ok": False, "cues": 0, "errors": ["empty subtitle file"]}
    previous_end = None
    for number, block in enumerate(re.split(r"\n[ \t]*\n+", text), start=1):
        lines = block.splitlines()
        if len(lines) < 3:
            errors.append(f"block {number}: missing index, time line or text")
            continue
        if lines[0].strip() != str(number):
            errors.append(f"block {number}: expected sequential index {number}")
        match = TIMELINE.fullmatch(lines[1].strip())
        if not match:
            errors.append(f"block {number}: unsupported time format")
            continue
        try:
            start, end = [milliseconds(value) for value in match.groups()]
        except ValueError as exc:
            errors.append(f"block {number}: {exc}")
            continue
        if start >= end:
            errors.append(f"block {number}: end must be after start")
        if previous_end is not None and start < previous_end:
            errors.append(f"block {number}: overlap needs manual review")
        if duration_ms is not None and end > duration_ms:
            errors.append(f"block {number}: beyond supplied media duration")
        if not "\n".join(lines[2:]).strip():
            errors.append(f"block {number}: empty subtitle text")
        previous_end = end if previous_end is None else max(previous_end, end)
        cues.append({"start_ms": start, "end_ms": end})
    return {"ok": not errors, "cues": len(cues), "errors": errors}


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("file", type=Path)
    parser.add_argument("--duration-seconds", type=float)
    args = parser.parse_args()
    duration = args.duration_seconds
    if duration is not None and (not math.isfinite(duration) or duration < 0):
        parser.error("duration must be a finite nonnegative number")
    try:
        report = check_srt(
            args.file.read_text(encoding="utf-8-sig"),
            round(duration * 1000) if duration is not None else None,
        )
    except (OSError, UnicodeError, ValueError) as exc:
        report = {"ok": False, "cues": 0, "errors": [str(exc)]}
    print(json.dumps(report, ensure_ascii=False, indent=2))
    raise SystemExit(0 if report["ok"] else 1)


if __name__ == "__main__":
    main()

python3 check_srt.py sample.srt --duration-seconds 4