Update app.py

app.py

@@ -13,14 +13,13 @@ from dotenv import load_dotenv
 load_dotenv()
 
 app = FastAPI(
-    title="Google GenAI TTS API with Multiple API Keys",
-    description="Text-to-Speech API using Google GenAI with multiple API keys fallback.",
-    version="1.2.0",
+    title="Google GenAI TTS API with Multi-Key Quota Fallback",
+    description="TTS API using Google GenAI with multiple API keys and 429 quota handling.",
+    version="1.3.0",
     docs_url="/docs",
     redoc_url=None
 )
 
-# Pydantic model for request body
 class TTSRequest(BaseModel):
     text: str
     voice_name: Optional[str] = "Kore"
@@ -30,27 +29,12 @@ class TTSRequest(BaseModel):
     sample_width: Optional[int] = 2
 
 def get_api_keys() -> List[str]:
-    """Retrieve list of API keys from environment variable"""
     api_keys = os.getenv("GEMINI_API_KEYS")
     if not api_keys:
         raise ValueError("No API keys found in GEMINI_API_KEYS environment variable.")
     return [key.strip() for key in api_keys.split(",") if key.strip()]
 
-def initialize_genai_client():
-    """Initialize the GenAI client by trying multiple API keys"""
-    api_keys = get_api_keys()
-    for key in api_keys:
-        try:
-            print(f"Trying API key: {key[:5]}...")  # Only show part for safety
-            client = genai.Client(api_key=key)
-            return client
-        except Exception as e:
-            print(f"Failed with key {key[:5]}... : {e}")
-
-    raise ValueError("No valid API key could initialize the GenAI client.")
-
 def generate_wave_bytes(pcm_data: bytes, channels: int, rate: int, sample_width: int) -> bytes:
-    """Convert PCM audio data into WAV bytes."""
     with io.BytesIO() as wav_buffer:
         with wave.open(wav_buffer, "wb") as wf:
             wf.setnchannels(channels)
@@ -59,54 +43,73 @@ def generate_wave_bytes(pcm_data: bytes, channels: int, rate: int, sample_width:
             wf.writeframes(pcm_data)
         return wav_buffer.getvalue()
 
-@app.post("/api/generate-tts/")
-async def generate_tts(request: TTSRequest):
-    """
-    Convert text to speech audio using Google GenAI.
-    """
-    try:
-        client = initialize_genai_client()
-
-        text_to_speak = f"Say cheerfully: {request.text}" if request.cheerful else request.text
-
-        response = client.models.generate_content(
-            model="gemini-2.5-flash-preview-tts",
-            contents=text_to_speak,
-            config=types.GenerateContentConfig(
-                response_modalities=["AUDIO"],
-                speech_config=types.SpeechConfig(
-                    voice_config=types.VoiceConfig(
-                        prebuilt_voice_config=types.PrebuiltVoiceConfig(
-                            voice_name=request.voice_name,
-                        )
+def try_generate_tts(api_key, request):
+    client = genai.Client(api_key=api_key)
+    text_to_speak = f"Say cheerfully: {request.text}" if request.cheerful else request.text
+
+    response = client.models.generate_content(
+        model="gemini-2.5-flash-preview-tts",
+        contents=text_to_speak,
+        config=types.GenerateContentConfig(
+            response_modalities=["AUDIO"],
+            speech_config=types.SpeechConfig(
+                voice_config=types.VoiceConfig(
+                    prebuilt_voice_config=types.PrebuiltVoiceConfig(
+                        voice_name=request.voice_name,
                     )
-                ),
-            )
+                )
+            ),
         )
+    )
 
-        if not response.candidates or not response.candidates[0].content.parts:
-            raise HTTPException(status_code=500, detail="No audio data received from GenAI.")
+    if not response.candidates or not response.candidates[0].content.parts:
+        raise HTTPException(status_code=500, detail="No audio data received from GenAI.")
 
-        audio_data = response.candidates[0].content.parts[0].inline_data.data
+    audio_data = response.candidates[0].content.parts[0].inline_data.data
 
-        wav_bytes = generate_wave_bytes(
-            audio_data,
-            channels=request.channels,
-            rate=request.sample_rate,
-            sample_width=request.sample_width
-        )
+    wav_bytes = generate_wave_bytes(
+        audio_data,
+        channels=request.channels,
+        rate=request.sample_rate,
+        sample_width=request.sample_width
+    )
 
-        return StreamingResponse(
-            io.BytesIO(wav_bytes),
-            media_type="audio/wav",
-            headers={"Content-Disposition": "attachment; filename=generated_audio.wav"}
-        )
+    return wav_bytes
 
-    except Exception as e:
-        return JSONResponse(
-            {"status": "error", "message": str(e)},
-            status_code=500
-        )
+@app.post("/api/generate-tts/")
+async def generate_tts(request: TTSRequest):
+    api_keys = get_api_keys()
+    last_error = None
+
+    for api_key in api_keys:
+        try:
+            print(f"Trying API key: {api_key[:5]}...")
+            wav_bytes = try_generate_tts(api_key, request)
+            return StreamingResponse(
+                io.BytesIO(wav_bytes),
+                media_type="audio/wav",
+                headers={"Content-Disposition": "attachment; filename=generated_audio.wav"}
+            )
+
+        except Exception as e:
+            error_msg = str(e)
+            print(f"Key {api_key[:5]} failed: {error_msg}")
+
+            if "RESOURCE_EXHAUSTED" in error_msg or "quota" in error_msg.lower() or "429" in error_msg:
+                # Quota exhausted, try next key
+                last_error = error_msg
+                continue
+            else:
+                # Some other error, don't continue
+                return JSONResponse(
+                    {"status": "error", "message": error_msg},
+                    status_code=500
+                )
+
+    return JSONResponse(
+        {"status": "error", "message": f"All API keys exhausted or invalid. Last error: {last_error}"},
+        status_code=429
+    )
 
 @app.get("/")
 async def root():