Update main.py

main.py

@@ -3,7 +3,7 @@ import time
 import random
 import asyncio
 import json
-from fastapi import FastAPI, HTTPException, Depends, File, UploadFile, Form  
+from fastapi import FastAPI, HTTPException, Depends, File, UploadFile, Form, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.security.api_key import APIKeyHeader
 from pydantic import BaseModel
@@ -16,6 +16,11 @@ import io
 import copy
 from pathlib import Path
 from pydub import AudioSegment
+import base64, uuid, mimetypes
+import struct
+from google import genai
+from google.genai import types
+import re 
 
 load_dotenv()
 
@@ -60,10 +65,14 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# Api Key GEMINI (Random della lista in modo da averne di più)
+def get_gemini_apikey():
+    return random.choice(API_KEYS)
+
 # Client OpenAI
 def get_openai_client():
     ''' Client OpenAI passando in modo RANDOM le Chiavi API. In questo modo posso aggirare i limiti "Quota Exceeded" '''
-    api_key = random.choice(API_KEYS)
+    api_key = get_gemini_apikey()
     return OpenAI(api_key=api_key, base_url=BASE_URL)
 
 # Validazione API       
@@ -299,7 +308,6 @@ def _transcribe_chunk(chunk_bytes: bytes,
         return resp.text
     return resp.get("text", "")
 
-
 def get_whisper_client():
     api_key = random.choice(GROQ_API_KEYS)
     return OpenAI(api_key=api_key, base_url=GROQ_BASE_URL)
@@ -322,6 +330,133 @@ def call_whisper_api(audio_file: io.BytesIO,
             return call_whisper_api(audio_file, model, language, response_format)
         raise e
 
+class SpeechRequest(BaseModel):
+    model: Optional[str] = "gemini-2.5-flash-preview-tts" 
+    input: str
+    voice: Optional[str] = "Kore"
+    speed: Optional[float] = 1.0           
+    response_format: Optional[str] = "wav"
+    class Config:
+        extra = "allow"    
+
+class SpeechResponse(BaseModel):
+    model: str
+    response_format: str
+    voice: str
+    audio: str   
+
+def convert_format(audio_bytes: bytes, from_fmt: str, to_fmt: str) -> bytes:
+    """
+    Converte i byte audio da 'from_fmt' a 'to_fmt' usando pydub/ffmpeg.
+    Supporta mp3, wav, opus, flac, aac, pcm (raw little-endian 16-bit).
+    """
+    if from_fmt == to_fmt:
+        return audio_bytes
+
+    audio = AudioSegment.from_file(io.BytesIO(audio_bytes), format=from_fmt)
+    buf = io.BytesIO()
+    if to_fmt == "pcm":                     # raw PCM 16-bit LE
+        audio.export(buf, format="raw")
+    else:
+        audio.export(buf, format=to_fmt)
+    return buf.getvalue()
+
+def parse_audio_mime_type(mime_type: str) -> dict[str, int | None]:
+    """Parses bits per sample and rate from an audio MIME type string """
+    bits_per_sample = 16
+    rate = 24000
+    parts = mime_type.split(";")
+    for param in parts: 
+        param = param.strip()
+        if param.lower().startswith("rate="):
+            try:
+                rate_str = param.split("=", 1)[1]
+                rate = int(rate_str)
+            except (ValueError, IndexError):
+                pass # Keep rate as default
+        elif param.startswith("audio/L"):
+            try:
+                bits_per_sample = int(param.split("L", 1)[1])
+            except (ValueError, IndexError):
+                pass # Keep bits_per_sample as default if conversion fails
+    return {"bits_per_sample": bits_per_sample, "rate": rate}
+
+def convert_to_wav(audio_data: bytes, mime_type: str) -> bytes:
+    """Generates a WAV file header for the given audio data and parameters."""
+    parameters = parse_audio_mime_type(mime_type)
+    bits_per_sample = parameters["bits_per_sample"]
+    sample_rate = parameters["rate"]
+    num_channels = 1
+    data_size = len(audio_data)
+    bytes_per_sample = bits_per_sample // 8
+    block_align = num_channels * bytes_per_sample
+    byte_rate = sample_rate * block_align
+    chunk_size = 36 + data_size  
+    header = struct.pack(
+        "<4sI4s4sIHHIIHH4sI",
+        b"RIFF",          # ChunkID
+        chunk_size,       # ChunkSize (total file size - 8 bytes)
+        b"WAVE",          # Format
+        b"fmt ",          # Subchunk1ID
+        16,               # Subchunk1Size (16 for PCM)
+        1,                # AudioFormat (1 for PCM)
+        num_channels,     # NumChannels
+        sample_rate,      # SampleRate
+        byte_rate,        # ByteRate
+        block_align,      # BlockAlign
+        bits_per_sample,  # BitsPerSample
+        b"data",          # Subchunk2ID
+        data_size         # Subchunk2Size (size of audio data)
+    )
+    return header + audio_data
+
+# Generazione Audio
+def generate_audio(model: str, 
+                   content: str,
+                   speaker1: str = "Kore",
+                   speaker2: str = "Schedar") -> bytes:
+    """Restituisce i byte WAV generati da Gemini-TTS (multi-speaker)."""
+    client = genai.Client(api_key=get_gemini_apikey())
+    contents = [types.Content(role="user", parts=[types.Part.from_text(text=content)])]
+    cfg = types.GenerateContentConfig(
+        temperature=1,
+        response_modalities=["audio"],
+        speech_config=types.SpeechConfig(
+            multi_speaker_voice_config=types.MultiSpeakerVoiceConfig(
+                speaker_voice_configs=[
+                    types.SpeakerVoiceConfig(
+                        speaker="Speaker 1",
+                        voice_config=types.VoiceConfig(
+                            prebuilt_voice_config=types.PrebuiltVoiceConfig(
+                                voice_name=speaker1
+                            )
+                        ),
+                    ),
+                    types.SpeakerVoiceConfig(
+                        speaker="Speaker 2",
+                        voice_config=types.VoiceConfig(
+                            prebuilt_voice_config=types.PrebuiltVoiceConfig(
+                                voice_name=speaker2
+                            )
+                        ),
+                    ),
+                ]
+            ),
+        ),
+    )
+
+    for chunk in client.models.generate_content_stream(
+        model=model, contents=contents, config=cfg
+    ):
+        part = chunk.candidates[0].content.parts[0]
+        if part.inline_data and part.inline_data.data:
+            data = part.inline_data.data
+            if mimetypes.guess_extension(part.inline_data.mime_type) is None:
+                data = convert_to_wav(data, part.inline_data.mime_type)
+            return data
+    raise RuntimeError("Nessun dato audio ricevuto")
+
+
 # ---------------------------------- Metodi API ---------------------------------------
 @app.get("/")
 def read_general(): 
@@ -368,6 +503,36 @@ async def audio_transcriptions_endpoint(
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+@app.post("/v1/audio/speech", dependencies=[Depends(verify_api_key)],
+          response_model=SpeechResponse)
+async def audio_speech_endpoint(req: SpeechRequest,  request: Request):
+    try:
+        voices = re.split(r"[;,|]", req.voice)
+        speaker1 = voices[0].strip()
+        speaker2 = voices[1].strip() if len(voices) > 1 else "Schedar"
+        print('------------------------------------------------------- INPUT ---------------------------------------------------------------')
+        print(req.voice)
+        print(req.input)
+        wav_bytes = generate_audio(
+            model=req.model,
+            content=req.input,
+            speaker1=speaker1,
+            speaker2=speaker2
+        )
+        audio_bytes = convert_format(wav_bytes, "wav", req.response_format)
+        audio_fmt   = req.response_format.lower()
+        audio_bytes = convert_format(wav_bytes, "wav", audio_fmt)
+        return StreamingResponse(
+            io.BytesIO(audio_bytes),
+            media_type="application/octet-stream",
+            headers={
+                "Content-Disposition": f'attachment; filename="audio.{audio_fmt}"',
+                "X-OpenAI-Response-Format": audio_fmt,
+            },
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)