api.py

"""
FastAPI server for transliteration API
Provides RESTful endpoints for programmatic access
"""

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List, Optional
from inference import Transliterator
import os

# Initialize FastAPI app
app = FastAPI(
    title="Multilingual Transliteration API",
    description="API for transliterating English text to Hindi, Bengali, and Tamil",
    version="1.0.0",
)

# Initialize transliterator
MODEL_PATH = "ct2_model" if os.path.exists("ct2_model") else "models/translit"
USE_CT2 = os.path.exists("ct2_model")
trans = Transliterator(model_path=MODEL_PATH, use_ct2=USE_CT2)


# Pydantic models for request/response
class TransliterateRequest(BaseModel):
    text: str
    lang: str = "hi"
    max_length: Optional[int] = 32
    num_beams: Optional[int] = 4


class TransliterateBatchRequest(BaseModel):
    texts: List[str]
    lang: str = "hi"
    max_length: Optional[int] = 32
    num_beams: Optional[int] = 4
    batch_size: Optional[int] = 32


class TransliterateResponse(BaseModel):
    input: str
    output: str
    language: str
    success: bool


class TransliterateBatchResponse(BaseModel):
    inputs: List[str]
    outputs: List[str]
    language: str
    count: int
    success: bool


class TransliterateAllResponse(BaseModel):
    input: str
    outputs: dict
    success: bool


@app.get("/")
def read_root():
    """Root endpoint with API information."""
    return {
        "message": "Multilingual Transliteration API",
        "version": "1.0.0",
        "languages": ["hi", "bn", "ta"],
        "endpoints": {
            "GET /": "This information",
            "POST /transliterate": "Transliterate single text",
            "POST /transliterate/batch": "Transliterate batch of texts",
            "POST /transliterate/all": "Transliterate to all languages",
            "GET /languages": "List supported languages",
        },
    }


@app.get("/languages")
def get_languages():
    """Get list of supported languages."""
    return {
        "languages": [
            {"code": "hi", "name": "Hindi", "native": "हिन्दी"},
            {"code": "bn", "name": "Bengali", "native": "বাংলা"},
            {"code": "ta", "name": "Tamil", "native": "தமிழ்"},
        ]
    }


@app.post("/transliterate", response_model=TransliterateResponse)
def transliterate_single(request: TransliterateRequest):
    """
    Transliterate a single text to the specified language.

    - **text**: English text to transliterate
    - **lang**: Target language code (hi, bn, ta)
    - **max_length**: Maximum output length (default: 32)
    - **num_beams**: Number of beams for beam search (default: 4)
    """
    try:
        result = trans.transliterate(
            text=request.text,
            lang=request.lang,
            max_length=request.max_length,
            num_beams=request.num_beams,
        )
        return TransliterateResponse(
            input=request.text, output=result, language=request.lang, success=True
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/transliterate/batch", response_model=TransliterateBatchResponse)
def transliterate_batch(request: TransliterateBatchRequest):
    """
    Transliterate a batch of texts to the specified language.

    - **texts**: List of English texts to transliterate
    - **lang**: Target language code (hi, bn, ta)
    - **max_length**: Maximum output length (default: 32)
    - **num_beams**: Number of beams for beam search (default: 4)
    - **batch_size**: Batch size for processing (default: 32)
    """
    try:
        results = trans.transliterate_batch(
            texts=request.texts,
            lang=request.lang,
            max_length=request.max_length,
            num_beams=request.num_beams,
            batch_size=request.batch_size,
        )
        return TransliterateBatchResponse(
            inputs=request.texts,
            outputs=results,
            language=request.lang,
            count=len(results),
            success=True,
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/transliterate/all", response_model=TransliterateAllResponse)
def transliterate_all(request: TransliterateRequest):
    """
    Transliterate text to all supported languages.

    - **text**: English text to transliterate
    - **max_length**: Maximum output length (default: 32)
    - **num_beams**: Number of beams for beam search (default: 4)
    """
    try:
        results = trans.transliterate_all(
            text=request.text, languages=["hi", "bn", "ta"]
        )
        return TransliterateAllResponse(
            input=request.text, outputs=results, success=True
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@app.get("/health")
def health_check():
    """Health check endpoint."""
    return {"status": "healthy", "model_loaded": True}


if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app, host="0.0.0.0", port=8000)