From f8677998760f09f0a8b680194dba216278e5447a Mon Sep 17 00:00:00 2001 From: Abdussamet Kocak Date: Tue, 20 Oct 2026 04:34:13 +0000 Subject: [PATCH] feat: Add subtitle timing and segmentation script --- rewrite_srt.py | 364 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 364 insertions(+) create mode 100755 rewrite_srt.py diff --git a/rewrite_srt.py b/rewrite_srt.py new file mode 100755 index 0000000..58a44b0 --- /dev/null +++ b/rewrite_srt.py @@ -0,0 +1,364 @@ +#!/usr/bin/env python3 +import argparse +import logging +import re +import textwrap +from dataclasses import dataclass +from pathlib import Path + +# lowercase tokens (en, tr) whose trailing period does not end a sentence +ABBREVIATIONS = {"mr", "mrs", "ms", "dr", "prof", "e.g", "i.e", "vs", "etc", "doç", "av", "sn", "vb", "bkz"} +# Finds candidate sentence boundaries: end punctuation, optional closers, then whitespace. +# Matches in "He left. Then" -> ". " and in 'He said "no." Then' -> '." '. +SENTENCE_END = re.compile( + r""" + [.!?…]+ # one or more end marks: "." "?!" "..." or the ellipsis character + [\"'”’)\]]* # closing quotes or brackets that belong to the finished sentence + \s+ # whitespace after it; one or more, so double spaces work too + """, + re.VERBOSE, +) +# Matches an SRT time line such as "00:01:02,345 --> 00:01:04,000" and captures the 8 time fields. +TIMELINE_PATTERN = re.compile( + r""" + (\d+):(\d{2}):(\d{2})[,.](\d{3}) # start: hours, minutes, seconds, milliseconds (comma or dot) + \s*-->\s* # arrow, with optional spaces around it + (\d+):(\d{2}):(\d{2})[,.](\d{3}) # end, same layout + """, + re.VERBOSE, +) +# Matches a whole cue that is only a sound description or music, e.g. "[Music]", "(laughing)", "♪ la la ♪". +NONSPEECH_PATTERN = re.compile( + r""" + ^( + \[[^\]]*\] # [ ... ] + | \([^)]*\) # ( ... ) + | ♪[^♪]*♪? # ♪ ... ♪, closing note optional + | ♫[^♫]*♫? # ♫ ... ♫, closing note optional + )$ + """, + re.VERBOSE, +) +# Matches inline markup to strip: HTML tags like and , and ASS/SSA overrides like {\an8}. +MARKUP_PATTERN = re.compile( + r""" + <[^>]+> # < ... > + | \{[^}]*\} # { ... } + """, + re.VERBOSE, +) +MIN_CUE_DURATION = 0.2 + +logger = logging.getLogger(__name__) + + +@dataclass +class Cue: + """A subtitle cue or piece of one; times in seconds. `dialogue` marks cues holding several '- ' speaker lines.""" + + start: float + end: float + text: str + dialogue: bool = False + + +def parse_args() -> argparse.Namespace: + """Parse command-line arguments.""" + parser = argparse.ArgumentParser( + description="Re-time and re-segment an SRT file mechanically: merge by sentence, split long cues, wrap lines, enforce reading speed.", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + parser.add_argument("subtitle", type=Path, help="Input SRT file") + parser.add_argument("--output", "-o", type=Path, help="Output SRT path (default: .rewritten.srt)") + parser.add_argument("--max-line-length", type=int, default=42, help="Max characters per line") + parser.add_argument("--max-lines", type=int, default=2, help="Max lines per cue") + parser.add_argument("--max-cps", type=float, default=17.0, help="Max characters per second before a cue's end is extended") + parser.add_argument("--min-duration", type=float, default=1.0, help="Cues shorter than this (seconds) are merged into a neighbour") + parser.add_argument("--max-duration", type=float, default=7.0, help="Cues longer than this (seconds) are split") + parser.add_argument("--min-gap", type=float, default=0.04, help="Minimum gap between cues in seconds") + parser.add_argument("--drop-nonspeech", action="store_true", help="Remove cues that are only [..], (..) or music notes") + return parser.parse_args() + + +def parse_timestamp(hours: str, minutes: str, seconds: str, milliseconds: str) -> float: + """Convert the four captured time fields of TIMELINE_PATTERN to seconds.""" + return int(hours) * 3600 + int(minutes) * 60 + int(seconds) + int(milliseconds) / 1000 + + +def parse_srt(content: str) -> list[Cue]: + """Parse SRT text into cues sorted by start time. + + Tolerates CRLF line endings and a missing index line. Text lines are flattened into one line and markup is + stripped. A cue with two or more lines starting with '- ' is flagged as dialogue. Empty cues are dropped. + """ + cues = [] + # \n\s*\n = a blank line (possibly containing spaces) separates SRT blocks + for block in re.split(r"\n\s*\n", content.replace("\r\n", "\n").replace("\r", "\n").strip()): + lines = block.split("\n") + match = next((found for line in lines[:3] if (found := TIMELINE_PATTERN.search(line))), None) + if match is None: + raise ValueError(f"Invalid SRT block: {block[:80]!r}") + position = next(position for position, line in enumerate(lines[:3]) if TIMELINE_PATTERN.search(line)) + body = [line.strip() for line in lines[position + 1 :] if line.strip()] + # \s+ -> " " collapses runs of whitespace (including the gaps left by removed markup) to one space + text = re.sub(r"\s+", " ", MARKUP_PATTERN.sub("", " ".join(body))).strip() + if text: + cues.append( + Cue( + start=parse_timestamp(*match.group(1, 2, 3, 4)), + end=parse_timestamp(*match.group(5, 6, 7, 8)), + text=text, + dialogue=sum(line.startswith("- ") for line in body) >= 2, + ) + ) + if not cues: + raise ValueError("SRT contains no cues") + cues.sort(key=lambda cue: cue.start) + return cues + + +def format_timestamp(seconds: float) -> str: + """Format seconds as an SRT timestamp, HH:MM:SS,mmm.""" + total_milliseconds = round(seconds * 1000) + hours, remainder = divmod(total_milliseconds, 3_600_000) + minutes, remainder = divmod(remainder, 60_000) + secs, milliseconds = divmod(remainder, 1000) + return f"{hours:02d}:{minutes:02d}:{secs:02d},{milliseconds:03d}" + + +def split_sentences(text: str) -> list[str]: + """Split text into sentences at SENTENCE_END matches. + + A boundary is kept only if the next character starts a sentence (uppercase, digit, opening quote/bracket or a + '- ' speaker dash) and the word before a period is not a known abbreviation or a single-letter initial. + Decimals such as "3.5" never match because no whitespace follows the period. + """ + sentences = [] + start = 0 + for match in SENTENCE_END.finditer(text): + following = text[match.end() : match.end() + 1] + starts_sentence = following.isupper() or following.isdigit() or following in "\"'“‘([" or text.startswith("- ", match.end()) + if not following or not starts_sentence: + continue + punctuation = match.group().strip() + # (\S+)$ = the last whitespace-delimited word before the punctuation, e.g. "Dr" in "... Dr." + word = re.search(r"(\S+)$", text[start : match.start()]) + token = word.group(1).lower().lstrip("\"'“‘([") if word else "" + if punctuation.startswith(".") and (token in ABBREVIATIONS or (len(token) == 1 and token.isalpha())): + continue + sentences.append(text[start : match.start() + len(match.group().rstrip())].strip()) + start = match.end() + sentences.append(text[start:].strip()) + return [sentence for sentence in sentences if sentence] + + +def wrap_text(text: str, width: int, max_lines: int) -> list[str] | None: + """Wrap text to at most `max_lines` lines of at most `width` characters, preferring balanced lines. + + Text of the form "- a - b" is split into one line per speaker when each fits. Returns None if no wrapping fits. + """ + if len(text) <= width: + return [text] + if text.startswith("- ") and " - " in text: + # \s+(?=- ) = whitespace followed by a dash-space (lookahead, not consumed): splits before each speaker dash + speakers = re.split(r"\s+(?=- )", text) + if len(speakers) <= max_lines and all(len(line) <= width for line in speakers): + return speakers + for count in range(2, max_lines + 1): + lines = textwrap.wrap(text, width=-(-len(text) // count), break_long_words=False, break_on_hyphens=False) + if len(lines) <= max_lines and all(len(line) <= width for line in lines): + return lines + lines = textwrap.wrap(text, width=width, break_long_words=False, break_on_hyphens=False) + return lines if len(lines) <= max_lines and all(len(line) <= width for line in lines) else None + + +def wrap_dialogue(text: str, width: int) -> list[str]: + """Wrap a dialogue cue, one or more lines per speaker. The number of lines is not limited.""" + lines = [] + # \s+(?=- ) = whitespace followed by a dash-space (lookahead, not consumed): splits before each speaker dash + for speaker in re.split(r"\s+(?=- )", text): + lines.extend(textwrap.wrap(speaker, width=width, break_long_words=False, break_on_hyphens=False)) + return lines + + +def time_at(spans: list[tuple[int, Cue]], offset: int, is_end: bool) -> float: + """Map a character offset in the joined text to a time, interpolating linearly inside the cue that holds it. + + `spans` are (offset of cue text in the joined text, cue). For an end offset the cue boundary belongs to the + earlier cue, for a start offset to the later one. Offsets in the joining gap snap to the nearest cue edge. + """ + for span_offset, cue in spans: + length = len(cue.text) + inside = span_offset < offset <= span_offset + length if is_end else span_offset <= offset < span_offset + length + if inside: + return cue.start + (cue.end - cue.start) * (offset - span_offset) / length + span_offset, cue = min(spans, key=lambda span: min(abs(offset - span[0]), abs(offset - span[0] - len(span[1].text)))) + return cue.start if offset <= span_offset else cue.end + + +def sentences_with_times(cues: list[Cue]) -> list[Cue]: + """Join the cues' text, split it into sentences and give each sentence a start and end time. + + A sentence spanning several cues starts where its first character is spoken and ends where its last one is. + """ + joined = " ".join(cue.text for cue in cues) + spans = [] + offset = 0 + for cue in cues: + spans.append((offset, cue)) + offset += len(cue.text) + 1 + pieces = [] + cursor = 0 + for sentence in split_sentences(text=joined): + position = joined.index(sentence, cursor) + cursor = position + len(sentence) + pieces.append( + Cue( + start=time_at(spans=spans, offset=position, is_end=False), + end=time_at(spans=spans, offset=cursor, is_end=True), + text=sentence, + ) + ) + return pieces + + +def fits(text: str, duration: float, args: argparse.Namespace) -> bool: + """Whether one cue can hold `text`: within --max-duration and wrappable into --max-lines lines.""" + return duration <= args.max_duration and wrap_text(text=text, width=args.max_line_length, max_lines=args.max_lines) is not None + + +def merge_short(pieces: list[Cue], args: argparse.Namespace) -> list[Cue]: + """Merge a piece into the previous one when either is shorter than --min-duration and the result still fits.""" + merged: list[Cue] = [] + for piece in pieces: + if merged: + previous = merged[-1] + short = piece.end - piece.start < args.min_duration or previous.end - previous.start < args.min_duration + text = f"{previous.text} {piece.text}" + if short and fits(text=text, duration=piece.end - previous.start, args=args): + previous.end = piece.end + previous.text = text + continue + merged.append(piece) + return merged + + +def find_split(text: str) -> int | None: + """Pick the index at which to cut `text` in two, or None if it is a single word. + + Prefers the start of the word after a comma, semicolon or colon if it is within 25% of the length from the + middle; otherwise the word start nearest the middle. + """ + middle = len(text) / 2 + # \s+ = any whitespace run; match.end() is where the next word starts (interior only, not at either edge) + word_starts = [match.end() for match in re.finditer(r"\s+", text) if 0 < match.start() and match.end() < len(text)] + if not word_starts: + return None + # [,;:]\s+ = a clause mark followed by whitespace; match.end() is the start of the next clause + clause_starts = [match.end() for match in re.finditer(r"[,;:]\s+", text) if match.end() < len(text)] + if clause_starts: + best = min(clause_starts, key=lambda index: abs(index - middle)) + if abs(best - middle) <= len(text) * 0.25: + return best + return min(word_starts, key=lambda index: abs(index - middle)) + + +def split_piece(piece: Cue, args: argparse.Namespace) -> list[Cue]: + """Recursively split a piece until every part fits, dividing its time in proportion to character length.""" + if fits(text=piece.text, duration=piece.end - piece.start, args=args): + return [piece] + index = find_split(text=piece.text) + if index is None: + return [piece] + left, right = piece.text[:index].strip(), piece.text[index:].strip() + middle = piece.start + (piece.end - piece.start) * len(left) / (len(left) + len(right)) + return split_piece(piece=Cue(start=piece.start, end=middle, text=left), args=args) + split_piece( + piece=Cue(start=middle, end=piece.end, text=right), args=args + ) + + +def retime(pieces: list[Cue], args: argparse.Namespace) -> list[int]: + """Fix timing in place: remove overlaps, keep --min-gap, and extend a cue's end to meet --max-cps. + + An end is only extended into free time before the next cue and never beyond --max-duration. + Returns the 1-based numbers of cues still above --max-cps. + """ + over_budget = [] + for index, piece in enumerate(pieces): + if index and piece.start < pieces[index - 1].end: + piece.start = pieces[index - 1].end + limit = pieces[index + 1].start - args.min_gap if index + 1 < len(pieces) else float("inf") + wanted = piece.start + len(piece.text) / args.max_cps + ceiling = min(piece.start + args.max_duration, limit) + if wanted > piece.end: + piece.end = max(piece.end, min(wanted, ceiling)) + if piece.end > limit: + piece.end = max(limit, piece.start + MIN_CUE_DURATION) + if piece.end <= piece.start: + piece.end = piece.start + MIN_CUE_DURATION + if len(piece.text) / (piece.end - piece.start) > args.max_cps + 0.01: + over_budget.append(index + 1) + return over_budget + + +def rewrite(cues: list[Cue], args: argparse.Namespace) -> tuple[list[Cue], list[int]]: + """Run the full pipeline. Dialogue and non-speech cues act as barriers and pass through unchanged; + the speech between them is merged into sentences, short pieces are merged, long ones split, then retimed. + + Returns (pieces, numbers of cues still above --max-cps). + """ + pieces: list[Cue] = [] + run: list[Cue] = [] + + def flush() -> None: + if run: + pieces.extend( + part + for piece in merge_short(pieces=sentences_with_times(cues=run), args=args) + for part in split_piece(piece=piece, args=args) + ) + run.clear() + + for cue in cues: + if cue.dialogue or NONSPEECH_PATTERN.match(cue.text): + flush() + if cue.dialogue or not args.drop_nonspeech: + pieces.append(Cue(start=cue.start, end=cue.end, text=cue.text, dialogue=cue.dialogue)) + else: + run.append(cue) + flush() + return pieces, retime(pieces=pieces, args=args) + + +def build_srt(pieces: list[Cue], args: argparse.Namespace) -> str: + """Render the pieces as SRT, wrapping each to --max-line-length (dialogue cues one speaker per line).""" + blocks = [] + for index, piece in enumerate(pieces, start=1): + if piece.dialogue: + lines = wrap_dialogue(text=piece.text, width=args.max_line_length) + else: + lines = wrap_text(text=piece.text, width=args.max_line_length, max_lines=args.max_lines) or [piece.text] + blocks.append(f"{index}\n{format_timestamp(piece.start)} --> {format_timestamp(piece.end)}\n" + "\n".join(lines) + "\n") + return "\n".join(blocks) + + +def main() -> None: + """Read the SRT, rewrite it and write the result next to it, refusing to overwrite the input.""" + logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s: %(message)s") + args = parse_args() + if min(args.max_line_length, args.max_lines) < 1 or args.max_cps <= 0: + raise SystemExit("--max-line-length, --max-lines and --max-cps must be positive") + output = args.output or args.subtitle.with_name(f"{args.subtitle.stem}.rewritten.srt") + if output.resolve() == args.subtitle.resolve(): + raise SystemExit("Refusing to overwrite the input file") + + cues = parse_srt(content=args.subtitle.read_text(encoding="utf-8-sig")) + pieces, over_budget = rewrite(cues=cues, args=args) + output.write_text(build_srt(pieces=pieces, args=args), encoding="utf-8") + logger.info("Wrote %d cues (from %d) to %s", len(pieces), len(cues), output) + if over_budget: + logger.warning("%d cue(s) still above %.1f chars/s (text is not shortened): %s", len(over_budget), args.max_cps, over_budget[:20]) + + +if __name__ == "__main__": + main()