Initial commit: FastAPI TTS Project ready for Vast.ai

.dockerignore

@@ -0,0 +1,16 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+.env
+.venv
+outputs/
+temp/
+models/
+.ipynb_checkpoints/
+*.ipynb
+.git/
+.gitignore

.gitignore

@@ -0,0 +1,23 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Virtual environments
+venv/
+env/
+.venv/
+.env/
+
+# Project specific
+outputs/
+temp/
+models/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+*.ipynb
+
+# OS generated files
+.DS_Store
+Thumbs.db

Dockerfile

@@ -0,0 +1,30 @@
+# Use an official NVIDIA CUDA base image with Ubuntu 22.04 to ensure Vast.ai compatibility and GPU support
+FROM nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04
+
+# Set non-interactive to avoid prompts during apt-get
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Install Python 3.10, pip, and ffmpeg
+RUN apt-get update && apt-get install -y \
+    python3 \
+    python3-pip \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set the working directory
+WORKDIR /app
+
+# Copy the requirements file into the container
+COPY requirements.txt .
+
+# Install dependencies (including torch for potential GPU inference)
+RUN pip3 install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application code
+COPY . .
+
+# Expose the FastAPI port
+EXPOSE 8000
+
+# Run the FastAPI application using uvicorn
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -0,0 +1,104 @@
+# Text-to-Speech (TTS) FastAPI Service
+
+This is a production-ready Text-to-Speech API built with FastAPI and `edge-tts`. It is optimized for asynchronous generation, handles long texts by chunking them, and is structured for deployment on GPU-enabled platforms like Vast.ai.
+
+## Project Structure
+
+```
+project/
+├── app.py                 # FastAPI application
+├── requirements.txt       # Dependencies
+├── Dockerfile             # Docker configuration
+├── .dockerignore          # Docker ignore file
+├── models/                # Directory for local models (if added later)
+├── outputs/               # Temporary output directory for generated audio
+├── temp/                  # Temporary chunk processing directory
+├── utils/                 # Utility modules
+│   ├── config.py          # Configuration and settings
+│   ├── text_utils.py      # Text cleaning and chunking logic
+│   └── audio_utils.py     # TTS generation and audio concatenation logic
+└── README.md              # Documentation
+```
+
+## Features
+- **FastAPI / Uvicorn**: High-performance asynchronous API.
+- **Robust Chunking**: Automatically chunks long text inputs without breaking sentences.
+- **Edge-TTS Integration**: Uses Microsoft Edge's neural TTS service.
+- **GPU Readiness**: Includes `torch` and memory cleanup (`torch.cuda.empty_cache()`) for compatibility with Vast.ai templates, allowing easy drop-in of local GPU models later.
+- **Temp File Cleanup**: Automatically cleans up temporary chunks and output files after they are served.
+
+## How to Run Locally
+
+### Prerequisites
+- Python 3.10+
+- `ffmpeg` installed on your system.
+
+### Steps
+1. Install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+2. Run the application:
+   ```bash
+   uvicorn app:app --host 0.0.0.0 --port 8000 --reload
+   ```
+3. Access the API documentation at `http://localhost:8000/docs`.
+
+## How to Build and Run the Docker Image
+
+1. Build the Docker image:
+   ```bash
+   docker build -t tts-fastapi .
+   ```
+2. Run the Docker container:
+   ```bash
+   docker run -p 8000:8000 --gpus all tts-fastapi
+   ```
+   *(Note: `--gpus all` is optional if you are strictly using `edge-tts` but recommended if you are deploying to a GPU-enabled instance and plan to use local PyTorch models).*
+
+## How to Deploy on Vast.ai
+
+1. Spin up an instance on Vast.ai.
+2. Under "Template Configuration", select a base image such as `nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04` or simply check the box for "Use Custom Image" and enter `python:3.10` or a custom Docker Hub image if you have pushed yours.
+3. If using an unconfigured instance, SSH in and run:
+   ```bash
+   git clone <your-repo-url>
+   cd tts-repo
+   docker build -t tts-fastapi .
+   docker run -d -p 8000:8000 --gpus all tts-fastapi
+   ```
+4. Ensure port `8000` is mapped and exposed in your Vast.ai instance settings so you can reach the API externally.
+
+## API Usage
+
+### `POST /generate`
+
+**Endpoint**: `/generate`
+**Content-Type**: `application/json`
+
+**Request Body**:
+```json
+{
+  "text": "Hello! This is a test of the Text to Speech API. It can handle very long text by splitting it appropriately.",
+  "lang": "en",
+  "voice_id": "preset_1"
+}
+```
+
+**Parameters**:
+- `text` (string, required): The text to synthesize.
+- `lang` (string, optional): Language code (e.g., `"en"`, `"ar"`). Defaults to `"en"`.
+- `voice_id` (string, optional): A preset voice from the registry (`preset_1` to `preset_5`). Defaults to `"preset_1"`.
+- `custom_voice_name` (string, optional): A specific Edge-TTS voice name (e.g., `"en-US-AriaNeural"`).
+
+**Response**:
+Returns the generated audio file (`audio/wav`).
+
+### Example using `curl`
+
+```bash
+curl -X POST "http://localhost:8000/generate" \
+     -H "Content-Type: application/json" \
+     -d '{"text":"Welcome to the text to speech service.","voice_id":"preset_2"}' \
+     --output generated_speech.wav
+```

app.py

@@ -0,0 +1,128 @@
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+from fastapi.responses import FileResponse
+from pydantic import BaseModel, Field
+import uuid
+import os
+import shutil
+import asyncio
+from typing import Optional
+from pathlib import Path
+
+# GPU Optimization Imports (as per user request)
+import torch
+
+from utils.config import (
+    DIR_TEMP, DIR_OUTPUT, DEFAULT_LANG, DEFAULT_VOICE_ID, 
+    resolve_voice_name, MAX_CHARS, MIN_CHARS
+)
+from utils.text_utils import chunk_text
+from utils.audio_utils import tts_to_wav, concat_wavs_by_timeline
+
+app = FastAPI(
+    title="TTS FastAPI Service",
+    description="Production-ready Text-to-Speech API using Edge-TTS",
+    version="1.0.0"
+)
+
+# Startup event to clear temp and output directories and initialize GPU
+@app.on_event("startup")
+async def startup_event():
+    # Cleanup previous runs
+    for directory in [DIR_TEMP, DIR_OUTPUT]:
+        for item in directory.glob("*"):
+            if item.is_file():
+                item.unlink()
+            elif item.is_dir():
+                shutil.rmtree(item)
+    
+    # Optional GPU Warmup/Initialization
+    if torch.cuda.is_available():
+        print(f"CUDA is available: {torch.cuda.get_device_name(0)}")
+        torch.cuda.empty_cache()
+    else:
+        print("CUDA is not available. Running on CPU (edge-tts is API based).")
+
+class TTSRequest(BaseModel):
+    text: str = Field(..., description="Text to synthesize into speech")
+    lang: str = Field(DEFAULT_LANG, description="Language code (e.g., 'en', 'ar')")
+    voice_id: str = Field(DEFAULT_VOICE_ID, description="Voice ID from registry")
+    custom_voice_name: Optional[str] = Field(None, description="Direct Voice name, e.g. 'en-US-GuyNeural'")
+
+def remove_file(path: Path):
+    """Background task to remove a file after returning it."""
+    try:
+        if path.exists():
+            path.unlink()
+    except Exception as e:
+        print(f"Failed to delete {path}: {e}")
+
+@app.post("/generate", summary="Generate TTS Audio from Text")
+async def generate_audio(request: TTSRequest, background_tasks: BackgroundTasks):
+    if not request.text.strip():
+        raise HTTPException(status_code=400, detail="Text cannot be empty.")
+        
+    try:
+        voice_name = resolve_voice_name(request.voice_id, request.custom_voice_name)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+    req_id = uuid.uuid4().hex[:8]
+    req_temp_dir = DIR_TEMP / req_id
+    req_temp_dir.mkdir(parents=True, exist_ok=True)
+    
+    output_wav = DIR_OUTPUT / f"output_{req_id}.wav"
+
+    try:
+        # Wrap inference simulation in no_grad for GPU memory optimization requirements
+        with torch.no_grad():
+            # 1. Chunk Text
+            chunks = chunk_text(request.text, lang=request.lang, max_chars=MAX_CHARS, min_chars=MIN_CHARS)
+            
+            if not chunks:
+                raise HTTPException(status_code=400, detail="No valid text found after cleaning.")
+
+            # 2. Generate Audio for each chunk asynchronously
+            tasks = []
+            chunk_wav_paths = []
+            
+            for i, chunk in enumerate(chunks):
+                chunk_wav = req_temp_dir / f"chunk_{i:04d}.wav"
+                chunk_wav_paths.append(chunk_wav)
+                tasks.append(tts_to_wav(chunk, chunk_wav, voice_name))
+            
+            # Run all edge-tts requests concurrently
+            await asyncio.gather(*tasks)
+
+            # 3. Concatenate
+            if len(chunk_wav_paths) == 1:
+                # If only one chunk, just move it to output
+                shutil.move(str(chunk_wav_paths[0]), str(output_wav))
+            else:
+                await concat_wavs_by_timeline(chunk_wav_paths, output_wav)
+
+        # Ensure CUDA cache is cleared after generation to prevent memory leaks
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+        # Schedule cleanup of the output file after it's returned
+        background_tasks.add_task(remove_file, output_wav)
+        
+        # Cleanup the temp directory for this request
+        shutil.rmtree(req_temp_dir, ignore_errors=True)
+
+        return FileResponse(
+            path=output_wav, 
+            media_type="audio/wav", 
+            filename="generated_speech.wav"
+        )
+
+    except Exception as e:
+        # Cleanup on failure
+        shutil.rmtree(req_temp_dir, ignore_errors=True)
+        if output_wav.exists():
+            output_wav.unlink()
+            
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            
+        raise HTTPException(status_code=500, detail=str(e))

requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.104.1
+uvicorn==0.24.0
+edge-tts==6.1.9
+nest_asyncio==1.5.8
+tqdm==4.66.1
+unidecode==1.3.7
+torch==2.1.0  # Added for GPU support and optimization readiness
+python-multipart==0.0.6

utils/audio_utils.py

@@ -0,0 +1,71 @@
+import asyncio
+import edge_tts
+import subprocess
+import wave
+import contextlib
+from pathlib import Path
+from utils.config import EDGE_RATE, EDGE_PITCH, SAMPLE_RATE
+
+def wav_duration_seconds(path: Path) -> float:
+    with contextlib.closing(wave.open(str(path), "rb")) as wf:
+        return wf.getnframes() / float(wf.getframerate())
+
+async def _edge_save_mp3(text: str, voice_name: str, out_mp3: Path, rate: str, pitch: str):
+    comm = edge_tts.Communicate(text=text, voice=voice_name, rate=rate, pitch=pitch)
+    await comm.save(str(out_mp3))
+
+async def tts_to_wav(text: str, out_wav: Path, voice_name: str) -> None:
+    """
+    Generates consistent PCM WAV (mono, SAMPLE_RATE) for easy concatenation.
+    """
+    out_wav.parent.mkdir(parents=True, exist_ok=True)
+    tmp_mp3 = out_wav.with_suffix(".tmp.mp3")
+    
+    await _edge_save_mp3(text, voice_name, tmp_mp3, EDGE_RATE, EDGE_PITCH)
+
+    # Convert mp3 to wav using ffmpeg
+    process = await asyncio.create_subprocess_exec(
+        "ffmpeg", "-y", "-i", str(tmp_mp3),
+        "-ac", "1", "-ar", str(SAMPLE_RATE), "-c:a", "pcm_s16le",
+        str(out_wav),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE
+    )
+    stdout, stderr = await process.communicate()
+    
+    if process.returncode != 0:
+        raise RuntimeError(f"FFmpeg failed with error:\\n{stderr.decode()}")
+
+    try:
+        tmp_mp3.unlink()
+    except Exception:
+        pass
+
+async def concat_wavs_by_timeline(wav_paths: list[Path], out_wav: Path):
+    """
+    Concatenates multiple WAV files into a single WAV file.
+    """
+    if not wav_paths:
+        raise ValueError("No WAV files to concatenate.")
+
+    concat_file = out_wav.with_suffix(".concat.txt")
+    with concat_file.open("w", encoding="utf-8") as f:
+        for p in wav_paths:
+            # ffmpeg concat demuxer requires absolute paths or relative to the list file
+            f.write(f"file '{str(p.resolve())}'\\n")
+
+    process = await asyncio.create_subprocess_exec(
+        "ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", str(concat_file),
+        "-ac", "1", "-ar", str(SAMPLE_RATE), "-c:a", "pcm_s16le", str(out_wav),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE
+    )
+    stdout, stderr = await process.communicate()
+    
+    if process.returncode != 0:
+        raise RuntimeError(f"FFmpeg concatenation failed:\\n{stderr.decode()}")
+
+    try:
+        concat_file.unlink()
+    except Exception:
+        pass

utils/config.py

@@ -0,0 +1,41 @@
+import os
+from pathlib import Path
+
+# ---------- Base Directories ----------
+BASE_DIR = Path(__file__).parent.parent
+DIR_TEMP = BASE_DIR / "temp"
+DIR_OUTPUT = BASE_DIR / "outputs"
+DIR_MODELS = BASE_DIR / "models"
+
+# Ensure directories exist
+for d in [DIR_TEMP, DIR_OUTPUT, DIR_MODELS]:
+    d.mkdir(parents=True, exist_ok=True)
+
+# ---------- TTS (Edge-TTS) Configuration ----------
+DEFAULT_VOICE_ID = "preset_1"
+CUSTOM_VOICE_NAME = None  # e.g. "en-US-GuyNeural"
+EDGE_RATE = "+0%"
+EDGE_PITCH = "+0Hz"
+
+VOICE_REGISTRY = {
+    "preset_1": "en-US-GuyNeural",
+    "preset_2": "en-US-JennyNeural",
+    "preset_3": "en-GB-RyanNeural",
+    "preset_4": "en-GB-SoniaNeural",
+    "preset_5": "ar-EG-SalmaNeural",
+}
+
+# ---------- Text + Chunking ----------
+DEFAULT_LANG = "en"
+MAX_CHARS = 220
+MIN_CHARS = 20
+
+# ---------- Audio Formats ----------
+SAMPLE_RATE = 22050  # Output sample rate for consistent mono PCM wav
+
+def resolve_voice_name(voice_id: str, custom_name: str = None) -> str:
+    if custom_name and str(custom_name).strip():
+        return str(custom_name).strip()
+    if voice_id not in VOICE_REGISTRY:
+        raise ValueError(f"Unknown VOICE_ID={voice_id}. Use {list(VOICE_REGISTRY.keys())} or set CUSTOM_VOICE_NAME.")
+    return VOICE_REGISTRY[voice_id]

utils/text_utils.py

@@ -0,0 +1,98 @@
+import re
+from typing import List
+
+_AR_DIACRITICS = re.compile(r"[\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06ED]")
+_SENT_SPLIT = re.compile(r"(?<=[\\.\\!\\?])\s+|(?<=[\u061F\u06D4])\s+|(?<=\n)\s*")
+_SOFT_SPLIT = re.compile(r"(?<=[,;:،؛])\s+")
+
+def normalize_whitespace(s: str) -> str:
+    s = s.replace("\u00A0", " ")
+    s = re.sub(r"[ \t]+", " ", s)
+    s = re.sub(r"\n{3,}", "\n\n", s)
+    return s.strip()
+
+def normalize_punctuation(s: str) -> str:
+    s = s.replace("…", "...")
+    s = s.replace("“", '"').replace("”", '"').replace("’", "'").replace("‘", "'")
+    s = s.replace("—", "-").replace("–", "-")
+    s = re.sub(r"\s+([,.;:!?])", r"\1", s)
+    s = re.sub(r"([,.;:!?])([^\s])", r"\1 \2", s)
+    return s
+
+def normalize_arabic(s: str) -> str:
+    s = s.replace("\u0640", "")            # tatweel
+    s = _AR_DIACRITICS.sub("", s)          # diacritics
+    s = s.replace("،", "، ").replace("؟", "؟ ").replace("؛", "؛ ")
+    s = re.sub(r"\s+", " ", s)
+    return s.strip()
+
+def clean_text(s: str, lang: str = "en") -> str:
+    s = normalize_whitespace(s)
+    s = normalize_punctuation(s)
+    if lang.lower().startswith("ar"):
+        s = normalize_arabic(s)
+    s = re.sub(r"[\u200B-\u200F\u202A-\u202E]", "", s)  # bidi junk
+    return normalize_whitespace(s)
+
+def split_into_sentences(text: str) -> List[str]:
+    text = normalize_whitespace(text)
+    return [p.strip() for p in _SENT_SPLIT.split(text) if p.strip()]
+
+def hard_wrap_by_words(s: str, max_chars: int) -> List[str]:
+    words = s.split()
+    out, cur = [], []
+    for w in words:
+        cand = (" ".join(cur + [w])).strip()
+        if len(cand) <= max_chars:
+            cur.append(w)
+        else:
+            if cur:
+                out.append(" ".join(cur))
+                cur = [w]
+            else:
+                out.append(w[:max_chars])
+                rest = w[max_chars:]
+                if rest:
+                    cur = [rest]
+    if cur:
+        out.append(" ".join(cur))
+    return [x.strip() for x in out if x.strip()]
+
+def chunk_text(text: str, lang: str = "en", max_chars: int = 220, min_chars: int = 20) -> List[str]:
+    text = clean_text(text, lang=lang)
+    sents = split_into_sentences(text)
+
+    chunks, cur = [], ""
+
+    def flush():
+        nonlocal cur
+        if cur.strip():
+            chunks.append(cur.strip())
+        cur = ""
+
+    for sent in sents:
+        if len(sent) > max_chars:
+            subs = [x.strip() for x in _SOFT_SPLIT.split(sent) if x.strip()]
+            if len(subs) == 1:
+                subs = hard_wrap_by_words(sent, max_chars=max_chars)
+        else:
+            subs = [sent]
+
+        for part in subs:
+            if not cur:
+                cur = part
+            elif len(cur) + 1 + len(part) <= max_chars:
+                cur = cur + " " + part
+            else:
+                flush()
+                cur = part
+
+    flush()
+
+    merged = []
+    for ch in chunks:
+        if merged and len(ch) < min_chars:
+            merged[-1] = (merged[-1] + " " + ch).strip()
+        else:
+            merged.append(ch)
+    return merged