taters 0.1.0__tar.gz

taters-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ryan L. Boyd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

taters-0.1.0/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: taters
+Version: 0.1.0
+Summary: Analyze, process, and extract from many types of input data. Highly modular/customizable.
+Author-email: "Ryan L. Boyd" <ryan@ryanboyd.io>
+License: MIT
+Project-URL: Homepage, https://github.com/ryanboyd/taters
+Project-URL: Issues, https://github.com/ryanboyd/taters/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Multimedia :: Sound/Audio :: Analysis
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: faster-whisper>=1.1.0
+Requires-Dist: transformers>=4.38.0
+Requires-Dist: librosa>=0.10.1
+Requires-Dist: pydub>=0.25.1
+Requires-Dist: contentcoder
+Requires-Dist: archetyper
+Requires-Dist: nltk
+Requires-Dist: sentence-transformers
+Provides-Extra: diarization
+Requires-Dist: nemo-toolkit[asr]>=2.dev; extra == "diarization"
+Provides-Extra: cuda
+Requires-Dist: nvidia-cudnn-cu12; extra == "cuda"
+Dynamic: license-file
+
+# TATERS — Takes All Things, Extracts Relevant Stuff
+
+Taters is a broad-scope toolkit for researchers that can be used to extract features from multiple types of data (video, audio, text) into clean, analysis-ready artifacts and features. Think of it as a small, dependable kitchen crew for your data: you bring potatoes (files), it handles the peeling, chopping, and plating.
+
+**Status:** active WIP. It works today, but expect some rough edges and breaking changes as the project grows.
+
+---
+
+## What Taters is (and isn't)
+
+Taters is **a library and a CLI** for end-to-end A/V + text processing with predictable outputs. It's **not** a monolithic "black box" pipeline — each step is a clear, reusable function you can run on its own or string together with YAML presets.
+
+---
+
+## What you can do with it (high level)
+
+Note: everything below is currently implemented, but is highly subject to change as the project evolves.
+
+* **Pull audio from video**: extract one or more WAV streams from containers.
+* **Diarize + transcribe**: wrap a proven third-party stack to produce per-recording CSV/SRT/TXT.
+* **Per-speaker WAVs**: build one WAV per speaker from a transcript CSV.
+* **Embeddings**
+
+  * **Whisper encoder embeddings** (segment-level from a transcript or general audio without one).
+  * **Sentence embeddings** (mean per row) for any text dataset.
+* **Text gatherer**: stream CSVs or folders of `.txt` into a single “analysis-ready” CSV, with optional grouping.
+* **Feature extraction**
+
+  * **Dictionary coding** across any number of ContentCoder dictionaries → one wide CSV with stable column order.
+  * **Archetype scoring** with sentence-transformers → tidy, fixed columns.
+* **Predictable outputs**: if you don't specify a path, Taters writes to `./features/<kind>/<filename>.csv`, where `<filename>` reflects how the text was gathered (e.g., grouped vs. concatenated).
+
+---
+
+## How you'll use it
+
+### Python (quick sketch)
+
+```python
+from taters import Taters
+t = Taters()
+
+# 1) Audio from video
+wavs = t.audio.extract_wavs_from_video(input_path="input.mp4")
+
+# 2) Diarize (CSV/SRT/TXT)
+diar = t.audio.diarize_with_thirdparty(audio_path=wavs[0], device="cuda")
+
+# 3) Features (defaults write under ./features/<kind>/)
+t.audio.extract_whisper_embeddings(source_wav=wavs[0], transcript_csv=diar["csv"])
+t.text.analyze_with_dictionaries(csv_path=diar["csv"], dict_paths=["dicts/LIWC-22.dicx"])
+t.text.analyze_with_archetypes(csv_path=diar["csv"], archetype_csvs=["archetypes/Resilience.csv"])
+t.text.extract_sentence_embeddings(csv_path=diar["csv"], text_cols=["text"], id_cols=["speaker"], group_by=["speaker"])
+```
+
+### CLI (quick sketch)
+
+```bash
+# Diarize
+python -m taters.audio.diarize_with_thirdparty \
+  --audio_path audio/session.wav --device cuda
+
+# Whisper embeddings (general audio; non-silent spans + mean pool)
+python -m taters.audio.extract_whisper_embeddings \
+  --source_wav audio/session.wav --strategy nonsilent --aggregate mean
+
+# Gather text from CSV (auto names the output if --out omitted)
+python -m taters.helpers.text_gather \
+  --csv transcripts/session.csv --text-col text --group-by speaker --delimiter ,
+```
+
+### Pipelines (do it all at once)
+
+Presets live in YAML (e.g., `taters/pipelines/presets/`). Point at a folder, choose a preset, and Taters will run the steps in order—using each step's output as the next step's input. You can override variables (like models, device, overwrite behavior) on the command line.
+
+---
+
+## Install (tidy version)
+
+Use a fresh virtual environment. Seriously, a fresh virtual environment is strongly recommended.
+
+```bash
+python -m venv venv-taters
+source venv-taters/bin/activate
+```
+
+### Quick path (when available)
+
+```bash
+pip install "taters[diarization,cuda]"
+```
+
+Then install the three git extras used by the diarization wrapper:
+
+```bash
+pip install git+https://github.com/MahmoudAshraf97/demucs.git
+pip install git+https://github.com/oliverguhr/deepmultilingualpunctuation.git
+pip install git+https://github.com/MahmoudAshraf97/ctc-forced-aligner.git
+```
+
+Install PyTorch built for **CUDA 12.4** (the stack ChopShop targets):
+
+```bash
+pip install --force-reinstall --no-cache-dir \
+  torch==2.6.0 torchvision==0.21.0 torchaudio==2.6.0 \
+  --index-url https://download.pytorch.org/whl/cu124
+```
+
+And ensure **FFmpeg** is on your `PATH` (Ubuntu: `sudo apt-get install ffmpeg`, macOS: `brew install ffmpeg`).
+
+> Tip: If you hit CUDA/cuDNN loader errors, it usually means your runtime and wheel builds don't match. Keep CUDA **12.4**, `cu124` wheels, and cuDNN 9 aligned.
+
+---
+
+## Roadmap (short)
+
+* More feature families
+* More obviously composable pipelines (per-item + global phases, manifests, post-run aggregation).
+* Rich gatherers/aggregators to unify outputs across large runs.
+* Clear docs, examples, and ready-to-run presets.
+
+If you try Taters on a real project, feedback on your flow and pain points is incredibly helpful.
+
+---
+
+## License & credits
+
+MIT license. Built on top of excellent open-source projects (Faster-Whisper, sentence-transformers, ContentCoder, and an incredible [community diarization stack](https://github.com/MahmoudAshraf97/whisper-diarization).
+
+*(Taters grew out of the earlier "ChopShop" prototype; many ideas and defaults carry over.)*
+

taters-0.1.0/README.MD

@@ -0,0 +1,131 @@
+# TATERS — Takes All Things, Extracts Relevant Stuff
+
+Taters is a broad-scope toolkit for researchers that can be used to extract features from multiple types of data (video, audio, text) into clean, analysis-ready artifacts and features. Think of it as a small, dependable kitchen crew for your data: you bring potatoes (files), it handles the peeling, chopping, and plating.
+
+**Status:** active WIP. It works today, but expect some rough edges and breaking changes as the project grows.
+
+---
+
+## What Taters is (and isn't)
+
+Taters is **a library and a CLI** for end-to-end A/V + text processing with predictable outputs. It's **not** a monolithic "black box" pipeline — each step is a clear, reusable function you can run on its own or string together with YAML presets.
+
+---
+
+## What you can do with it (high level)
+
+Note: everything below is currently implemented, but is highly subject to change as the project evolves.
+
+* **Pull audio from video**: extract one or more WAV streams from containers.
+* **Diarize + transcribe**: wrap a proven third-party stack to produce per-recording CSV/SRT/TXT.
+* **Per-speaker WAVs**: build one WAV per speaker from a transcript CSV.
+* **Embeddings**
+
+  * **Whisper encoder embeddings** (segment-level from a transcript or general audio without one).
+  * **Sentence embeddings** (mean per row) for any text dataset.
+* **Text gatherer**: stream CSVs or folders of `.txt` into a single “analysis-ready” CSV, with optional grouping.
+* **Feature extraction**
+
+  * **Dictionary coding** across any number of ContentCoder dictionaries → one wide CSV with stable column order.
+  * **Archetype scoring** with sentence-transformers → tidy, fixed columns.
+* **Predictable outputs**: if you don't specify a path, Taters writes to `./features/<kind>/<filename>.csv`, where `<filename>` reflects how the text was gathered (e.g., grouped vs. concatenated).
+
+---
+
+## How you'll use it
+
+### Python (quick sketch)
+
+```python
+from taters import Taters
+t = Taters()
+
+# 1) Audio from video
+wavs = t.audio.extract_wavs_from_video(input_path="input.mp4")
+
+# 2) Diarize (CSV/SRT/TXT)
+diar = t.audio.diarize_with_thirdparty(audio_path=wavs[0], device="cuda")
+
+# 3) Features (defaults write under ./features/<kind>/)
+t.audio.extract_whisper_embeddings(source_wav=wavs[0], transcript_csv=diar["csv"])
+t.text.analyze_with_dictionaries(csv_path=diar["csv"], dict_paths=["dicts/LIWC-22.dicx"])
+t.text.analyze_with_archetypes(csv_path=diar["csv"], archetype_csvs=["archetypes/Resilience.csv"])
+t.text.extract_sentence_embeddings(csv_path=diar["csv"], text_cols=["text"], id_cols=["speaker"], group_by=["speaker"])
+```
+
+### CLI (quick sketch)
+
+```bash
+# Diarize
+python -m taters.audio.diarize_with_thirdparty \
+  --audio_path audio/session.wav --device cuda
+
+# Whisper embeddings (general audio; non-silent spans + mean pool)
+python -m taters.audio.extract_whisper_embeddings \
+  --source_wav audio/session.wav --strategy nonsilent --aggregate mean
+
+# Gather text from CSV (auto names the output if --out omitted)
+python -m taters.helpers.text_gather \
+  --csv transcripts/session.csv --text-col text --group-by speaker --delimiter ,
+```
+
+### Pipelines (do it all at once)
+
+Presets live in YAML (e.g., `taters/pipelines/presets/`). Point at a folder, choose a preset, and Taters will run the steps in order—using each step's output as the next step's input. You can override variables (like models, device, overwrite behavior) on the command line.
+
+---
+
+## Install (tidy version)
+
+Use a fresh virtual environment. Seriously, a fresh virtual environment is strongly recommended.
+
+```bash
+python -m venv venv-taters
+source venv-taters/bin/activate
+```
+
+### Quick path (when available)
+
+```bash
+pip install "taters[diarization,cuda]"
+```
+
+Then install the three git extras used by the diarization wrapper:
+
+```bash
+pip install git+https://github.com/MahmoudAshraf97/demucs.git
+pip install git+https://github.com/oliverguhr/deepmultilingualpunctuation.git
+pip install git+https://github.com/MahmoudAshraf97/ctc-forced-aligner.git
+```
+
+Install PyTorch built for **CUDA 12.4** (the stack ChopShop targets):
+
+```bash
+pip install --force-reinstall --no-cache-dir \
+  torch==2.6.0 torchvision==0.21.0 torchaudio==2.6.0 \
+  --index-url https://download.pytorch.org/whl/cu124
+```
+
+And ensure **FFmpeg** is on your `PATH` (Ubuntu: `sudo apt-get install ffmpeg`, macOS: `brew install ffmpeg`).
+
+> Tip: If you hit CUDA/cuDNN loader errors, it usually means your runtime and wheel builds don't match. Keep CUDA **12.4**, `cu124` wheels, and cuDNN 9 aligned.
+
+---
+
+## Roadmap (short)
+
+* More feature families
+* More obviously composable pipelines (per-item + global phases, manifests, post-run aggregation).
+* Rich gatherers/aggregators to unify outputs across large runs.
+* Clear docs, examples, and ready-to-run presets.
+
+If you try Taters on a real project, feedback on your flow and pain points is incredibly helpful.
+
+---
+
+## License & credits
+
+MIT license. Built on top of excellent open-source projects (Faster-Whisper, sentence-transformers, ContentCoder, and an incredible [community diarization stack](https://github.com/MahmoudAshraf97/whisper-diarization).
+
+*(Taters grew out of the earlier "ChopShop" prototype; many ideas and defaults carry over.)*
+

taters-0.1.0/pyproject.toml

@@ -0,0 +1,72 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "taters"
+version = "0.1.0"
+authors = [{ name = "Ryan L. Boyd", email = "ryan@ryanboyd.io" }]
+description = "Analyze, process, and extract from many types of input data. Highly modular/customizable."
+
+# Make sure the filename matches your repo exactly (case-sensitive on Linux)
+readme = { file = "README.MD", content-type = "text/markdown" }
+requires-python = ">=3.10"
+license = { text = "MIT" }
+
+dependencies = [
+  # Core, minimal runtime for splitting, per-speaker builds, and embeddings
+  "faster-whisper>=1.1.0",
+  "transformers>=4.38.0",   # for WhisperFeatureExtractor
+  "librosa>=0.10.1",
+  "pydub>=0.25.1",
+  "contentcoder",
+  "archetyper",
+  "nltk",
+  "sentence-transformers",
+  # NOTE TO SELF:
+  # Do NOT list torch/torchaudio here;
+  # users must install the right CUDA wheel themselves
+]
+
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Topic :: Multimedia :: Sound/Audio :: Analysis",
+  "Intended Audience :: Science/Research",
+]
+
+[project.urls]
+Homepage = "https://github.com/ryanboyd/taters"
+Issues   = "https://github.com/ryanboyd/taters/issues"
+
+[project.optional-dependencies]
+# Full diarization pipeline (large downloads)
+diarization = [
+  "nemo-toolkit[asr]>=2.dev",
+]
+# User-space cuDNN libs for CUDA 12 (handy on many systems)
+cuda = [
+  "nvidia-cudnn-cu12",
+]
+
+[tool.setuptools]
+# Map top-level packages to the 'src' directory
+package-dir = {"" = "src"}
+include-package-data = true
+zip-safe = false
+
+
+# find packages
+packages = { find = { where = ["src"], include = ["taters*"] } }
+
+
+[tool.setuptools.package-data]
+# Because I vendored the diarizer repo under taters/audio/diarizer/whisper-diarization/
+"taters.diarizer" = ["whisper-diarization/**"]
+"taters.pipeline.presets" = ["*.yaml"]
+
+[project.scripts]
+# Entry points must target a callable, not __main__
+# Ensure extract_whisper_embeddings.py defines a `main()` (or `cli()`) function.
+taters-embeddings = "taters.extract_whisper_embeddings:main"

taters-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

taters-0.1.0/src/taters/Taters.py

@@ -0,0 +1,115 @@
+# taters/Taters.py
+from __future__ import annotations
+from pathlib import Path
+from typing import Any
+import inspect
+
+def _abs(p: str | Path) -> str:
+    return str(Path(p).resolve())
+
+def _forward(func, kwargs: dict[str, Any]):
+    sig = inspect.signature(func)
+    try:
+        # validate names & requireds; don't execute defaults here
+        sig.bind_partial(**kwargs)
+    except TypeError as e:
+        allowed = ", ".join([str(p) for p in sig.parameters.values()])
+        raise TypeError(f"{func.__module__}.{func.__name__}: {e}\nAllowed params: {allowed}")
+    return func(**kwargs)
+
+
+class Taters:
+    def __init__(self):
+        self.audio = _AudioAPI(self)
+        self.text = _TextAPI(self)
+        self.helpers = _HelpersAPI(self)
+
+    # back-compat pass-throughs
+    
+    # audio
+    def convert_to_wav(self, **kwargs):                         return self.audio.convert_to_wav(**kwargs)
+    def extract_wavs_from_video(self, **kwargs):                return self.audio.extract_wavs_from_video(**kwargs)
+    def split_wav_by_speaker(self, **kwargs):                   return self.audio.split_wav_by_speaker(**kwargs)
+    def extract_whisper_embeddings(self, **kwargs):             return self.audio.extract_whisper_embeddings(**kwargs)
+    def diarize_with_thirdparty(self, **kwargs):                return self.audio.diarize_with_thirdparty(**kwargs)
+    
+    #text
+    def analyze_with_dictionaries(self, **kwargs):              return self.text.analyze_with_dictionaries(**kwargs)
+    def analyze_with_archetypes(self, **kwargs):                return self.text.analyze_with_archetypes(**kwargs)
+    def extract_sentence_embeddings(self, **kwargs):            return self.text.extract_sentence_embeddings(**kwargs)
+    
+    # helpers
+    def txt_folder_to_analysis_ready_csv(self, **kwargs):       return self.helpers.txt_folder_to_analysis_ready_csv(**kwargs)
+    def csv_to_analysis_ready_csv(self, **kwargs):              return self.helpers.csv_to_analysis_ready_csv(**kwargs)
+    def find_files(self, **kwargs):                             return self.helpers.find_files(**kwargs)
+    def feature_gather(self, **kwargs):                         return self.helpers.feature_gather(**kwargs)
+    
+
+    def txt_folder_to_analysis_ready_csv(self, **kwargs):
+        from .helpers.text_gather import txt_folder_to_analysis_ready_csv
+        return _forward(txt_folder_to_analysis_ready_csv, kwargs)
+    
+    def csv_to_analysis_ready_csv(self, **kwargs):
+        from .helpers.text_gather import csv_to_analysis_ready_csv
+        return _forward(csv_to_analysis_ready_csv, kwargs)
+
+
+class _AudioAPI:
+    def __init__(self, parent: Taters): self._cs = parent
+
+    def convert_to_wav(self, **kwargs):
+        from .audio.convert_to_wav import convert_audio_to_wav
+        return _forward(convert_audio_to_wav, kwargs)
+
+    def extract_wavs_from_video(self, **kwargs):
+        from .audio.extract_wav_from_video import split_audio_streams_to_wav
+        return _forward(split_audio_streams_to_wav, kwargs)
+
+    def split_wav_by_speaker(self, **kwargs):
+        from .audio.split_wav_by_speaker import make_speaker_wavs_from_csv
+        return _forward(make_speaker_wavs_from_csv, kwargs)
+
+    def extract_whisper_embeddings(self, **kwargs):
+        from .audio.extract_whisper_embeddings import extract_whisper_embeddings
+        return _forward(extract_whisper_embeddings, kwargs)
+
+    def diarize_with_thirdparty(self, **kwargs):
+        from .audio.diarizer.whisper_diar_wrapper import run_whisper_diarization_repo
+        return _forward(run_whisper_diarization_repo, kwargs)
+
+
+class _TextAPI:
+    def __init__(self, parent: Taters): self._cs = parent
+
+    def analyze_with_dictionaries(self, **kwargs):
+        from .text.analyze_with_dictionaries import analyze_with_dictionaries
+        return _forward(analyze_with_dictionaries, kwargs)
+    
+    def analyze_with_archetypes(self, **kwargs):
+        from .text.analyze_with_archetypes import analyze_with_archetypes
+        return _forward(analyze_with_archetypes, kwargs)
+    
+    def extract_sentence_embeddings(self, **kwargs):
+        from .text.extract_sentence_embeddings import analyze_with_sentence_embeddings
+        return _forward(analyze_with_sentence_embeddings, kwargs)
+
+
+class _HelpersAPI:
+    def __init__(self, parent: Taters): self._cs = parent
+    
+    def txt_folder_to_analysis_ready_csv(self, **kwargs):
+        from .helpers.text_gather import txt_folder_to_analysis_ready_csv
+        return _forward(txt_folder_to_analysis_ready_csv, kwargs)
+    
+    def csv_to_analysis_ready_csv(self, **kwargs):
+        from .helpers.text_gather import csv_to_analysis_ready_csv
+        return _forward(csv_to_analysis_ready_csv, kwargs)
+    
+    def find_files(self, **kwargs):
+        from .helpers.find_files import find_files
+        return _forward(find_files, kwargs)
+    
+    def feature_gather(self, **kwargs):
+        from .helpers import feature_gather
+        return _forward(feature_gather, kwargs)
+    

taters-0.1.0/src/taters/audio/convert_to_wav.py

@@ -0,0 +1,112 @@
+# taters/audio/convert_to_wav.py
+from __future__ import annotations
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Optional, Union
+
+class FFmpegNotFoundError(RuntimeError):
+    pass
+
+def _check_ffmpeg():
+    if shutil.which("ffmpeg") is None or shutil.which("ffprobe") is None:
+        raise FFmpegNotFoundError("ffmpeg and/or ffprobe not found on PATH.")
+
+def convert_audio_to_wav(
+    input_path: Union[str, Path],
+    *,
+    output_path: Optional[Union[str, Path]] = None,
+    output_dir: Optional[Union[str, Path]] = None,
+    sample_rate: int = 16000,          # common for ASR
+    bit_depth: int = 16,               # 16/24/32 signed PCM
+    channels: int = 1,                 # 1=mono, 2=stereo
+    overwrite_existing: bool = False,  # if the file already exists, let's not overwrite by default
+) -> Path:
+    """
+    Convert any audio (or A/V container) to a PCM WAV file using ffmpeg.
+
+    If output_path is None and output_dir is None, writes <input_stem>.wav next to input.
+    If output_dir is given (and output_path is None), writes <output_dir>/<input_stem>.wav.
+    If output_path is given, it takes precedence.
+
+    Returns the Path to the created WAV.
+    """
+    _check_ffmpeg()
+
+    in_path = Path(input_path).resolve()
+    if not in_path.exists():
+        raise FileNotFoundError(f"Input file not found: {in_path}")
+
+    if output_path and output_dir:
+        raise ValueError("Provide at most one of output_path or output_dir.")
+
+    if output_path:
+        out_path = Path(output_path).resolve()
+    else:
+        base = in_path.stem + ".wav"
+        out_dir = Path(output_dir).resolve() if output_dir else Path.cwd() / "audio"
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / base
+
+    if not overwrite_existing and Path(out_path).is_file():
+        print("WAV file already exists; returning existing file.")
+        return out_path
+
+    pcm_map = {16: "pcm_s16le", 24: "pcm_s24le", 32: "pcm_s32le"}
+    if bit_depth not in pcm_map:
+        raise ValueError("bit_depth must be one of {16, 24, 32}.")
+    if channels not in (1, 2):
+        raise ValueError("channels must be 1 (mono) or 2 (stereo).")
+
+    cmd = [
+        "ffmpeg",
+        "-nostdin",
+        "-hide_banner", "-loglevel", "error",
+        "-y" if overwrite_existing else "-n",
+        "-i", str(in_path),
+        "-vn",                        # ignore video
+        "-acodec", pcm_map[bit_depth],
+        "-ar", str(sample_rate),
+        "-ac", str(channels),
+        str(out_path),
+    ]
+
+    result = subprocess.run(cmd, capture_output=True, text=True, stdin=subprocess.DEVNULL)
+    if result.returncode != 0:
+        if not overwrite_existing and out_path.exists():
+            raise FileExistsError(f"Target exists (use overwrite=True): {out_path}")
+        raise RuntimeError(f"ffmpeg failed: {result.stderr.strip()}")
+
+    return out_path
+
+
+# --- CLI --------------------------------------------------------------------
+def _build_arg_parser():
+    import argparse
+    p = argparse.ArgumentParser(description="Convert any audio (or A/V) file to PCM WAV via ffmpeg.")
+    p.add_argument("input", help="Input file (audio or video container)")
+    p.add_argument("--out", dest="output_path", default=None,
+                   help="Exact output .wav path (overrides --out-dir)")
+    p.add_argument("--out-dir", dest="output_dir", default=None,
+                   help="Directory for output (filename will be <input_stem>.wav)")
+    p.add_argument("--sr", dest="sample_rate", type=int, default=16000, help="Sample rate (Hz)")
+    p.add_argument("--bit-depth", type=int, choices=[16, 24, 32], default=16, help="PCM bit depth")
+    p.add_argument("--channels", type=int, choices=[1, 2], default=1, help="1=mono, 2=stereo")
+    p.add_argument("--overwrite_existing", type=bool, default=False, help="Overwrite existing output")
+    return p
+
+def main():
+    args = _build_arg_parser().parse_args()
+    out = convert_audio_to_wav(
+        args.input,
+        output_path=args.output_path,
+        output_dir=args.output_dir,
+        sample_rate=args.sample_rate,
+        bit_depth=args.bit_depth,
+        channels=args.channels,
+        overwrite_existing=args.overwrite_existing,
+    )
+    print(str(out))
+
+if __name__ == "__main__":
+    main()

taters-0.1.0/src/taters/audio/diarize_with_thirdparty.py

@@ -0,0 +1,5 @@
+# thin alias (args still pass through)
+from .diarizer.whisper_diar_wrapper import main as main
+
+if __name__ == "__main__":
+    main()

taters-0.1.0/src/taters/audio/diarizer/whisper-diarization/diarization/__init__.py

@@ -0,0 +1,3 @@
+from .msdd.msdd import MSDDDiarizer
+
+__all__ = ["MSDDDiarizer"]