| """Core data models and IO helpers shared across the pipeline.""" |
|
|
| from __future__ import annotations |
|
|
| import json |
| from dataclasses import dataclass, field, asdict |
| from pathlib import Path |
| from typing import Any, Iterable, Iterator, Optional |
|
|
| VIDEO_EXTENSIONS: frozenset[str] = frozenset( |
| {".mp4", ".mkv", ".avi", ".mov", ".webm"} |
| ) |
|
|
|
|
| @dataclass(slots=True) |
| class Segment: |
| """A single transcribed time span. |
| |
| Serializes to the spec's shape: ``{"start": .., "end": .., "text": ..}``. |
| """ |
|
|
| start: float |
| end: float |
| text: str |
|
|
| @property |
| def duration(self) -> float: |
| return max(0.0, self.end - self.start) |
|
|
| def to_dict(self) -> dict[str, Any]: |
| return {"start": round(self.start, 3), "end": round(self.end, 3), "text": self.text} |
|
|
| @classmethod |
| def from_dict(cls, data: dict[str, Any]) -> "Segment": |
| return cls( |
| start=float(data["start"]), |
| end=float(data["end"]), |
| text=str(data["text"]).strip(), |
| ) |
|
|
|
|
| @dataclass(slots=True) |
| class DatasetEntry: |
| """A finalized dataset row pointing at a clipped audio file.""" |
|
|
| audio: str |
| text: str |
| duration: float |
| speaker: Optional[str] = None |
| language: Optional[str] = None |
| source_video: Optional[str] = None |
|
|
| def to_jsonl_dict(self) -> dict[str, Any]: |
| """Match the spec: audio/text/duration (extra keys retained if present).""" |
| row: dict[str, Any] = { |
| "audio": self.audio, |
| "text": self.text, |
| "duration": round(self.duration, 3), |
| } |
| if self.speaker is not None: |
| row["speaker"] = self.speaker |
| if self.language is not None: |
| row["language"] = self.language |
| return row |
|
|
| @classmethod |
| def from_dict(cls, data: dict[str, Any]) -> "DatasetEntry": |
| return cls( |
| audio=str(data["audio"]), |
| text=str(data["text"]), |
| duration=float(data["duration"]), |
| speaker=data.get("speaker"), |
| language=data.get("language"), |
| source_video=data.get("source_video"), |
| ) |
|
|
|
|
| def ensure_dir(path: str | Path) -> Path: |
| """Create ``path`` (and parents) if needed and return it as ``Path``.""" |
| p = Path(path) |
| p.mkdir(parents=True, exist_ok=True) |
| return p |
|
|
|
|
| def iter_video_files(root: str | Path) -> Iterator[Path]: |
| """Recursively yield supported video files under ``root`` (sorted, stable).""" |
| root_path = Path(root) |
| if not root_path.exists(): |
| raise FileNotFoundError(f"Video directory not found: {root_path}") |
| for path in sorted(root_path.rglob("*")): |
| if path.is_file() and path.suffix.lower() in VIDEO_EXTENSIONS: |
| yield path |
|
|
|
|
| def write_jsonl(path: str | Path, rows: Iterable[dict[str, Any]]) -> int: |
| """Stream ``rows`` to a JSONL file. Returns the number of rows written.""" |
| ensure_dir(Path(path).parent) |
| count = 0 |
| with Path(path).open("w", encoding="utf-8") as fh: |
| for row in rows: |
| fh.write(json.dumps(row, ensure_ascii=False)) |
| fh.write("\n") |
| count += 1 |
| return count |
|
|
|
|
| def read_jsonl(path: str | Path) -> Iterator[dict[str, Any]]: |
| """Lazily read a JSONL file, yielding one dict per non-empty line.""" |
| with Path(path).open("r", encoding="utf-8") as fh: |
| for line in fh: |
| line = line.strip() |
| if line: |
| yield json.loads(line) |
|
|
|
|
| def clip_index_name(index: int, *, width: int = 6, ext: str = "wav") -> str: |
| """Return a zero-padded clip filename, e.g. ``000001.wav``.""" |
| return f"{index:0{width}d}.{ext}" |
|
|
