Transcribe Anything

https://github.com/zackees/transcribe-anything
Admin
Multi-backend whisper app. Blazing fast. Mac-arm optimized. Easy install. Input a local file or url...
Tokens:5,627
Snippets:45
Trust Score:9.3
License:MIT
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install and Use transcribe-anything via Command Line

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

This section provides commands for installing `transcribe-anything` via pip and demonstrates various command-line usage patterns. It covers basic CPU-only transcription, GPU acceleration for Windows/Linux, Apple Silicon (MLX) acceleration, and examples with advanced options like batch size and verbosity. Requires Python and pip for installation, and appropriate hardware/drivers for accelerated modes.

```bash
pip install transcribe-anything

# Basic usage - CPU mode (works everywhere, slower)
transcribe-anything https://www.youtube.com/watch?v=dQw4w9WgXcQ

# GPU accelerated (Windows/Linux)
transcribe-anything https://www.youtube.com/watch?v=dQw4w9WgXcQ --device insane

# Mac Apple Silicon accelerated
transcribe-anything https://www.youtube.com/watch?v=dQw4w9WgXcQ --device mlx

# Advanced options (see Advanced Options section below for full details)
transcribe-anything video.mp4 --device mlx --batch_size 16 --verbose
transcribe-anything video.mp4 --device insane --batch-size 8 --flash True
```

--------------------------------

### Common Project Utility Scripts

Source: https://github.com/zackees/transcribe-anything/blob/main/DEV.md

A collection of frequently used bash scripts for standard project operations such as installation, cleaning build artifacts, running tests, and performing code linting.

```bash
./install
./clean
./test
./lint
```

--------------------------------

### Install Transcribe Anything with Pip

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

Instructions for installing the 'transcribe-anything' package using pip, leveraging 'isolated-environment' for simplified setup and dependency management.

```bash
pip install transcribe-anything
```

--------------------------------

### Executing Commands in Isolated Backend Environments

Source: https://github.com/zackees/transcribe-anything/blob/main/DEV.md

Instructions on how to run specific commands within a backend's isolated virtual environment. This is achieved by first installing the program, locating the `.venv` directory, and then using `uv run` to execute the desired command.

```bash
uv run <command>
```

--------------------------------

### Install and Use Transcribe-Anything CLI

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

Provides commands to install the `transcribe-anything` package using pip, making the `transcribe_anything` command-line tool available globally. It then demonstrates how to use the CLI to transcribe a YouTube URL directly.

```bash
pip install transcribe-anything
transcribe_anything <YOUTUBE_URL>
```

--------------------------------

### Configure MLX Backend for Apple Silicon

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

Examples of command-line arguments specific to the MLX backend, optimized for Apple Silicon. These options allow fine-tuning performance by adjusting batch size, enabling verbose output, and applying initial prompts.

```bash
transcribe-anything video.mp4 --device mlx --batch_size 24
```

```bash
transcribe-anything video.mp4 --device mlx --verbose
```

```bash
transcribe-anything video.mp4 --device mlx --initial_prompt "The speaker discusses AI, machine learning, and neural networks."
```

--------------------------------

### Perform Transcription using the Universal CPU Backend

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

Shows how to use the CPU backend, which is universally compatible across systems but generally slower. Examples include basic CPU transcription and specifying a custom model, language, and task for the process.

```bash
transcribe-anything video.mp4 --device cpu
```

```bash
transcribe-anything video.mp4 --device cpu --model medium --language fr --task transcribe
```

--------------------------------

### Set Up Transcribe-Anything Development Environment

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

Instructions for setting up the development environment on Ubuntu, MacOS, or Win32 (using git-bash). This involves navigating to the project directory, running an installation script, and activating the virtual environment. The environment needs to be reactivated by sourcing `activate.sh` if the terminal is closed.

```bash
cd transcribe_anything
./install.sh
# Enter the environment:
source activate.sh
```

--------------------------------

### Backend Quick Reference for Transcribe Anything

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

A quick reference guide detailing the available backends for 'transcribe-anything', their respective device flags, key arguments, and optimal use cases. This helps users select the best backend for their hardware and needs.

```APIDOC
Backend:
  - MLX:
    - Device Flag: --device mlx
    - Key Arguments: --batch_size, --verbose, --initial_prompt
    - Best For: Mac Apple Silicon
  - Insanely Fast:
    - Device Flag: --device insane
    - Key Arguments: --batch-size, --hf_token, --flash, --timestamp
    - Best For: Windows/Linux GPU
  - CPU:
    - Device Flag: --device cpu
    - Key Arguments: Standard whisper args
    - Best For: Universal compatibility
```

--------------------------------

### Mandatory Checks Before Issuing a Pull Request

Source: https://github.com/zackees/transcribe-anything/blob/main/DEV.md

These scripts must be executed to ensure code quality and functionality before submitting a pull request. They include running the linter to check code style and executing tests to verify correctness.

```bash
./lint
./test
```

--------------------------------

### Configure Insanely Fast Whisper Backend

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

Examples of command-line arguments for the Insanely Fast Whisper backend. These options include adjusting batch size for GPU memory management, selecting different model variants, and enabling Flash Attention 2 for faster processing.

```bash
transcribe-anything video.mp4 --device insane --batch-size 8
```

```bash
transcribe-anything video.mp4 --device insane --model large-v3
```

```bash
transcribe-anything video.mp4 --device insane --flash True
```

--------------------------------

### Transcribe Audio/Video from URL using Python API

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

Demonstrates how to use the `transcribe-anything` Python API to transcribe audio or video from a given URL, saving the output to a specified directory. This example uses a YouTube URL as input.

```python
from transcribe_anything.api import transcribe

transcribe(
    url_or_file="https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    output_dir="output_dir",
)
```

--------------------------------

### Development Workflow Commands

Source: https://github.com/zackees/transcribe-anything/blob/main/AI_README.md

Provides a set of common commands for managing the development environment, including installation, quality checks, testing, and cleanup.

```bash
./install     # Install development dependencies
./lint        # Run code quality checks
./test        # Run full test suite
./clean       # Clean up generated files
```

--------------------------------

### Utilize MLX Backend for Apple Silicon Transcription

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

Provides examples of using the MLX backend specifically designed for Apple Silicon. This includes basic usage, custom batch size, verbose output, providing an initial prompt for specialized content, and combining multiple options for language and task.

```bash
transcribe-anything video.mp4 --device mlx
```

```bash
transcribe-anything video.mp4 --device mlx --batch_size 16 --verbose
```

```bash
transcribe-anything lecture.mp4 --device mlx --initial_prompt "The speaker discusses machine learning, neural networks, PyTorch, and TensorFlow."
```

```bash
transcribe-anything video.mp4 --device mlx --batch_size 20 --verbose --task translate --language es
```

--------------------------------

### Configure Standard OpenAI Whisper Options for CPU Backend

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

Provides examples of various standard OpenAI Whisper arguments that can be utilized with the `--device cpu` backend. These options cover language and task selection, generation parameters, quality thresholds, output formatting, and audio processing settings.

```bash
transcribe-anything video.mp4 --device cpu --language es --task translate
```

```bash
transcribe-anything video.mp4 --device cpu --temperature 0.1 --best_of 5 --beam_size 5
```

```bash
transcribe-anything video.mp4 --device cpu --compression_ratio_threshold 2.4 --logprob_threshold -1.0
```

```bash
transcribe-anything video.mp4 --device cpu --word_timestamps --highlight_words True
```

```bash
transcribe-anything video.mp4 --device cpu --threads 4 --clip_timestamps "0,30"
```

--------------------------------

### Optimize Transcription with Insanely Fast Whisper Backend on GPU

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

Demonstrates various configurations for the Insanely Fast Whisper backend, optimized for GPU usage. Examples include basic operation, custom batch size for memory management, enabling Flash Attention 2 for speed, speaker diarization, word-level timestamps, and combining multiple high-performance settings.

```bash
transcribe-anything video.mp4 --device insane
```

```bash
transcribe-anything video.mp4 --device insane --batch-size 8
```

```bash
transcribe-anything video.mp4 --device insane --batch-size 12 --flash True
```

```bash
transcribe-anything video.mp4 --device insane --hf_token your_huggingface_token
```

```bash
transcribe-anything video.mp4 --device insane --timestamp word --hf_token your_token --num-speakers 3
```

```bash
transcribe-anything video.mp4 --device insane --batch-size 16 --flash True --timestamp word
```

--------------------------------

### Pull transcribe-anything Docker Image

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

This command pulls the official `transcribe-anything` Docker image from Docker Hub. This image includes GPU acceleration and is suitable for large-scale translation tasks. Requires Docker installed on the system.

```bash
docker pull niteris/transcribe-anything
```

--------------------------------

### JSON Output Format for Speaker Diarization (`speaker.json`)

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

An example of the `speaker.json` file structure, which provides de-chunkified speaker information when diarization is enabled. Each entry includes the speaker ID, timestamp range, transcribed text, and the reason for the segment (e.g., 'beginning', 'speaker-switch').

```JSON
[
  {
    "speaker": "SPEAKER_00",
    "timestamp": [0.0, 7.44],
    "text": "for that. But welcome, Zach Vorhees. Great to have you back on. Thank you, Matt. Craving me back onto your show. Man, we got a lot to talk about.",
    "reason": "beginning"
  },
  {
    "speaker": "SPEAKER_01",
    "timestamp": [7.44, 33.52],
    "text": "Oh, we do. 2023 was the year that OpenAI released, you know, chat GPT-4, which I think most people would say has surpassed average human intelligence, at least in test taking, perhaps not in, you know, reasoning and things like that. But it was a major year for AI. I think that most people are behind the curve on this. What's your take of what just happened in the last 12 months and what it means for the future of human cognition versus machine cognition?",
    "reason": "speaker-switch"
  },
  {
    "speaker": "SPEAKER_00",
    "timestamp": [33.52, 44.08],
    "text": "Yeah. Well, you know, at the beginning of 2023, we had a pretty weak AI system, which was a chat GPT 3.5 turbo was the best that we had. And then between the beginning of last",
    "reason": "speaker-switch"
  }
]
```

--------------------------------

### NVIDIA Detection Cache File Structure Example

Source: https://github.com/zackees/transcribe-anything/blob/main/NVIDIA_CACHE_FIX.md

This JSON snippet illustrates the structure of the '~/.transcribe_anything_nvidia_cache.json' file. It stores mappings where keys are system fingerprints (combining platform, architecture, version, and nvidia-smi existence) and values are boolean results indicating NVIDIA GPU detection.

```json
{
  "Windows-AMD64-10.0.19041-nvidia_smi:true": true,
  "Linux-x86_64-5.4.0-nvidia_smi:false": false
}
```

--------------------------------

### Perform Basic Transcription from URL or Local File

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

Illustrates the fundamental usage of `transcribe-anything` for transcribing content, either by providing a YouTube URL or a path to a local video file.

```bash
transcribe-anything https://www.youtube.com/watch?v=dQw4w9WgXcQ
```

```bash
transcribe-anything video.mp4
```

--------------------------------

### Run Project Test Suite

Source: https://github.com/zackees/transcribe-anything/blob/main/AI_README.md

Instructions on how to execute the test suite for the `transcribe-anything` project using `pytest` with verbose output.

```bash
bash test
```

--------------------------------

### Insanely Fast Whisper Backend Command-Line Arguments

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

Documents the specific command-line arguments available for the `--device insane` backend, including their data types, default values, and descriptions. These arguments are critical for managing GPU memory and optimizing performance.

```APIDOC
Argument: --batch-size
  Type: int
  Default: 24
  Description: Batch size for processing. Critical for GPU memory management

Argument: --flash
  Type: bool
  Default: false
  Description: Use Flash Attention 2 for faster processing

Argument: --timestamp
  Type: choice
  Default: chunk
  Description: Timestamp granularity: "chunk" or "word"

Argument: --hf_token
  Type: string
  Default: None
  Description: HuggingFace token for speaker diarization

Argument: --num-speakers
  Type: int
  Default: None
  Description: Exact number of speakers (cannot use with min/max)

Argument: --min-speakers
  Type: int
  Default: None
  Description: Minimum number of speakers

Argument: --max-speakers
  Type: int
  Default: None
  Description: Maximum number of speakers

Argument: --diarization_model
  Type: string
  Default: pyannote/speaker-diarization
  Description: Diarization model to use
```

--------------------------------

### Python: Isolated Environment Management Pattern

Source: https://github.com/zackees/transcribe-anything/blob/main/AI_README.md

Demonstrates the pattern for creating and managing isolated Python environments for different backends using `uv-iso-env`, ensuring dependency isolation and dynamic configuration based on system capabilities.

```Python
# Each backend creates its own pyproject.toml and isolated environment
def get_environment() -> IsoEnv:
    venv_dir = HERE / "venv" / "backend_name"
    # Dynamic pyproject.toml generation based on system capabilities
```

--------------------------------

### MLX Backend Specific Arguments

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

Detailed documentation for arguments supported by the MLX backend, including their types, default values, and descriptions. These arguments allow fine-grained control over MLX-specific transcription processes.

```APIDOC
Argument:
  - --batch_size:
    - Type: int
    - Default: 12
    - Description: Batch size for processing. Higher values use more memory but may be faster
  - --verbose:
    - Type: flag
    - Default: false
    - Description: Enable verbose output for debugging
  - --initial_prompt:
    - Type: string
    - Default: None
    - Description: Custom vocabulary/context prompt for better recognition
```

--------------------------------

### Transcribe-Anything Core Technologies

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

An overview of the key technologies and libraries that form the foundation of `transcribe-anything`, including AI models for transcription, video downloaders, and audio processing tools.

```APIDOC
OpenAI whisper
insanely-fast-whisper
yt-dlp: https://github.com/yt-dlp/yt-dlp
static-ffmpeg:
  github: https://github.com/zackees/static_ffmpeg
  pypi: https://pypi.org/project/static-ffmpeg/
```

--------------------------------

### Initial Batch Size and Model Adjustments for Transcription

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

Commands to adjust the batch size for MLX and 'insane' device modes, and to use a smaller model, primarily for initial resource management or testing.

```bash
transcribe-anything video.mp4 --device mlx --batch_size 8
```

```bash
transcribe-anything video.mp4 --device insane --batch-size 4
```

```bash
transcribe-anything video.mp4 --device insane --model small --batch-size 8
```

--------------------------------

### Implement a New Transcription Backend in Python

Source: https://github.com/zackees/transcribe-anything/blob/main/AI_README.md

Detailed steps for integrating a new transcription backend into the `transcribe-anything` project. This involves creating a dedicated Python module, updating the device enumeration, adding CLI support, and integrating the backend into the main API's transcription logic.

```python
# src/transcribe_anything/my_backend.py
def get_environment() -> IsoEnv:
    # Define dependencies in pyproject.toml format

def run_my_backend(input_wav: Path, model: str, output_dir: Path, ...):
    # Implement transcription logic
```

```python
# In api.py
class Device(Enum):
    MY_BACKEND = "my_backend"
```

```python
# In _cmd.py parse_arguments()
choices = [None, "cpu", "cuda", "insane", "my_backend"]
```

```python
# In api.py transcribe()
elif device_enum == Device.MY_BACKEND:
    run_my_backend(...)
```

--------------------------------

### Define Core Project Dependencies

Source: https://github.com/zackees/transcribe-anything/blob/main/AI_README.md

Listing of the main Python package dependencies for the `transcribe-anything` project, as specified in the `pyproject.toml` file. These packages are essential for audio/video processing, URL downloading, file system operations, and environment management.

```toml
# From pyproject.toml
dependencies = [
    "static-ffmpeg>=2.7",      # Audio/video processing
    "yt-dlp>=2025.1.15",       # URL downloading
    "appdirs>=1.4.4",          # Cross-platform directories
    "disklru>=1.0.7",          # Disk caching
    "FileLock",                # File system synchronization
    "webvtt-py==0.4.6",        # Subtitle format conversion
    "uv-iso-env>=1.0.43",      # Isolated environments
    "python-dotenv>=1.0.1",    # Environment variables
]
```

--------------------------------

### Configure Speaker Diarization with Insanely Fast Whisper

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

Demonstrates how to enable speaker diarization using a HuggingFace token and specify the exact number of speakers or a range for speaker identification when using the 'insane' device backend.

```bash
transcribe-anything video.mp4 --device insane --hf_token your_token_here
```

```bash
transcribe-anything video.mp4 --device insane --hf_token your_token --num-speakers 3
```

```bash
transcribe-anything video.mp4 --device insane --hf_token your_token --min-speakers 2 --max-speakers 5
```

--------------------------------

### Project File Structure: Core Components

Source: https://github.com/zackees/transcribe-anything/blob/main/AI_README.md

An overview of the main directories and files within the `src/transcribe_anything/` module, illustrating the project's organization and key functional areas for transcription, API, and utility modules.

```Text
src/transcribe_anything/
├── __init__.py           # Main API export
├── __main__.py          # Module entry point
├── _cmd.py              # CLI interface and argument parsing
├── api.py               # Main transcription API
├── whisper.py           # Standard OpenAI Whisper backend
├── insanely_fast_whisper.py  # GPU-accelerated backend
├── whisper_mac.py       # Apple Silicon MLX backend
├── audio.py             # Audio processing and conversion
├── util.py              # Utility functions and system detection
├── logger.py            # Logging utilities
└── [other modules...]   # Specialized functionality
```

--------------------------------

### Project Integration Patterns

Source: https://github.com/zackees/transcribe-anything/blob/main/AI_README.md

Outlines various methods and common patterns for integrating the `transcribe-anything` library and its functionalities into larger applications or workflows.

```APIDOC
Integration Patterns:
  - Library Usage: Import `transcribe_anything` and use `transcribe()` function
  - CLI Extension: Add new arguments and backend support
  - Batch Processing: Use API in loops with different configurations
  - Pipeline Integration: Incorporate into larger media processing workflows
```

--------------------------------

### Transcribe with transcribe-anything Python API

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

This Python code snippet demonstrates how to use the `transcribe_anything` function programmatically. It shows how to specify a URL or file, an output directory, the task (transcribe/translate), the Whisper model size, and the device for acceleration (e.g., 'cuda'). This allows for integration into larger Python applications.

```python
from transcribe_anything import transcribe_anything

transcribe_anything(
    url_or_file="https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    output_dir="output_dir",
    task="transcribe",
    model="large",
    device="cuda"
)
```

--------------------------------

### Maintenance Notes: Version Management

Source: https://github.com/zackees/transcribe-anything/blob/main/AI_README.md

Details the strategies and considerations for managing versions within the `transcribe-anything` project, including manual versioning and dependency pinning.

```APIDOC
Version Management:
  - Manual Versioning: Version in `pyproject.toml` updated manually
  - Backend Dependencies: Pin specific versions for stability
  - Model Compatibility: Backend-specific model version management
```

--------------------------------

### Apply Custom Prompts for Improved Transcription Accuracy

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

Demonstrates how to use custom prompts to enhance transcription accuracy for domain-specific vocabulary, names, or technical terms, via both command line and Python API. This feature is crucial for specialized content.

```bash
transcribe-anything video.mp4 --initial_prompt "The speaker discusses artificial intelligence, machine learning, and neural networks."
```

```bash
transcribe-anything video.mp4 --prompt_file my_custom_prompt.txt
```

```python
from transcribe_anything import transcribe

# Direct prompt
transcribe(
    url_or_file="video.mp4",
    initial_prompt="The speaker discusses AI, PyTorch, TensorFlow, and deep learning algorithms."
)

# Load prompt from file
with open("my_prompt.txt", "r") as f:
    prompt = f.read()

transcribe(
    url_or_file="video.mp4",
    initial_prompt=prompt
)
```

--------------------------------

### Optimize Transcription Performance and Speed

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

Commands focused on accelerating the transcription process by increasing batch sizes (where memory permits), enabling Flash Attention 2 for significant speedups, or selecting smaller and distilled models for faster processing.

```bash
transcribe-anything video.mp4 --device mlx --batch_size 24
```

```bash
transcribe-anything video.mp4 --device insane --batch-size 16
```

```bash
transcribe-anything video.mp4 --device insane --flash True --batch-size 16
```

```bash
transcribe-anything video.mp4 --device insane --model small
```

```bash
transcribe-anything video.mp4 --device insane --model distil-whisper/large-v2 --flash True
```

--------------------------------

### Python: Device Detection and Selection Pattern

Source: https://github.com/zackees/transcribe-anything/blob/main/AI_README.md

Illustrates how the `transcribe-anything` project detects NVIDIA GPUs using `has_nvidia_smi()` and defines a `Device` Enum for various processing devices (CPU, CUDA, Insane, MLX) to abstract hardware selection.

```Python
# From util.py - Cached NVIDIA detection
def has_nvidia_smi() -> bool:
    # Uses system fingerprinting and caching to avoid repeated detection
    
# From api.py - Device enum pattern
class Device(Enum):
    CPU = "cpu"
    CUDA = "cuda" 
    INSANE = "insane"
    MLX = "mlx"
```

--------------------------------

### Python: Subprocess Communication Pattern

Source: https://github.com/zackees/transcribe-anything/blob/main/AI_README.md

Shows the general pattern used by `transcribe-anything` backends for inter-process communication via subprocesses. This includes opening a process with a command list and handling its completion and potential errors.

```Python
# All backends use subprocess communication
proc = env.open_proc(cmd_list, shell=False)
# Wait for completion and handle errors
```

--------------------------------

### Key Project Extension Points

Source: https://github.com/zackees/transcribe-anything/blob/main/AI_README.md

Describes the primary modules and functionalities within the `transcribe-anything` project that are designed for extension and customization.

```APIDOC
Common Extension Points:
  1. New Audio Sources: Extend `ytldp_download.py`
  2. Additional Output Formats: Add converters in utility modules
  3. Custom Post-Processing: Extend speaker diarization logic
  4. UI Interfaces: Build on top of `api.py`
  5. Cloud Integration: Add cloud storage backends
```

--------------------------------

### Enhance Transcription Quality

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

Commands to improve transcription accuracy and quality by utilizing larger models, enabling Flash Attention 2 for better performance, applying custom prompts for domain-specific content, or fine-tuning CPU backend parameters.

```bash
transcribe-anything video.mp4 --device insane --model large-v3
```

```bash
transcribe-anything video.mp4 --device insane --flash True
```

```bash
transcribe-anything video.mp4 --initial_prompt "Medical terminology: diagnosis, treatment, symptoms, patient care"
```

```bash
transcribe-anything video.mp4 --device cpu --compression_ratio_threshold 2.0 --logprob_threshold -0.5
```

--------------------------------

### Maintenance Notes: Testing Requirements

Source: https://github.com/zackees/transcribe-anything/blob/main/AI_README.md

Specifies the key requirements and considerations for testing the `transcribe-anything` project, covering platform compatibility, hardware-specific tests, and test isolation.

```APIDOC
Testing Requirements:
  - Cross-Platform: Tests must work on Windows, macOS, Linux
  - Hardware-Specific: GPU tests conditional on hardware availability
  - Isolation: Each test should clean up after itself
```

--------------------------------

### transcribe_anything Python Function API

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

Documentation for the `transcribe_anything` Python function, detailing its parameters and their purpose. This function serves as the primary interface for programmatic transcription and translation using the `transcribe-anything` library.

```APIDOC
transcribe_anything(
  url_or_file: str,
  output_dir: str,
  task: str = "transcribe",
  model: str = "large",
  device: str = "cpu"
)
  url_or_file: The URL or local file path to transcribe.
  output_dir: The directory where output files (text, subtitles, speaker.json) will be saved.
  task: The task to perform, either "transcribe" or "translate". Defaults to "transcribe".
  model: The Whisper model size to use (e.g., "tiny", "base", "small", "medium", "large"). Defaults to "large".
  device: The device to use for transcription (e.g., "cpu", "cuda", "insane", "mlx"). Defaults to "cpu".
```

--------------------------------

### API for Transcription Output Format Conversions

Source: https://github.com/zackees/transcribe-anything/blob/main/AI_README.md

Documentation for key internal functions responsible for converting transcription results between various standard subtitle and data formats, ensuring compatibility and utility across different applications.

```APIDOC
convert_json_to_srt():
  Converts transcription metadata from JSON format to SubRip (.srt) subtitle format.
```

```APIDOC
convert_to_webvtt():
  Converts SubRip (.srt) subtitle format to WebVTT (.vtt) format.
```

```APIDOC
generate_speaker_json():
  Generates speaker diarization results in JSON format based on transcription data.
```

--------------------------------

### Transcribe-Anything Python `transcribe` Function API

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

Detailed API definition for the `transcribe` function, outlining all available parameters for controlling transcription behavior, output format, device utilization, and advanced features like speaker diarization and subtitle embedding.

```Python
def transcribe(
    url_or_file: str,
    output_dir: Optional[str] = None,
    model: Optional[str] = None,              # tiny,small,medium,large
    task: Optional[str] = None,               # transcribe or translate
    language: Optional[str] = None,           # auto detected if none, "en" for english...
    device: Optional[str] = None,             # cuda,cpu,insane,mlx
    embed: bool = False,                      # Produces a video.mp4 with the subtitles burned in.
    hugging_face_token: Optional[str] = None, # If you want a speaker.json
    other_args: Optional[list[str]] = None,   # Other args to be passed to to the whisper backend
    initial_prompt: Optional[str] = None,     # Custom prompt for better recognition of specific terms
) -> str:
```

--------------------------------

### Set Timestamp Granularity for Transcription

Source: https://github.com/zackees/transcribe-anything/blob/main/README.md

Illustrates how to control the granularity of timestamps in the transcription output, allowing for either chunk-level (default) or more detailed word-level timestamps.

```bash
transcribe-anything video.mp4 --device insane --timestamp chunk
```

```bash
transcribe-anything video.mp4 --device insane --timestamp word
```

--------------------------------

### Clear NVIDIA Detection Cache Command

Source: https://github.com/zackees/transcribe-anything/blob/main/NVIDIA_CACHE_FIX.md

This command-line option allows users to manually clear the cached NVIDIA detection results. This is useful for debugging purposes or when hardware configurations have changed and a re-detection is required.

```bash
transcribe-anything --clear-nvidia-cache
```
Tokens:
Raw