dinscribe 0.1.0__tar.gz

dinscribe-0.1.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: dinscribe
+Version: 0.1.0
+Summary: Audio denoising and transcription pipeline using Demucs, Silero VAD, and Whisper
+Requires-Python: >=3.10
+Requires-Dist: demucs>=4.0.0
+Requires-Dist: torchcodec
+Requires-Dist: torch
+Requires-Dist: pydub
+Requires-Dist: packaging
+Requires-Dist: openai-whisper
+Requires-Dist: pyyaml

dinscribe-0.1.0/README.md

@@ -0,0 +1,44 @@
+## dinscribe audio transcription
+Processes audio through a three-step pipeline to produce a transcription JSON: denoise, voice activity detection, transcribe.
+
+### Setup
+```bash
+python -m venv venv
+source venv/Scripts/activate
+pip install -r requirements.txt
+```
+
+
+### Run the full pipeline
+```bash
+python main.py input/audio.mp3          # Run for a single file
+python main.py input/                   # Run for all audio files in a folder
+python main.py input/audio.mp3 -f       # Force re-run all steps
+```
+Each step checks whether its output already exists and skips it if so. Use `-f` to force all steps to re-run regardless, `-o <output_dir>` to specify a different output directory, and `-c <config.yaml>` to specify a different config file.
+
+Output is written to `output/<filename>/` and contains:
+- `<filename>_denoised.wav` (vocals isolated from background noise)
+- `<filename>_vad.json` (detected speech segment boundaries)
+- `<filename>_transcription.json` (final transcription with timestamps)
+
+
+### Configuration
+Edit `config.yaml` to adjust settings for each step. Some important options are:
+- `denoise.model` - Demucs model for vocal isolation (default: `htdemucs`)
+- `vad.threshold` - VAD speech detection sensitivity (default: `0.5`)
+- `transcribe.model` - Whisper model size `tiny` through `large` (default: `base`)
+- `transcribe.language` - Transcription language code (default: `en`)
+
+
+#### Other tips for best results
+Add domain-specific vocabulary to `vocab.txt` to improve transcription accuracy on unusual words and jargon. For noisy or technical audio, set `temperature: 0` to disable attempts to fallback to higher-temperature decoding, and consider filtering out any common hallucinations specific to your dataset.
+
+
+### Run individual steps
+Each step can also be run alone:
+```bash
+python denoise.py audio.mp3
+python vad.py audio_denoised.wav
+python transcribe.py audio_denoised.wav audio_vad.json
+```

dinscribe-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dinscribe"
+version = "0.1.0"
+description = "Audio denoising and transcription pipeline using Demucs, Silero VAD, and Whisper"
+requires-python = ">=3.10"
+dependencies = [
+    "demucs>=4.0.0",
+    "torchcodec",
+    "torch",
+    "pydub",
+    "packaging",
+    "openai-whisper",
+    "pyyaml",
+]
+
+[project.scripts]
+dinscribe = "dinscribe.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+dinscribe = ["config.yaml", "vocab.txt"]

dinscribe-0.1.0/setup.cfg

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

dinscribe-0.1.0/src/dinscribe/__init__.py

@@ -0,0 +1,4 @@
+from . import denoise, vad, transcribe
+from .pipeline import process_file
+
+__all__ = ["denoise", "vad", "transcribe", "process_file"]

dinscribe-0.1.0/src/dinscribe/cli.py

@@ -0,0 +1,82 @@
+"""
+CLI entry point for dinscribe.
+"""
+
+import argparse
+import sys
+import time
+from pathlib import Path
+from .utils import AUDIO_EXTENSIONS, load_config, fmt_time, warn_if_no_cuda, setup_user_config, get_config_dir
+from .pipeline import process_file
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Process audio files into transcriptions"
+    )
+    parser.add_argument("input")
+    parser.add_argument("-o", "--output", default="output")
+    parser.add_argument("-c", "--config", default=None,
+                        help="Path to config.yaml (default: user config dir)")
+    parser.add_argument("-f", "--force", action="store_true")
+    args = parser.parse_args()
+
+    config_dir = setup_user_config()
+    config_path = args.config or str(config_dir / "config.yaml")
+    config = load_config(config_path)
+
+    # Point vocab_file default at the user config dir if not set in config
+    transcribe_cfg = config.setdefault("transcribe", {})
+    if not transcribe_cfg.get("vocab_file"):
+        vocab_path = config_dir / "vocab.txt"
+        if vocab_path.exists():
+            transcribe_cfg["vocab_file"] = str(vocab_path)
+    input_path = Path(args.input)
+    output_dir = Path(args.output)
+
+    if input_path.is_file():
+        if input_path.suffix.lower() not in AUDIO_EXTENSIONS:
+            print(f"Unrecognised audio extension: {input_path.suffix}")
+            sys.exit(1)
+        files = [input_path]
+    elif input_path.is_dir():
+        files = sorted(
+            f for f in input_path.iterdir()
+            if f.is_file() and f.suffix.lower() in AUDIO_EXTENSIONS
+        )
+        if not files:
+            print(f"No audio files found in {input_path}/")
+            sys.exit(1)
+    else:
+        print(f"Not found: {input_path}")
+        sys.exit(1)
+
+    print(f"Files to process: {len(files)}")
+    print(f"Output directory: {output_dir}/")
+    warn_if_no_cuda()
+
+    success = 0
+    batch_start = time.monotonic()
+
+    for i, audio_file in enumerate(files, 1):
+        if len(files) > 1:
+            print(f"\n{'═' * 60}")
+            print(f"  File {i}/{len(files)}: {audio_file.name}")
+
+        if process_file(audio_file, output_dir, config, force=args.force):
+            success += 1
+
+    failed = len(files) - success
+
+    if len(files) > 1:
+        print(f"\n{'─' * 60}")
+        print(f"  Batch complete: {success} succeeded, {failed} failed")
+        print(f"  Total time: {fmt_time(time.monotonic() - batch_start)}")
+        print(f"\n{'─' * 60}")
+
+    if failed:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

dinscribe-0.1.0/src/dinscribe/config.yaml

@@ -0,0 +1,67 @@
+denoise:
+  # Demucs model used for vocal isolation.
+  # Options: htdemucs, htdemucs_ft, mdx, mdx_extra, htdemucs_6s
+  # See: https://github.com/facebookresearch/demucs
+  model: htdemucs
+
+vad:
+  # Detection sensitivity (0.0–1.0). Higher values require clearer speech to trigger.
+  # See: https://github.com/snakers4/silero-vad
+  threshold: 0.5
+
+  # Minimum duration of a detected speech region to keep (milliseconds).
+  # Set to null to use Silero's default (250ms).
+  min_speech_duration_ms: 250
+
+  # Minimum silence gap required before a new segment begins (milliseconds).
+  # Set to null to use Silero's default (100ms).
+  min_silence_duration_ms: 100
+
+  # Padding added before and after each detected segment (milliseconds).
+  # Set to null to disable padding.
+  padding_ms: 500
+
+  # Segments longer than this are discarded as likely noise or music (seconds).
+  # Set to null to keep all segments regardless of length.
+  max_segment_length_sec: 30
+
+  # Segments with less than this gap between them are merged into one (seconds).
+  # Set to null to disable merging of neighboring segments.
+  merge_within_sec: 1.0
+
+transcribe:
+  # Whisper model size. Larger models are slower but more accurate.
+  # Options: tiny, base, small, medium, large
+  # See: https://github.com/openai/whisper
+  model: base
+
+  # Language code for transcription.
+  # Examples: en, fr, de, es, ja. Set to null to auto-detect.
+  language: en
+
+  # Decoding temperature.
+  # Set to 0 for single-pass greedy decoding with no fallback.
+  # Set to null to use Whisper's default fallback sequence (0.0, 0.2, …, 1.0),
+  # retrying at higher temperatures when output quality metrics look poor.
+  temperature: null
+
+  # Segments where Whisper's no-speech probability exceeds this are discarded.
+  # Set to null to use Whisper's default (0.6).
+  no_speech_threshold: 0.6
+
+  # Segments with average log-probability below this are discarded as likely low-quality audio.
+  # Set to null to use Whisper's default (-1.0).
+  logprob_threshold: -1.0
+
+  # Segments with compression ratio above this are discarded as likely hallucinations.
+  # Set to null to use Whisper's default (2.4).
+  compression_ratio_threshold: 2.4
+
+  # Whether Whisper should use the previous segment's output as context for the next.
+  # Improves coherence across segments but can propagate errors.
+  # Default: false.
+  condition_on_previous_text: false
+
+  # Path to a file containing domain-specific vocabulary to guide transcription.
+  # Set to null to disable.
+  vocab_file: vocab.txt

dinscribe-0.1.0/src/dinscribe/denoise.py

@@ -0,0 +1,59 @@
+"""
+Uses Demucs to isolate vocals in audio.
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from .utils import cuda_available
+
+
+def _ffmpeg_env():
+    """Return env with FFmpeg bin dir on PATH so subprocess can load torchcodec DLLs."""
+    import glob as g
+    env = dict(os.environ)
+    if sys.platform != "win32":
+        return env
+    local_appdata = env.get("LOCALAPPDATA", "")
+    winget_packages = os.path.join(local_appdata, "Microsoft", "WinGet", "Packages")
+    for bin_dir in g.glob(os.path.join(winget_packages, "Gyan.FFmpeg.Shared*", "**", "bin"), recursive=True):
+        if any(g.glob(os.path.join(bin_dir, "avcodec-*.dll"))):
+            env["PATH"] = bin_dir + os.pathsep + env.get("PATH", "")
+            break
+    return env
+
+
+def _run_demucs(input_file: Path, output_file: Path, model: str = "htdemucs", device: str = "cpu"):
+    """Run Demucs and copy the vocals stem to the destination path."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        tmp_path = Path(tmp_dir)
+
+        result = subprocess.run(
+            [sys.executable, "-m", "demucs", "-n", model, "--two-stems=vocals",
+             "--device", device, "-o", str(tmp_path), str(input_file)],
+            env=_ffmpeg_env(),
+        )
+        if result.returncode != 0:
+            raise RuntimeError(f"demucs exited with code {result.returncode}")
+
+        vocals_path = tmp_path / model / input_file.stem / "vocals.wav"
+        if not vocals_path.exists():
+            raise FileNotFoundError(f"Demucs output not found: {vocals_path}")
+
+        shutil.copy2(vocals_path, output_file)
+
+
+def run(input_path: Path, output_dir: Path, config: dict, force: bool = False) -> Path:
+    """Denoise a single audio file using Demucs vocal isolation. Returns path to denoised .wav."""
+    output_file = output_dir / f"{output_dir.name}_denoised.wav"
+    if not force and output_file.exists():
+        return output_file
+
+    model = config.get("model", "htdemucs")
+    device = "cuda" if cuda_available() else "cpu"
+    output_dir.mkdir(parents=True, exist_ok=True)
+    _run_demucs(input_path, output_file, model=model, device=device)
+    return output_file

dinscribe-0.1.0/src/dinscribe/pipeline.py

@@ -0,0 +1,103 @@
+"""
+Chains full audio pre-processing pipeline with transcription.
+"""
+
+import json
+import time
+from pathlib import Path
+from . import denoise, vad, transcribe
+from .utils import fmt_time, progress_bar, cuda_available
+
+
+def process_file(input_path: Path, output_dir: Path, config: dict, force: bool = False) -> bool:
+    """Run the full pipeline for one audio file."""
+    file_dir = output_dir / input_path.stem
+    file_dir.mkdir(parents=True, exist_ok=True)
+
+    total_start = time.monotonic()
+
+    print(f"\n{'─' * 60}")
+    print(f"  Input: {input_path}")
+    print(f"  Output: {file_dir}/")
+    print('─' * 60)
+
+    # Step 1: Denoise
+    print("\n  [1/3] Denoising")
+    denoised_path = file_dir / f"{input_path.stem}_denoised.wav"
+    if not force and denoised_path.exists():
+        print("        ✓ Skipped (cached)")
+    else:
+        print("        Running Demucs vocal isolation...")
+        step_start = time.monotonic()
+        try:
+            denoised_path = denoise.run(input_path, file_dir, config.get("denoise", {}), force=force)
+        except Exception as e:
+            print(f"\n  ERROR: Denoising failed: {e}")
+            return False
+        print(f"        ✓ Done  ({fmt_time(time.monotonic() - step_start)})")
+
+    # Step 2: VAD
+    print("\n  [2/3] Voice Activity Detection")
+    vad_path = file_dir / f"{input_path.stem}_vad.json"
+    vad_cached = not force and vad_path.exists()
+    step_start = time.monotonic()
+    if vad_cached:
+        print("        ✓ Skipped (cached)")
+    else:
+        print("        Detecting speech segments...")
+        try:
+            vad_path = vad.run(denoised_path, file_dir, config.get("vad", {}), force=force)
+        except Exception as e:
+            print(f"\n  ERROR: VAD failed: {e}")
+            return False
+
+    vad_meta = json.loads(vad_path.read_text(encoding="utf-8"))["metadata"]
+    segment_count = vad_meta["segment_count"]
+    if not vad_cached:
+        speech_s = vad_meta["total_speech_ms"] / 1000
+        audio_s = vad_meta["audio_duration_ms"] / 1000
+        print(f"        ✓ {segment_count} segments found  "
+              f"({speech_s:.1f}s speech in {audio_s:.1f}s audio)  "
+              f"({fmt_time(time.monotonic() - step_start)})")
+
+    # Step 3: Transcribe
+    print("\n  [3/3] Transcribing")
+    transcription_path = file_dir / f"{input_path.stem}_transcription.json"
+    trans_cached = not force and transcription_path.exists()
+    if trans_cached:
+        print("        ✓ Skipped (cached)")
+    else:
+        trans_config = config.get("transcribe", {})
+        model_name = trans_config.get("model", "base")
+        device = "cuda" if cuda_available() else "cpu"
+        print(f"        Loading Whisper '{model_name}' on {device}...")
+
+        step_start = time.monotonic()
+
+        def on_segment(current: int, total: int):
+            bar = progress_bar(current, total)
+            print(f"\r        [{bar}] {current}/{total} segments", end="", flush=True)
+
+        try:
+            transcription_path = transcribe.run(
+                denoised_path, vad_path, file_dir, trans_config, on_segment=on_segment, force=force,
+            )
+        except Exception as e:
+            print(f"\n  ERROR: Transcription failed: {e}")
+            return False
+
+        print()
+        trans_meta = json.loads(transcription_path.read_text(encoding="utf-8"))["metadata"]
+        kept = trans_meta["processed_segments"]
+        print(f"        ✓ {kept}/{segment_count} segments processed  "
+              f"({fmt_time(time.monotonic() - step_start)})")
+
+    # Summary
+    print(f"\n{'─' * 60}")
+    print(f"  Total time: {fmt_time(time.monotonic() - total_start)}")
+    print("  Output:")
+    for p in (denoised_path, vad_path, transcription_path):
+        print(f"    {p.relative_to(output_dir.parent)}")
+    print('─' * 60)
+
+    return True

dinscribe-0.1.0/src/dinscribe/transcribe.py

@@ -0,0 +1,162 @@
+"""
+Transcribes speech segments from denoised audio using Whisper.
+"""
+
+import json
+import shutil
+from pathlib import Path
+from typing import Optional
+from pydub import AudioSegment
+import whisper
+from .utils import cuda_available
+
+# Loaded once per process, keyed by (model_name, device)
+_whisper_cache: dict = {}
+
+
+def _load_model(model_name: str, device: str):
+    key = (model_name, device)
+    if key not in _whisper_cache:
+        _whisper_cache[key] = whisper.load_model(model_name, device=device)
+    return _whisper_cache[key]
+
+
+def _load_vocabulary(vocab_file: Optional[str]) -> str:
+    """Build Whisper's initial_prompt from a vocabulary file."""
+    if not vocab_file:
+        return ""
+    vocab_path = Path(vocab_file)
+    if not vocab_path.exists():
+        return ""
+    terms = [
+        line.strip()
+        for line in vocab_path.read_text(encoding="utf-8").splitlines()
+        if line.strip() and not line.startswith("#")
+    ]
+    return f"Common terms: {', '.join(terms)}." if terms else ""
+
+
+def run(
+    audio_path: Path,
+    vad_path: Path,
+    output_dir: Path,
+    config: dict,
+    on_segment=None,
+    force: bool = False,
+) -> Path:
+    """Transcribe speech segments from denoised audio. Returns path to transcription.json."""
+    output_file = output_dir / f"{output_dir.name}_transcription.json"
+    if not force and output_file.exists():
+        return output_file
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    model_name = config.get("model", "base")
+    language = config.get("language", "en")
+    temperature = config.get("temperature", None)
+    no_speech_threshold = config.get("no_speech_threshold", None)
+    logprob_threshold = config.get("logprob_threshold", None)
+    compression_ratio_threshold = config.get("compression_ratio_threshold", None)
+    condition_on_previous_text = config.get("condition_on_previous_text", False)
+    vocab_file = config.get("vocab_file", None)
+
+    device = "cuda" if cuda_available() else "cpu"
+    model = _load_model(model_name, device)
+    initial_prompt = _load_vocabulary(vocab_file) or None
+
+    vad_data = json.loads(vad_path.read_text(encoding="utf-8"))
+    segments = vad_data.get("segments", [])
+    if not segments:
+        raise RuntimeError(f"No segments found in {vad_path.name}")
+
+    audio = AudioSegment.from_file(str(audio_path))
+    audio_duration_ms = len(audio)
+
+    valid_segments = [
+        (seg["start_ms"], min(seg["end_ms"], audio_duration_ms))
+        for seg in segments
+        if seg["start_ms"] < audio_duration_ms
+    ]
+    total = len(valid_segments)
+
+    output = {
+        "metadata": {
+            "source_audio": audio_path.name,
+            "model": model_name,
+            "language": language,
+            "temperature": temperature,
+            "no_speech_threshold": no_speech_threshold,
+            "logprob_threshold": logprob_threshold,
+            "compression_ratio_threshold": compression_ratio_threshold,
+            "total_segments": total,
+            "processed_segments": 0,
+        },
+        "transcription": [],
+    }
+    _write_json(output_file, output)
+
+    temp_dir = output_dir / "_temp_segments"
+    if temp_dir.exists():
+        shutil.rmtree(temp_dir)
+    temp_dir.mkdir()
+
+    try:
+        for i, (start_ms, end_ms) in enumerate(valid_segments, 1):
+            temp_file = temp_dir / f"seg_{i}.wav"
+            audio[start_ms:end_ms].export(str(temp_file), format="wav")
+
+            try:
+                transcribe_kwargs = dict(
+                    language=language,
+                    fp16=(device == "cuda"),
+                    condition_on_previous_text=condition_on_previous_text,
+                    initial_prompt=initial_prompt,
+                )
+                if temperature is not None:
+                    transcribe_kwargs["temperature"] = temperature
+                if no_speech_threshold is not None:
+                    transcribe_kwargs["no_speech_threshold"] = no_speech_threshold
+                if logprob_threshold is not None:
+                    transcribe_kwargs["logprob_threshold"] = logprob_threshold
+                if compression_ratio_threshold is not None:
+                    transcribe_kwargs["compression_ratio_threshold"] = compression_ratio_threshold
+                result = model.transcribe(str(temp_file), **transcribe_kwargs)
+            except Exception:
+                temp_file.unlink(missing_ok=True)
+                if on_segment:
+                    on_segment(i, total)
+                continue
+
+            temp_file.unlink(missing_ok=True)
+
+            text = result["text"].strip()
+            no_speech_prob = max(
+                (s.get("no_speech_prob", 0) for s in result.get("segments", [])),
+                default=0,
+            )
+
+            output["metadata"]["processed_segments"] += 1
+
+            if not text or (no_speech_threshold is not None and no_speech_prob > no_speech_threshold):
+                _write_json(output_file, output)
+                if on_segment:
+                    on_segment(i, total)
+                continue
+
+            output["transcription"].append({
+                "timestamp": {"start": start_ms / 1000, "end": end_ms / 1000},
+                "text": text,
+            })
+            _write_json(output_file, output)
+
+            if on_segment:
+                on_segment(i, total)
+    finally:
+        if temp_dir.exists():
+            shutil.rmtree(temp_dir)
+
+    return output_file
+
+
+def _write_json(path: Path, data: dict):
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2, ensure_ascii=False)

dinscribe-0.1.0/src/dinscribe/utils.py

@@ -0,0 +1,84 @@
+import os
+import shutil
+import sys
+from importlib import resources
+from pathlib import Path
+
+AUDIO_EXTENSIONS = frozenset({".mp3", ".wav", ".m4a", ".flac", ".ogg", ".aac"})
+
+_CONFIG_FILES = ("config.yaml", "vocab.txt")
+
+
+def get_config_dir() -> Path:
+    """Return the platform-appropriate user config directory for dinscribe."""
+    if sys.platform == "win32":
+        base = Path(os.environ.get("APPDATA", Path.home()))
+    elif sys.platform == "darwin":
+        base = Path.home() / "Library" / "Application Support"
+    else:
+        base = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config"))
+    return base / "dinscribe"
+
+
+def setup_user_config() -> Path:
+    """Copy default config files to the user config dir if they don't exist yet.
+
+    Returns the config dir path.
+    """
+    config_dir = get_config_dir()
+    config_dir.mkdir(parents=True, exist_ok=True)
+
+    pkg = resources.files("dinscribe")
+    for name in _CONFIG_FILES:
+        dest = config_dir / name
+        if not dest.exists():
+            src = pkg.joinpath(name)
+            with resources.as_file(src) as src_path:
+                shutil.copy2(src_path, dest)
+            print(f"Created default config: {dest}")
+
+    return config_dir
+
+
+def load_config(config_path: str, section: str = "") -> dict:
+    """Loads config.yaml and return the full config dict, or a single named section"""
+    try:
+        import yaml
+        with open(config_path, encoding="utf-8") as f:
+            cfg = yaml.safe_load(f) or {}
+        return cfg.get(section, {}) if section else cfg
+    except FileNotFoundError:
+        return {}
+    except Exception as e:
+        print(f"Warning: could not parse config ({config_path}): {e}")
+        return {}
+
+
+def progress_bar(current: int, total: int, width: int = 28) -> str:
+    """Returns an ASCII block progress bar string"""
+    if total == 0:
+        return "░" * width
+    filled = int(width * current / total)
+    return "▓" * filled + "░" * (width - filled)
+
+
+def fmt_time(seconds: float) -> str:
+    """Formats duration in seconds as a human-readable string"""
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    return f"{int(seconds // 60)}m {seconds % 60:.0f}s"
+
+
+def cuda_available() -> bool:
+    """Returns True if a CUDA-capable GPU is available"""
+    try:
+        import torch
+        return torch.cuda.is_available()
+    except Exception:
+        return False
+
+
+def warn_if_no_cuda() -> None:
+    """Prints a warning when CUDA is not available"""
+    if not cuda_available():
+        print("WARNING: CUDA is not available! Audio processing will run on CPU, which will be much slower.")

dinscribe-0.1.0/src/dinscribe/vad.py

@@ -0,0 +1,126 @@
+"""
+Uses Silero VAD to detect speech segments in denoised audio and writes a JSON file with segment boundaries.
+"""
+
+import json
+from pathlib import Path
+import torch
+from .utils import cuda_available
+
+# Loaded once per process
+_vad_model_cache = None
+
+
+def _load_model():
+    global _vad_model_cache
+    if _vad_model_cache is None:
+        print("Loading VAD model...")
+        torch.set_num_threads(1)
+        model, utils = torch.hub.load(
+            repo_or_dir="snakers4/silero-vad",
+            model="silero_vad",
+            force_reload=False,
+            onnx=False,
+        )
+        get_speech_timestamps, _, read_audio, *_ = utils
+        device = "cuda" if cuda_available() else "cpu"
+        model = model.to(device)
+        _vad_model_cache = (model, get_speech_timestamps, read_audio, device)
+    return _vad_model_cache
+
+
+def _detect_segments(audio_path: Path, config: dict):
+    """Run Silero VAD and return (segments, duration_ms).
+
+    segments is a list of [start_ms, end_ms] pairs.
+    """
+    threshold = config.get("threshold", 0.5)
+    min_speech_ms = config.get("min_speech_duration_ms", None)
+    min_silence_ms = config.get("min_silence_duration_ms", None)
+    padding_ms = config.get("padding_ms", 500) or 0
+    max_seg_sec = config.get("max_segment_length_sec", 30)
+    merge_within_sec = config.get("merge_within_sec", 1.0)
+    sample_rate = 16000  # required by Silero VAD
+
+    model, get_speech_timestamps, read_audio, device = _load_model()
+
+    wav = read_audio(str(audio_path), sampling_rate=sample_rate).to(device)
+    duration_ms = len(wav) / sample_rate * 1000
+
+    vad_kwargs = dict(
+        threshold=threshold,
+        sampling_rate=sample_rate,
+        window_size_samples=512,
+        speech_pad_ms=30,
+    )
+    if min_speech_ms is not None:
+        vad_kwargs["min_speech_duration_ms"] = min_speech_ms
+    if min_silence_ms is not None:
+        vad_kwargs["min_silence_duration_ms"] = min_silence_ms
+    speech_timestamps = get_speech_timestamps(wav, model, **vad_kwargs)
+
+    # Convert sample indices to ms and apply padding
+    samples_per_ms = sample_rate / 1000
+    segments = []
+    for ts in speech_timestamps:
+        start_ms = max(0, int(ts["start"] / samples_per_ms) - padding_ms)
+        end_ms = min(duration_ms, int(ts["end"] / samples_per_ms) + padding_ms)
+        if segments and start_ms < segments[-1][1]:
+            start_ms = segments[-1][1]
+        if start_ms < end_ms:
+            segments.append([start_ms, end_ms])
+
+    # Merge nearby segments
+    if merge_within_sec is not None:
+        merge_gap_ms = merge_within_sec * 1000
+        merged = []
+        for start_ms, end_ms in segments:
+            if merged and start_ms - merged[-1][1] <= merge_gap_ms:
+                merged[-1][1] = end_ms
+            else:
+                merged.append([start_ms, end_ms])
+        segments = merged
+
+    # Discard segments that exceed the maximum length
+    if max_seg_sec is not None:
+        max_ms = max_seg_sec * 1000
+        segments = [[s, e] for s, e in segments if e - s <= max_ms]
+
+    return segments, duration_ms
+
+
+def _build_output(audio_path: Path, segments: list, duration_ms: float, config: dict) -> dict:
+    total_speech_ms = sum(e - s for s, e in segments)
+    return {
+        "metadata": {
+            "source_audio": audio_path.name,
+            "audio_duration_ms": duration_ms,
+            "total_speech_ms": total_speech_ms,
+            "segment_count": len(segments),
+            "vad_threshold": config.get("threshold", 0.5),
+            "max_segment_length_sec": config.get("max_segment_length_sec", 30),
+            "merge_within_sec": config.get("merge_within_sec", 1.0),
+        },
+        "segments": [
+            {"segment_id": i, "start_ms": s, "end_ms": e, "duration_ms": e - s}
+            for i, (s, e) in enumerate(segments)
+        ],
+    }
+
+
+def run(input_path: Path, output_dir: Path, config: dict, force: bool = False) -> Path:
+    """Run Silero VAD on a single audio file. Returns path to vad.json."""
+    output_file = output_dir / f"{output_dir.name}_vad.json"
+    if not force and output_file.exists():
+        return output_file
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    segments, duration_ms = _detect_segments(input_path, config)
+    if not segments:
+        raise RuntimeError(f"No speech segments detected in {input_path.name}")
+
+    output = _build_output(input_path, segments, duration_ms, config)
+    with open(output_file, "w", encoding="utf-8") as f:
+        json.dump(output, f, indent=2, ensure_ascii=False)
+
+    return output_file

dinscribe-0.1.0/src/dinscribe/vocab.txt

@@ -0,0 +1,16 @@
+# You can add words or phrases here that will be included in Whisper's initial prompt,
+# increasing the likelihood those words will be predicted during transcription.
+# Add one word or phrase per line and note that lines starting with # are ignored.
+#
+# Examples of what to add:
+#   - Technical jargon specific to your subject matter
+#   - Proper nouns (names of people, places, organizations, products)
+#   - Acronyms and their expansions
+#   - Any word Whisper is consistently getting wrong
+#
+# Example entries:
+# box box
+# VSC
+# DRS
+# understeer
+# oversteer

dinscribe-0.1.0/src/dinscribe.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: dinscribe
+Version: 0.1.0
+Summary: Audio denoising and transcription pipeline using Demucs, Silero VAD, and Whisper
+Requires-Python: >=3.10
+Requires-Dist: demucs>=4.0.0
+Requires-Dist: torchcodec
+Requires-Dist: torch
+Requires-Dist: pydub
+Requires-Dist: packaging
+Requires-Dist: openai-whisper
+Requires-Dist: pyyaml

dinscribe-0.1.0/src/dinscribe.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+pyproject.toml
+src/dinscribe/__init__.py
+src/dinscribe/cli.py
+src/dinscribe/config.yaml
+src/dinscribe/denoise.py
+src/dinscribe/pipeline.py
+src/dinscribe/transcribe.py
+src/dinscribe/utils.py
+src/dinscribe/vad.py
+src/dinscribe/vocab.txt
+src/dinscribe.egg-info/PKG-INFO
+src/dinscribe.egg-info/SOURCES.txt
+src/dinscribe.egg-info/dependency_links.txt
+src/dinscribe.egg-info/entry_points.txt
+src/dinscribe.egg-info/requires.txt
+src/dinscribe.egg-info/top_level.txt

dinscribe-0.1.0/src/dinscribe.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dinscribe-0.1.0/src/dinscribe.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dinscribe = dinscribe.cli:main

dinscribe-0.1.0/src/dinscribe.egg-info/requires.txt

@@ -0,0 +1,7 @@
+demucs>=4.0.0
+torchcodec
+torch
+pydub
+packaging
+openai-whisper
+pyyaml

dinscribe-0.1.0/src/dinscribe.egg-info/top_level.txt

@@ -0,0 +1 @@
+dinscribe