"""Compute summary statistics for the raw and segmented subsets. Usage: python -m scripts.dataset_summary python -m scripts.dataset_summary --json python -m scripts.dataset_summary --char-mode nowhitespace python -m scripts.dataset_summary --no-progress """ from __future__ import annotations import argparse import csv import json import re import sys from array import array from pathlib import Path REPO_ROOT = Path(__file__).resolve().parent.parent CHAR_MODES = ("raw", "strip", "nowhitespace") WS_RE = re.compile(r"\s+") def _increase_csv_field_limit() -> None: """Raise CSV field size limit to handle long transcripts safely.""" max_int = sys.maxsize while True: try: csv.field_size_limit(max_int) return except OverflowError: max_int = int(max_int / 10) def _count_chars(text: str, mode: str) -> int: if mode == "raw": return len(text) if mode == "strip": return len(text.strip()) if mode == "nowhitespace": return len(WS_RE.sub("", text)) raise ValueError(f"Unsupported char mode: {mode}") def _median(values: array, numpy) -> float | None: if not values: return None if numpy is not None: if values.typecode in ("d", "f"): dtype = numpy.float64 else: dtype = numpy.uint64 arr = numpy.frombuffer(values, dtype=dtype) return float(numpy.median(arr)) values_list = list(values) values_list.sort() mid = len(values_list) // 2 if len(values_list) % 2 == 1: return float(values_list[mid]) return float((values_list[mid - 1] + values_list[mid]) / 2) def compute_raw(raw_metadata: Path, char_mode: str, numpy, progress=None, task_id=None): durations = array("d") char_counts = array("Q") total_duration = 0.0 total_chars = 0 row_count = 0 missing_duration = 0 missing_text = 0 _increase_csv_field_limit() with raw_metadata.open("r", encoding="utf-8", newline="") as f: reader = csv.DictReader(f) for row in reader: row_count += 1 if progress is not None and task_id is not None and row_count % 500 == 0: progress.update(task_id, completed=row_count) duration_raw = (row.get("duration_seconds") or "").strip() if duration_raw: try: duration = float(duration_raw) except ValueError: duration = None if duration is not None: durations.append(duration) total_duration += duration else: missing_duration += 1 else: missing_duration += 1 transcription = row.get("transcription") if transcription is None: missing_text += 1 continue char_count = _count_chars(transcription, char_mode) char_counts.append(char_count) total_chars += char_count if progress is not None and task_id is not None: progress.update(task_id, completed=row_count) duration_count = len(durations) char_count_n = len(char_counts) avg_duration = (total_duration / duration_count) if duration_count else None avg_chars = (total_chars / char_count_n) if char_count_n else None return { "files": row_count, "total_duration_seconds": total_duration, "avg_duration_seconds": avg_duration, "median_duration_seconds": _median(durations, numpy), "total_subtitle_chars": total_chars, "avg_subtitle_chars": avg_chars, "median_subtitle_chars": _median(char_counts, numpy), "missing_duration_rows": missing_duration, "missing_transcription_rows": missing_text, } def compute_segmented(segmented_dir: Path, char_mode: str, numpy, batch_size: int, progress=None, task_id=None): try: import pyarrow.dataset as ds except ImportError as exc: raise RuntimeError( "pyarrow is required to read segmented parquet shards. " "Install with: pip install pyarrow (or uv sync --extra hf)." ) from exc durations = array("d") char_counts = array("Q") total_duration = 0.0 total_chars = 0 row_count = 0 missing_duration = 0 missing_text = 0 dataset = ds.dataset(segmented_dir, format="parquet") scanner = dataset.scanner(columns=["duration", "text"], batch_size=batch_size) for batch in scanner.to_batches(): row_count += batch.num_rows if progress is not None and task_id is not None: progress.update(task_id, completed=row_count) duration_arr = batch.column(0) if duration_arr.null_count: for value in duration_arr.to_pylist(): if value is None: missing_duration += 1 continue durations.append(float(value)) total_duration += float(value) else: if numpy is not None: values = duration_arr.to_numpy(zero_copy_only=False) durations.extend(values) total_duration += float(values.sum()) else: for value in duration_arr.to_pylist(): durations.append(float(value)) total_duration += float(value) text_arr = batch.column(1) if text_arr.null_count: for value in text_arr.to_pylist(): if value is None: missing_text += 1 continue char_count = _count_chars(value, char_mode) char_counts.append(char_count) total_chars += char_count else: for value in text_arr.to_pylist(): char_count = _count_chars(value, char_mode) char_counts.append(char_count) total_chars += char_count duration_count = len(durations) char_count_n = len(char_counts) avg_duration = (total_duration / duration_count) if duration_count else None avg_chars = (total_chars / char_count_n) if char_count_n else None return { "segments": row_count, "total_duration_seconds": total_duration, "avg_duration_seconds": avg_duration, "median_duration_seconds": _median(durations, numpy), "total_subtitle_chars": total_chars, "avg_subtitle_chars": avg_chars, "median_subtitle_chars": _median(char_counts, numpy), "missing_duration_rows": missing_duration, "missing_text_rows": missing_text, } def _format_seconds(seconds: float | None) -> str: if seconds is None: return "n/a" hours = seconds / 3600 return f"{seconds:.2f} ({hours:.2f} hours)" def _format_number(value: float | int | None) -> str: if value is None: return "n/a" if isinstance(value, float): return f"{value:.2f}" return str(value) def main() -> int: parser = argparse.ArgumentParser(description="Compute dataset summary statistics") parser.add_argument( "--raw-metadata", type=Path, default=REPO_ROOT / "raw" / "metadata.csv", help="Path to raw metadata.csv (default: %(default)s)", ) parser.add_argument( "--segmented-dir", type=Path, default=REPO_ROOT / "segmented", help="Directory with segmented parquet shards (default: %(default)s)", ) parser.add_argument( "--char-mode", choices=CHAR_MODES, default="nowhitespace", help="How to count subtitle characters: raw, strip, or nowhitespace (default: %(default)s)", ) parser.add_argument( "--batch-size", type=int, default=10000, help="Batch size when scanning segmented parquet shards (default: %(default)s)", ) parser.add_argument( "--json", action="store_true", help="Print machine-readable JSON only", ) parser.add_argument( "--no-progress", action="store_true", help="Disable rich progress output", ) args = parser.parse_args() try: import numpy as np # pyarrow depends on numpy, but keep optional except ImportError: np = None if not args.raw_metadata.exists(): print(f"Missing raw metadata: {args.raw_metadata}", file=sys.stderr) return 2 if not args.segmented_dir.exists(): print(f"Missing segmented directory: {args.segmented_dir}", file=sys.stderr) return 2 show_progress = (not args.json) and (not args.no_progress) progress = None raw_stats = None segmented_stats = None if show_progress: from rich.progress import Progress, SpinnerColumn, TextColumn, TimeElapsedColumn progress = Progress( SpinnerColumn(), TextColumn("[bold blue]{task.description}"), TextColumn("{task.completed} rows"), TimeElapsedColumn(), ) with progress: raw_task = progress.add_task("Raw subset", total=None) raw_stats = compute_raw(args.raw_metadata, args.char_mode, np, progress=progress, task_id=raw_task) seg_task = progress.add_task("Segmented subset", total=None) try: segmented_stats = compute_segmented( args.segmented_dir, args.char_mode, np, args.batch_size, progress=progress, task_id=seg_task, ) except RuntimeError as exc: progress.stop() print(str(exc), file=sys.stderr) return 2 else: raw_stats = compute_raw(args.raw_metadata, args.char_mode, np) try: segmented_stats = compute_segmented(args.segmented_dir, args.char_mode, np, args.batch_size) except RuntimeError as exc: print(str(exc), file=sys.stderr) return 2 payload = { "char_mode": args.char_mode, "raw": raw_stats, "segmented": segmented_stats, } if args.json: print(json.dumps(payload, ensure_ascii=False, indent=2)) return 0 print(f"Dataset summary (char_mode={args.char_mode})") print("") print("Raw subset") print(f"- files: {raw_stats['files']}") print(f"- total_duration_seconds: {_format_seconds(raw_stats['total_duration_seconds'])}") print(f"- avg_duration_seconds: {_format_number(raw_stats['avg_duration_seconds'])}") print(f"- median_duration_seconds: {_format_number(raw_stats['median_duration_seconds'])}") print(f"- total_subtitle_chars: {_format_number(raw_stats['total_subtitle_chars'])}") print(f"- avg_subtitle_chars: {_format_number(raw_stats['avg_subtitle_chars'])}") print(f"- median_subtitle_chars: {_format_number(raw_stats['median_subtitle_chars'])}") if raw_stats["missing_duration_rows"] or raw_stats["missing_transcription_rows"]: print(f"- missing_duration_rows: {raw_stats['missing_duration_rows']}") print(f"- missing_transcription_rows: {raw_stats['missing_transcription_rows']}") print("") print("Segmented subset") print(f"- segments: {segmented_stats['segments']}") print(f"- total_duration_seconds: {_format_seconds(segmented_stats['total_duration_seconds'])}") print(f"- avg_duration_seconds: {_format_number(segmented_stats['avg_duration_seconds'])}") print(f"- median_duration_seconds: {_format_number(segmented_stats['median_duration_seconds'])}") print(f"- total_subtitle_chars: {_format_number(segmented_stats['total_subtitle_chars'])}") print(f"- avg_subtitle_chars: {_format_number(segmented_stats['avg_subtitle_chars'])}") print(f"- median_subtitle_chars: {_format_number(segmented_stats['median_subtitle_chars'])}") if segmented_stats["missing_duration_rows"] or segmented_stats["missing_text_rows"]: print(f"- missing_duration_rows: {segmented_stats['missing_duration_rows']}") print(f"- missing_text_rows: {segmented_stats['missing_text_rows']}") return 0 if __name__ == "__main__": raise SystemExit(main())