Splitting Large Audio Files with PyDub for Efficient Transcription

Welcome back! In our previous lessons, we've explored using basic transcribing techniques with OpenAI's gpt-4o-transcribe API, as well as calculating media duration using PyDub. Today, we'll shift our focus to transcribing large files with OpenAI gpt-4o-transcribe and PyDub. Managing large audio or video files by splitting them into manageable pieces ensures that tasks like transcription can be performed efficiently and without errors. This lesson will empower you to handle these files smoothly, leveraging PyDub's capabilities.

OpenAI's gpt-4o-transcribe has file size limitations, which pose a challenge when attempting to transcribe large audio files. To work around this constraint, we need a method to divide these large files into smaller, manageable chunks that can be processed sequentially. Our strategy involves leveraging PyDub's capabilities to split the files into segments that fall within the permissible size limit. This will ensure compatibility with OpenAI's gpt-4o-transcribe while maintaining the quality and integrity of the original content. By breaking down large files, we facilitate efficient transcription, allowing for smooth and accurate processing of each smaller segment.

Let's see how we can retrieve the duration of an audio file using PyDub. This is much simpler than using command-line tools, as PyDub provides a high-level interface:

from pydub import AudioSegment

def get_audio_duration(file_path):
    """
    Get the duration of an audio file using PyDub
    """
    try:
        audio = AudioSegment.from_file(file_path)
        return audio.duration_seconds
    except Exception as e:
        print(f"Error getting audio duration: {e}")
        return None

This function uses PyDub's AudioSegment.from_file() method, which automatically detects and loads the appropriate file format. The duration is then easily accessed through the .duration_seconds property, which gives us the total playback time in seconds.

Now, let's see how to split a media file into smaller chunks using PyDub's simple and intuitive slicing API:

import os
import uuid
import tempfile
import math
from pydub import AudioSegment

def split_media(file_path, chunk_size_mb=20):
    """
    Split media file into chunks smaller than the API limit
    """
    print("\nSplitting media into chunks...")
    
    # Get the audio file
    audio = AudioSegment.from_file(file_path)
    duration = audio.duration_seconds
    
    # Calculate file size and determine chunk duration
    file_size = os.path.getsize(file_path)
    chunk_duration_ms = duration * 1000 * (chunk_size_mb * 1024 * 1024) / file_size
    num_chunks = math.ceil(audio.duration_seconds * 1000 / chunk_duration_ms)
    
    chunks = []
    for i in range(num_chunks):
        # Calculate start and end times in milliseconds
        start_time = i * chunk_duration_ms
        end_time = min((i + 1) * chunk_duration_ms, len(audio))
        
        # Extract the chunk
        print(f"Extracting chunk {i+1}/{num_chunks}")
        chunk = audio[start_time:end_time]
        
        # Save to a temporary file
        file_ext = os.path.splitext(file_path)[1]
        temp_file = os.path.join(tempfile.gettempdir(), f"tmp-{uuid.uuid4().hex[:6]}{file_ext}")
        chunk.export(temp_file, format=file_ext.lstrip('.'))
        
        chunks.append(temp_file)
    
    print(f"Split media into {len(chunks)} chunk(s): {chunks}")
    return chunks

Code Explanation:

1. Initialize Variables:

   • We load the audio file using PyDub's AudioSegment.from_file() method.
   • We retrieve the file size using Python's os.path.getsize() to calculate the appropriate chunk duration.

2. Calculate Chunks:

   • chunk_duration_ms calculates how long each chunk should be in milliseconds, based on the desired chunk size in megabytes.
   • num_chunks determines the total number of chunks needed.

3. Create Each Chunk:

   • We iterate through each chunk, calculating the start and end times in milliseconds.
   • PyDub allows us to slice the audio using a simple bracket notation: audio[start_time:end_time].

4. Save Each Chunk:

   • We create a unique temporary file for each chunk using Python's tempfile and uuid modules.
   • We export the audio chunk using PyDub's .export() method, which handles the file format automatically.

5. Return Chunk Paths:

   • We store and return the paths to all the temporary files we created.

This approach provides a clean, Pythonic way to split audio files without having to deal with complex command-line parameters.