audio-scribe 0.1.0__py3-none-any.whl

audio_scribe/cli.py

@@ -0,0 +1,567 @@
+#!/usr/bin/env python3
+"""
+Audio Scribe 
+-----------------
+A command-line script for transcribing audio files with speaker diarization
+using Whisper and Pyannote. The script uses a Hugging Face token for
+downloading Pyannote speaker-diarization models and displays a progress bar
+with resource usage while transcribing.
+"""
+
+print("Initializing environment... Please wait while we load dependencies and models.")
+import sys
+sys.stdout.flush()
+
+import os
+import glob
+import wave
+import json
+import logging
+import warnings
+import argparse
+import readline  # <--- For enabling tab-completion on Unix/Linux
+from pathlib import Path
+from datetime import datetime
+from typing import Optional, Dict
+from dataclasses import dataclass
+import base64
+
+from cryptography.fernet import Fernet
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+
+import torch
+import whisper
+
+import importlib.metadata
+from importlib.metadata import PackageNotFoundError
+
+from pyannote.audio import Pipeline
+
+# Attempt to import optional packages for progress bar and resource monitoring
+try:
+    from alive_progress import alive_bar
+    import psutil
+    import GPUtil
+    HAVE_PROGRESS_SUPPORT = True
+except ImportError:
+    HAVE_PROGRESS_SUPPORT = False
+
+# Configure logging
+LOG_FORMAT = "%(asctime)s - %(levelname)s - %(message)s"
+logging.basicConfig(
+    level=logging.INFO,
+    format=LOG_FORMAT,
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler("transcription.log", mode="a", encoding="utf-8"),
+    ],
+)
+logger = logging.getLogger(__name__)
+
+# ---------- FILE PATH TAB-COMPLETION SNIPPET ----------
+def complete_path(text, state):
+    """
+    Return the 'state'-th completion for 'text'.
+    This function will be used by 'readline' to enable file path autocompletion.
+    """
+    # If the user typed a glob pattern (with * or ?)
+    if '*' in text or '?' in text:
+        matches = glob.glob(text)
+    else:
+        # Split off the directory name and partial file/directory name
+        directory, partial = os.path.split(text)
+        if not directory:
+            directory = '.'
+        try:
+            # List everything in 'directory' that starts with 'partial'
+            entries = os.listdir(directory)
+        except OSError:
+            # If directory doesn't exist or we lack permission, no matches
+            entries = []
+
+        matches = []
+        for entry in entries:
+            if entry.startswith(partial):
+                full_path = os.path.join(directory, entry)
+                # If it's a directory, add a trailing slash to indicate that
+                if os.path.isdir(full_path) and not full_path.endswith(os.path.sep):
+                    full_path += os.path.sep
+                matches.append(full_path)
+
+    # Sort matches to have a consistent order
+    matches.sort()
+
+    # If 'state' is beyond last match, return None
+    return matches[state] if state < len(matches) else None
+
+
+@dataclass
+class TranscriptionConfig:
+    """
+    Configuration settings for the transcription pipeline.
+    """
+    output_directory: Path
+    whisper_model: str = "base.en"
+    diarization_model: str = "pyannote/speaker-diarization-3.1"
+    temp_directory: Optional[Path] = None
+    device: Optional[str] = None
+
+    def __post_init__(self):
+        # Use CUDA if available, else fall back to CPU
+        self.device = self.device or ("cuda" if torch.cuda.is_available() else "cpu")
+        # Default temp directory inside the output directory
+        self.temp_directory = self.temp_directory or (self.output_directory / "temp")
+        # Ensure directories exist
+        self.temp_directory.mkdir(parents=True, exist_ok=True)
+        self.output_directory.mkdir(parents=True, exist_ok=True)
+
+
+class TokenManager:
+    """
+    Handles secure storage and retrieval of the Hugging Face authentication token.
+    """
+    def __init__(self):
+        # Store config in ~/.pyannote/config.json
+        self.config_dir = Path.home() / ".pyannote"
+        self.config_file = self.config_dir / "config.json"
+        self._initialize_config()
+
+    def _initialize_config(self) -> None:
+        """
+        Initialize configuration directory and file with secure permissions.
+        """
+        self.config_dir.mkdir(exist_ok=True)
+        if not self.config_file.exists():
+            self._save_config({})
+
+        # Set secure file and directory permissions on POSIX systems
+        if os.name == "posix":
+            os.chmod(self.config_dir, 0o700)
+            os.chmod(self.config_file, 0o600)
+
+    def _get_encryption_key(self) -> bytes:
+        """
+        Generate an encryption key from system-specific data.
+        """
+        salt = b"pyannote-audio-salt"
+        kdf = PBKDF2HMAC(
+            algorithm=hashes.SHA256(),
+            length=32,
+            salt=salt,
+            iterations=100000,
+        )
+        key = kdf.derive(str(Path.home()).encode())
+        return base64.urlsafe_b64encode(key)
+
+    def _save_config(self, config: dict) -> None:
+        """
+        Securely save configuration to file.
+        """
+        with open(self.config_file, "w", encoding="utf-8") as f:
+            json.dump(config, f)
+
+    def _load_config(self) -> dict:
+        """
+        Load configuration from file.
+        """
+        try:
+            with open(self.config_file, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception:
+            return {}
+
+    def store_token(self, token: str) -> bool:
+        """
+        Securely store authentication token.
+        """
+        try:
+            fernet = Fernet(self._get_encryption_key())
+            encrypted_token = fernet.encrypt(token.encode())
+
+            config = self._load_config()
+            config["token"] = encrypted_token.decode()
+
+            self._save_config(config)
+            return True
+        except Exception as e:
+            logger.error(f"Failed to store token: {e}")
+            return False
+
+    def retrieve_token(self) -> Optional[str]:
+        """
+        Retrieve stored authentication token.
+        """
+        try:
+            config = self._load_config()
+            if "token" in config:
+                fernet = Fernet(self._get_encryption_key())
+                return fernet.decrypt(config["token"].encode()).decode()
+        except Exception as e:
+            logger.error(f"Failed to retrieve token: {e}")
+        return None
+
+    def delete_token(self) -> bool:
+        """
+        Delete stored authentication token.
+        """
+        try:
+            config = self._load_config()
+            if "token" in config:
+                del config["token"]
+                self._save_config(config)
+            return True
+        except Exception as e:
+            logger.error(f"Failed to delete token: {e}")
+            return False
+
+
+class DependencyManager:
+    """
+    Manages and verifies system dependencies using importlib.metadata.
+    """
+    REQUIRED_PACKAGES = {
+        "torch": None,
+        "pyannote.audio": None,
+        "openai-whisper": None,
+        "pytorch-lightning": None,
+        "keyring": None,
+    }
+
+    @classmethod
+    def verify_dependencies(cls) -> bool:
+        """
+        Verify all required dependencies are installed with correct versions
+        (if specified). Returns True if all are installed and correct, False otherwise.
+        """
+        missing = []
+        outdated = []
+
+        for package, required_version in cls.REQUIRED_PACKAGES.items():
+            try:
+                installed_version = importlib.metadata.version(package)
+                if required_version and installed_version != required_version:
+                    outdated.append(
+                        f"{package} (installed: {installed_version}, required: {required_version})"
+                    )
+            except PackageNotFoundError:
+                missing.append(package)
+
+        if missing or outdated:
+            if missing:
+                logger.error("Missing packages: %s", ", ".join(missing))
+            if outdated:
+                logger.error("Outdated packages: %s", ", ".join(outdated))
+            logger.info(
+                "Install required packages: pip install %s",
+                " ".join(
+                    f"{pkg}=={ver}" if ver else pkg
+                    for pkg, ver in cls.REQUIRED_PACKAGES.items()
+                ),
+            )
+            return False
+        return True
+
+
+class AudioProcessor:
+    """
+    Handles audio file processing and segmentation using the `wave` module.
+    """
+    def __init__(self, config: TranscriptionConfig):
+        self.config = config
+
+    def load_audio_segment(
+        self,
+        audio_path: Path,
+        start_time: float,
+        end_time: float,
+        output_path: Path,
+    ) -> bool:
+        """
+        Extract and save the audio segment from `start_time` to `end_time`.
+        """
+        try:
+            with wave.open(str(audio_path), "rb") as infile:
+                params = infile.getparams()
+                frame_rate = params.framerate
+                start_frame = int(start_time * frame_rate)
+                end_frame = min(int(end_time * frame_rate), infile.getnframes())
+
+                infile.setpos(start_frame)
+                frames = infile.readframes(end_frame - start_frame)
+
+                with wave.open(str(output_path), "wb") as outfile:
+                    outfile.setparams(params)
+                    outfile.writeframes(frames)
+            return True
+        except Exception as e:
+            logger.error(f"Failed to process audio segment: {e}")
+            return False
+
+
+class TranscriptionPipeline:
+    """
+    Main pipeline for audio transcription (Whisper) and speaker diarization (Pyannote).
+    """
+    def __init__(self, config: TranscriptionConfig):
+        self.config = config
+        self.diarization_pipeline = None
+        self.whisper_model = None
+        self.token_manager = TokenManager()
+        self._running = False  # used for resource monitor thread
+
+    def initialize_models(self, auth_token: str) -> bool:
+        """
+        Initialize the Pyannote diarization pipeline and the Whisper model.
+        """
+        try:
+            # Load Whisper model (set download root to avoid clutter in home directory)
+            self.whisper_model = whisper.load_model(
+                self.config.whisper_model,
+                device=self.config.device,
+                download_root=str(self.config.output_directory / "models"),
+            )
+
+            # Load Pyannote diarization pipeline
+            self.diarization_pipeline = Pipeline.from_pretrained(
+                self.config.diarization_model, use_auth_token=auth_token
+            )
+            self.diarization_pipeline.to(torch.device(self.config.device))
+
+            if self.config.device == "cpu":
+                warnings.warn("Running on CPU. GPU is recommended for better performance.")
+
+            return True
+        except Exception as e:
+            logger.error(f"Model initialization failed: {e}")
+            logger.error("Please ensure you have accepted the model conditions at:")
+            logger.error("  1. https://huggingface.co/pyannote/segmentation-3.0")
+            logger.error("  2. https://huggingface.co/pyannote/speaker-diarization-3.1")
+            return False
+
+    def _update_resources(self, bar):
+        """
+        Continuously update progress bar text with CPU/MEM/GPU usage, until self._running is False.
+        """
+        while self._running:
+            try:
+                import time
+                time.sleep(0.5)
+
+                cpu_usage = psutil.cpu_percent(interval=None) if HAVE_PROGRESS_SUPPORT else 0
+                memory_usage = psutil.virtual_memory().percent if HAVE_PROGRESS_SUPPORT else 0
+
+                if HAVE_PROGRESS_SUPPORT and GPUtil.getGPUs():
+                    gpus = GPUtil.getGPUs()
+                    gpu_mem_used = f"{gpus[0].memoryUsed:.0f}"
+                    gpu_mem_total = f"{gpus[0].memoryTotal:.0f}"
+                    gpu_usage_text = f"{gpu_mem_used}/{gpu_mem_total} MB"
+                else:
+                    gpu_usage_text = "N/A"
+
+                resource_text = f"CPU: {cpu_usage}%, MEM: {memory_usage}%, GPU Mem: {gpu_usage_text}"
+                bar.text(resource_text)
+            except Exception as e:
+                logger.error(f"Resource monitoring error: {e}")
+
+    def process_file(self, audio_path: Path) -> bool:
+        """
+        Diarize, segment, and transcribe using Whisper + Pyannote with progress feedback.
+        """
+        try:
+            logger.info("Starting audio processing...")
+            diarization = self.diarization_pipeline(str(audio_path))
+            segments = list(diarization.itertracks(yield_label=True))
+            total_segments = len(segments)
+
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            output_file = self.config.output_directory / f"transcript_{timestamp}.txt"
+            audio_processor = AudioProcessor(self.config)
+
+            if not HAVE_PROGRESS_SUPPORT:
+                # No alive_progress, psutil, or GPUtil installed
+                logger.info("Processing audio without progress bar (missing optional packages).")
+                with output_file.open("w", encoding="utf-8") as f:
+                    for turn, _, speaker in segments:
+                        segment_path = (
+                            self.config.temp_directory
+                            / f"segment_{speaker}_{turn.start:.2f}_{turn.end:.2f}.wav"
+                        )
+                        if audio_processor.load_audio_segment(audio_path, turn.start, turn.end, segment_path):
+                            transcription = self.whisper_model.transcribe(str(segment_path))["text"]
+                            segment_path.unlink(missing_ok=True)
+
+                            line = f"[{turn.start:.2f}s - {turn.end:.2f}s] Speaker {speaker}: {transcription.strip()}\n"
+                            f.write(line)
+                            logger.info(line.strip())
+            else:
+                # Use a progress bar to track segment transcription
+                from alive_progress import alive_bar
+                import threading
+
+                self._running = True
+                with output_file.open("w", encoding="utf-8") as f, alive_bar(
+                    total_segments,
+                    title="Transcribing Audio",
+                    spinner="pulse",
+                    theme="classic",
+                    stats=False,
+                    elapsed=True,
+                    monitor=True,
+                ) as bar:
+
+                    # Start a background thread for resource monitoring
+                    resource_thread = threading.Thread(target=self._update_resources, args=(bar,))
+                    resource_thread.start()
+
+                    for turn, _, speaker in segments:
+                        segment_path = (
+                            self.config.temp_directory
+                            / f"segment_{speaker}_{turn.start:.2f}_{turn.end:.2f}.wav"
+                        )
+                        if audio_processor.load_audio_segment(audio_path, turn.start, turn.end, segment_path):
+                            transcription = self.whisper_model.transcribe(str(segment_path))["text"]
+                            segment_path.unlink(missing_ok=True)
+
+                            line = f"[{turn.start:.2f}s - {turn.end:.2f}s] Speaker {speaker}: {transcription.strip()}\n"
+                            f.write(line)
+                            logger.info(line.strip())
+
+                        # Update the progress bar
+                        bar()
+
+                    # Stop resource monitoring
+                    self._running = False
+                    resource_thread.join()
+
+            logger.info(f"Transcription completed. Output saved to: {output_file}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Processing failed: {e}")
+            return False
+
+
+def get_token(token_manager: TokenManager) -> Optional[str]:
+    """
+    Get authentication token from storage or user input.
+    """
+    stored_token = token_manager.retrieve_token()
+    if stored_token:
+        choice = input("\nUse the stored Hugging Face token? (y/n): ").lower().strip()
+        if choice == "y":
+            return stored_token
+
+    print("\nA HuggingFace token is required for speaker diarization.")
+    print("Get your token at: https://huggingface.co/settings/tokens")
+    print("\nEnsure you have accepted:")
+    print("  1. pyannote/segmentation-3.0 conditions")
+    print("  2. pyannote/speaker-diarization-3.1 conditions")
+
+    token = input("\nEnter HuggingFace token: ").strip()
+    if token:
+        choice = input("Save token for future use? (y/n): ").lower().strip()
+        if choice == "y":
+            if token_manager.store_token(token):
+                print("Token saved successfully.")
+            else:
+                print("Failed to save token. It will be used for this session only.")
+    return token if token else None
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Audio Transcription Pipeline using Whisper + Pyannote, with optional progress bar."
+    )
+    parser.add_argument(
+        "--audio", 
+        type=Path, 
+        help="Path to the audio file to transcribe."
+    )
+    parser.add_argument(
+        "--token", 
+        help="HuggingFace API token. Overrides any saved token."
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        help="Path to the output directory for transcripts and temporary files.",
+    )
+    parser.add_argument(
+        "--delete-token",
+        action="store_true",
+        help="Delete any stored Hugging Face token and exit.",
+    )
+    parser.add_argument(
+        "--show-warnings",
+        action="store_true",
+        help="Enable user warnings (e.g., from pyannote.audio). Disabled by default.",
+    )
+    parser.add_argument(
+        "--whisper-model",
+        default="base.en",
+        help="Specify the Whisper model to use (default: 'base.en').",
+    )
+    args = parser.parse_args()
+
+    # Manage user warnings
+    if not args.show_warnings:
+        warnings.filterwarnings("ignore", category=UserWarning, module=r"pyannote\.audio")
+        warnings.filterwarnings("ignore", category=FutureWarning, module="whisper")
+    else:
+        warnings.resetwarnings()
+
+    # Check dependencies
+    if not DependencyManager.verify_dependencies():
+        sys.exit(1)
+
+    # Initialize tab-completion for file paths (Unix-like only, or with pyreadline on Windows)
+    readline.set_completer_delims(' \t\n;')
+    readline.set_completer(complete_path)
+    readline.parse_and_bind("tab: complete")
+
+    # Initialize the token manager
+    token_manager = TokenManager()
+
+    # If user wants to delete the stored token, do so and exit
+    if args.delete_token:
+        success = token_manager.delete_token()
+        sys.exit(0 if success else 1)
+
+    # Prepare configuration
+    output_dir = args.output or (Path("transcripts") / datetime.now().strftime("%Y%m%d"))
+    config = TranscriptionConfig(
+        output_directory=output_dir,
+        whisper_model=args.whisper_model
+    )
+
+    # Initialize pipeline
+    pipeline = TranscriptionPipeline(config)
+    hf_token = args.token or get_token(token_manager)
+    if not hf_token:
+        logger.error("No Hugging Face token provided. Exiting.")
+        sys.exit(1)
+
+    # Initialize models
+    if not pipeline.initialize_models(hf_token):
+        logger.error("Failed to initialize pipeline. Exiting.")
+        sys.exit(1)
+
+    # Prompt user for audio file path if not passed in
+    audio_path = args.audio
+    while not audio_path or not audio_path.exists():
+        audio_path_str = input("\nEnter path to audio file (Tab for autocomplete): ").strip()
+        audio_path = Path(audio_path_str)
+        if not audio_path.exists():
+            print(f"File '{audio_path}' not found. Please try again.")
+
+    print("Audio file path accepted. Preparing to process the audio...")
+    sys.stdout.flush()
+
+    # Process the audio file
+    if not pipeline.process_file(audio_path):
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

audio_scribe-0.1.0.dist-info/METADATA

@@ -0,0 +1,273 @@
+Metadata-Version: 2.2
+Name: audio_scribe
+Version: 0.1.0
+Summary: A command-line tool for audio transcription with Whisper and Pyannote.
+Home-page: https://gitlab.genomicops.cloud/genomicops/audio-scribe
+Author: Gurasis Osahan
+Author-email: contact@genomicops.com
+License: Apache-2.0
+Project-URL: Source, https://gitlab.genomicops.cloud/genomicops/audio-scribe
+Project-URL: Tracker, https://gitlab.genomicops.cloud/genomicops/audio-scribe/-/issues
+Keywords: whisper pyannote transcription audio diarization
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: torch
+Requires-Dist: openai-whisper
+Requires-Dist: pyannote.audio
+Requires-Dist: pytorch-lightning
+Requires-Dist: keyring
+Requires-Dist: cryptography
+Requires-Dist: alive-progress
+Requires-Dist: psutil
+Requires-Dist: GPUtil
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Audio Scribe
+
+**A Command-Line Tool for Audio Transcription (Audio Scribe) and Speaker Diarization Using OpenAI Whisper and Pyannote**
+
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
+
+## Overview
+
+**Audio Scribe** is a command-line tool that transcribes audio files with speaker diarization. Leveraging [OpenAI Whisper](https://github.com/openai/whisper) for transcription and [Pyannote Audio](https://github.com/pyannote/pyannote-audio) for speaker diarization, this solution converts audio into segmented text files, identifying each speaker turn. Key features include:
+
+- **Progress Bar & Resource Monitoring**: See real-time CPU, memory, and GPU usage with a live progress bar.  
+- **Speaker Diarization**: Automatically separates speaker turns using Pyannote’s state-of-the-art models.  
+- **Tab-Completion for File Paths**: Easily navigate your file system when prompted for the audio path.  
+- **Secure Token Storage**: Encrypts and stores your Hugging Face token for private model downloads.  
+- **Customizable Whisper Models**: Default to `base.en`, or specify `tiny`, `small`, `medium`, `large`, etc.
+
+This repository is licensed under the [Apache License 2.0](#license).
+
+---
+
+## Table of Contents
+
+- [Audio Scribe](#audio-scribe)
+  - [Overview](#overview)
+  - [Table of Contents](#table-of-contents)
+  - [Features](#features)
+  - [Installation](#installation)
+    - [Installing from PyPI](#installing-from-pypi)
+    - [Installing from GitHub](#installing-from-github)
+  - [Quick Start](#quick-start)
+  - [Usage](#usage)
+  - [Dependencies](#dependencies)
+    - [Sample `requirements.txt`](#sample-requirementstxt)
+  - [Contributing](#contributing)
+  - [License](#license)
+
+---
+
+## Features
+
+- **Whisper Transcription**  
+  Utilizes [OpenAI Whisper](https://github.com/openai/whisper) to convert speech to text in multiple languages.  
+- **Pyannote Speaker Diarization**  
+  Identifies different speakers and segments your audio output accordingly.  
+- **Progress Bar & Resource Usage**  
+  Displays a live progress bar with CPU, memory, and GPU stats through [alive-progress](https://github.com/rsalmei/alive-progress), [psutil](https://pypi.org/project/psutil/), and [GPUtil](https://pypi.org/project/GPUtil/).  
+- **Tab-Completion**  
+  Press **Tab** to autocomplete file paths on Unix-like systems (and on Windows with [pyreadline3](https://pypi.org/project/pyreadline3/)).  
+- **Secure Token Storage**  
+  Saves your Hugging Face token via [cryptography](https://pypi.org/project/cryptography/) for model downloads (e.g., `pyannote/speaker-diarization-3.1`).  
+- **Configurable Models**  
+  Default is `base.en` but you can specify any other Whisper model using `--whisper-model`.
+
+---
+
+## Installation
+
+### Installing from PyPI
+
+**Audio Scribe** is available on PyPI. You can install it with:
+
+```bash
+pip install audio-scribe
+```
+
+After installation, the **`audio-scribe`** command should be available in your terminal (depending on how your PATH is configured). If you prefer to run via Python module, you can also do:
+
+```bash
+python -m audio-scribe --audio path/to/yourfile.wav
+```
+
+### Installing from GitHub
+
+To install the latest development version directly from GitHub:
+
+```bash
+git clone https://gitlab.genomicops.cloud/genomicops/audio-scribe.git
+cd audio-scribe
+pip install -r requirements.txt
+```
+
+This approach is particularly useful if you want the newest changes or plan to contribute.
+
+---
+
+## Quick Start
+
+1. **Obtain a Hugging Face Token**  
+   - Create a token at [Hugging Face Settings](https://huggingface.co/settings/tokens).  
+   - Accept the model conditions for `pyannote/segmentation-3.0` and `pyannote/speaker-diarization-3.1`.
+
+2. **Run the Command-Line Tool**  
+   ```bash
+   audio-scribe --audio path/to/audio.wav
+   ```
+   > On the first run, you’ll be prompted for your Hugging Face token if you haven’t stored one yet.
+
+3. **Watch the Progress Bar**  
+   - The tool displays a progress bar for each diarized speaker turn, along with real-time CPU, GPU, and memory usage.
+
+---
+
+## Usage
+
+Below is a summary of the main command-line options:
+
+```
+usage: audio-scribe [options]
+
+Audio Transcription (Audio Scribe) Pipeline using Whisper + Pyannote, with optional progress bar.
+
+optional arguments:
+  --audio PATH           Path to the audio file to transcribe.
+  --token TOKEN          HuggingFace API token. Overrides any saved token.
+  --output PATH          Path to the output directory for transcripts and temporary files.
+  --delete-token         Delete any stored Hugging Face token and exit.
+  --show-warnings        Enable user warnings (e.g., from pyannote.audio). Disabled by default.
+  --whisper-model MODEL  Specify the Whisper model to use (default: 'base.en').
+```
+
+**Examples:**
+
+- **Basic Transcription**  
+  ```bash
+  audio-scribe --audio meeting.wav
+  ```
+
+- **Specify a Different Whisper Model**  
+  ```bash
+  audio-scribe --audio webinar.mp3 --whisper-model small
+  ```
+
+- **Delete a Stored Token**  
+  ```bash
+  audio-scribe --delete-token
+  ```
+
+- **Show Internal Warnings**  
+  ```bash
+  audio-scribe --audio session.wav --show-warnings
+  ```
+
+- **Tab-Completion**  
+  ```bash
+  audio-scribe
+  # When prompted for an audio file path, press Tab to autocomplete
+  ```
+
+---
+
+## Dependencies
+
+**Core Libraries**  
+- **Python 3.8+**  
+- [PyTorch](https://pytorch.org/)  
+- [openai-whisper](https://github.com/openai/whisper)  
+- [pyannote.audio](https://github.com/pyannote/pyannote-audio)  
+- [pytorch-lightning](https://pypi.org/project/pytorch-lightning/)  
+- [cryptography](https://pypi.org/project/cryptography/)  
+- [keyring](https://pypi.org/project/keyring/)  
+
+**Optional for Extended Functionality**  
+- [alive-progress](https://pypi.org/project/alive-progress/) – Real-time progress bar  
+- [psutil](https://pypi.org/project/psutil/) – CPU/memory usage  
+- [GPUtil](https://pypi.org/project/GPUtil/) – GPU usage  
+- [pyreadline3](https://pypi.org/project/pyreadline3/) (for Windows tab-completion)
+
+### Sample `requirements.txt`
+
+Below is a typical `requirements.txt` you can place in your repository:
+
+```
+torch>=1.9
+openai-whisper
+pyannote.audio
+pytorch-lightning
+cryptography
+keyring
+alive-progress
+psutil
+GPUtil
+pyreadline3; sys_platform == "win32"
+```
+
+> Note:  
+> - `pyreadline3` is appended with a [PEP 508 marker](https://peps.python.org/pep-0508/) (`; sys_platform == "win32"`) so it only installs on Windows.  
+> - For GPU support, ensure you install a compatible PyTorch version with CUDA.
+
+---
+
+## Contributing
+
+We welcome contributions to **Audio Scribe**!
+
+1. **Fork** the repository and clone your fork.  
+2. **Create a new branch** for your feature or bugfix.  
+3. **Implement your changes**, ensuring code is well-documented and follows best practices.  
+4. **Open a pull request**, detailing the changes you’ve made.
+
+Please read any available guidelines or templates in our repository (such as `CONTRIBUTING.md` or `CODE_OF_CONDUCT.md`) before submitting.
+
+---
+
+## License
+
+This project is licensed under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0).
+
+```
+Copyright 2025 Gurasis Osahan
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+---
+
+**Thank you for using Audio Scribe!**  
+For questions or feedback, please open a [GitHub issue](https://gitlab.genomicops.cloud/genomicops/audio-scribe/issues) or contact the maintainers.

audio_scribe-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+audio_scribe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+audio_scribe/cli.py,sha256=dabh7fe9wAEORwVIBd-V8FAzHBBzbkjnfMSR-wOywO8,20286
+audio_scribe-0.1.0.dist-info/METADATA,sha256=BBx81TI9DPCYgsdKyBn2PWEJ9pJsnhqTUb8ZsWoS1Ps,9503
+audio_scribe-0.1.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+audio_scribe-0.1.0.dist-info/entry_points.txt,sha256=eaO9r_zAFnrWseKyJcBpGUHQq-P7NXBw5er8sZaPfFU,55
+audio_scribe-0.1.0.dist-info/top_level.txt,sha256=L1mltKt-5HrbTXPpAXwht8SXQCgcCceoqpCq4OCZRsk,13
+audio_scribe-0.1.0.dist-info/RECORD,,

audio_scribe-0.1.0.dist-info/WHEEL

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

audio_scribe-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+audio-scribe = audio_scribe.cli:main

audio_scribe-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+audio_scribe