Deep Dive: OpenAI Whisper 2.0 vs. Deepgram 2.0 for Code Transcription in 2026

import whisper
import os
import json
import time
from typing import Dict, List, Optional
from dataclasses import dataclass

# Configuration for Whisper 2.0 transcription
@dataclass
class WhisperConfig:
    model_size: str = "large-v3"  # Whisper 2.0 default model
    device: str = "cuda" if whisper.utils.is_available_cuda() else "cpu"
    compute_type: str = "float16" if device == "cuda" else "int8"
    language: str = "en"  # Default to English, supports 98 languages
    code_specific: bool = True  # Enable code-optimized decoding

class WhisperTranscriber:
    def __init__(self, config: WhisperConfig = WhisperConfig()):
        self.config = config
        self.model = None
        self._load_model()

    def _load_model(self):
        """Load Whisper 2.0 model with error handling for missing weights"""
        try:
            print(f"Loading Whisper 2.0 {self.config.model_size} model on {self.config.device}...")
            self.model = whisper.load_model(
                self.config.model_size,
                device=self.config.device,
                compute_type=self.config.compute_type
            )
            print("Model loaded successfully")
        except FileNotFoundError as e:
            raise RuntimeError(f"Whisper model weights not found: {e}. Run `whisper download --model {self.config.model_size}` first.") from e
        except Exception as e:
            raise RuntimeError(f"Failed to load Whisper model: {e}") from e

    def transcribe(self, audio_path: str, output_path: Optional[str] = None) -> Dict:
        """
        Transcribe code audio file using Whisper 2.0
        Args:
            audio_path: Path to audio file (supports mp3, wav, m4a, up to 30s per chunk)
            output_path: Optional path to save JSON results
        Returns:
            Dictionary with transcription text, segments, and metadata
        """
        if not os.path.exists(audio_path):
            raise FileNotFoundError(f"Audio file not found: {audio_path}")

        start_time = time.time()
        try:
            # Whisper 2.0 code-optimized transcription parameters
            result = self.model.transcribe(
                audio_path,
                language=self.config.language,
                task="transcribe",
                # Enable code-specific decoding: prioritizes programming keywords
                initial_prompt="def class import from return if else for while function variable" if self.config.code_specific else None,
                # Split long audio into 30s chunks (Whisper 2.0 max chunk size)
                chunk_length_s=30,
                stride_length_s=5
            )
        except Exception as e:
            raise RuntimeError(f"Transcription failed for {audio_path}: {e}") from e

        # Add metadata
        result["metadata"] = {
            "tool": "OpenAI Whisper 2.0",
            "model": self.config.model_size,
            "device": self.config.device,
            "transcription_time_s": round(time.time() - start_time, 2),
            "audio_path": audio_path
        }

        # Save output if path provided
        if output_path:
            with open(output_path, "w") as f:
                json.dump(result, f, indent=2)
            print(f"Transcription saved to {output_path}")

        return result

if __name__ == "__main__":
    # Example usage: Transcribe a 1-hour Python code recording split into 30s chunks
    transcriber = WhisperTranscriber()
    try:
        # Process all 30s chunks in a directory
        audio_dir = "./code_audio_chunks"
        for filename in os.listdir(audio_dir):
            if filename.endswith((".wav", ".mp3", ".m4a")):
                audio_path = os.path.join(audio_dir, filename)
                output_path = os.path.join("./transcriptions", f"{os.path.splitext(filename)[0]}.json")
                os.makedirs("./transcriptions", exist_ok=True)
                result = transcriber.transcribe(audio_path, output_path)
                print(f"Transcribed {filename} in {result['metadata']['transcription_time_s']}s")
    except Exception as e:
        print(f"Fatal error: {e}")
        exit(1)

import os
import json
import time
from typing import Dict, Optional
from dataclasses import dataclass
from deepgram import DeepgramClient, PrerecordedOptions, FileSource

# Configuration for Deepgram 2.0 API transcription
@dataclass
class DeepgramConfig:
    api_key: str = os.getenv("DEEPGRAM_API_KEY", "")
    model: str = "nova-2-code"  # Deepgram 2.0 code-optimized model
    language: str = "en"  # Supports 85 languages
    smart_format: bool = True  # Format code snippets (indentation, punctuation)
    punctuate: bool = True
    diarize: bool = False  # Disable speaker diarization for code recordings

class DeepgramTranscriber:
    def __init__(self, config: DeepgramConfig = DeepgramConfig()):
        self.config = config
        if not self.config.api_key:
            raise ValueError("DEEPGRAM_API_KEY environment variable not set")
        self.client = DeepgramClient(self.config.api_key)

    def transcribe_file(self, audio_path: str, output_path: Optional[str] = None) -> Dict:
        """
        Transcribe code audio file using Deepgram 2.0 API
        Args:
            audio_path: Path to audio file (supports up to 4 hours per request)
            output_path: Optional path to save JSON results
        Returns:
            Dictionary with transcription text, utterances, and metadata
        """
        if not os.path.exists(audio_path):
            raise FileNotFoundError(f"Audio file not found: {audio_path}")

        start_time = time.time()
        try:
            # Configure Deepgram 2.0 options for code transcription
            options = PrerecordedOptions(
                model=self.config.model,
                language=self.config.language,
                smart_format=self.config.smart_format,
                punctuate=self.config.punctuate,
                diarize=self.config.diarize,
                # Code-specific keywords to boost recognition
                keywords=["def", "class", "import", "return", "if", "else", "for", "while", "function", "variable"]
            )

            # Read audio file
            with open(audio_path, "rb") as f:
                buffer_data = f.read()

            payload: FileSource = {
                "buffer": buffer_data
            }

            # Send request to Deepgram 2.0 API
            response = self.client.listen.prerecorded.v("1").transcribe_file(payload, options)
            result = json.loads(response.to_json())

        except Exception as e:
            raise RuntimeError(f"Deepgram transcription failed for {audio_path}: {e}") from e

        # Add metadata
        result["metadata"] = {
            "tool": "Deepgram 2.0",
            "model": self.config.model,
            "transcription_time_s": round(time.time() - start_time, 2),
            "audio_path": audio_path,
            "api_version": "v1"
        }

        # Save output if path provided
        if output_path:
            with open(output_path, "w") as f:
                json.dump(result, f, indent=2)
            print(f"Transcription saved to {output_path}")

        return result

    def transcribe_url(self, audio_url: str, output_path: Optional[str] = None) -> Dict:
        """Transcribe audio from URL (supports up to 4 hour recordings)"""
        start_time = time.time()
        try:
            options = PrerecordedOptions(
                model=self.config.model,
                language=self.config.language,
                smart_format=self.config.smart_format
            )
            response = self.client.listen.prerecorded.v("1").transcribe_url(audio_url, options)
            result = json.loads(response.to_json())
        except Exception as e:
            raise RuntimeError(f"Deepgram URL transcription failed for {audio_url}: {e}") from e

        result["metadata"] = {
            "tool": "Deepgram 2.0",
            "model": self.config.model,
            "transcription_time_s": round(time.time() - start_time, 2),
            "audio_url": audio_url
        }

        if output_path:
            with open(output_path, "w") as f:
                json.dump(result, f, indent=2)
        return result

if __name__ == "__main__":
    # Example usage: Transcribe 1-hour code recording via Deepgram API
    try:
        transcriber = DeepgramTranscriber()
        audio_path = "./1hour_python_code_recording.wav"
        output_path = "./deepgram_transcription.json"
        result = transcriber.transcribe_file(audio_path, output_path)
        print(f"Transcribed {audio_path} in {result['metadata']['transcription_time_s']}s")
        print(f"Transcription preview: {result['results']['channels'][0]['alternatives'][0]['transcript'][:200]}...")
    except Exception as e:
        print(f"Fatal error: {e}")
        exit(1)

import json
import time
import os
from typing import Dict, List
from dataclasses import dataclass
from whisper_transcriber import WhisperTranscriber, WhisperConfig  # From Example 1
from deepgram_transcriber import DeepgramTranscriber, DeepgramConfig  # From Example 2

@dataclass
class BenchmarkConfig:
    audio_paths: List[str]  # List of audio file paths to test
    whisper_config: WhisperConfig = WhisperConfig()
    deepgram_config: DeepgramConfig = DeepgramConfig()
    output_path: str = "./benchmark_results.json"

class TranscriptionBenchmark:
    def __init__(self, config: BenchmarkConfig):
        self.config = config
        self.whisper_transcriber = WhisperTranscriber(config.whisper_config)
        self.deepgram_transcriber = DeepgramTranscriber(config.deepgram_config)
        self.results = []

    def calculate_wer(self, reference: str, hypothesis: str) -> float:
        """
        Calculate Word Error Rate (WER) between reference and hypothesis
        WER = (substitutions + insertions + deletions) / total words in reference
        """
        ref_words = reference.split()
        hyp_words = hypothesis.split()
        total_ref_words = len(ref_words)

        if total_ref_words == 0:
            return 0.0 if len(hyp_words) == 0 else 1.0

        # Dynamic programming for edit distance
        dp = [[0] * (len(hyp_words) + 1) for _ in range(len(ref_words) + 1)]
        for i in range(len(ref_words) + 1):
            dp[i][0] = i
        for j in range(len(hyp_words) + 1):
            dp[0][j] = j

        for i in range(1, len(ref_words) + 1):
            for j in range(1, len(hyp_words) + 1):
                if ref_words[i-1] == hyp_words[j-1]:
                    dp[i][j] = dp[i-1][j-1]
                else:
                    dp[i][j] = min(dp[i-1][j-1], dp[i-1][j], dp[i][j-1]) + 1

        wer = dp[len(ref_words)][len(hyp_words)] / total_ref_words
        return round(wer * 100, 2)  # Return as percentage

    def run_benchmark(self):
        """Run benchmark on all audio files for both tools"""
        for audio_path in self.config.audio_paths:
            print(f"\nBenchmarking {audio_path}...")
            result = {"audio_path": audio_path, "whisper": {}, "deepgram": {}}

            # Whisper 2.0 transcription
            try:
                print("Running Whisper 2.0 transcription...")
                whisper_start = time.time()
                whisper_result = self.whisper_transcriber.transcribe(audio_path)
                whisper_time = round(time.time() - whisper_start, 2)
                whisper_text = whisper_result["text"]
                result["whisper"] = {
                    "transcription_time_s": whisper_time,
                    "text_length": len(whisper_text.split()),
                    "raw_result": whisper_result
                }
            except Exception as e:
                result["whisper"] = {"error": str(e)}
                print(f"Whisper error: {e}")

            # Deepgram 2.0 transcription
            try:
                print("Running Deepgram 2.0 transcription...")
                deepgram_start = time.time()
                deepgram_result = self.deepgram_transcriber.transcribe_file(audio_path)
                deepgram_time = round(time.time() - deepgram_start, 2)
                deepgram_text = deepgram_result["results"]["channels"][0]["alternatives"][0]["transcript"]
                result["deepgram"] = {
                    "transcription_time_s": deepgram_time,
                    "text_length": len(deepgram_text.split()),
                    "raw_result": deepgram_result
                }
            except Exception as e:
                result["deepgram"] = {"error": str(e)}
                print(f"Deepgram error: {e}")

            # Calculate WER if reference transcript exists
            ref_path = f"{os.path.splitext(audio_path)[0]}.txt"
            if os.path.exists(ref_path):
                with open(ref_path, "r") as f:
                    reference_text = f.read()
                if "text" in result["whisper"]:
                    result["whisper"]["wer"] = self.calculate_wer(reference_text, whisper_text)
                if "text" in result["deepgram"]:
                    result["deepgram"]["wer"] = self.calculate_wer(reference_text, deepgram_text)

            self.results.append(result)

        # Save results
        with open(self.config.output_path, "w") as f:
            json.dump(self.results, f, indent=2)
        print(f"\nBenchmark results saved to {self.config.output_path}")

        # Print summary
        self.print_summary()

    def print_summary(self):
        """Print aggregate benchmark summary"""
        print("\n=== Benchmark Summary ===")
        total_whisper_time = 0
        total_deepgram_time = 0
        total_whisper_wer = 0
        total_deepgram_wer = 0
        count = 0

        for res in self.results:
            if "transcription_time_s" in res["whisper"]:
                total_whisper_time += res["whisper"]["transcription_time_s"]
            if "transcription_time_s" in res["deepgram"]:
                total_deepgram_time += res["deepgram"]["transcription_time_s"]
            if "wer" in res["whisper"]:
                total_whisper_wer += res["whisper"]["wer"]
                count += 1
            if "wer" in res["deepgram"]:
                total_deepgram_wer += res["deepgram"]["wer"]

        print(f"Total Whisper 2.0 time: {total_whisper_time}s")
        print(f"Total Deepgram 2.0 time: {total_deepgram_time}s")
        if count > 0:
            print(f"Average Whisper WER: {round(total_whisper_wer / count, 2)}%")
            print(f"Average Deepgram WER: {round(total_deepgram_wer / count, 2)}%")
            print(f"Deepgram speedup: {round(total_whisper_time / total_deepgram_time, 2)}x")

if __name__ == "__main__":
    # Example benchmark run on 5 1-minute Python code recordings
    benchmark_config = BenchmarkConfig(
        audio_paths=[f"./test_audio/code_{i}.wav" for i in range(5)],
        output_path="./benchmark_results.json"
    )
    benchmark = TranscriptionBenchmark(benchmark_config)
    benchmark.run_benchmark()

from whisper_transcriber import WhisperTranscriber, WhisperConfig

# Python-optimized initial prompt
config = WhisperConfig(initial_prompt="def class import from return if else for while async await try except")
transcriber = WhisperTranscriber(config)
result = transcriber.transcribe("./python_code.wav")

from deepgram_transcriber import DeepgramTranscriber, DeepgramConfig
from deepgram import PrerecordedOptions

# TypeScript-optimized keyword boosting
config = DeepgramConfig()
options = PrerecordedOptions(
    model="nova-2-code",
    keywords=["async", "await", "Promise", "interface", "type", "React", "Node.js"]
)
transcriber = DeepgramTranscriber(config)
result = transcriber.transcribe_file("./typescript_code.wav", options=options)

def hybrid_transcribe(audio_path: str, is_sensitive: bool, audio_length_hours: float):
    whisper_transcriber = WhisperTranscriber()
    deepgram_transcriber = DeepgramTranscriber()

    # Route long audio to Deepgram
    if audio_length_hours > 1:
        return deepgram_transcriber.transcribe_file(audio_path)
    # Route sensitive audio to Whisper
    elif is_sensitive:
        return whisper_transcriber.transcribe(audio_path)
    # Route non-sensitive short audio to Deepgram
    else:
        return deepgram_transcriber.transcribe_file(audio_path)