Comprehensive comparison for Text-to-Speech technology in AI applications

import os
import asyncio
from elevenlabs import VoiceSettings
from elevenlabs.client import ElevenLabs
from fastapi import FastAPI, HTTPException, BackgroundTasks
from pydantic import BaseModel, Field
from typing import Optional
import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Initialize ElevenLabs client
client = ElevenLabs(api_key=os.getenv("ELEVENLABS_API_KEY"))

app = FastAPI(title="AI Text-to-Speech Service")

class TTSRequest(BaseModel):
    text: str = Field(..., min_length=1, max_length=5000)
    voice_id: str = Field(default="21m00Tcm4TlvDq8ikWAM")  # Rachel voice
    model_id: str = Field(default="eleven_monolingual_v1")
    stability: float = Field(default=0.5, ge=0.0, le=1.0)
    similarity_boost: float = Field(default=0.75, ge=0.0, le=1.0)
    style: float = Field(default=0.0, ge=0.0, le=1.0)
    use_speaker_boost: bool = Field(default=True)

class TTSResponse(BaseModel):
    success: bool
    audio_url: Optional[str] = None
    message: str
    character_count: int

@app.post("/api/v1/text-to-speech", response_model=TTSResponse)
async def generate_speech(request: TTSRequest, background_tasks: BackgroundTasks):
    """
    Generate speech from text using ElevenLabs API.
    Handles rate limiting, errors, and saves audio files.
    """
    try:
        logger.info(f"Processing TTS request for {len(request.text)} characters")
        
        # Validate voice exists
        try:
            voices = client.voices.get_all()
            voice_exists = any(v.voice_id == request.voice_id for v in voices.voices)
            if not voice_exists:
                raise HTTPException(status_code=400, detail="Invalid voice_id")
        except Exception as e:
            logger.error(f"Voice validation failed: {str(e)}")
            raise HTTPException(status_code=500, detail="Voice validation error")
        
        # Configure voice settings
        voice_settings = VoiceSettings(
            stability=request.stability,
            similarity_boost=request.similarity_boost,
            style=request.style,
            use_speaker_boost=request.use_speaker_boost
        )
        
        # Generate audio
        try:
            audio_generator = client.generate(
                text=request.text,
                voice=request.voice_id,
                model=request.model_id,
                voice_settings=voice_settings
            )
            
            # Collect audio chunks
            audio_data = b""
            for chunk in audio_generator:
                if chunk:
                    audio_data += chunk
            
            if not audio_data:
                raise HTTPException(status_code=500, detail="No audio generated")
            
            # Save audio file
            output_path = f"output/audio_{hash(request.text)}.mp3"
            os.makedirs("output", exist_ok=True)
            
            with open(output_path, "wb") as f:
                f.write(audio_data)
            
            logger.info(f"Audio saved to {output_path}")
            
            return TTSResponse(
                success=True,
                audio_url=f"/audio/{os.path.basename(output_path)}",
                message="Speech generated successfully",
                character_count=len(request.text)
            )
            
        except Exception as e:
            logger.error(f"Audio generation failed: {str(e)}")
            raise HTTPException(status_code=500, detail=f"Generation error: {str(e)}")
    
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Unexpected error: {str(e)}")
        raise HTTPException(status_code=500, detail="Internal server error")

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)