dinnote 0.1.0__py3-none-any.whl

dinnote/__init__.py

@@ -0,0 +1,8 @@
+from . import denoise, vad, diarize, transcribe
+from .pipeline import process_file
+from .config import DenoiseConfig, VadConfig, DiarizeConfig, TranscribeConfig, PipelineConfig
+
+__all__ = [
+    "denoise", "vad", "diarize", "transcribe", "process_file",
+    "DenoiseConfig", "VadConfig", "DiarizeConfig", "TranscribeConfig", "PipelineConfig",
+]

dinnote/cli.py

@@ -0,0 +1,80 @@
+import argparse
+import sys
+import time
+from pathlib import Path
+from .utils import AUDIO_EXTENSIONS, load_config, warn_if_no_cuda, setup_user_config, fmt_time
+from .pipeline import process_file
+from .config import PipelineConfig
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Denoise, VAD, diarize, and transcribe audio files"
+    )
+    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")
+    raw = load_config(config_path)
+
+    transcribe_raw = raw.setdefault("transcribe", {})
+    if not transcribe_raw.get("vocab_file"):
+        vocab_path = config_dir / "vocab.txt"
+        if vocab_path.exists():
+            transcribe_raw["vocab_file"] = str(vocab_path)
+
+    config = PipelineConfig.from_dict(raw)
+    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"Unrecognized 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()

dinnote/config.py

@@ -0,0 +1,64 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class DenoiseConfig:
+    model: str = "htdemucs"
+
+
+@dataclass
+class VadConfig:
+    threshold: float = 0.5
+    min_speech_duration_ms: Optional[int] = 250
+    min_silence_duration_ms: Optional[int] = 100
+    padding_ms: int = 500
+    max_segment_length_sec: Optional[float] = 30.0
+    """Segments longer than this are discarded as likely noise or music. None keeps all."""
+    merge_within_sec: Optional[float] = 1.0
+    """Segments with less than this gap between them are merged. None disables merging."""
+
+
+@dataclass
+class DiarizeConfig:
+    hf_token: Optional[str] = None
+    num_speakers: Optional[int] = None
+    min_speakers: Optional[int] = None
+    max_speakers: Optional[int] = None
+    min_turn_ms: int = 200
+    """Turns less than this length are discarded."""
+
+
+@dataclass
+class TranscribeConfig:
+    model: str = "base"
+    language: str = "en"
+    temperature: Optional[float] = None
+    """0 for greedy decoding, None to use Whisper's fallback sequence."""
+    no_speech_threshold: Optional[float] = 0.6
+    logprob_threshold: Optional[float] = -1.0
+    compression_ratio_threshold: Optional[float] = 2.4
+    condition_on_previous_text: bool = False
+    """Use previous segment output as context. Improves coherence but can propagate errors."""
+    vocab_file: Optional[str] = None
+
+
+@dataclass
+class PipelineConfig:
+    denoise: DenoiseConfig = field(default_factory=DenoiseConfig)
+    vad: VadConfig = field(default_factory=VadConfig)
+    diarize: DiarizeConfig = field(default_factory=DiarizeConfig)
+    transcribe: TranscribeConfig = field(default_factory=TranscribeConfig)
+
+    @staticmethod
+    def from_dict(d: dict) -> "PipelineConfig":
+        def _build(cls, section):
+            fields = {f.name for f in cls.__dataclass_fields__.values()}
+            return cls(**{k: v for k, v in section.items() if k in fields})
+
+        return PipelineConfig(
+            denoise=_build(DenoiseConfig, d.get("denoise", {})),
+            vad=_build(VadConfig, d.get("vad", {})),
+            diarize=_build(DiarizeConfig, d.get("diarize", {})),
+            transcribe=_build(TranscribeConfig, d.get("transcribe", {})),
+        )

dinnote/config.yaml

@@ -0,0 +1,81 @@
+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
+
+diarize:
+  # HuggingFace token with access to pyannote/speaker-diarization-3.1.
+  # hf_token: hf_...
+
+  # Fix the number of speakers if known. Set to null to let pyannote estimate.
+  num_speakers: null
+
+  # Alternatively constrain the range and let pyannote pick within it.
+  min_speakers: null
+  max_speakers: null
+
+  # Turns shorter than this are discarded (milliseconds).
+  min_turn_ms: 200
+
+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

dinnote/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

dinnote/diarize.py

@@ -0,0 +1,145 @@
+"""
+Uses pyannote speaker diarization to split denoised audio into per-speaker turns,
+writing a diarization JSON that replaces VAD segments as the unit fed to Whisper.
+
+Each turn is a single-speaker slice with absolute timestamps in the source audio,
+so Whisper gets clean single-speaker audio and speaker attribution is built-in.
+
+Output JSON format:
+{
+  "metadata": { ... },
+  "turns": [
+    {"turn_id": 0, "speaker": "SPEAKER_00", "start_ms": 1200, "end_ms": 3450, "duration_ms": 2250},
+    ...
+  ]
+}
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+from .utils import cuda_available
+
+_pipeline_cache = None
+
+
+def _load_pipeline(hf_token: str, num_speakers: int | None, device: str):
+    global _pipeline_cache
+    if _pipeline_cache is None:
+        from pyannote.audio import Pipeline
+        import torch
+        pipeline = Pipeline.from_pretrained(
+            "pyannote/speaker-diarization-3.1",
+            token=hf_token,
+        )
+        pipeline.to(torch.device(device))
+        _pipeline_cache = pipeline
+    return _pipeline_cache
+
+
+def _ensure_ffmpeg_dlls():
+    """Register FFmpeg shared DLL directory on Windows (required by torchcodec)."""
+    if sys.platform != "win32":
+        return
+    import glob as g
+    local_appdata = os.environ.get("LOCALAPPDATA", "")
+    winget_packages = os.path.join(local_appdata, "Microsoft", "WinGet", "Packages")
+    if not os.path.isdir(winget_packages):
+        return
+    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"))):
+            os.add_dll_directory(bin_dir)
+            return
+
+
+def run(
+    audio_path: Path,
+    output_dir: Path,
+    config: dict,
+    force: bool = False,
+) -> Path:
+    """Run pyannote diarization on a denoised audio file. Returns path to diarization JSON."""
+    output_file = output_dir / f"{output_dir.name}_diarization.json"
+    if not force and output_file.exists():
+        return output_file
+
+    _ensure_ffmpeg_dlls()
+
+    hf_token = config.get("hf_token")
+    if not hf_token:
+        raise RuntimeError(
+            "HuggingFace token required for pyannote. "
+            "Set diarize.hf_token in config.yaml."
+        )
+
+    num_speakers = config.get("num_speakers", None)
+    min_speakers = config.get("min_speakers", None)
+    max_speakers = config.get("max_speakers", None)
+    min_turn_ms = config.get("min_turn_ms", 200)
+    device = "cuda" if cuda_available() else "cpu"
+
+    pipeline = _load_pipeline(hf_token, num_speakers, device)
+
+    import torchaudio
+    waveform, sr = torchaudio.load(str(audio_path))
+    if sr != 16000:
+        waveform = torchaudio.functional.resample(waveform, sr, 16000)
+        sr = 16000
+    if waveform.shape[0] > 1:
+        waveform = waveform.mean(dim=0, keepdim=True)
+
+    diarize_kwargs = {}
+    if num_speakers is not None:
+        diarize_kwargs["num_speakers"] = num_speakers
+    if min_speakers is not None:
+        diarize_kwargs["min_speakers"] = min_speakers
+    if max_speakers is not None:
+        diarize_kwargs["max_speakers"] = max_speakers
+
+    result = pipeline({"waveform": waveform, "sample_rate": sr}, **diarize_kwargs)
+    del waveform
+
+    # Extract the Annotation object (handles pyannote API differences)
+    annotation = result.speaker_diarization if hasattr(result, "speaker_diarization") else result
+
+    speakers = sorted({s for _, _, s in annotation.itertracks(yield_label=True)})
+
+    turns = []
+    for i, (turn, _, speaker) in enumerate(annotation.itertracks(yield_label=True)):
+        start_ms = round(turn.start * 1000)
+        end_ms = round(turn.end * 1000)
+        duration_ms = end_ms - start_ms
+        if duration_ms < min_turn_ms:
+            continue
+        turns.append({
+            "turn_id": i,
+            "speaker": speaker,
+            "start_ms": start_ms,
+            "end_ms": end_ms,
+            "duration_ms": duration_ms,
+        })
+
+    for i, t in enumerate(turns):
+        t["turn_id"] = i
+
+    from pydub import AudioSegment
+    audio_duration_ms = len(AudioSegment.from_file(str(audio_path)))
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    output = {
+        "metadata": {
+            "source_audio": audio_path.name,
+            "audio_duration_ms": audio_duration_ms,
+            "speakers_detected": speakers,
+            "num_turns": len(turns),
+            "total_speech_ms": sum(t["duration_ms"] for t in turns),
+            "num_speakers_param": num_speakers,
+            "min_turn_ms": min_turn_ms,
+        },
+        "turns": turns,
+    }
+    with open(output_file, "w", encoding="utf-8") as f:
+        json.dump(output, f, indent=2, ensure_ascii=False)
+
+    return output_file

dinnote/pipeline.py

@@ -0,0 +1,137 @@
+"""
+Extends the dinscribe pipeline with a speaker diarization step (pyannote) between VAD and
+transcription. Diarization replaces VAD segments as the unit fed to Whisper, giving each
+transcription entry a speaker label and cleaner single-speaker audio.
+
+Pipeline: denoise -> vad -> diarize -> transcribe
+"""
+
+import json
+import time
+from pathlib import Path
+
+from . import denoise, vad, diarize, transcribe
+from .config import PipelineConfig
+from .utils import fmt_time, progress_bar, cuda_available
+
+
+def process_file(input_path: Path, output_dir: Path, config: PipelineConfig = PipelineConfig(), force: bool = False) -> bool:
+    """Run the full pipeline for one audio file. Returns True on success."""
+    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)
+
+    print("\n  [1/4] 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:
+            import dataclasses
+            denoised_path = denoise.run(input_path, file_dir, dataclasses.asdict(config.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)})")
+
+    print("\n  [2/4] 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:
+            import dataclasses
+            vad_path = vad.run(denoised_path, file_dir, dataclasses.asdict(config.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"]
+    if not vad_cached:
+        speech_s = vad_meta["total_speech_ms"] / 1000
+        audio_s = vad_meta["audio_duration_ms"] / 1000
+        print(f"        ✓ {vad_meta['segment_count']} segments found  "
+              f"({speech_s:.1f}s speech in {audio_s:.1f}s audio)  "
+              f"({fmt_time(time.monotonic() - step_start)})")
+
+    print("\n  [3/4] Speaker Diarization")
+    diarization_path = file_dir / f"{input_path.stem}_diarization.json"
+    diar_cached = not force and diarization_path.exists()
+    step_start = time.monotonic()
+    if diar_cached:
+        print("        ✓ Skipped (cached)")
+    else:
+        import dataclasses
+        diar_config = dataclasses.asdict(config.diarize)
+        num_spk = diar_config.get("num_speakers")
+        print(f"        Running pyannote{f' (num_speakers={num_spk})' if num_spk else ''}...")
+        try:
+            diarization_path = diarize.run(denoised_path, file_dir, diar_config, force=force)
+        except Exception as e:
+            print(f"\n  ERROR: Diarization failed: {e}")
+            return False
+
+    diar_meta = json.loads(diarization_path.read_text(encoding="utf-8"))["metadata"]
+    if not diar_cached:
+        speakers = diar_meta["speakers_detected"]
+        print(f"        ✓ {len(speakers)} speaker(s): {', '.join(speakers)}  "
+              f"| {diar_meta['num_turns']} turns  "
+              f"({fmt_time(time.monotonic() - step_start)})")
+
+    print("\n  [4/4] 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:
+        import dataclasses
+        trans_config = dataclasses.asdict(config.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} turns", end="", flush=True)
+
+        try:
+            transcription_path = transcribe.run(
+                denoised_path,
+                file_dir,
+                trans_config,
+                diarization_path=diarization_path,
+                vad_path=vad_path,
+                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"]
+        total_turns = diar_meta["num_turns"]
+        print(f"        ✓ {kept}/{total_turns} turns transcribed  "
+              f"({fmt_time(time.monotonic() - step_start)})")
+
+    print(f"\n{'─' * 60}")
+    print(f"  Total time: {fmt_time(time.monotonic() - total_start)}")
+    print("  Output:")
+    for p in (denoised_path, vad_path, diarization_path, transcription_path):
+        print(f"    {p.relative_to(output_dir.parent)}")
+    print('─' * 60)
+
+    return True

dinnote/transcribe.py

@@ -0,0 +1,201 @@
+"""
+Transcribes speech segments from denoised audio using Whisper.
+
+Accepts either:
+  - a diarization JSON (preferred) — per-speaker turns from pyannote
+  - a VAD JSON (fallback) — speaker-agnostic segments from Silero
+
+When using diarization, each transcription entry includes the speaker label.
+"""
+
+import json
+import shutil
+from pathlib import Path
+from typing import Optional, Callable
+from pydub import AudioSegment
+import whisper
+from .utils import cuda_available
+
+_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 _load_segments(diarization_path: Optional[Path], vad_path: Optional[Path]):
+    """Load segments from diarization JSON (preferred) or VAD JSON (fallback).
+
+    Returns (segments, source) where each segment has start_ms, end_ms,
+    and optionally speaker. source is "diarization" or "vad".
+    """
+    if diarization_path and diarization_path.exists():
+        data = json.loads(diarization_path.read_text(encoding="utf-8"))
+        turns = data.get("turns", [])
+        segments = [
+            {"start_ms": t["start_ms"], "end_ms": t["end_ms"], "speaker": t["speaker"]}
+            for t in turns
+        ]
+        return segments, "diarization"
+
+    if vad_path and vad_path.exists():
+        data = json.loads(vad_path.read_text(encoding="utf-8"))
+        segments = [
+            {"start_ms": s["start_ms"], "end_ms": s["end_ms"]}
+            for s in data.get("segments", [])
+        ]
+        return segments, "vad"
+
+    raise RuntimeError("No diarization or VAD file provided.")
+
+
+def run(
+    audio_path: Path,
+    output_dir: Path,
+    config: dict,
+    diarization_path: Optional[Path] = None,
+    vad_path: Optional[Path] = None,
+    on_segment: Optional[Callable] = None,
+    force: bool = False,
+) -> Path:
+    """Transcribe speaker turns 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", "vocab.txt")
+
+    device = "cuda" if cuda_available() else "cpu"
+    model = _load_model(model_name, device)
+    initial_prompt = _load_vocabulary(vocab_file) or None
+
+    segments, source = _load_segments(diarization_path, vad_path)
+    if not segments:
+        raise RuntimeError("No segments found to transcribe.")
+
+    audio = AudioSegment.from_file(str(audio_path))
+    audio_duration_ms = len(audio)
+
+    valid_segments = [seg for seg in segments if seg["start_ms"] < audio_duration_ms]
+    for seg in valid_segments:
+        seg["end_ms"] = min(seg["end_ms"], audio_duration_ms)
+
+    total = len(valid_segments)
+
+    output = {
+        "metadata": {
+            "source_audio": audio_path.name,
+            "model": model_name,
+            "language": language,
+            "segment_source": source,
+            "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, seg in enumerate(valid_segments, 1):
+            start_ms = seg["start_ms"]
+            end_ms = seg["end_ms"]
+            speaker = seg.get("speaker")
+
+            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
+
+            entry = {
+                "timestamp": {"start": start_ms / 1000, "end": end_ms / 1000},
+                "text": text,
+            }
+            if speaker is not None:
+                entry["speaker"] = speaker
+
+            output["transcription"].append(entry)
+            _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)

dinnote/utils.py

@@ -0,0 +1,73 @@
+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:
+    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 / "dinnote"
+
+
+def setup_user_config() -> Path:
+    """Copy default config files to the user config dir if they don't exist yet."""
+    config_dir = get_config_dir()
+    config_dir.mkdir(parents=True, exist_ok=True)
+
+    pkg = resources.files("dinnote")
+    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)
+
+    return config_dir
+
+
+def load_config(config_path: str, section: str = "") -> dict:
+    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:
+        return {}
+
+
+def progress_bar(current: int, total: int, width: int = 28) -> str:
+    if total == 0:
+        return "░" * width
+    filled = int(width * current / total)
+    return "▓" * filled + "░" * (width - filled)
+
+
+def fmt_time(seconds: float) -> str:
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    return f"{int(seconds // 60)}m {seconds % 60:.0f}s"
+
+
+def cuda_available() -> bool:
+    try:
+        import torch
+        return torch.cuda.is_available()
+    except Exception:
+        return False
+
+
+def warn_if_no_cuda() -> None:
+    if not cuda_available():
+        print("WARNING: CUDA is not available! Audio processing will run on CPU, which will be much slower.")

dinnote/vad.py

@@ -0,0 +1,125 @@
+"""
+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
+from .config import VadConfig
+
+_vad_model_cache = None
+
+
+def _load_model():
+    global _vad_model_cache
+    if _vad_model_cache is None:
+        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

dinnote/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

dinnote-0.1.0.dist-info/METADATA

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: dinnote
+Version: 0.1.0
+Summary: Audio denoising, VAD, speaker diarization, and transcription pipeline using Demucs, Silero VAD, pyannote, and Whisper
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: demucs>=4.0.0
+Requires-Dist: torchcodec
+Requires-Dist: torch
+Requires-Dist: torchaudio
+Requires-Dist: pydub
+Requires-Dist: packaging
+Requires-Dist: pyannote.audio>=3.1.0
+Requires-Dist: openai-whisper
+Requires-Dist: pyyaml
+
+## dinnote audio transcription
+Processes audio through a four-step pipeline to produce a transcription JSON with per-speaker diarization: denoising (Demucs), voice activity detection (Silero VAD), speaker diarization (pyannote), and transcription (Whisper).
+
+### Installation
+```bash
+pip install dinnote
+```
+
+On first run, dinnote copies default config files to your platform config directory:
+- **Windows:** `%APPDATA%\dinnote\`
+- **macOS:** `~/Library/Application Support/dinnote/`
+- **Linux:** `~/.config/dinnote/`
+
+Edit `config.yaml` and `vocab.txt` to customize settings.
+
+Speaker diarization requires a HuggingFace token with access to [pyannote/speaker-diarization-3.1](https://huggingface.co/pyannote/speaker-diarization-3.1). 
+Set it via `diarize.hf_token` in `config.yaml`.
+
+
+### CLI usage
+```bash
+dinnote input/audio.mp3            # single file
+dinnote input/                     # all audio files in a folder
+dinnote input/audio.mp3 -f         # force re-run all steps
+dinnote input/audio.mp3 -c path/to/config.yaml   # custom config
+dinnote input/audio.mp3 -o results/              # custom output dir
+```
+
+Each step checks whether its output already exists and skips it if so. Use `-f` to force all steps to re-run.
+
+Output is written to `output/<filename>/` and contains:
+- `<filename>_denoised.wav` (vocals isolated from background noise)
+- `<filename>_vad.json` (detected speech segment boundaries)
+- `<filename>_diarization.json` (per-speaker turn boundaries from pyannote)
+- `<filename>_transcription.json` (final transcription with timestamps and speaker labels)
+
+
+### Python API
+```python
+from pathlib import Path
+import dinnote
+from dinnote import PipelineConfig, VadConfig, DiarizeConfig, TranscribeConfig
+
+# Run the full pipeline with defaults
+dinnote.process_file(
+    input_path=Path("recording.wav"),
+    output_dir=Path("output"),
+)
+
+# Custom config
+config = PipelineConfig(
+    vad=VadConfig(threshold=0.4, max_segment_length_sec=20),
+    diarize=DiarizeConfig(num_speakers=2),
+    transcribe=TranscribeConfig(model="small", language="en"),
+)
+dinnote.process_file(Path("recording.wav"), Path("output"), config=config)
+
+# Or use individual stages
+from dinnote import denoise, vad, diarize, transcribe
+
+denoised      = denoise.run(Path("recording.wav"), Path("output/recording"), config={})
+vad_file      = vad.run(denoised, Path("output/recording"), config={})
+diarization   = diarize.run(denoised, Path("output/recording"), config={})
+result        = transcribe.run(denoised, Path("output/recording"), config={}, diarization_path=diarization)
+```
+
+
+### Configuration
+
+```yaml
+denoise:
+  model: htdemucs        # htdemucs | htdemucs_ft | mdx | mdx_extra | htdemucs_6s
+
+vad:
+  threshold: 0.5         # 0.0–1.0, higher = requires clearer speech
+  min_speech_duration_ms: 250
+  min_silence_duration_ms: 100
+  padding_ms: 500
+  max_segment_length_sec: 30
+  merge_within_sec: 1.0
+
+diarize:
+  # hf_token: hf_...
+  num_speakers: null     # fix speaker count or leave null to let pyannote estimate
+  min_speakers: null
+  max_speakers: null
+  min_turn_ms: 200       # turns shorter than this are discarded (ms)
+
+transcribe:
+  model: base            # tiny | base | small | medium | large
+  language: en           # set to null to auto-detect
+  temperature: null      # null = Whisper fallback sequence, 0 = greedy
+  no_speech_threshold: 0.6
+  logprob_threshold: -1.0
+  compression_ratio_threshold: 2.4
+  condition_on_previous_text: false
+  vocab_file: null       # path to domain-specific vocabulary, defaults to vocab.txt in config dir
+```
+
+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 Whisper's fallback to higher-temperature decoding, and consider filtering out common hallucinations specific to your dataset.
+
+If `num_speakers` is known in advance, setting it gives more reliable diarization. Otherwise use `min_speakers`/`max_speakers` to constrain the range, or leave both null to let pyannote estimate freely.

dinnote-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+dinnote/__init__.py,sha256=vc55iHsOM2HYZhpzNLrMVrgMmXZ58FviGlqZpvpQSg8,344
+dinnote/cli.py,sha256=FMPG9xza0fsJJaC6nAKJ5kkJy_tKI6bG3y6hovL89jc,2531
+dinnote/config.py,sha256=S8c9v61az-HfPt839INBkG2prx4qCiYEbH5Y61ex9-k,2225
+dinnote/config.yaml,sha256=m4yCcbeCaMraP35C94lq9hUvTTPxzF1FsuHUCuqj8J4,2919
+dinnote/denoise.py,sha256=x1ifNQH92gTeV_9hyJ6bfSHLxH6XFrcdpLMaK7OusWM,2192
+dinnote/diarize.py,sha256=xfrtYd3dB-GY3SENSwi3Hg_wVmGfQbc566GSZl-mebM,4725
+dinnote/pipeline.py,sha256=VIr7pqlqHN5uYD3AYLcFhpSQyYpqAfaMKvR7OnIBs5Y,5474
+dinnote/transcribe.py,sha256=bzYs5lEJ6nQP8ekqUlkGKlWUecOGXj81fgwtBjXrHH8,7066
+dinnote/utils.py,sha256=1YwSmT0womyKWXb44eOxQcZhvZMkNBQhX2APwjcpkFo,2066
+dinnote/vad.py,sha256=6kVc2OStv004RuYeZacR6_yykwlwqXEOawjOlnsYUbA,4535
+dinnote/vocab.txt,sha256=SGKEzbXHiX9PaxLworj15o7O8rCca-0gM3K8f5G75N0,575
+dinnote-0.1.0.dist-info/METADATA,sha256=aJnkBEwEoknptUZgnTZ88_c_tbVbOhxQK72BhnxgL4M,4663
+dinnote-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+dinnote-0.1.0.dist-info/entry_points.txt,sha256=XV293h8uFditIf7hAHSOnhyMDpXj0hq2uFhmwTkxlb4,45
+dinnote-0.1.0.dist-info/top_level.txt,sha256=r_aQmbXJhOy4NsX6fxjdCyyD_TJvbjUasmbek0lJ7Ew,8
+dinnote-0.1.0.dist-info/RECORD,,

dinnote-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dinnote-0.1.0.dist-info/entry_points.txt

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

dinnote-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dinnote