core/app.py

from fastapi import FastAPI, HTTPException, Response, Request
from fastapi.responses import HTMLResponse
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
from pydantic import BaseModel, Field
from typing import Optional
from vocify import generate_speech
import os
from slowapi import Limiter
from slowapi.util import get_remote_address
from slowapi.errors import RateLimitExceeded
from fastapi.middleware.cors import CORSMiddleware
from langdetect import detect, LangDetectException

# Create necessary directories if they don't exist
os.makedirs("static", exist_ok=True)
os.makedirs("templates", exist_ok=True)

# Initialize FastAPI app
app = FastAPI(
    title="Pyxilabs._.Vocify",
    description="A Text-to-Speech API",
    swagger_ui_parameters={"favicon": "/static/icon.png"}
)

# Rate Limiter Setup
limiter = Limiter(key_func=get_remote_address)
app.state.limiter = limiter

# Rate limit error handler
@app.exception_handler(RateLimitExceeded)
async def rate_limit_exceeded_handler(request: Request, exc: RateLimitExceeded):
    return HTTPException(
        status_code=429,
        detail="Rate limit exceeded. Please try again later."
    )

# Mount static files directory
app.mount("/static", StaticFiles(directory="static"), name="static")

# Initialize templates
templates = Jinja2Templates(directory="templates")

# Model and voice information structure
MODEL_INFO = {
    "Pyx r1-voice": {
        "name": "Pyx r1-voice",
        "created": "2024-12-12",
        "owner": "Pyxilabs AI Studio",
        "voices": {
            "charlottee": "XB0fDUnXU5powFXDhCwa",
            "daniel": "onwK4e9ZLuTAKqWW03F9",
            "callum": "N2lVS1w4EtoT3dr4eOWO",
            "charlie": "IKne3meq5aSn9XLyUdCD",
            "clyde": "2EiwWnXFnvU5JabPnv8n",
            "dave": "CYw3kZ02Hs0563khs1Fj",
            "emily": "LcfcDJNUP1GQjkzn1xUU",
            "ethan": "g5CIjZEefAph4nQFvHAz",
            "fin": "D38z5RcWu1voky8WS1ja",
            "freya": "jsCqWAovK2LkecY7zXl4",
            "gigi": "jBpfuIE2acCO8z3wKNLl",
            "giovanni": "zcAOhNBS3c14rBihAFp1",
            "glinda": "z9fAnlkpzviPz146aGWa",
            "grace": "oWAxZDx7w5VEj9dCyTzz",
            "harry": "SOYHLrjzK2X1ezoPC6cr",
            "james": "ZQe5CZNOzWyzPSCn5a3c",
            "jeremy": "bVMeCyTHy58xNoL34h3p"
        }
    }
}

# Rate limits for free tier
RATE_LIMITS = {
    "rpm": 10,  # Requests per minute
    "rph": 100,  # Requests per hour
    "rpd": 1000,  # Requests per day
}

# Pydantic model for speech request
class SpeechRequest(BaseModel):
    model: Optional[str] = Field(default="Pyx r1-voice")
    input: str = Field(..., max_length=5000)
    voice: str

# Allowed languages
ALLOWED_LANGUAGES = {"en", "ja", "zh", "id"}  # Codes for English, Japanese, Chinese, Indonesian

# Function to validate language
def validate_language(text: str) -> bool:
    try:
        lang = detect(text)
        return lang in ALLOWED_LANGUAGES
    except LangDetectException:
        return False

# Endpoint to generate speech
@app.post("/v1/audio/speech")
@app.get("/v1/audio/speech")
@limiter.limit(f"{RATE_LIMITS['rpm']}/minute")
@limiter.limit(f"{RATE_LIMITS['rph']}/hour")
@limiter.limit(f"{RATE_LIMITS['rpd']}/day")
async def create_speech(request: Request, speech_request: SpeechRequest):
    try:
        # Validate input language
        if not validate_language(speech_request.input):
            raise HTTPException(
                status_code=400,
                detail="Input text must be in English, Japanese, Chinese, or Indonesian."
            )

        if speech_request.model != "Pyx r1-voice":
            raise HTTPException(status_code=400, detail="Invalid model. Only 'Pyx r1-voice' is supported.")
        
        if speech_request.voice not in MODEL_INFO["Pyx r1-voice"]["voices"]:
            raise HTTPException(status_code=400, detail="Invalid voice ID")
        
        voice_id = MODEL_INFO["Pyx r1-voice"]["voices"][speech_request.voice]
        
        result = generate_speech(
            model="eleven_multilingual_v2",
            voice=voice_id,
            input_text=speech_request.input
        )
        
        if isinstance(result, list):
            raise HTTPException(status_code=result[0], detail=result[1])
        
        return Response(content=result, media_type="audio/mpeg")
    
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

# Endpoint to get available models
@app.get("/models")
@app.get("/v1/models")
async def get_models():
    models_response = []
    for model_id, model_data in MODEL_INFO.items():
        model_info = {
            "id": model_id,
            "name": model_data["name"],
            "created": model_data["created"],
            "owner": model_data["owner"],
            "vocals": [
                {
                    "id": voice_name,
                }
                for voice_name, voice_id in model_data["voices"].items()
            ]
        }
        models_response.append(model_info)
    
    return {"models": models_response}

# Root endpoint to serve the HTML frontend
@app.get("/", response_class=HTMLResponse)
async def root(request: Request):
    with open("templates/index.html", "r") as file:
        return HTMLResponse(content=file.read())

# Favicon endpoint
@app.get("/favicon.ico", include_in_schema=False)
async def favicon():
    return {"url": "/static/icon.png"}

# Run the application
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=7860)