Initial transcription scripts

- transcribe-transformers.py: Cohere Transcribe via transformers (161x RT on A100)
- transcribe.py: vLLM variant (214x RT, experimental)
- download-ia.py: Internet Archive to HF Bucket downloader

README.md

@@ -0,0 +1,75 @@
+---
+viewer: false
+tags:
+  - uv-script
+  - audio
+  - transcription
+  - automatic-speech-recognition
+private: true
+---
+
+# Transcription
+
+Scripts for transcribing audio files using HF Buckets and Jobs.
+
+## Quick Start
+
+```bash
+# 1. Download audio from Internet Archive straight into a bucket
+hf jobs uv run \
+    -v bucket/user/audio-files:/output \
+    download-ia.py SUSPENSE /output
+
+# 2. Transcribe — audio bucket in, transcript bucket out
+hf jobs uv run --flavor l4x1 -s HF_TOKEN \
+    -e UV_TORCH_BACKEND=cu124 \
+    -v bucket/user/audio-files:/input:ro \
+    -v bucket/user/transcripts:/output \
+    transcribe-transformers.py /input /output --language en --compile
+```
+
+No download/upload step. Buckets are mounted directly as volumes via [hf-mount](https://github.com/huggingface/hf-mount).
+
+## Scripts
+
+### Transcription
+
+| Script | Model | Backend | Speed (A100) |
+|--------|-------|---------|--------------|
+| `transcribe-transformers.py` | Cohere Transcribe (2B) | transformers | 161x RT |
+| `transcribe.py` | Cohere Transcribe (2B) | vLLM nightly | 214x RT |
+
+**`transcribe-transformers.py`** (recommended) — uses `model.transcribe()` with automatic long-form chunking, overlap, and reassembly. Stable dependencies.
+
+**`transcribe.py`** — experimental vLLM variant. Faster but requires nightly vLLM and has minor duplication at chunk boundaries.
+
+#### Options
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--language` | required | en, de, fr, it, es, pt, el, nl, pl, ar, vi, zh, ja, ko |
+| `--compile` | off | torch.compile encoder (one-time warmup, faster after) |
+| `--batch-size` | 16 | Batch size for inference |
+| `--max-files` | all | Limit files to process (for testing) |
+
+#### Benchmarks
+
+CBS Suspense (1940s radio drama), 66 episodes, 33 hours of audio:
+
+| GPU | Time | RTFx |
+|-----|------|------|
+| A100-SXM4-80GB | 12.3 min | 161x realtime |
+| L4 | ~64s / 30 min episode | 28x realtime |
+
+### Data
+
+| Script | Description |
+|--------|-------------|
+| `download-ia.py` | Download audio from Internet Archive into a mounted bucket |
+
+## Notes
+
+- **`UV_TORCH_BACKEND=cu124`**: Needed on A100 for correct CUDA torch build. Not needed on L4.
+- **`torch==2.6.0`**: Pinned for A100 CUDA driver compatibility.
+- **Gated model**: Accept terms at the [model page](https://huggingface.co/CohereLabs/cohere-transcribe-03-2026) before use.
+- **Tokenizer workaround**: `transcribe-transformers.py` applies a one-line patch for a tokenizer compat issue. Will be removed once upstream fixes land ([model discussion](https://huggingface.co/CohereLabs/cohere-transcribe-03-2026/discussions/11)).

download-ia.py

@@ -0,0 +1,152 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "internetarchive",
+#     "huggingface-hub",
+# ]
+# ///
+
+"""
+Download audio files from an Internet Archive item to an HF Bucket.
+
+Designed to run as a CPU HF Job with a mounted output bucket.
+
+Examples:
+
+  # Local — download to a local directory
+  uv run download-ia.py SUSPENSE ./suspense-audio
+
+  # HF Jobs — download straight into a bucket
+  hf jobs uv run \
+      -v bucket/user/audio-bucket:/output \
+      download-ia.py SUSPENSE /output
+
+  # With filters
+  uv run download-ia.py SUSPENSE ./output --glob '43-*'  --max-files 10
+"""
+
+import argparse
+import logging
+import sys
+import time
+from pathlib import Path
+
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+AUDIO_EXTENSIONS = {".mp3", ".wav", ".flac", ".ogg", ".m4a", ".aac", ".opus"}
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Download audio files from Internet Archive to a directory.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  uv run download-ia.py SUSPENSE ./output
+  uv run download-ia.py SUSPENSE ./output --glob '43-*' --max-files 10
+  uv run download-ia.py Dragnet_OTR ./output --max-files 20
+
+HF Jobs with bucket volume:
+  hf jobs uv run \\
+      -v bucket/user/audio-bucket:/output \\
+      download-ia.py SUSPENSE /output
+        """,
+    )
+    parser.add_argument("item_id", help="Internet Archive item identifier")
+    parser.add_argument("output_dir", help="Directory to download files to")
+    parser.add_argument(
+        "--glob",
+        default="*.mp3",
+        help="Glob pattern for files to download (default: *.mp3)",
+    )
+    parser.add_argument(
+        "--max-files",
+        type=int,
+        default=None,
+        help="Limit number of files to download",
+    )
+
+    args = parser.parse_args()
+
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    import internetarchive as ia
+
+    logger.info(f"Fetching file list for '{args.item_id}'...")
+    item = ia.get_item(args.item_id)
+
+    # Filter to audio files matching glob
+    import fnmatch
+
+    files = []
+    for f in item.files:
+        name = f["name"]
+        ext = Path(name).suffix.lower()
+        if ext in AUDIO_EXTENSIONS and fnmatch.fnmatch(name, args.glob):
+            files.append(f)
+
+    files.sort(key=lambda f: f["name"])
+
+    if not files:
+        logger.error(f"No audio files matching '{args.glob}' in item '{args.item_id}'")
+        sys.exit(1)
+
+    if args.max_files:
+        files = files[: args.max_files]
+
+    total_size = sum(int(f.get("size", 0)) for f in files)
+    logger.info(
+        f"Downloading {len(files)} file(s) "
+        f"({total_size / 1024 / 1024:.1f} MB) from '{args.item_id}'"
+    )
+
+    start_time = time.time()
+    downloaded = 0
+
+    for i, f in enumerate(files, 1):
+        name = f["name"]
+        dest = output_dir / name
+        if dest.exists():
+            logger.info(f"  [{i}/{len(files)}] {name} (already exists, skipping)")
+            downloaded += 1
+            continue
+
+        logger.info(f"  [{i}/{len(files)}] {name} ({int(f.get('size', 0)) / 1024 / 1024:.1f} MB)")
+        item.download(files=[name], destdir=str(output_dir), no_directory=True)
+        downloaded += 1
+
+    elapsed = time.time() - start_time
+    elapsed_str = f"{elapsed / 60:.1f} min" if elapsed > 60 else f"{elapsed:.1f}s"
+
+    logger.info("=" * 50)
+    logger.info(f"Done! Downloaded {downloaded} file(s) in {elapsed_str}")
+    logger.info(f"  Output: {output_dir}")
+    logger.info(f"  Total size: {total_size / 1024 / 1024:.1f} MB")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 1:
+        print("=" * 60)
+        print("Download Internet Archive Audio to Directory/Bucket")
+        print("=" * 60)
+        print()
+        print("Usage:")
+        print("  uv run download-ia.py ITEM_ID OUTPUT_DIR")
+        print()
+        print("Examples:")
+        print("  uv run download-ia.py SUSPENSE ./suspense-audio")
+        print("  uv run download-ia.py Dragnet_OTR ./dragnet --max-files 20")
+        print()
+        print("HF Jobs with bucket:")
+        print("  hf jobs uv run \\")
+        print("      -v bucket/user/audio-bucket:/output \\")
+        print("      download-ia.py SUSPENSE /output")
+        print()
+        print("For full help: uv run download-ia.py --help")
+        sys.exit(0)
+
+    main()

transcribe-transformers.py

@@ -0,0 +1,285 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "transformers>=4.56,<5.3,!=5.0.*,!=5.1.*",
+#     "torch==2.6.0",
+#     "huggingface-hub",
+#     "soundfile",
+#     "librosa",
+#     "sentencepiece",
+#     "protobuf",
+# ]
+# ///
+
+"""
+Transcribe audio files from a directory using Cohere Transcribe via transformers.
+
+Uses model.transcribe() which handles long-form audio automatically (chunking,
+overlap, reassembly). No nightly dependencies required.
+
+Designed to work with HF Buckets mounted as volumes via `hf jobs uv run -v ...`.
+
+Input:                              Output:
+  /input/episode1.mp3         ->      /output/episode1.txt
+  /input/sub/clip.wav         ->      /output/sub/clip.txt
+
+Examples:
+
+  # Local test (requires CUDA GPU)
+  uv run transcribe-transformers.py ./test-audio ./test-output --language en
+
+  # HF Jobs with bucket volumes
+  hf jobs uv run --flavor l4x1 \\
+      -s HF_TOKEN \\
+      -v bucket/user/audio-input:/input:ro \\
+      -v bucket/user/transcripts:/output \\
+      transcribe-transformers.py /input /output --language en --compile
+
+Model: CohereLabs/cohere-transcribe-03-2026 (2B, Apache 2.0)
+  - 14 languages: en, de, fr, it, es, pt, el, nl, pl, ar, vi, zh, ja, ko
+  - Automatic long-form chunking (>35s handled transparently)
+  - compile=True for torch.compile speedup (one-time warmup cost)
+"""
+
+import argparse
+import json
+import logging
+import sys
+import time
+from pathlib import Path
+
+import torch
+
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+MODEL = "CohereLabs/cohere-transcribe-03-2026"
+
+AUDIO_EXTENSIONS = {".mp3", ".wav", ".flac", ".ogg", ".m4a", ".wma", ".aac", ".opus"}
+
+SUPPORTED_LANGUAGES = {
+    "en", "de", "fr", "it", "es", "pt", "el", "nl", "pl", "ar", "vi", "zh", "ja", "ko",
+}
+
+
+def check_cuda_availability():
+    if not torch.cuda.is_available():
+        logger.error("CUDA is not available. This script requires a GPU.")
+        sys.exit(1)
+    logger.info(f"CUDA available. GPU: {torch.cuda.get_device_name(0)}")
+
+
+def discover_audio_files(input_dir: Path) -> list[Path]:
+    """Walk input_dir recursively, returning sorted list of audio files."""
+    files = []
+    for path in sorted(input_dir.rglob("*")):
+        if path.is_file() and path.suffix.lower() in AUDIO_EXTENSIONS:
+            files.append(path)
+    return files
+
+
+def get_audio_duration(file_path: Path) -> float | None:
+    """Get audio duration in seconds."""
+    try:
+        import librosa
+        return librosa.get_duration(path=str(file_path))
+    except Exception:
+        return None
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Transcribe audio files using Cohere Transcribe (transformers).",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Languages: en, de, fr, it, es, pt, el, nl, pl, ar, vi, zh, ja, ko
+
+Examples:
+  uv run transcribe-transformers.py ./audio ./output --language en
+  uv run transcribe-transformers.py /input /output --language en --compile
+
+HF Jobs with bucket volumes:
+  hf jobs uv run --flavor l4x1 -s HF_TOKEN \\
+      -v bucket/user/audio-bucket:/input:ro \\
+      -v bucket/user/transcripts:/output \\
+      transcribe-transformers.py /input /output --language en --compile
+        """,
+    )
+    parser.add_argument("input_dir", help="Directory containing audio files")
+    parser.add_argument("output_dir", help="Directory to write transcript text files")
+    parser.add_argument(
+        "--language",
+        required=True,
+        choices=sorted(SUPPORTED_LANGUAGES),
+        help="Language code (required, model does not auto-detect)",
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=16,
+        help="Batch size for inference (default: 16)",
+    )
+    parser.add_argument(
+        "--compile",
+        action="store_true",
+        help="Use torch.compile for faster throughput (one-time warmup cost)",
+    )
+    parser.add_argument(
+        "--max-files",
+        type=int,
+        default=None,
+        help="Limit number of files to process (for testing)",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Print resolved package versions",
+    )
+
+    args = parser.parse_args()
+
+    check_cuda_availability()
+
+    input_dir = Path(args.input_dir)
+    output_dir = Path(args.output_dir)
+
+    if not input_dir.is_dir():
+        logger.error(f"Input directory does not exist: {input_dir}")
+        sys.exit(1)
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Discover audio files
+    logger.info(f"Scanning {input_dir} for audio files...")
+    files = discover_audio_files(input_dir)
+    if not files:
+        logger.error(f"No audio files found in {input_dir}")
+        logger.error(f"Supported extensions: {', '.join(sorted(AUDIO_EXTENSIONS))}")
+        sys.exit(1)
+
+    if args.max_files:
+        files = files[: args.max_files]
+
+    logger.info(f"Found {len(files)} audio file(s)")
+
+    # Load model
+    logger.info(f"Loading {MODEL}...")
+    from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor
+
+    processor = AutoProcessor.from_pretrained(MODEL, trust_remote_code=True)
+
+    # Workaround: model.transcribe() -> _ensure_decode_pool accesses tokenizer
+    # attributes that CohereAsrTokenizer doesn't expose via the standard
+    # transformers interface. Patch them so transcribe() can build its pool.
+    tokenizer = processor.tokenizer
+    if not hasattr(tokenizer, "additional_special_tokens"):
+        tokenizer.additional_special_tokens = []
+
+    model = AutoModelForSpeechSeq2Seq.from_pretrained(
+        MODEL, trust_remote_code=True
+    ).to("cuda:0")
+    model.eval()
+    logger.info("Model loaded")
+
+    # Transcribe all files — model.transcribe() handles chunking and batching
+    file_paths = [str(f) for f in files]
+
+    logger.info(
+        f"Transcribing {len(files)} file(s) "
+        f"(compile={args.compile}, batch_size={args.batch_size})..."
+    )
+
+    start_time = time.time()
+
+    texts = model.transcribe(
+        processor=processor,
+        audio_files=file_paths,
+        language=args.language,
+        compile=args.compile,
+        pipeline_detokenization=True,
+        batch_size=args.batch_size,
+    )
+
+    elapsed = time.time() - start_time
+
+    # Write outputs
+    total_audio_duration = 0.0
+    results = []
+
+    for file_path, text in zip(files, texts):
+        rel = file_path.relative_to(input_dir)
+        txt_path = output_dir / rel.with_suffix(".txt")
+        txt_path.parent.mkdir(parents=True, exist_ok=True)
+        txt_path.write_text(text, encoding="utf-8")
+
+        duration = get_audio_duration(file_path)
+        if duration:
+            total_audio_duration += duration
+
+        results.append({
+            "file": str(rel),
+            "duration_s": round(duration, 1) if duration else None,
+            "transcript_length": len(text),
+            "word_count": len(text.split()),
+        })
+        logger.info(
+            f"  {rel} -> {txt_path.name} "
+            f"({len(text.split())} words"
+            f"{f', {duration:.0f}s audio' if duration else ''})"
+        )
+
+    # Write summary
+    summary_path = output_dir / "summary.jsonl"
+    with open(summary_path, "w", encoding="utf-8") as f:
+        for r in results:
+            f.write(json.dumps(r) + "\n")
+
+    # Report
+    elapsed_str = f"{elapsed / 60:.1f} min" if elapsed > 60 else f"{elapsed:.1f}s"
+    logger.info("=" * 50)
+    logger.info(f"Done! Transcribed {len(files)} file(s) in {elapsed_str}")
+    logger.info(f"  Output: {output_dir}")
+    if total_audio_duration > 0:
+        rtfx = total_audio_duration / elapsed
+        logger.info(f"  Audio: {total_audio_duration / 60:.1f} min total")
+        logger.info(f"  RTFx: {rtfx:.1f}x realtime")
+    logger.info(f"  Summary: {summary_path}")
+
+    if args.verbose:
+        import importlib.metadata
+        logger.info("--- Package versions ---")
+        for pkg in ["transformers", "torch", "librosa", "soundfile", "huggingface-hub"]:
+            try:
+                logger.info(f"  {pkg}=={importlib.metadata.version(pkg)}")
+            except importlib.metadata.PackageNotFoundError:
+                logger.info(f"  {pkg}: not installed")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 1:
+        print("=" * 60)
+        print("Audio Transcription with Cohere Transcribe (transformers)")
+        print("=" * 60)
+        print("\nTranscribe audio files from a directory -> text files.")
+        print("Long audio handled automatically (chunking + overlap).")
+        print("Designed for HF Buckets mounted as volumes.")
+        print()
+        print("Usage:")
+        print("  uv run transcribe-transformers.py INPUT_DIR OUTPUT_DIR --language en")
+        print()
+        print("Examples:")
+        print("  uv run transcribe-transformers.py ./audio ./output --language en")
+        print("  uv run transcribe-transformers.py ./audio ./output --language en --compile")
+        print()
+        print("HF Jobs with bucket volumes:")
+        print("  hf jobs uv run --flavor l4x1 -s HF_TOKEN \\")
+        print("      -v bucket/user/audio-input:/input:ro \\")
+        print("      -v bucket/user/transcripts:/output \\")
+        print("      transcribe-transformers.py /input /output --language en --compile")
+        print()
+        print("For full help: uv run transcribe-transformers.py --help")
+        sys.exit(0)
+
+    main()

transcribe.py

@@ -0,0 +1,338 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "vllm",
+#     "torch",
+#     "huggingface-hub",
+#     "soundfile",
+#     "librosa",
+#     "numpy",
+# ]
+#
+# [[tool.uv.index]]
+# url = "https://wheels.vllm.ai/nightly/cu129"
+#
+# [tool.uv]
+# prerelease = "allow"
+# ///
+
+"""
+Transcribe audio files from a directory using Cohere Transcribe via vLLM.
+
+Designed to work with HF Buckets mounted as volumes via `hf jobs uv run -v ...`.
+
+Long audio files (>30s) are automatically chunked with overlap and reassembled.
+All chunks from all files are batched through vLLM in a single call for maximum
+throughput.
+
+Input:                              Output:
+  /input/episode1.mp3         ->      /output/episode1.txt
+  /input/sub/clip.wav         ->      /output/sub/clip.txt
+
+Examples:
+
+  # Local test (requires CUDA GPU)
+  uv run transcribe.py ./test-audio ./test-output --language en
+
+  # HF Jobs with bucket volumes
+  hf jobs uv run --flavor l4x1 \\
+      -s HF_TOKEN \\
+      -v bucket/user/audio-input:/input:ro \\
+      -v bucket/user/transcripts:/output \\
+      transcribe.py /input /output --language en
+
+Model: CohereLabs/cohere-transcribe-03-2026 (2B, Apache 2.0)
+  - 14 languages: en, de, fr, it, es, pt, el, nl, pl, ar, vi, zh, ja, ko
+  - Up to 3x faster than other dedicated ASR models in same size range
+"""
+
+import argparse
+import json
+import logging
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+MODEL = "CohereLabs/cohere-transcribe-03-2026"
+
+AUDIO_EXTENSIONS = {".mp3", ".wav", ".flac", ".ogg", ".m4a", ".wma", ".aac", ".opus"}
+
+SUPPORTED_LANGUAGES = {
+    "en", "de", "fr", "it", "es", "pt", "el", "nl", "pl", "ar", "vi", "zh", "ja", "ko",
+}
+
+# Chunking config — matches model's internal chunking behavior
+CHUNK_DURATION_S = 30  # seconds per chunk
+OVERLAP_S = 2  # overlap between chunks to avoid cutting mid-word
+SAMPLE_RATE = 16000
+
+
+def check_cuda_availability():
+    if not torch.cuda.is_available():
+        logger.error("CUDA is not available. This script requires a GPU.")
+        sys.exit(1)
+    logger.info(f"CUDA available. GPU: {torch.cuda.get_device_name(0)}")
+
+
+def discover_audio_files(input_dir: Path) -> list[Path]:
+    """Walk input_dir recursively, returning sorted list of audio files."""
+    files = []
+    for path in sorted(input_dir.rglob("*")):
+        if path.is_file() and path.suffix.lower() in AUDIO_EXTENSIONS:
+            files.append(path)
+    return files
+
+
+def load_audio(file_path: Path) -> tuple[np.ndarray, int]:
+    """Load audio file resampled to 16kHz mono."""
+    import librosa
+    audio, sr = librosa.load(str(file_path), sr=SAMPLE_RATE, mono=True)
+    return audio, sr
+
+
+def chunk_audio(audio: np.ndarray, sr: int) -> list[np.ndarray]:
+    """Split audio into overlapping chunks. Short audio returned as single chunk."""
+    chunk_samples = CHUNK_DURATION_S * sr
+    overlap_samples = OVERLAP_S * sr
+    step = chunk_samples - overlap_samples
+
+    if len(audio) <= chunk_samples:
+        return [audio]
+
+    chunks = []
+    start = 0
+    while start < len(audio):
+        end = min(start + chunk_samples, len(audio))
+        chunks.append(audio[start:end])
+        if end >= len(audio):
+            break
+        start += step
+
+    return chunks
+
+
+def build_prompt(language: str) -> str:
+    """Build the CohereASR prompt with language tokens."""
+    return (
+        f"<|startofcontext|><|startoftranscript|>"
+        f"<|emo:undefined|><|{language}|><|{language}|><|pnc|><|noitn|>"
+        f"<|notimestamp|><|nodiarize|>"
+    )
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Transcribe audio files using Cohere Transcribe via vLLM.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Languages: en, de, fr, it, es, pt, el, nl, pl, ar, vi, zh, ja, ko
+
+Examples:
+  uv run transcribe.py ./audio ./output --language en
+  uv run transcribe.py /input /output --language en --max-files 3
+
+HF Jobs with bucket volumes:
+  hf jobs uv run --flavor l4x1 -s HF_TOKEN \\
+      -v bucket/user/audio-bucket:/input:ro \\
+      -v bucket/user/transcripts:/output \\
+      transcribe.py /input /output --language en
+        """,
+    )
+    parser.add_argument("input_dir", help="Directory containing audio files")
+    parser.add_argument("output_dir", help="Directory to write transcript text files")
+    parser.add_argument(
+        "--language",
+        required=True,
+        choices=sorted(SUPPORTED_LANGUAGES),
+        help="Language code (required, model does not auto-detect)",
+    )
+    parser.add_argument(
+        "--max-files",
+        type=int,
+        default=None,
+        help="Limit number of files to process (for testing)",
+    )
+    parser.add_argument(
+        "--gpu-memory-utilization",
+        type=float,
+        default=0.8,
+        help="GPU memory utilization (default: 0.8)",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Print resolved package versions",
+    )
+
+    args = parser.parse_args()
+
+    check_cuda_availability()
+
+    input_dir = Path(args.input_dir)
+    output_dir = Path(args.output_dir)
+
+    if not input_dir.is_dir():
+        logger.error(f"Input directory does not exist: {input_dir}")
+        sys.exit(1)
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Discover audio files
+    logger.info(f"Scanning {input_dir} for audio files...")
+    files = discover_audio_files(input_dir)
+    if not files:
+        logger.error(f"No audio files found in {input_dir}")
+        logger.error(f"Supported extensions: {', '.join(sorted(AUDIO_EXTENSIONS))}")
+        sys.exit(1)
+
+    if args.max_files:
+        files = files[: args.max_files]
+
+    logger.info(f"Found {len(files)} audio file(s)")
+
+    # Load and chunk audio files
+    logger.info("Loading and chunking audio files...")
+    file_audio = []  # (file_path, full_audio, sr)
+    all_chunks = []  # (file_index, chunk_array) — flat list for batching
+    for i, f in enumerate(files):
+        audio, sr = load_audio(f)
+        file_audio.append((f, audio, sr))
+        chunks = chunk_audio(audio, sr)
+        duration = len(audio) / sr
+        logger.info(f"  {f.name}: {duration:.0f}s -> {len(chunks)} chunk(s)")
+        for chunk in chunks:
+            all_chunks.append((i, chunk))
+
+    total_chunks = len(all_chunks)
+    logger.info(f"Total chunks to transcribe: {total_chunks}")
+
+    # Init vLLM
+    logger.info(f"Initializing vLLM with {MODEL}...")
+    from vllm import LLM, SamplingParams
+
+    llm = LLM(
+        model=MODEL,
+        trust_remote_code=True,
+        limit_mm_per_prompt={"audio": 1},
+        gpu_memory_utilization=args.gpu_memory_utilization,
+    )
+
+    sampling_params = SamplingParams(
+        temperature=0.0,
+        max_tokens=1024,
+    )
+
+    # Build inputs — one prompt per chunk
+    prompt = build_prompt(args.language)
+    inputs = [
+        {
+            "prompt": prompt,
+            "multi_modal_data": {"audio": [(chunk, SAMPLE_RATE)]},
+        }
+        for _, chunk in all_chunks
+    ]
+
+    # Transcribe all chunks in one batch
+    logger.info(f"Transcribing {total_chunks} chunk(s) across {len(files)} file(s)...")
+    start_time = time.time()
+
+    outputs = llm.generate(inputs, sampling_params)
+
+    elapsed = time.time() - start_time
+
+    # Reassemble chunks per file
+    file_texts: dict[int, list[str]] = {}
+    for (file_idx, _), output in zip(all_chunks, outputs):
+        text = output.outputs[0].text.strip()
+        file_texts.setdefault(file_idx, []).append(text)
+
+    # Write outputs
+    total_audio_duration = 0.0
+    results = []
+
+    for i, (file_path, audio, sr) in enumerate(file_audio):
+        chunks_text = file_texts.get(i, [])
+        full_text = " ".join(chunks_text)
+
+        rel = file_path.relative_to(input_dir)
+        txt_path = output_dir / rel.with_suffix(".txt")
+        txt_path.parent.mkdir(parents=True, exist_ok=True)
+        txt_path.write_text(full_text, encoding="utf-8")
+
+        duration = len(audio) / sr
+        total_audio_duration += duration
+
+        results.append({
+            "file": str(rel),
+            "duration_s": round(duration, 1),
+            "chunks": len(chunks_text),
+            "transcript_length": len(full_text),
+            "word_count": len(full_text.split()),
+        })
+        logger.info(
+            f"  {rel} -> {txt_path.name} "
+            f"({len(full_text.split())} words, {len(chunks_text)} chunks, "
+            f"{duration:.0f}s audio)"
+        )
+
+    # Write summary
+    summary_path = output_dir / "summary.jsonl"
+    with open(summary_path, "w", encoding="utf-8") as f:
+        for r in results:
+            f.write(json.dumps(r) + "\n")
+
+    # Report
+    elapsed_str = f"{elapsed / 60:.1f} min" if elapsed > 60 else f"{elapsed:.1f}s"
+    rtfx = total_audio_duration / elapsed if elapsed > 0 else 0
+    logger.info("=" * 50)
+    logger.info(f"Done! Transcribed {len(files)} file(s) in {elapsed_str}")
+    logger.info(f"  Output: {output_dir}")
+    logger.info(f"  Audio: {total_audio_duration / 60:.1f} min total")
+    logger.info(f"  RTFx: {rtfx:.1f}x realtime")
+    logger.info(f"  Total chunks: {total_chunks}")
+    logger.info(f"  Summary: {summary_path}")
+
+    if args.verbose:
+        import importlib.metadata
+        logger.info("--- Package versions ---")
+        for pkg in ["vllm", "transformers", "torch", "librosa", "soundfile"]:
+            try:
+                logger.info(f"  {pkg}=={importlib.metadata.version(pkg)}")
+            except importlib.metadata.PackageNotFoundError:
+                logger.info(f"  {pkg}: not installed")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 1:
+        print("=" * 60)
+        print("Audio Transcription with Cohere Transcribe (vLLM)")
+        print("=" * 60)
+        print("\nTranscribe audio files from a directory -> text files.")
+        print("Long audio automatically chunked with overlap.")
+        print("Designed for HF Buckets mounted as volumes.")
+        print()
+        print("Usage:")
+        print("  uv run transcribe.py INPUT_DIR OUTPUT_DIR --language en")
+        print()
+        print("Examples:")
+        print("  uv run transcribe.py ./audio ./output --language en")
+        print("  uv run transcribe.py ./audio ./output --language en --max-files 3")
+        print()
+        print("HF Jobs with bucket volumes:")
+        print("  hf jobs uv run --flavor l4x1 -s HF_TOKEN \\")
+        print("      -v bucket/user/audio-input:/input:ro \\")
+        print("      -v bucket/user/transcripts:/output \\")
+        print("      transcribe.py /input /output --language en")
+        print()
+        print("For full help: uv run transcribe.py --help")
+        sys.exit(0)
+
+    main()