Initial deployment

.dockerignore

@@ -0,0 +1,9 @@
+.git
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.env
+.venv/
+venv/
+*.log

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+hint.wav filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.pyc
+.env
+.venv/
+.venv310/

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.10
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+# Install system dependencies for soundfile
+RUN apt-get update && apt-get install -y libsndfile1 && rm -rf /var/lib/apt/lists/*
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . /code
+
+# Set up a new user named "user" with user ID 1000
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+COPY --chown=user . $HOME/app
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,15 @@
+---
+title: tts Text To Speech
+emoji: 🌍
+colorFrom: yellow
+colorTo: pink
+sdk: docker
+sdk_version: 5.25.2
+python_version: 3.10.0
+app_file: app.py
+pinned: false
+short_description: Text-to-speech (TTS) with Next-gen Kaldi
+license: apache-2.0
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,299 @@
+#!/usr/bin/env python3
+
+import base64
+import io
+import os
+import time
+import uuid
+from datetime import datetime
+from functools import lru_cache
+from typing import Optional
+
+import gradio as gr
+import pymongo
+import soundfile as sf
+from bson.binary import Binary
+from bson.objectid import ObjectId
+from dotenv import load_dotenv
+from fastapi import Body, FastAPI, Form, Request, Response
+from pydantic import BaseModel
+
+from model import ENGLISH_REPO_ID, get_pretrained_model
+
+load_dotenv()
+
+MONGO_URI = os.getenv("MONGO_URI", "").strip()
+MONGO_DB_NAME = os.getenv("MONGO_DB_NAME", "image_to_speech").strip()
+MONGO_COLLECTION = os.getenv("MONGO_COLLECTION", "audio").strip()
+MONGO_CAPTIONS_COLLECTION = os.getenv("MONGO_CAPTIONS_COLLECTION", "captions").strip()
+
+
+def log(msg: str) -> None:
+    now = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
+    print(f"{now}: {msg}")
+
+
+def build_html_output(msg: str, style: str = "result_item_success") -> str:
+    return f"""
+    <div class='result'>
+        <div class='result_item {style}'>
+          {msg}
+        </div>
+    </div>
+    """
+
+
+@lru_cache(maxsize=1)
+def _get_mongo_client():
+    if not MONGO_URI:
+        raise ValueError("MONGO_URI is missing in .env")
+    return pymongo.MongoClient(MONGO_URI)
+
+
+def _get_mongo_collection():
+    client = _get_mongo_client()
+    return client[MONGO_DB_NAME][MONGO_COLLECTION]
+
+
+def _get_captions_collection():
+    client = _get_mongo_client()
+    return client[MONGO_DB_NAME][MONGO_CAPTIONS_COLLECTION]
+
+
+def _as_opus_bytes(samples, sample_rate: int) -> bytes:
+    buffer = io.BytesIO()
+    sf.write(buffer, samples, samplerate=sample_rate, format="OGG", subtype="OPUS")
+    return buffer.getvalue()
+
+
+def _save_audio_to_db(
+    samples,
+    sample_rate: int,
+    caption_id: Optional[str] = None,
+    caption: Optional[str] = None,
+) -> dict:
+    audio_id = str(uuid.uuid4())
+    duration = len(samples) / sample_rate
+    opus_bytes = _as_opus_bytes(samples, sample_rate)
+    doc = {
+        "audio_id": audio_id,
+        "audio_file": Binary(opus_bytes),
+        "sample_rate": int(sample_rate),
+        "duration_seconds": float(duration),
+        "audio_format": "opus",
+        "created_at": datetime.utcnow(),
+    }
+    if caption_id:
+        doc["caption_id"] = caption_id
+    if caption:
+        doc["caption"] = caption
+
+    inserted = _get_mongo_collection().insert_one(doc)
+    return {
+        "audio_file_id": str(inserted.inserted_id),
+        "audio_id": audio_id,
+        "sample_rate": int(sample_rate),
+        "duration_seconds": float(duration),
+        "caption_id": caption_id,
+        "caption": caption,
+    }
+
+
+def _generate_audio_from_text(
+    text: str,
+    sid: int,
+    speed: float,
+    caption_id: Optional[str] = None,
+) -> dict:
+    tts = get_pretrained_model(ENGLISH_REPO_ID, speed)
+    audio = tts.generate(text, sid=sid)
+    if len(audio.samples) == 0:
+        raise ValueError("No audio was generated.")
+    return _save_audio_to_db(
+        audio.samples,
+        audio.sample_rate,
+        caption_id=caption_id,
+        caption=text,
+    )
+
+
+def process(text: str, sid: str, speed: float):
+    max_len = 4000
+    log(f"Input text {len(text)}: {text[:max_len]}. sid: {sid}, speed: {speed}")
+    if len(text) > max_len:
+        info = (
+            "Text is too long for this demo. Please keep it under 4000 characters."
+        )
+        return None, build_html_output(info, style="result_item_error")
+
+    tts = get_pretrained_model(ENGLISH_REPO_ID, speed)
+
+    start = time.time()
+    audio = tts.generate(text, sid=int(sid))
+    end = time.time()
+
+    if len(audio.samples) == 0:
+        raise ValueError("No audio was generated.")
+
+    duration = len(audio.samples) / audio.sample_rate
+    elapsed = end - start
+    rtf = elapsed / duration
+    info = (
+        f"Wave duration: {duration:.3f}s<br/>"
+        f"Processing time: {elapsed:.3f}s<br/>"
+        f"RTF: {elapsed:.3f}/{duration:.3f} = {rtf:.3f}<br/>"
+    )
+
+    saved = _save_audio_to_db(audio.samples, audio.sample_rate)
+    info += f"Audio ID: {saved['audio_id']}<br/>Saved to MongoDB"
+    return (audio.sample_rate, audio.samples), build_html_output(info)
+
+
+css = """
+.result {display:flex;flex-direction:column}
+.result_item {padding:15px;margin-bottom:8px;border-radius:15px;width:100%}
+.result_item_success {background-color:mediumaquamarine;color:white;align-self:start}
+.result_item_error {background-color:#ff7070;color:white;align-self:start}
+"""
+
+
+with gr.Blocks(css=css) as demo:
+    gr.Markdown("#Text-to-Speech")
+    gr.Markdown(f"Model: `{ENGLISH_REPO_ID}`")
+
+    input_text = gr.Textbox(
+        label="Input text (English)",
+        lines=3,
+        placeholder="Type English text here...",
+    )
+    input_sid = gr.Textbox(
+        label="Speaker ID",
+        lines=1,
+        max_lines=1,
+        value="0",
+        placeholder="0 to 10",
+    )
+    input_speed = gr.Slider(
+        minimum=0.1,
+        maximum=10,
+        value=1,
+        step=0.1,
+        label="Speed",
+    )
+
+    input_button = gr.Button("Submit")
+    output_audio = gr.Audio(label="Output")
+    output_info = gr.HTML(label="Info")
+
+    input_button.click(
+        process,
+        inputs=[input_text, input_sid, input_speed],
+        outputs=[output_audio, output_info],
+    )
+
+
+class AudioByIdRequest(BaseModel):
+    audio_id: str
+    sid: Optional[int] = 0
+    speed: Optional[float] = 1.0
+
+
+api = FastAPI(title="Text-to-Speech API")
+
+
+def _api_response(succes: bool, messase: str, data):
+    return {"succes": succes, "messase": messase, "data": data}
+
+
+def _find_audio_doc(identifier: str):
+    doc = _get_mongo_collection().find_one({"audio_id": identifier})
+    if doc:
+        return doc
+    if ObjectId.is_valid(identifier):
+        return _get_mongo_collection().find_one({"_id": ObjectId(identifier)})
+    return None
+
+
+@api.post("/audio/by-id")
+def get_audio_by_id(
+    request: Request,
+    payload: Optional[AudioByIdRequest] = Body(default=None),
+    audio_id: Optional[str] = Form(default=None),
+    sid: Optional[int] = Form(default=0),
+    speed: Optional[float] = Form(default=1.0),
+):
+    resolved_audio_id = audio_id or (payload.audio_id if payload else None)
+    resolved_sid = payload.sid if payload and payload.sid is not None else sid
+    resolved_speed = payload.speed if payload and payload.speed is not None else speed
+
+    if not resolved_audio_id:
+        return _api_response(False, "audio_id is required", None)
+
+    doc = _find_audio_doc(resolved_audio_id)
+    if not doc and ObjectId.is_valid(resolved_audio_id):
+        doc = _get_mongo_collection().find_one({"caption_id": resolved_audio_id})
+        if not doc:
+            caption_doc = _get_captions_collection().find_one({"_id": ObjectId(resolved_audio_id)})
+            if caption_doc:
+                caption_text = str(caption_doc.get("caption", "")).strip()
+                if caption_text:
+                    try:
+                        saved = _generate_audio_from_text(
+                            caption_text,
+                            sid=resolved_sid,
+                            speed=resolved_speed,
+                            caption_id=resolved_audio_id,
+                        )
+                        doc = _find_audio_doc(saved["audio_id"])
+                    except Exception as e:
+                        log(f"Error generating audio from caption {resolved_audio_id}: {e}")
+
+    if not doc:
+        return _api_response(False, "Audio not found", None)
+
+    audio_bytes = bytes(doc.get("audio_file", b""))
+    if not audio_bytes:
+        return _api_response(False, "Document found but audio_file is missing", None)
+
+    resolved_id = str(doc.get("audio_id") or doc.get("_id"))
+    audio_url = str(request.base_url) + f"audio/{resolved_id}.opus"
+
+    return _api_response(
+        True,
+        "Audio fetched successfully",
+        {
+            "audio_id": resolved_id,
+            "audio_url": audio_url,
+            "sample_rate": int(doc.get("sample_rate", 0)),
+            "duration_seconds": float(doc.get("duration_seconds", 0.0)),
+            "caption": doc.get("caption"),
+        },
+    )
+
+
+@api.get("/audio/{audio_id}.opus")
+def stream_audio(audio_id: str):
+    doc = _find_audio_doc(audio_id)
+    if not doc:
+        return Response(status_code=404)
+
+    audio_bytes = bytes(doc.get("audio_file", b""))
+    if not audio_bytes:
+        return Response(status_code=404)
+
+    resolved_id = str(doc.get("audio_id") or doc.get("_id"))
+    return Response(
+        content=audio_bytes,
+        media_type="audio/ogg",
+        headers={
+            "Content-Disposition": f'inline; filename="{resolved_id}.opus"',
+            "Cache-Control": "public, max-age=31536000",
+        },
+    )
+
+
+app = gr.mount_gradio_app(api, demo, path="/")
+
+
+if __name__ == "__main__":
+    demo.launch()

model.py

@@ -0,0 +1,69 @@
+from functools import lru_cache
+from pathlib import Path
+
+import sherpa_onnx
+from huggingface_hub import hf_hub_download, snapshot_download
+
+ENGLISH_REPO_ID = "vidhi0405/TextToSpeech"
+
+
+def _normalize_repo_id(repo_id: str) -> str:
+    v = repo_id.strip()
+    if v.startswith("https://huggingface.co/"):
+        v = v.removeprefix("https://huggingface.co/").strip("/")
+    return v
+
+
+def _get_file(repo_id: str, filename: str, subfolder: str) -> str:
+    return hf_hub_download(
+        repo_id=repo_id,
+        filename=filename,
+        subfolder=subfolder,
+    )
+
+
+@lru_cache(maxsize=2)
+def get_pretrained_model(repo_id: str, speed: float) -> sherpa_onnx.OfflineTts:
+    source_repo = _normalize_repo_id(repo_id)
+    if source_repo != ENGLISH_REPO_ID:
+        raise ValueError(f"Unsupported repo_id: {repo_id}. Use {ENGLISH_REPO_ID}")
+
+    model = _get_file(
+        repo_id=source_repo,
+        filename="model.onnx",
+        subfolder="kokoro-en-v0_19",
+    )
+    tokens = _get_file(
+        repo_id=source_repo,
+        filename="tokens.txt",
+        subfolder="kokoro-en-v0_19",
+    )
+    voices = _get_file(
+        repo_id=source_repo,
+        filename="voices.bin",
+        subfolder="kokoro-en-v0_19",
+    )
+
+    root_dir = snapshot_download(
+        repo_id=source_repo,
+        allow_patterns=["kokoro-en-v0_19/espeak-ng-data/*"],
+    )
+    data_dir = str(Path(root_dir) / "kokoro-en-v0_19" / "espeak-ng-data")
+
+    tts_config = sherpa_onnx.OfflineTtsConfig(
+        model=sherpa_onnx.OfflineTtsModelConfig(
+            kokoro=sherpa_onnx.OfflineTtsKokoroModelConfig(
+                model=model,
+                voices=voices,
+                tokens=tokens,
+                data_dir=data_dir,
+                length_scale=1.0 / speed,
+            ),
+            provider="cpu",
+            debug=True,
+            num_threads=2,
+        ),
+        max_num_sentences=1,
+    )
+    return sherpa_onnx.OfflineTts(tts_config)
+

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+uvicorn
+gradio
+pymongo
+soundfile
+python-dotenv
+pydantic
+sherpa-onnx
+huggingface_hub