| """Typed configuration loading for video_vec2wav2_tokenizer. |
| |
| The configuration is a plain dataclass so it is easy to construct in tests and |
| serialize. ``load_config`` merges, in order of increasing priority: |
| |
| 1. the packaged ``configs/default.yaml`` |
| 2. an optional user supplied YAML file |
| 3. explicit keyword overrides (typically parsed from CLI flags) |
| """ |
|
|
| from __future__ import annotations |
|
|
| import dataclasses |
| from dataclasses import dataclass, field, fields |
| from pathlib import Path |
| from typing import Any, Optional |
|
|
| import yaml |
|
|
| _PACKAGE_DEFAULT = Path(__file__).resolve().parent.parent / "configs" / "default.yaml" |
|
|
|
|
| @dataclass(slots=True) |
| class Config: |
| """Strongly-typed pipeline configuration.""" |
|
|
| |
| model_name: str = "facebook/wav2vec2-base-960h" |
| whisper_model: str = "large-v3" |
|
|
| |
| language: Optional[str] = None |
| device: str = "auto" |
| compute_type: str = "auto" |
| beam_size: int = 5 |
| vad_filter: bool = True |
|
|
| |
| sample_rate: int = 16000 |
| channels: int = 1 |
| audio_format: str = "wav" |
|
|
| |
| min_segment_length: float = 1.0 |
| max_segment_length: float = 20.0 |
| segment_padding: float = 0.0 |
|
|
| |
| default_speaker: str = "speaker_001" |
| speaker_mode: str = "fixed" |
|
|
| |
| input_dir: str = "input/videos" |
| output_dir: str = "dataset" |
| features_dir: str = "features" |
|
|
| |
| num_workers: int = 4 |
| batch_size: int = 16 |
| log_level: str = "INFO" |
|
|
| |
| @property |
| def audio_dir(self) -> Path: |
| """Directory holding the segmented audio clips.""" |
| return Path(self.output_dir) / "audio" |
|
|
| @property |
| def metadata_csv(self) -> Path: |
| return Path(self.output_dir) / "metadata.csv" |
|
|
| @property |
| def dataset_jsonl(self) -> Path: |
| return Path(self.output_dir) / "dataset.jsonl" |
|
|
| @property |
| def tts_metadata_csv(self) -> Path: |
| return Path(self.output_dir) / "tts_metadata.csv" |
|
|
| @property |
| def report_json(self) -> Path: |
| return Path(self.output_dir) / "report.json" |
|
|
| def to_dict(self) -> dict[str, Any]: |
| return dataclasses.asdict(self) |
|
|
| def validate(self) -> None: |
| """Raise ``ValueError`` if the configuration is internally inconsistent.""" |
| if self.sample_rate <= 0: |
| raise ValueError("sample_rate must be positive") |
| if self.channels not in (1, 2): |
| raise ValueError("channels must be 1 or 2") |
| if self.min_segment_length < 0: |
| raise ValueError("min_segment_length must be >= 0") |
| if self.max_segment_length <= self.min_segment_length: |
| raise ValueError("max_segment_length must exceed min_segment_length") |
| if self.device not in ("auto", "cpu", "cuda"): |
| raise ValueError("device must be one of auto|cpu|cuda") |
| if self.speaker_mode not in ("fixed", "per_video", "per_file"): |
| raise ValueError("speaker_mode must be one of fixed|per_video|per_file") |
| if self.num_workers < 1: |
| raise ValueError("num_workers must be >= 1") |
|
|
|
|
| def _read_yaml(path: Path) -> dict[str, Any]: |
| with path.open("r", encoding="utf-8") as fh: |
| data = yaml.safe_load(fh) or {} |
| if not isinstance(data, dict): |
| raise ValueError(f"Config file {path} must contain a mapping at the top level") |
| return data |
|
|
|
|
| def _filter_known(data: dict[str, Any]) -> dict[str, Any]: |
| known = {f.name for f in fields(Config)} |
| unknown = set(data) - known |
| if unknown: |
| |
| import warnings |
|
|
| warnings.warn(f"Ignoring unknown config keys: {sorted(unknown)}", stacklevel=2) |
| return {k: v for k, v in data.items() if k in known} |
|
|
|
|
| def load_config( |
| path: Optional[str | Path] = None, |
| *, |
| overrides: Optional[dict[str, Any]] = None, |
| ) -> Config: |
| """Load configuration merging defaults, an optional file, and overrides. |
| |
| Args: |
| path: Optional path to a user YAML config. |
| overrides: Mapping of explicit overrides (``None`` values are ignored so |
| unset CLI flags do not clobber file values). |
| """ |
| merged: dict[str, Any] = {} |
|
|
| if _PACKAGE_DEFAULT.exists(): |
| merged.update(_filter_known(_read_yaml(_PACKAGE_DEFAULT))) |
|
|
| if path is not None: |
| p = Path(path) |
| if not p.exists(): |
| raise FileNotFoundError(f"Config file not found: {p}") |
| merged.update(_filter_known(_read_yaml(p))) |
|
|
| if overrides: |
| merged.update(_filter_known({k: v for k, v in overrides.items() if v is not None})) |
|
|
| cfg = Config(**merged) |
| cfg.validate() |
| return cfg |
|
|
