kala-tts 0.1.0__tar.gz

kala_tts-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ampixa Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

kala_tts-0.1.0/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: kala-tts
+Version: 0.1.0
+Summary: CPU-native Nepali TTS — real_nepali G2P + VITS ONNX inference
+Author-email: Ampixa <hello@ampixa.com>
+License: MIT
+Project-URL: Homepage, https://tts.ampixa.com/kala/
+Project-URL: Repository, https://github.com/voidash/kala-tts
+Project-URL: Hugging Face, https://huggingface.co/ampixa/real-nepali-v0.2-kala
+Project-URL: Bug Tracker, https://github.com/voidash/kala-tts/issues
+Keywords: nepali,tts,text-to-speech,speech-synthesis,g2p,onnx
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: onnxruntime>=1.17
+Requires-Dist: huggingface_hub>=0.23
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# kala-tts
+
+CPU-native Nepali text-to-speech. The first open-source Nepali TTS built without eSpeak.
+
+```bash
+pip install kala-tts
+```
+
+```python
+import kala_tts
+
+kala_tts.synthesize_to_file("नमस्कार, कसरी हुनुहुन्छ?", "out.wav")
+```
+
+## What makes it different
+
+eSpeak-ng maps Nepali affricates to alveolar labels (`ts`, `tsh`) that do not match
+how Kathmandu speakers actually produce **च** and **छ**.  `kala-tts` uses the
+`real_nepali` G2P — built from Khatiwada (2009) and a 48 000-entry curated lexicon —
+which outputs palatal `ch`/`chh` as the acoustic target.
+
+| Feature | eSpeak `ne` | kala-tts |
+|---|---|---|
+| च / छ | ts / tsh (alveolar) | ch / chh (palatal) |
+| Gemination | often lost | explicit ː tokens |
+| Schwa deletion | heuristic | rule-based, audited |
+| Latin code-switch | undefined | letter-by-letter + lexicon |
+| Lexicon | none | 48 000 entries |
+
+## API
+
+```python
+import kala_tts
+
+# Returns WAV bytes (16-bit PCM mono, 22050 Hz)
+wav: bytes = kala_tts.synthesize("नेपाल सुन्दर देश हो।", speaker="kala")
+
+# Write directly to file
+kala_tts.synthesize_to_file("नमस्कार", "output.wav", speaker="barsha")
+
+# Speed control
+wav = kala_tts.synthesize("राम्रो दिन!", speed=0.85)  # slower
+
+# List speakers
+print(kala_tts.list_speakers())
+# ('kala', 'barsha', 'slr143_F', 'slr43_0546', 'slr43_2099')
+```
+
+## CLI
+
+```bash
+kala-tts "नमस्कार, कसरी हुनुहुन्छ?" --speaker kala -o out.wav
+kala-tts --list-speakers
+echo "नेपाल सुन्दर देश हो।" | kala-tts -o out.wav
+```
+
+## Speakers
+
+| Name | Data | Notes |
+|---|---|---|
+| `kala` | human studio | recommended |
+| `barsha` | human recording | most data |
+| `slr143_F` | OpenSLR-143 | neutral prosody |
+| `slr43_0546` | OpenSLR-43 | read speech |
+| `slr43_2099` | OpenSLR-43 | read speech |
+
+## Model
+
+The first call auto-downloads the ONNX model (~60 MB) from
+[ampixa/real-nepali-v0.2-kala](https://huggingface.co/ampixa/real-nepali-v0.2-kala)
+via `huggingface_hub` and caches it locally.  No internet needed after first run.
+No GPU required.
+
+- Architecture: VITS (ONNX FP32)
+- Sample rate: 22050 Hz
+- CPU RTF: ~0.020 (50× real-time on a laptop)
+
+## License
+
+MIT (code) — CC-BY-SA 4.0 (model weights and training data).
+See [LICENSES.md](LICENSES.md) for full attribution.

kala_tts-0.1.0/README.md

@@ -0,0 +1,81 @@
+# kala-tts
+
+CPU-native Nepali text-to-speech. The first open-source Nepali TTS built without eSpeak.
+
+```bash
+pip install kala-tts
+```
+
+```python
+import kala_tts
+
+kala_tts.synthesize_to_file("नमस्कार, कसरी हुनुहुन्छ?", "out.wav")
+```
+
+## What makes it different
+
+eSpeak-ng maps Nepali affricates to alveolar labels (`ts`, `tsh`) that do not match
+how Kathmandu speakers actually produce **च** and **छ**.  `kala-tts` uses the
+`real_nepali` G2P — built from Khatiwada (2009) and a 48 000-entry curated lexicon —
+which outputs palatal `ch`/`chh` as the acoustic target.
+
+| Feature | eSpeak `ne` | kala-tts |
+|---|---|---|
+| च / छ | ts / tsh (alveolar) | ch / chh (palatal) |
+| Gemination | often lost | explicit ː tokens |
+| Schwa deletion | heuristic | rule-based, audited |
+| Latin code-switch | undefined | letter-by-letter + lexicon |
+| Lexicon | none | 48 000 entries |
+
+## API
+
+```python
+import kala_tts
+
+# Returns WAV bytes (16-bit PCM mono, 22050 Hz)
+wav: bytes = kala_tts.synthesize("नेपाल सुन्दर देश हो।", speaker="kala")
+
+# Write directly to file
+kala_tts.synthesize_to_file("नमस्कार", "output.wav", speaker="barsha")
+
+# Speed control
+wav = kala_tts.synthesize("राम्रो दिन!", speed=0.85)  # slower
+
+# List speakers
+print(kala_tts.list_speakers())
+# ('kala', 'barsha', 'slr143_F', 'slr43_0546', 'slr43_2099')
+```
+
+## CLI
+
+```bash
+kala-tts "नमस्कार, कसरी हुनुहुन्छ?" --speaker kala -o out.wav
+kala-tts --list-speakers
+echo "नेपाल सुन्दर देश हो।" | kala-tts -o out.wav
+```
+
+## Speakers
+
+| Name | Data | Notes |
+|---|---|---|
+| `kala` | human studio | recommended |
+| `barsha` | human recording | most data |
+| `slr143_F` | OpenSLR-143 | neutral prosody |
+| `slr43_0546` | OpenSLR-43 | read speech |
+| `slr43_2099` | OpenSLR-43 | read speech |
+
+## Model
+
+The first call auto-downloads the ONNX model (~60 MB) from
+[ampixa/real-nepali-v0.2-kala](https://huggingface.co/ampixa/real-nepali-v0.2-kala)
+via `huggingface_hub` and caches it locally.  No internet needed after first run.
+No GPU required.
+
+- Architecture: VITS (ONNX FP32)
+- Sample rate: 22050 Hz
+- CPU RTF: ~0.020 (50× real-time on a laptop)
+
+## License
+
+MIT (code) — CC-BY-SA 4.0 (model weights and training data).
+See [LICENSES.md](LICENSES.md) for full attribution.

kala_tts-0.1.0/kala_tts/__init__.py

@@ -0,0 +1,17 @@
+"""kala-tts: CPU-native Nepali text-to-speech using the real_nepali G2P.
+
+Quick start::
+
+    from kala_tts import synthesize_to_file
+    synthesize_to_file("नमस्कार, कसरी हुनुहुन्छ?", "out.wav")
+
+The first call downloads the ONNX model (~60 MB) from HuggingFace Hub
+and caches it in the HF Hub cache directory.
+"""
+
+from __future__ import annotations
+
+from kala_tts._api import list_speakers, synthesize, synthesize_to_file
+
+__all__ = ["synthesize", "synthesize_to_file", "list_speakers"]
+__version__ = "0.1.0"

kala_tts-0.1.0/kala_tts/__main__.py

@@ -0,0 +1,74 @@
+"""CLI entry point: python -m kala_tts "..." or kala-tts "..." """
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from kala_tts._api import DEFAULT_SPEAKER, list_speakers, synthesize_to_file
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog="kala-tts",
+        description="Synthesize Nepali text with the kala TTS model.",
+    )
+    parser.add_argument(
+        "text",
+        nargs="?",
+        help="Nepali text to synthesize (Devanagari). Read from stdin if omitted.",
+    )
+    parser.add_argument(
+        "-o", "--out",
+        default="out.wav",
+        type=Path,
+        metavar="FILE",
+        help="Output WAV file path (default: out.wav).",
+    )
+    parser.add_argument(
+        "--speaker",
+        default=DEFAULT_SPEAKER,
+        metavar="NAME",
+        help=f"Speaker name (default: {DEFAULT_SPEAKER}). Use --list-speakers to see choices.",
+    )
+    parser.add_argument(
+        "--speed",
+        type=float,
+        default=1.0,
+        metavar="X",
+        help="Speaking speed multiplier: 0.8=slower, 1.0=natural, 1.3=faster (default: 1.0).",
+    )
+    parser.add_argument(
+        "--list-speakers",
+        action="store_true",
+        help="Print available speaker names and exit.",
+    )
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = _parse_args()
+
+    if args.list_speakers:
+        for name in list_speakers():
+            print(name)
+        return 0
+
+    text = args.text
+    if text is None:
+        text = sys.stdin.read()
+    text = text.strip()
+    if not text:
+        print("error: no text provided", file=sys.stderr)
+        return 1
+
+    out_path: Path = args.out
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    synthesize_to_file(text, out_path, speaker=args.speaker, speed=args.speed)
+    print(f"wrote {out_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

kala_tts-0.1.0/kala_tts/_api.py

@@ -0,0 +1,63 @@
+"""High-level public API for kala-tts."""
+
+from __future__ import annotations
+
+import threading
+from pathlib import Path
+
+from kala_tts._download import config_path, model_path, speakers_path
+from kala_tts._infer import DEFAULT_SPEAKER, KalaEngine
+
+
+_engine: KalaEngine | None = None
+_lock = threading.Lock()
+
+
+def _get_engine() -> KalaEngine:
+    global _engine
+    if _engine is None:
+        with _lock:
+            if _engine is None:
+                _engine = KalaEngine(
+                    model_path=model_path(),
+                    config_path=config_path(),
+                    speakers_path=speakers_path(),
+                )
+    return _engine
+
+
+def synthesize(
+    text: str,
+    *,
+    speaker: str = DEFAULT_SPEAKER,
+    speed: float = 1.0,
+) -> bytes:
+    """Synthesize ``text`` and return WAV bytes.
+
+    Args:
+        text:    Nepali text in Devanagari script (Latin code-switching supported).
+        speaker: One of the available speaker names.  Defaults to ``"kala"``.
+        speed:   Speaking speed multiplier.  1.0 is natural, 0.8 is slower, 1.3 faster.
+
+    Returns:
+        WAV audio as bytes (16-bit PCM mono, 22050 Hz).
+    """
+    length_scale = 1.0 / max(speed, 0.1)
+    return _get_engine().synthesize(text, speaker=speaker, length_scale=length_scale)
+
+
+def synthesize_to_file(
+    text: str,
+    output_path: str | Path,
+    *,
+    speaker: str = DEFAULT_SPEAKER,
+    speed: float = 1.0,
+) -> None:
+    """Synthesize ``text`` and write a WAV file to ``output_path``."""
+    wav = synthesize(text, speaker=speaker, speed=speed)
+    Path(output_path).write_bytes(wav)
+
+
+def list_speakers() -> tuple[str, ...]:
+    """Return the names of the available speakers."""
+    return _get_engine().speakers

kala_tts-0.1.0/kala_tts/_download.py

@@ -0,0 +1,29 @@
+"""HuggingFace Hub download helpers."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from huggingface_hub import hf_hub_download
+
+
+HF_REPO_ID = "ampixa/real-nepali-v0.2-kala"
+ONNX_FILENAME = "real_nepali_v02_kala.fp32.onnx"
+CONFIG_FILENAME = "config.json"
+SPEAKERS_FILENAME = "speaker_id_map.json"
+
+
+def _download(filename: str, repo_id: str = HF_REPO_ID) -> Path:
+    return Path(hf_hub_download(repo_id=repo_id, filename=filename))
+
+
+def model_path() -> Path:
+    return _download(ONNX_FILENAME)
+
+
+def config_path() -> Path:
+    return _download(CONFIG_FILENAME)
+
+
+def speakers_path() -> Path:
+    return _download(SPEAKERS_FILENAME)

kala_tts-0.1.0/kala_tts/_infer.py

@@ -0,0 +1,175 @@
+"""ONNX inference core for the real_nepali_v02_kala model."""
+
+from __future__ import annotations
+
+import io
+import json
+import re
+import time
+import wave
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import onnxruntime as ort
+
+from real_nepali import g2p as _g2p
+
+
+PUNCTUATION_PATTERN = re.compile(r"([^।॥?!.,،;:]+)([।॥?!.,،;:]*)")
+
+PAUSE_SECONDS: dict[str, float] = {
+    "period": 0.18,
+    "question": 0.22,
+    "exclaim": 0.18,
+    "comma": 0.10,
+}
+
+PUBLIC_SPEAKERS = ("kala", "barsha", "slr143_F", "slr43_0546", "slr43_2099")
+DEFAULT_SPEAKER = "kala"
+SAMPLE_RATE = 22050
+G2P_PROFILE = "real_nepali_v0.2"
+
+
+@dataclass(frozen=True)
+class _Chunk:
+    text: str
+    punctuation: str
+    pause_s: float
+
+
+def _pause_seconds(punctuation: str) -> float:
+    pauses: list[float] = []
+    for ch in punctuation:
+        if ch in {"?", "？"}:
+            pauses.append(PAUSE_SECONDS["question"])
+        elif ch == "!":
+            pauses.append(PAUSE_SECONDS["exclaim"])
+        elif ch in {",", "،", ";", ":"}:
+            pauses.append(PAUSE_SECONDS["comma"])
+        elif ch in {".", "।", "॥"}:
+            pauses.append(PAUSE_SECONDS["period"])
+    return max(pauses) if pauses else 0.0
+
+
+def _split_chunks(text: str) -> list[_Chunk]:
+    chunks: list[_Chunk] = []
+    for m in PUNCTUATION_PATTERN.finditer(text):
+        chunk_text = " ".join(m.group(1).split())
+        if not chunk_text:
+            continue
+        punct = m.group(2) or ""
+        chunks.append(_Chunk(text=chunk_text, punctuation=punct, pause_s=_pause_seconds(punct)))
+    if not chunks and text.strip():
+        chunks.append(_Chunk(text=" ".join(text.split()), punctuation="", pause_s=0.0))
+    return chunks
+
+
+def _phones_to_ids(phones: list[str], id_map: dict[str, list[int]]) -> list[int]:
+    ids = [id_map["^"][0]]
+    for phone in phones:
+        if phone in {".", "|"}:
+            continue
+        if phone not in id_map:
+            raise ValueError(f"phone not in model vocabulary: {phone!r}")
+        ids.extend(id_map[phone])
+    ids.append(id_map["$"][0])
+    return ids
+
+
+def _phonemize_chunk(text: str, id_map: dict[str, list[int]]) -> list[int]:
+    phones: list[str] = []
+    for word in _g2p.phonemize_text(text, profile=G2P_PROFILE):
+        if not word.phones:
+            continue
+        phones.extend(word.phones)
+        phones.append("|")
+    if phones and phones[-1] == "|":
+        phones.pop()
+    return _phones_to_ids(phones, id_map)
+
+
+def _silence(seconds: float) -> np.ndarray:
+    n = max(0, int(round(seconds * SAMPLE_RATE)))
+    return np.zeros(n, dtype=np.float32)
+
+
+def _audio_to_wav_bytes(audio: np.ndarray) -> bytes:
+    samples = np.clip(audio.reshape(-1).astype(np.float32), -1.0, 1.0)
+    pcm = (samples * 32767.0).astype(np.int16)
+    buf = io.BytesIO()
+    with wave.open(buf, "wb") as wf:
+        wf.setnchannels(1)
+        wf.setsampwidth(2)
+        wf.setframerate(SAMPLE_RATE)
+        wf.writeframes(pcm.tobytes())
+    return buf.getvalue()
+
+
+class KalaEngine:
+    """Loaded ONNX inference engine. Keep one instance and call synthesize()."""
+
+    def __init__(self, model_path: Path, config_path: Path, speakers_path: Path) -> None:
+        config = json.loads(config_path.read_text(encoding="utf-8"))
+        self._id_map: dict[str, list[int]] = {
+            str(k): [int(i) for i in v]
+            for k, v in config["phoneme_id_map"].items()
+        }
+        self._speaker_map: dict[str, int] = {
+            str(k): int(v)
+            for k, v in json.loads(speakers_path.read_text(encoding="utf-8")).items()
+        }
+        self._session = ort.InferenceSession(
+            str(model_path),
+            providers=["CPUExecutionProvider"],
+        )
+        self._input_names = {inp.name for inp in self._session.get_inputs()}
+
+    @property
+    def speakers(self) -> tuple[str, ...]:
+        return tuple(s for s in PUBLIC_SPEAKERS if s in self._speaker_map)
+
+    def synthesize(
+        self,
+        text: str,
+        *,
+        speaker: str = DEFAULT_SPEAKER,
+        length_scale: float = 1.0,
+        noise_scale: float = 0.667,
+        noise_scale_w: float = 0.8,
+    ) -> bytes:
+        if speaker not in self._speaker_map:
+            valid = ", ".join(sorted(self._speaker_map))
+            raise ValueError(f"unknown speaker {speaker!r}; valid: {valid}")
+
+        sid = np.array([self._speaker_map[speaker]], dtype=np.int64)
+        scales = np.array([noise_scale, length_scale, noise_scale_w], dtype=np.float32)
+        audio_parts: list[np.ndarray] = []
+
+        for chunk in _split_chunks(" ".join(text.split())):
+            phone_ids = _phonemize_chunk(chunk.text, self._id_map)
+            feed: dict[str, Any] = {
+                "input": np.array([phone_ids], dtype=np.int64),
+                "input_lengths": np.array([len(phone_ids)], dtype=np.int64),
+                "scales": scales,
+            }
+            if "sid" in self._input_names:
+                feed["sid"] = sid
+            output = self._session.run(None, feed)[0]
+            audio_parts.append(np.asarray(output).reshape(-1).astype(np.float32))
+            if chunk.pause_s > 0:
+                audio_parts.append(_silence(chunk.pause_s))
+
+        audio = np.concatenate(audio_parts) if audio_parts else np.array([], dtype=np.float32)
+        return _audio_to_wav_bytes(audio)
+
+    def rtf(self, text: str, speaker: str = DEFAULT_SPEAKER) -> float:
+        """Return real-time factor (inference time / audio duration) on this text."""
+        t0 = time.perf_counter()
+        wav = self.synthesize(text, speaker=speaker)
+        elapsed = time.perf_counter() - t0
+        buf = io.BytesIO(wav)
+        with wave.open(buf) as wf:
+            duration = wf.getnframes() / wf.getframerate()
+        return elapsed / duration if duration > 0 else float("inf")

kala_tts-0.1.0/kala_tts.egg-info/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: kala-tts
+Version: 0.1.0
+Summary: CPU-native Nepali TTS — real_nepali G2P + VITS ONNX inference
+Author-email: Ampixa <hello@ampixa.com>
+License: MIT
+Project-URL: Homepage, https://tts.ampixa.com/kala/
+Project-URL: Repository, https://github.com/voidash/kala-tts
+Project-URL: Hugging Face, https://huggingface.co/ampixa/real-nepali-v0.2-kala
+Project-URL: Bug Tracker, https://github.com/voidash/kala-tts/issues
+Keywords: nepali,tts,text-to-speech,speech-synthesis,g2p,onnx
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: onnxruntime>=1.17
+Requires-Dist: huggingface_hub>=0.23
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# kala-tts
+
+CPU-native Nepali text-to-speech. The first open-source Nepali TTS built without eSpeak.
+
+```bash
+pip install kala-tts
+```
+
+```python
+import kala_tts
+
+kala_tts.synthesize_to_file("नमस्कार, कसरी हुनुहुन्छ?", "out.wav")
+```
+
+## What makes it different
+
+eSpeak-ng maps Nepali affricates to alveolar labels (`ts`, `tsh`) that do not match
+how Kathmandu speakers actually produce **च** and **छ**.  `kala-tts` uses the
+`real_nepali` G2P — built from Khatiwada (2009) and a 48 000-entry curated lexicon —
+which outputs palatal `ch`/`chh` as the acoustic target.
+
+| Feature | eSpeak `ne` | kala-tts |
+|---|---|---|
+| च / छ | ts / tsh (alveolar) | ch / chh (palatal) |
+| Gemination | often lost | explicit ː tokens |
+| Schwa deletion | heuristic | rule-based, audited |
+| Latin code-switch | undefined | letter-by-letter + lexicon |
+| Lexicon | none | 48 000 entries |
+
+## API
+
+```python
+import kala_tts
+
+# Returns WAV bytes (16-bit PCM mono, 22050 Hz)
+wav: bytes = kala_tts.synthesize("नेपाल सुन्दर देश हो।", speaker="kala")
+
+# Write directly to file
+kala_tts.synthesize_to_file("नमस्कार", "output.wav", speaker="barsha")
+
+# Speed control
+wav = kala_tts.synthesize("राम्रो दिन!", speed=0.85)  # slower
+
+# List speakers
+print(kala_tts.list_speakers())
+# ('kala', 'barsha', 'slr143_F', 'slr43_0546', 'slr43_2099')
+```
+
+## CLI
+
+```bash
+kala-tts "नमस्कार, कसरी हुनुहुन्छ?" --speaker kala -o out.wav
+kala-tts --list-speakers
+echo "नेपाल सुन्दर देश हो।" | kala-tts -o out.wav
+```
+
+## Speakers
+
+| Name | Data | Notes |
+|---|---|---|
+| `kala` | human studio | recommended |
+| `barsha` | human recording | most data |
+| `slr143_F` | OpenSLR-143 | neutral prosody |
+| `slr43_0546` | OpenSLR-43 | read speech |
+| `slr43_2099` | OpenSLR-43 | read speech |
+
+## Model
+
+The first call auto-downloads the ONNX model (~60 MB) from
+[ampixa/real-nepali-v0.2-kala](https://huggingface.co/ampixa/real-nepali-v0.2-kala)
+via `huggingface_hub` and caches it locally.  No internet needed after first run.
+No GPU required.
+
+- Architecture: VITS (ONNX FP32)
+- Sample rate: 22050 Hz
+- CPU RTF: ~0.020 (50× real-time on a laptop)
+
+## License
+
+MIT (code) — CC-BY-SA 4.0 (model weights and training data).
+See [LICENSES.md](LICENSES.md) for full attribution.