Audio Transcription and TTS

from litellm import transcription

with open("audio.mp3", "rb") as audio_file:
    response = transcription(
        model="whisper-1",
        file=audio_file
    )

print(response.text)

def transcription(
    model: str,
    file: FileTypes,
    # Optional parameters
    language: Optional[str] = None,
    prompt: Optional[str] = None,
    response_format: Optional[str] = None,
    timestamp_granularities: Optional[List[str]] = None,
    temperature: Optional[int] = None,
    # API configuration
    timeout: float = 600,
    api_key: Optional[str] = None,
    api_base: Optional[str] = None,
    api_version: Optional[str] = None,
    max_retries: Optional[int] = None,
    custom_llm_provider: Optional[str] = None,
    **kwargs
) -> TranscriptionResponse

class TranscriptionResponse:
    text: str  # The transcribed text

from litellm import transcription

with open("interview.mp3", "rb") as audio_file:
    response = transcription(
        model="whisper-1",
        file=audio_file
    )

print(response.text)

from litellm import transcription

with open("french_audio.mp3", "rb") as audio_file:
    response = transcription(
        model="whisper-1",
        file=audio_file,
        language="fr"  # French
    )

print(response.text)

from litellm import transcription

with open("audio.mp3", "rb") as audio_file:
    # SRT format (with timestamps)
    srt_response = transcription(
        model="whisper-1",
        file=audio_file,
        response_format="srt"
    )
    print(srt_response.text)
    
    # VTT format (web video text tracks)
    vtt_response = transcription(
        model="whisper-1",
        file=audio_file,
        response_format="vtt"
    )
    print(vtt_response.text)

import asyncio
from litellm import atranscription

async def transcribe_audio():
    with open("audio.mp3", "rb") as audio_file:
        response = await atranscription(
            model="whisper-1",
            file=audio_file
        )
    return response.text

text = asyncio.run(transcribe_audio())
print(text)

import asyncio
from litellm import atranscription

async def transcribe_multiple(files: list):
    tasks = []
    for file_path in files:
        with open(file_path, "rb") as f:
            task = atranscription(model="whisper-1", file=f)
            tasks.append(task)
    
    responses = await asyncio.gather(*tasks)
    return [r.text for r in responses]

files = ["audio1.mp3", "audio2.mp3", "audio3.mp3"]
transcripts = asyncio.run(transcribe_multiple(files))

for i, text in enumerate(transcripts):
    print(f"File {i + 1}: {text}")

from litellm import speech
from pathlib import Path

response = speech(
    model="tts-1",
    input="Hello, this is a test of text to speech.",
    voice="alloy"
)

# Save audio file
response.stream_to_file("output.mp3")

def speech(
    model: str,
    input: str,
    voice: Optional[Union[str, dict]] = None,
    # Optional parameters
    response_format: Optional[str] = None,
    speed: Optional[int] = None,
    instructions: Optional[str] = None,
    # API configuration
    api_key: Optional[str] = None,
    api_base: Optional[str] = None,
    api_version: Optional[str] = None,
    organization: Optional[str] = None,
    project: Optional[str] = None,
    max_retries: Optional[int] = None,
    metadata: Optional[dict] = None,
    timeout: Optional[Union[float, httpx.Timeout]] = None,
    client: Optional[Any] = None,
    headers: Optional[dict] = None,
    custom_llm_provider: Optional[str] = None,
    **kwargs
) -> HttpxBinaryResponseContent

response.stream_to_file("output.mp3")  # Save to file
response.content  # Raw bytes

from litellm import speech

response = speech(
    model="tts-1",
    input="Welcome to the future of voice synthesis!",
    voice="nova"
)

response.stream_to_file("welcome.mp3")

from litellm import speech

text = "This is a test of different voices."
voices = ["alloy", "echo", "fable", "onyx", "nova", "shimmer"]

for voice in voices:
    response = speech(
        model="tts-1",
        input=text,
        voice=voice
    )
    response.stream_to_file(f"voice_{voice}.mp3")

from litellm import speech

response = speech(
    model="tts-1-hd",  # High quality model
    input="This is high quality audio synthesis.",
    voice="onyx",
    response_format="flac"  # Lossless format
)

response.stream_to_file("hq_audio.flac")

from litellm import speech

text = "The quick brown fox jumps over the lazy dog."

# Slow speech
slow = speech(model="tts-1", input=text, voice="alloy", speed=0.5)
slow.stream_to_file("slow.mp3")

# Normal speech
normal = speech(model="tts-1", input=text, voice="alloy", speed=1.0)
normal.stream_to_file("normal.mp3")

# Fast speech
fast = speech(model="tts-1", input=text, voice="alloy", speed=2.0)
fast.stream_to_file("fast.mp3")

from litellm import speech

text = "Converting to different audio formats."

formats = ["mp3", "opus", "aac", "flac", "wav"]
for fmt in formats:
    response = speech(
        model="tts-1",
        input=text,
        voice="echo",
        response_format=fmt
    )
    response.stream_to_file(f"output.{fmt}")

import asyncio
from litellm import aspeech

async def generate_speech():
    response = await aspeech(
        model="tts-1",
        input="Hello from async!",
        voice="nova"
    )
    response.stream_to_file("async_output.mp3")

asyncio.run(generate_speech())

import asyncio
from litellm import aspeech

async def generate_multiple():
    texts = [
        "Welcome to section one.",
        "This is section two.",
        "And this is section three."
    ]
    
    tasks = [
        aspeech(model="tts-1", input=text, voice="alloy")
        for text in texts
    ]
    
    responses = await asyncio.gather(*tasks)
    
    for i, response in enumerate(responses):
        response.stream_to_file(f"section_{i + 1}.mp3")

asyncio.run(generate_multiple())

from litellm import transcription, completion

# Transcribe voice message
with open("voice_message.mp3", "rb") as audio:
    transcript_response = transcription(
        model="whisper-1",
        file=audio
    )

transcript = transcript_response.text
print(f"Transcription: {transcript}")

# Analyze or respond using LLM
llm_response = completion(
    model="gpt-4",
    messages=[{
        "role": "user",
        "content": f"Summarize this voice message: {transcript}"
    }]
)

print(f"Summary: {llm_response.choices[0].message.content}")

from litellm import speech
import time

chapters = [
    "Chapter 1: The Beginning. It was a dark and stormy night...",
    "Chapter 2: The Journey. The hero set off on an adventure...",
    "Chapter 3: The End. And they lived happily ever after."
]

for i, chapter in enumerate(chapters):
    print(f"Generating chapter {i + 1}...")
    
    response = speech(
        model="tts-1-hd",
        input=chapter,
        voice="onyx",
        speed=0.9  # Slightly slower for audiobook
    )
    
    response.stream_to_file(f"audiobook_chapter_{i + 1}.mp3")
    time.sleep(1)  # Rate limiting

print("Audiobook generated!")

from litellm import speech, completion

# Get translation
response = completion(
    model="gpt-4",
    messages=[{
        "role": "user",
        "content": "Translate to Spanish: 'Good morning, how are you?'"
    }]
)

translation = response.choices[0].message.content
print(f"Translation: {translation}")

# Generate speech in target language
audio = speech(
    model="tts-1",
    input=translation,
    voice="nova"
)

audio.stream_to_file("spanish_phrase.mp3")

from litellm import transcription, completion

# Transcribe meeting recording
with open("meeting.mp3", "rb") as audio:
    transcript = transcription(
        model="whisper-1",
        file=audio,
        response_format="text"
    )

print(f"Transcript length: {len(transcript.text)} characters")

# Generate summary
summary_response = completion(
    model="gpt-4",
    messages=[{
        "role": "user",
        "content": f"Summarize this meeting transcript and extract action items:\n\n{transcript.text}"
    }]
)

print(f"\nSummary:\n{summary_response.choices[0].message.content}")

from litellm import transcription, speech
from litellm.exceptions import (
    BadRequestError,
    AuthenticationError,
    Timeout
)

# Transcription error handling
try:
    with open("audio.mp3", "rb") as audio:
        response = transcription(model="whisper-1", file=audio)
except FileNotFoundError:
    print("Audio file not found")
except BadRequestError as e:
    print(f"Invalid request: {e}")
except AuthenticationError:
    print("Invalid API key")
except Timeout:
    print("Request timed out")

# TTS error handling
try:
    response = speech(
        model="tts-1",
        input="Hello world",
        voice="alloy"
    )
    response.stream_to_file("output.mp3")
except BadRequestError as e:
    print(f"Invalid request: {e}")
except Exception as e:
    print(f"Error: {e}")