Initial commit: Parler TTS FastAPI with Docker

.gitignore

@@ -0,0 +1,13 @@
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+dist/
+build/
+.env
+.venv
+venv/
+*.log
+.DS_Store
+.claude/
+test_speech.wav

Dockerfile

@@ -0,0 +1,24 @@
+FROM pytorch/pytorch:2.1.0-cuda11.8-runtime-ubuntu22.04
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    git \
+    libsndfile1 \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements and install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+RUN pip install --no-cache-dir uvicorn[standard]
+
+# Copy application code
+COPY api.py .
+
+# Expose port
+EXPOSE 7860
+
+# Run the application
+CMD ["python", "-m", "uvicorn", "api:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,151 @@
+---
+title: Parler TTS API
+emoji: 🎙️
+colorFrom: blue
+colorTo: green
+sdk: docker
+app_file: api.py
+python_version: 3.10
+---
+
+# Indic Parler-TTS API
+
+FastAPI endpoint for Urdu Text-to-Speech using [ai4bharat/indic-parler-tts](https://huggingface.co/ai4bharat/indic-parler-tts).
+
+## API Endpoints
+
+### Health Check
+```
+GET /
+```
+Returns model status and available speakers.
+
+**Response:**
+```json
+{
+  "status": "ok",
+  "model": "Indic Parler-TTS",
+  "speakers": ["Divya", "Rani", "Rohit", "Aman", "Generic Female", "Generic Male"],
+  "sample_rate": 24000
+}
+```
+
+### Generate Speech
+```
+POST /tts
+```
+
+**Request Body:**
+```json
+{
+  "text": "السلام علیکم، میرا نام اردو ٹی ٹی ایس ہے۔",
+  "speaker": "Divya",
+  "pitch": "Moderate",
+  "rate": "Moderate",
+  "temperature": 0.8,
+  "do_sample": true
+}
+```
+
+**Parameters:**
+- `text` (string, required): Urdu text to synthesize
+- `speaker` (string, optional): Speaker name. Options: `Divya`, `Rani`, `Rohit`, `Aman`, `Generic Female`, `Generic Male`. Default: `Divya`
+- `pitch` (string, optional): Voice pitch. Options: `High`, `Moderate`, `Low`. Default: `Moderate`
+- `rate` (string, optional): Speaking rate. Options: `Slow`, `Moderate`, `Fast`. Default: `Moderate`
+- `temperature` (float, optional): Sampling temperature (0.1-2.0). Default: `0.8`
+- `do_sample` (boolean, optional): Use sampling vs greedy decoding. Default: `true`
+
+**Response:**
+- WAV audio file (audio/wav)
+
+### Get Available Speakers
+```
+GET /speakers
+```
+
+**Response:**
+```json
+{
+  "speakers": ["Divya", "Rani", "Rohit", "Aman", "Generic Female", "Generic Male"]
+}
+```
+
+## Example Usage
+
+### cURL
+```bash
+curl -X POST http://localhost:7860/tts \
+  -H "Content-Type: application/json" \
+  -d '{
+    "text": "السلام علیکم",
+    "speaker": "Divya",
+    "pitch": "Moderate",
+    "rate": "Moderate"
+  }' \
+  --output speech.wav
+```
+
+### Python
+```python
+import requests
+import json
+
+url = "http://localhost:7860/tts"
+payload = {
+    "text": "السلام علیکم، میرا نام اردو ٹی ٹی ایس ہے۔",
+    "speaker": "Divya",
+    "pitch": "Moderate",
+    "rate": "Moderate",
+    "temperature": 0.8,
+    "do_sample": True
+}
+
+response = requests.post(url, json=payload)
+if response.status_code == 200:
+    with open("speech.wav", "wb") as f:
+        f.write(response.content)
+    print("Audio saved!")
+else:
+    print(f"Error: {response.status_code}")
+    print(response.text)
+```
+
+## Running Locally
+
+### With Docker
+```bash
+docker build -t parler-tts-api .
+docker run -p 7860:7860 --gpus all parler-tts-api
+```
+
+### Without Docker
+```bash
+python3 -m venv venv
+source venv/bin/activate
+pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
+pip install -r requirements.txt
+pip install uvicorn[standard]
+python api.py
+```
+
+Then visit `http://localhost:7860/docs` for interactive API documentation.
+
+## Environment Variables
+
+For HF Spaces deployment, set the following secret:
+- `HF_TOKEN`: Your Hugging Face API token (required for gated model access)
+
+## Technical Details
+
+- **Model**: Indic Parler-TTS (multi-speaker, multi-language)
+- **Language**: Urdu (auto-detected from script)
+- **Sample Rate**: 24 kHz
+- **Audio Format**: WAV (16-bit PCM)
+- **Framework**: FastAPI + PyTorch
+- **Deployment**: HF Spaces Docker runtime
+
+### Quality Notes
+- Language is auto-detected from Urdu script — do NOT mention language in voice descriptions
+- Named speakers (Divya, Rohit, etc.) provide consistent voices
+- Same random seed used across sentences for voice consistency within a generation
+- Text cleaning removes Latin/English characters to prevent language mixing

api.py

@@ -0,0 +1,205 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import StreamingResponse
+import torch
+import numpy as np
+import re
+from io import BytesIO
+import soundfile as sf
+from pydantic import BaseModel
+from parler_tts import ParlerTTSForConditionalGeneration
+from transformers import AutoTokenizer
+
+# Try to import spaces for HF Spaces deployment
+try:
+    import spaces
+    HAS_SPACES = True
+except ImportError:
+    HAS_SPACES = False
+    class _NoOpSpaces:
+        def GPU(self, *args, **kwargs):
+            def decorator(fn):
+                return fn
+            return decorator
+    spaces = _NoOpSpaces()
+
+# --- Model Loading ---
+
+MODEL_ID = "ai4bharat/indic-parler-tts"
+DEVICE = "cpu"
+
+print("Loading Indic Parler-TTS model...")
+model = ParlerTTSForConditionalGeneration.from_pretrained(MODEL_ID).to(DEVICE)
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+description_tokenizer = AutoTokenizer.from_pretrained(model.config.text_encoder._name_or_path)
+SAMPLE_RATE = model.config.sampling_rate
+print("Model loaded!")
+
+# Named speakers
+SPEAKERS = {
+    "Divya": "Divya",
+    "Rani": "Rani",
+    "Rohit": "Rohit",
+    "Aman": "Aman",
+    "Generic Female": "",
+    "Generic Male": "",
+}
+
+app = FastAPI(title="Parler TTS API", version="1.0")
+
+
+class TTSRequest(BaseModel):
+    text: str
+    speaker: str = "Divya"
+    pitch: str = "Moderate"
+    rate: str = "Moderate"
+    temperature: float = 0.8
+    do_sample: bool = True
+
+
+def build_description(speaker_name, gender, pitch, rate):
+    """Build voice description prompt."""
+    if speaker_name:
+        return (
+            f"{speaker_name}'s voice delivers a slightly expressive speech "
+            f"with a {pitch.lower()} pitch and a {rate.lower()} speaking rate. "
+            f"The recording is of very high quality, with the speaker's voice sounding clear "
+            f"and very close up. Very clear audio."
+        )
+    else:
+        return (
+            f"A {gender.lower()} speaker delivers a slightly expressive and clear speech "
+            f"with a {pitch.lower()} pitch and a {rate.lower()} speaking rate. "
+            f"The recording is of very high quality, with the speaker's voice sounding clear "
+            f"and very close up. Very clear audio."
+        )
+
+
+def split_sentences(text):
+    """Split Urdu text into sentences."""
+    sentences = re.split(r'[۔।\.\!\?]+', text)
+    return [s.strip() for s in sentences if s.strip()]
+
+
+def clean_urdu_text(text):
+    """Clean and normalize Urdu text."""
+    text = re.sub(r'[a-zA-Z]+', '', text)
+    text = re.sub(r'\s+', ' ', text)
+    text = text.strip()
+    if text and text[-1] not in '۔.!?،':
+        text += '۔'
+    return text
+
+
+@spaces.GPU()
+def generate_speech_internal(text, speaker, pitch, rate, temperature, do_sample):
+    """Internal function for speech generation."""
+    if not text.strip():
+        return None
+
+    try:
+        text = clean_urdu_text(text)
+        speaker_name = SPEAKERS.get(speaker, "")
+        gender = "female" if "Female" in speaker or speaker in ["Divya", "Rani"] else "male"
+        description = build_description(speaker_name, gender, pitch, rate)
+        model.to("cuda")
+
+        sentences = split_sentences(text)
+        if not sentences:
+            sentences = [text.strip()]
+
+        all_audio = []
+        seed = torch.randint(0, 2**32, (1,)).item()
+
+        for sentence in sentences:
+            desc_tokens = description_tokenizer(description, return_tensors="pt")
+            prompt_tokens = tokenizer(sentence, return_tensors="pt")
+
+            torch.manual_seed(seed)
+            if torch.cuda.is_available():
+                torch.cuda.manual_seed(seed)
+
+            with torch.no_grad():
+                generation = model.generate(
+                    input_ids=desc_tokens.input_ids.to("cuda"),
+                    attention_mask=desc_tokens.attention_mask.to("cuda"),
+                    prompt_input_ids=prompt_tokens.input_ids.to("cuda"),
+                    prompt_attention_mask=prompt_tokens.attention_mask.to("cuda"),
+                    do_sample=do_sample,
+                    temperature=temperature if do_sample else 1.0,
+                    min_new_tokens=10,
+                )
+
+            audio_chunk = generation.cpu().numpy().squeeze()
+            audio_chunk = (audio_chunk * 32767).astype(np.int16)
+            all_audio.append(audio_chunk)
+
+            silence = np.zeros(int(SAMPLE_RATE * 0.3), dtype=np.int16)
+            all_audio.append(silence)
+
+        model.to("cpu")
+
+        if not all_audio:
+            return None
+
+        audio = np.concatenate(all_audio)
+        return audio
+
+    except Exception as e:
+        print(f"Error generating speech: {e}")
+        model.to("cpu")
+        return None
+
+
+@app.get("/")
+async def root():
+    """Health check endpoint."""
+    return {
+        "status": "ok",
+        "model": "Indic Parler-TTS",
+        "speakers": list(SPEAKERS.keys()),
+        "sample_rate": SAMPLE_RATE
+    }
+
+
+@app.post("/tts")
+async def text_to_speech(request: TTSRequest):
+    """Generate speech from Urdu text."""
+    if not request.text.strip():
+        raise HTTPException(status_code=400, detail="Text cannot be empty")
+
+    if request.speaker not in SPEAKERS:
+        raise HTTPException(status_code=400, detail=f"Invalid speaker. Choose from: {list(SPEAKERS.keys())}")
+
+    audio = generate_speech_internal(
+        request.text,
+        request.speaker,
+        request.pitch,
+        request.rate,
+        request.temperature,
+        request.do_sample
+    )
+
+    if audio is None:
+        raise HTTPException(status_code=500, detail="Failed to generate speech")
+
+    # Convert to WAV in memory
+    audio_buffer = BytesIO()
+    sf.write(audio_buffer, audio, SAMPLE_RATE, format='WAV')
+    audio_buffer.seek(0)
+
+    return StreamingResponse(
+        iter([audio_buffer.getvalue()]),
+        media_type="audio/wav",
+        headers={"Content-Disposition": "attachment; filename=speech.wav"}
+    )
+
+
+@app.get("/speakers")
+async def get_speakers():
+    """Get list of available speakers."""
+    return {"speakers": list(SPEAKERS.keys())}
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -0,0 +1,20 @@
+# --- Shared ---
+torch>=2.1
+numpy
+gradio
+soundfile
+
+# --- Transformers ecosystem ---
+transformers
+accelerate
+huggingface_hub
+
+# --- For Orpheus Urdu TTS (app_orpheus.py) ---
+snac
+bitsandbytes
+
+# --- For Indic Parler-TTS (app.py) ---
+git+https://github.com/huggingface/parler-tts.git
+
+# --- For MMS-TTS Urdu (app_mms.py) ---
+# uses transformers only (already included above)