How to Translate SRT Subtitles with ChatGPT (Japanese to English) Without Breaking the Timing + a Free Python Checker

4
00:00:10,000 --> 00:00:12,400
駅前の新しいカフェ、

駅前の新しいカフェ、                  (the new café by the station,)
昨日オープンしたって聞いたんだけど      (I heard it opened yesterday, but)
行ってみない?                          (want to go?)

python3 srtcheck.py to-json sample_ja.srt > cues.json

{
  "id": "4",
  "text": "駅前の新しいカフェ、",
  "prev": "……まあ、いっか。なんとかなるでしょ。",
  "next": "昨日オープンしたって聞いたんだけど"
}

You are translating Japanese subtitles into natural U.S. English.

Input: a JSON array. Each item has "id", "text" (translate this),
and "prev"/"next" (neighboring cues, for context only - do not translate them).

Rules:
1. Return a JSON array with exactly one item per input item, same order,
   each item {"id": <same id>, "text": <English>}. Nothing else.
2. Never merge, split, add or drop items. Never change an id.
3. When a Japanese sentence runs across several cues, translate the whole
   sentence, then divide the English across those same cues in a natural
   reading order. Each cue must still make sense where it breaks.
4. Keep each cue short: at most 2 lines, at most 42 characters per line.
   Use "\n" for a line break. Prefer shorter wording to long, literal wording.
5. Keep the speaker's tone (casual stays casual). Add a subject only when
   English needs one.
6. Use the single ellipsis character (…) instead of three dots,
   and no em or en dashes.
7. If something cannot be translated with confidence (a name, a pun),
   keep your best version and add "[CHECK]" at the end of that text.

[
  {"id": "1", "text": "Wait, it's already this late?"},
  {"id": "2", "text": "Sorry, go on ahead.\nI'll catch up!"},
  {"id": "3", "text": "Oh well. It'll work out."},
  {"id": "4", "text": "That new café by the station"},
  {"id": "5", "text": "opened yesterday, I heard."},
  {"id": "6", "text": "Want to check it out?"},
  {"id": "7", "text": "Yeah!"}
]

python3 srtcheck.py from-json sample_ja.srt translated_en.json > sample_en.srt

python3 srtcheck.py check sample_ja.srt sample_en.srt

WARN    cue 1->2: gap 4.8 frames (24 fps rule: gaps of 3-11 frames must be closed to 2; source timing, fix in a timing pass)
WARN    cue 2->3: gap 7.2 frames (24 fps rule: gaps of 3-11 frames must be closed to 2; source timing, fix in a timing pass)
WARN    cue 4->5: gap 1.92 frames (min 2)
WARN    cue 7: duration 0.800s (min 5/6 s = 0.833s, 20 frames at 24 fps)

7 cues checked: 0 error(s), 4 warning(s)

ERROR   cue count changed: source 7, target 6
ERROR   cue 6: timecode changed (00:00:15,084 --> 00:00:17,500 -> 00:00:15,084 --> 00:00:19,000)
ERROR   cue 2: line has 73 chars (max 42): "I'm sorry, please go ahead first and I will catch up with you right away!"
ERROR   cue 3: line has 45 chars (max 42): "...Well, it's fine. It will work out somehow."
WARN    cue 1->2: gap 4.8 frames (24 fps rule: gaps of 3-11 frames must be closed to 2; source timing, fix in a timing pass)
WARN    cue 2: reading speed 28.1 CPS (max 20) - shorten the text, don't retime
WARN    cue 2->3: gap 7.2 frames (24 fps rule: gaps of 3-11 frames must be closed to 2; source timing, fix in a timing pass)
WARN    cue 3: three dots; use the single ellipsis character
WARN    cue 4->5: gap 1.92 frames (min 2)

6 cues checked: 4 error(s), 5 warning(s)

#!/usr/bin/env python3
"""srtcheck.py - round-trip an SRT through JSON and check a translated SRT.

  python3 srtcheck.py to-json  source.srt  > cues.json
  python3 srtcheck.py from-json source.srt translated.json > target.srt
  python3 srtcheck.py check    source.srt  target.srt [--fps 24]

Standard library only. Limits come from Netflix's public Timed Text Style Guide
pages (English (USA), General Requirements, Subtitle Timing Guidelines).
--fps sets the frame rate used for frame-based checks (default 24).
"""
import json, re, sys

MAX_CHARS_PER_LINE = 42   # English (USA) guide, II.3
MAX_LINES = 2             # English (USA) guide, II.13
MAX_CPS = 20.0            # English (USA) guide, II.17 (adult programs)
MAX_DURATION = 7.0        # General Requirements, 1. Duration
MIN_DURATION = 5 / 6      # General Requirements, 1. Duration: 5/6 s (20 frames at 24 fps)
MIN_GAP_FRAMES = 2        # Timing Guidelines, 5: minimum 2 frames between subtitles

TC = re.compile(r"(\d{2}):(\d{2}):(\d{2})[,.](\d{3})\s*-->\s*(\d{2}):(\d{2}):(\d{2})[,.](\d{3})")

def parse(path):
    text = open(path, encoding="utf-8-sig").read().replace("\r\n", "\n")
    cues = []
    for block in re.split(r"\n\s*\n", text.strip()):
        lines = block.split("\n")
        if len(lines) < 2 or not TC.search(lines[1]):
            raise SystemExit(f"Cannot parse block:\n{block}")
        m = TC.search(lines[1]).groups()
        t = [int(x) for x in m]
        start = t[0]*3600 + t[1]*60 + t[2] + t[3]/1000
        end = t[4]*3600 + t[5]*60 + t[6] + t[7]/1000
        cues.append({"id": lines[0].strip(), "timing": lines[1].strip(),
                     "start": start, "end": end, "lines": lines[2:]})
    return cues

def to_json(src):
    cues = parse(src)
    out = []
    for i, c in enumerate(cues):
        out.append({"id": c["id"], "text": "\n".join(c["lines"]),
                    "prev": "\n".join(cues[i-1]["lines"]) if i else "",
                    "next": "\n".join(cues[i+1]["lines"]) if i + 1 < len(cues) else ""})
    print(json.dumps(out, ensure_ascii=False, indent=2))

def from_json(src, translated):
    cues = parse(src)
    tr = {str(x["id"]): x["text"] for x in json.load(open(translated, encoding="utf-8"))}
    missing = [c["id"] for c in cues if c["id"] not in tr]
    if missing:
        raise SystemExit(f"Translated JSON is missing ids: {', '.join(missing)}")
    blocks = [f'{c["id"]}\n{c["timing"]}\n{tr[c["id"]].strip()}' for c in cues]
    print("\n\n".join(blocks) + "\n")

def check(src, tgt, fps=24.0):
    a, b = parse(src), parse(tgt)
    errors, warnings = [], []
    if len(a) != len(b):
        errors.append(f"cue count changed: source {len(a)}, target {len(b)}")
    for x, y in zip(a, b):
        if x["id"] != y["id"]:
            errors.append(f"cue {x['id']}: index changed to {y['id']}")
        if x["timing"] != y["timing"]:
            errors.append(f"cue {x['id']}: timecode changed ({x['timing']} -> {y['timing']})")
    for i, c in enumerate(b):
        cid, dur = c["id"], c["end"] - c["start"]
        text = [l.strip() for l in c["lines"] if l.strip()]
        chars = sum(len(l) for l in text)          # characters incl. spaces, excl. line breaks
        if not text:
            errors.append(f"cue {cid}: empty text")
        if len(text) > MAX_LINES:
            errors.append(f"cue {cid}: {len(text)} lines (max {MAX_LINES})")
        for l in text:
            if len(l) > MAX_CHARS_PER_LINE:
                errors.append(f"cue {cid}: line has {len(l)} chars (max {MAX_CHARS_PER_LINE}): {l!r}")
        if dur > 0 and chars / dur > MAX_CPS:
            warnings.append(f"cue {cid}: reading speed {chars/dur:.1f} CPS (max {MAX_CPS:g}) - shorten the text, don't retime")
        if dur > MAX_DURATION:
            warnings.append(f"cue {cid}: duration {dur:.2f}s (max {MAX_DURATION:g}s)")
        if dur < MIN_DURATION - 1e-6:
            warnings.append(f"cue {cid}: duration {dur:.3f}s (min 5/6 s = {MIN_DURATION:.3f}s, {MIN_DURATION*fps:g} frames at {fps:g} fps)")
        for l in text:
            if "  " in l: warnings.append(f"cue {cid}: double space")
            if "\u2013" in l or "\u2014" in l: warnings.append(f"cue {cid}: en/em dash (not permitted)")
            if "..." in l: warnings.append(f"cue {cid}: three dots; use the single ellipsis character")
        if i + 1 < len(b):
            gap_frames = round((b[i+1]["start"] - c["end"]) * fps, 2)
            if gap_frames < MIN_GAP_FRAMES:
                warnings.append(f"cue {cid}->{b[i+1]['id']}: gap {gap_frames:g} frames (min {MIN_GAP_FRAMES})")
            elif fps == 24 and 3 <= gap_frames <= 11:
                warnings.append(f"cue {cid}->{b[i+1]['id']}: gap {gap_frames:g} frames (24 fps rule: gaps of 3-11 frames must be closed to 2; source timing, fix in a timing pass)")
    for e in errors: print("ERROR  ", e)
    for w in warnings: print("WARN   ", w)
    print(f"\n{len(b)} cues checked: {len(errors)} error(s), {len(warnings)} warning(s)")
    return 1 if errors else 0

if __name__ == "__main__":
    args = sys.argv[1:]
    fps = 24.0
    if "--fps" in args:
        k = args.index("--fps"); fps = float(args[k+1]); del args[k:k+2]
    if len(args) == 2 and args[0] == "to-json": to_json(args[1])
    elif len(args) == 3 and args[0] == "from-json": from_json(args[1], args[2])
    elif len(args) == 3 and args[0] == "check": sys.exit(check(args[1], args[2], fps))
    else: print(__doc__); sys.exit(2)

1
00:00:01,000 --> 00:00:03,200
えっ、もうこんな時間?

2
00:00:03,400 --> 00:00:06,000
ごめん、先に行ってて。すぐ追いつくから!

3
00:00:06,300 --> 00:00:09,000
……まあ、いっか。なんとかなるでしょ。

4
00:00:10,000 --> 00:00:12,400
駅前の新しいカフェ、

5
00:00:12,480 --> 00:00:15,000
昨日オープンしたって聞いたんだけど

6
00:00:15,084 --> 00:00:17,500
行ってみない?

7
00:00:18,200 --> 00:00:19,000
うん!

1
00:00:01,000 --> 00:00:03,200
Eh, is it already this time?

2
00:00:03,400 --> 00:00:06,000
I'm sorry, please go ahead first and I will catch up with you right away!

3
00:00:06,300 --> 00:00:09,000
...Well, it's fine. It will work out somehow.

4
00:00:10,000 --> 00:00:12,400
The new café in front of the station,

5
00:00:12,480 --> 00:00:15,000
I heard it opened yesterday, but

6
00:00:15,084 --> 00:00:19,000
won't you go? Yes!