Implementing Robust Audio/Video Transcription and Cleanup with Python | CodeSignal Learn

Implementing Robust Audio/Video Transcription and Cleanup with Python | CodeSignal Learn

Implementing the Audio/Video Transcription Process with Python

Welcome back! Let's continue our path to implementing the Audio/Video Transcriber using the OpenAI GPT-4o Transcribe API! In this lesson, we will wrap up the main functionality by putting together the media file split functionality we've done in the previous lesson and the GPT-4o Transcribe API call on a small media chunk. In addition, we will make sure to properly handle all potential errors and ensure we don't leave any redundant garbage on our disk to avoid wasting disk space. Ensuring robust error handling and cleanup is key to avoiding data loss and maintaining efficiency, even in unexpected scenarios. Let's step in to see how exciting this all is!

Building the Transcription Process

Let's examine our main transcription function and understand how it handles errors and cleanup: Pythondef transcribe(file_path): """Transcribe a large media file by splitting it into chunks""" chunks = [] try: # split_media is implemented in the previous lesson # it splits a large media file into smaller chunks using PyDub chunks = split_media(file_path, 1) transcriptions = [] for chunk in chunks: # transcribe_small_media uses OpenAI GPT-4o Transcribe # to transcribe chunks under 25MB text = transcribe_small_media(chunk) if text: transcriptions.append(text) return ' '.join(transcriptions) except Exception as e: print(f"Error processing large file: {e}") return None finally: # Clean up all chunks in the finally block for chunk in chunks: cleanup_temp_files(chunk) The function works in several steps: We initialize an empty chunks list outside the try block to ensure it's accessible in the finally block. Using split_media (implemented in our previous lesson), we split the large media file into manageable chunks using PyDub. For each chunk, we use transcribe_small_media (which wraps the OpenAI GPT-4o Transcribe API call we learned about earlier) to get the text transcription. Finally, we join all transcriptions into a single text. Notice how we've placed the chunks list initialization outside the try block. This ensures that even if an error occurs during splitting or transcription, we'll still have access to any chunks that were created, allowing us to clean them up properly.

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Cleanup Process Implementation

The cleanup process is handled by our cleanup_temp_files function, which uses Python's file system operations: Pythonimport os import shutil def cleanup_temp_files(file_path): """Clean up temporary files and directories""" try: if os.path.isfile(file_path): os.remove(file_path) elif os.path.isdir(file_path): shutil.rmtree(file_path) except Exception as e: print(f"Warning: Could not clean up {file_path}: {e}") The cleanup is guaranteed to work because: We initialize the chunks list before any operations. We use a finally block, which executes regardless of success or failure. Each cleanup operation is wrapped in its own try-except block. We handle both files and directories systematically using Python's os and shutil modules. Any cleanup failures are logged but don't prevent the cleanup of other files. We use Python's straightforward file operations with proper error handling. Our implementation leverages Python's simplicity for file operations. For directories, we use shutil.rmtree(), which automatically handles recursive deletion of directories and their contents, making our code much cleaner than it would be if we had to implement recursion manually.

Transcribing Small Media Files

Now let's look at the implementation of the transcribe_small_media function that handles the actual transcription using the GPT-4o Transcribe API: Pythonimport openai import os def transcribe_small_media(file_path): """Transcribe a small media file using GPT-4o Transcribe""" try: # Make sure the file exists and is under 25MB if not os.path.exists(file_path): raise FileNotFoundError(f"File {file_path} not found") file_size = os.path.getsize(file_path) / (1024 * 1024) # Size in MB if file_size > 25: raise ValueError(f"File size ({file_size:.2f}MB) exceeds the 25MB limit") # Open the file and send it to the OpenAI API with open(file_path, "rb") as audio_file: response = openai.audio.transcriptions.create( model="gpt-4o-transcribe", file=audio_file ) return response.text except Exception as e: print(f"Error transcribing file {file_path}: {e}") return None This function: Checks if the file exists. Verifies the file is under the 25MB limit for the API. Opens and passes the file to the GPT-4o Transcribe API. Returns the transcribed text or None if an error occurs.