termux-tts 1.1.3__tar.gz

termux_tts-1.1.3/LICENSE

@@ -0,0 +1,17 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2026 UnoKim & AMEVA Open-Source Foundation
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

termux_tts-1.1.3/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: termux-tts
+Version: 1.1.3
+Summary: On-device Text-to-Speech framework utilizing device resources (DSP Formant Vocoder, ONNX Neural Runtime & Android Native Voice Bridge)
+Home-page: https://github.com/uno-km/termux-tts
+Author: AMEVA Foundation
+Author-email: AOSF / uno-km <zhfldk014745@naver.com>
+License: Apache-2.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software 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: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Provides-Extra: onnx
+Requires-Dist: onnxruntime>=1.15.0; extra == "onnx"
+Provides-Extra: neural
+Requires-Dist: onnxruntime>=1.15.0; extra == "neural"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: paramiko>=3.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Termux-TTS (Python)
+
+[![PyPI](https://img.shields.io/pypi/v/termux-tts.svg?style=flat-square&color=0369a1)](https://pypi.org/project/termux-tts/)
+[![Python](https://img.shields.io/pypi/pyversions/termux-tts.svg?style=flat-square)](https://pypi.org/project/termux-tts/)
+[![License](https://img.shields.io/badge/License-Apache_2.0-004499.svg?style=flat-square)](https://github.com/uno-km/termux-tts)
+
+> **High-Performance Multi-Backend Speech Synthesis Framework for Android Termux & Edge Linux**  
+> Supports Zero-Dependency Parametric DSP Formant Vocoder, Deep Learning ONNX Neural Runtime, and Android Native System Voice Bridge.
+
+## Installation
+
+```bash
+pip install termux-tts
+```
+
+## Quickstart
+
+```python
+import termux_tts as tts
+
+# 1. Zero-Dependency DSP Formant Mode (Default)
+with tts.load(engine="dsp", language="ko") as engine:
+    res = engine.synthesize("안녕하세요, 텀묵스 음성 합성입니다.", output="dsp.wav")
+    print(f"Synthesized in {res.elapsed_ms:.1f}ms (RTF: {res.rtf:.4f}x)")
+
+# 2. Deep Learning ONNX Mode
+with tts.load(engine="onnx", model="vits_ko.onnx", language="ko") as engine:
+    res = engine.synthesize("신경망 고품질 음성 합성입니다.", output="onnx.wav")
+
+# 3. Android System Native Speak Mode
+with tts.load(engine="native", language="ko") as engine:
+    engine.speak("스피커로 즉시 발화합니다.")
+```
+
+## Features
+- **Zero-Dependency DSP Engine**: Instant CPU execution with 0MB download overhead (Rosenberg Glottal Pulse + 5-Band Biquad Filters).
+- **Authentic ONNX Neural Runtime**: Deep learning acoustic model execution for VITS, Piper, and FastSpeech ONNX models.
+- **Android Native Bridge**: Direct speaker speech playback via Termux IPC.
+- **Cross-Platform CLI & Node.js Binding**: First-class support for Python, npm, and shell scripts.
+
+## Documentation
+- [Official Documentation & API Reference](https://uno-km.vercel.app/lib/tts/)
+- [GitHub Repository](https://github.com/uno-km/termux-tts)
+
+## License
+Apache-2.0 License. Copyright (c) 2026 Eunho Kim (@uno-km).
+

termux_tts-1.1.3/README.md

@@ -0,0 +1,31 @@
+# termux-tts
+
+[![License](https://img.shields.io/badge/License-Apache_2.0-004499.svg?style=flat-square)](https://github.com/uno-km/uno-km)
+
+> ****  
+> **
+
+---
+
+## 📌 Architecture & Overview
+
+
+
+
+
+---
+
+## 🚀 Installation & Quickstart
+
+
+---
+
+## 📖 Official Documentation & Benchmarks
+- [Official Architecture & API Reference](https://uno-km.vercel.app/lib/tts/)
+- [Ecosystem Metrics & Registry Stats](https://uno-km.vercel.app/foundation/metrics)
+- [AMEVA Open-Source Foundation Portal](https://uno-km.vercel.app/foundation/index.html)
+
+---
+
+## 📄 License
+Licensed under the Apache-2.0 License. Copyright (c) 2026 Eunho Kim ([@uno-km](https://github.com/uno-km)).

termux_tts-1.1.3/README.pypi.md

@@ -0,0 +1,47 @@
+# Termux-TTS (Python)
+
+[![PyPI](https://img.shields.io/pypi/v/termux-tts.svg?style=flat-square&color=0369a1)](https://pypi.org/project/termux-tts/)
+[![Python](https://img.shields.io/pypi/pyversions/termux-tts.svg?style=flat-square)](https://pypi.org/project/termux-tts/)
+[![License](https://img.shields.io/badge/License-Apache_2.0-004499.svg?style=flat-square)](https://github.com/uno-km/termux-tts)
+
+> **High-Performance Multi-Backend Speech Synthesis Framework for Android Termux & Edge Linux**  
+> Supports Zero-Dependency Parametric DSP Formant Vocoder, Deep Learning ONNX Neural Runtime, and Android Native System Voice Bridge.
+
+## Installation
+
+```bash
+pip install termux-tts
+```
+
+## Quickstart
+
+```python
+import termux_tts as tts
+
+# 1. Zero-Dependency DSP Formant Mode (Default)
+with tts.load(engine="dsp", language="ko") as engine:
+    res = engine.synthesize("안녕하세요, 텀묵스 음성 합성입니다.", output="dsp.wav")
+    print(f"Synthesized in {res.elapsed_ms:.1f}ms (RTF: {res.rtf:.4f}x)")
+
+# 2. Deep Learning ONNX Mode
+with tts.load(engine="onnx", model="vits_ko.onnx", language="ko") as engine:
+    res = engine.synthesize("신경망 고품질 음성 합성입니다.", output="onnx.wav")
+
+# 3. Android System Native Speak Mode
+with tts.load(engine="native", language="ko") as engine:
+    engine.speak("스피커로 즉시 발화합니다.")
+```
+
+## Features
+- **Zero-Dependency DSP Engine**: Instant CPU execution with 0MB download overhead (Rosenberg Glottal Pulse + 5-Band Biquad Filters).
+- **Authentic ONNX Neural Runtime**: Deep learning acoustic model execution for VITS, Piper, and FastSpeech ONNX models.
+- **Android Native Bridge**: Direct speaker speech playback via Termux IPC.
+- **Cross-Platform CLI & Node.js Binding**: First-class support for Python, npm, and shell scripts.
+
+## Documentation
+- [Official Documentation & API Reference](https://uno-km.vercel.app/lib/tts/)
+- [GitHub Repository](https://github.com/uno-km/termux-tts)
+
+## License
+Apache-2.0 License. Copyright (c) 2026 Eunho Kim (@uno-km).
+

termux_tts-1.1.3/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "termux-tts"
+version = "1.1.3"
+description = "On-device Text-to-Speech framework utilizing device resources (DSP Formant Vocoder, ONNX Neural Runtime & Android Native Voice Bridge)"
+readme = "README.pypi.md"
+requires-python = ">=3.10"
+license = { text = "Apache-2.0" }
+authors = [
+    { name = "AOSF / uno-km", email = "zhfldk014745@naver.com" }
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Multimedia :: Sound/Audio :: Speech",
+]
+dependencies = [
+    "numpy>=1.20.0",
+]
+
+[project.optional-dependencies]
+onnx = ["onnxruntime>=1.15.0"]
+neural = ["onnxruntime>=1.15.0"]
+dev = ["pytest>=7.0", "paramiko>=3.0"]
+
+[project.scripts]
+termux-tts = "termux_tts.cli:main"
+
+[project.entry-points."ameva.components"]
+termux-tts = "termux_tts.adapter:create_adapter"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["termux_tts*"]

termux_tts-1.1.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

termux_tts-1.1.3/setup.py

@@ -0,0 +1,38 @@
+import os
+from setuptools import setup, find_packages
+
+setup(
+    name="termux-tts",
+    version="1.1.3",
+    description="Ultra-Fast On-Device Dual-Engine Text-to-Speech Framework (Parametric Formant Acoustic Synthesizer & Android Native Voice Bridge)",
+    long_description=open("README.pypi.md", encoding="utf-8").read() if os.path.exists("README.pypi.md") else open("README.md", encoding="utf-8").read(),
+    long_description_content_type="text/markdown",
+    author="AMEVA Foundation",
+    license="Apache-2.0",
+    url="https://github.com/uno-km/termux-tts",
+    packages=find_packages(include=["termux_tts", "termux_tts.*"]),
+    python_requires=">=3.8",
+    install_requires=[
+        "numpy>=1.20.0",
+        "ameva-vulkan-runtime>=1.0.0",
+    ],
+    extras_require={
+        "onnx": ["onnxruntime>=1.15.0"],
+        "neural": ["onnxruntime>=1.15.0"],
+        "dev": ["pytest>=7.0.0", "pytest-asyncio"],
+    },
+    entry_points={
+        "console_scripts": [
+            "termux-tts=termux_tts.cli:main",
+        ],
+    },
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: Apache Software License",
+        "Operating System :: Android",
+        "Operating System :: POSIX :: Linux",
+        "Programming Language :: Python :: 3",
+        "Topic :: Multimedia :: Sound/Audio :: Speech",
+    ],
+)

termux_tts-1.1.3/termux_tts/__init__.py

@@ -0,0 +1,47 @@
+"""
+termux-tts: Production-Grade Dual-Engine TTS Framework for Android Termux.
+- Option A: Deep Learning VITS ONNX Neural Vocoder (Vulkan GPU Accelerated)
+- Option B: Android System Native Voice Engine Bridge (Samsung / Google Voice)
+"""
+
+from .engine import TTSEngine, load, doctor
+from .engine_native import NativeAndroidEngine, NativeResult
+from .engine_dsp import ParametricDSPEngine, DSPResult, QUALITY_PRESETS, DSPSynthesizer
+from .engine_onnx import ONNXNeuralEngine, ONNXResult
+from .tokenizer import PhoneticTokenizer, EXPRESSIVE_TAGS
+from .g2p_korean import KoreanG2PEngine, korean_text_to_phonemes
+from .audio import AudioBuffer
+from .exceptions import (
+    TTSError,
+    TTSModelLoadError,
+    TTSInferenceError,
+    VulkanInitializationError,
+    TTSAudioEncodingError,
+    TTSLanguageNotSupportedError
+)
+
+__version__ = "1.1.2"
+__all__ = [
+    "TTSEngine",
+    "load",
+    "doctor",
+    "ParametricDSPEngine",
+    "DSPSynthesizer",
+    "DSPResult",
+    "NativeAndroidEngine",
+    "NativeResult",
+    "ONNXNeuralEngine",
+    "ONNXResult",
+    "QUALITY_PRESETS",
+    "PhoneticTokenizer",
+    "KoreanG2PEngine",
+    "korean_text_to_phonemes",
+    "EXPRESSIVE_TAGS",
+    "AudioBuffer",
+    "TTSError",
+    "TTSModelLoadError",
+    "TTSInferenceError",
+    "VulkanInitializationError",
+    "TTSAudioEncodingError",
+    "TTSLanguageNotSupportedError"
+]

termux_tts-1.1.3/termux_tts/adapter.py

@@ -0,0 +1,99 @@
+"""
+termux_tts.adapter
+===================
+AMEVA Component Protocol v1 — Orchestrator Adapter (v0.8.1 호환)
+"""
+from __future__ import annotations
+
+from typing import Any, AsyncIterator
+
+from ameva_component.adapter_base import BaseOrchestratorAdapter
+from termux_tts.control.component import TTSControl
+
+
+class TTSOrchestratorAdapter(BaseOrchestratorAdapter):
+    """TTS (Text-to-Speech) Orchestrator Adapter.
+
+    합성은 파일 기반으로 수행됩니다.
+    infer()는 text를 받아 audio 파일 경로를 반환합니다.
+    요청 모델과 실행 모델이 다르면 fallback_used=True를 명시합니다.
+    """
+
+    COMPONENT_ID = "termux-tts"
+
+    def __init__(self, control: TTSControl | None = None) -> None:
+        self._control = control or TTSControl()
+
+    async def infer(self, request: dict[str, Any]) -> AsyncIterator[dict[str, Any]]:
+        """TTS synthesis: text → audio file path.
+
+        request 키:
+            text (str): 합성할 텍스트 (필수)
+            voice_id (str): 목소리 ID (선택)
+            model_id (str): 모델 ID (선택)
+            output_path (str): 출력 파일 경로 (선택, 없으면 임시 파일)
+
+        반환 프레임:
+            {"type": "audio", "audio_path": str, "final": bool, "fallback_used": bool}
+            {"type": "error", "code": str, "message": str}
+        """
+        text = request.get("text", "").strip()
+        if not text:
+            yield {
+                "type": "error",
+                "ok": False,
+                "error": {
+                    "code": "TEXT_EMPTY",
+                    "message": "text is required and must not be empty",
+                    "operation": "infer",
+                    "component_id": self.COMPONENT_ID,
+                    "retryable": False,
+                },
+            }
+            return
+
+        if hasattr(self._control, "synthesize"):
+            try:
+                result = await self._control.synthesize(request)
+                audio_path = result.get("audio_path", "")
+                if not audio_path:
+                    yield {
+                        "type": "error",
+                        "ok": False,
+                        "error": {
+                            "code": "SYNTHESIS_FAILED",
+                            "message": "synthesize() returned no audio_path",
+                            "operation": "infer",
+                            "component_id": self.COMPONENT_ID,
+                            "retryable": True,
+                        },
+                    }
+                    return
+                yield {
+                    "type": "audio",
+                    "audio_path": audio_path,
+                    "final": True,
+                    "fallback_used": result.get("fallback_used", False),
+                    "requested_voice": result.get("requested_voice"),
+                    "executed_voice": result.get("executed_voice"),
+                    "ok": True,
+                }
+            except Exception as exc:
+                yield {
+                    "type": "error",
+                    "ok": False,
+                    "error": {
+                        "code": "SYNTHESIS_FAILED",
+                        "message": str(exc),
+                        "operation": "infer",
+                        "component_id": self.COMPONENT_ID,
+                        "retryable": True,
+                    },
+                }
+        else:
+            yield self._not_supported("infer.synthesize")
+
+
+def create_adapter() -> TTSOrchestratorAdapter:
+    """Entry Point Factory."""
+    return TTSOrchestratorAdapter()

termux_tts-1.1.3/termux_tts/audio.py

@@ -0,0 +1,75 @@
+"""
+Zero-Dependency Audio Buffer and RIFF WAV Stream Encoder.
+Handles 16-bit Linear PCM formatting with soft-clipping protection.
+"""
+
+import io
+import wave
+import numpy as np
+from typing import Union
+from .exceptions import TTSAudioEncodingError
+
+class AudioBuffer:
+    """Manages raw floating-point audio samples and converts to 16-bit PCM WAV."""
+
+    def __init__(self, samples: Union[np.ndarray, list], sample_rate: int = 22050):
+        if isinstance(samples, list):
+            self.samples = np.array(samples, dtype=np.float32)
+        elif isinstance(samples, np.ndarray):
+            self.samples = samples.astype(np.float32).flatten()
+        else:
+            raise TTSAudioEncodingError("Samples must be a list or numpy ndarray.")
+
+        self.sample_rate = sample_rate
+        self._normalize_and_clip()
+
+    def _normalize_and_clip(self) -> None:
+        """Apply peak normalization and soft clipping to prevent distortion."""
+        if len(self.samples) == 0:
+            return
+
+        peak = np.max(np.abs(self.samples))
+        if peak > 1.0:
+            self.samples = self.samples / peak
+        elif peak < 0.0001:
+            pass # Keep quiet signals as is
+        else:
+            # Gentle scale to target -1dB
+            self.samples = self.samples * 0.95
+
+    @property
+    def duration_seconds(self) -> float:
+        """Duration of the audio in seconds."""
+        if self.sample_rate <= 0:
+            return 0.0
+        return len(self.samples) / float(self.sample_rate)
+
+    def to_pcm16_bytes(self) -> bytes:
+        """Convert float32 [-1.0, 1.0] samples into 16-bit signed integer bytes."""
+        clipped = np.clip(self.samples, -1.0, 1.0)
+        pcm16 = (clipped * 32767.0).astype(np.int16)
+        return pcm16.tobytes()
+
+    def to_wav_bytes(self) -> bytes:
+        """Encode raw samples into standard RIFF WAV format."""
+        try:
+            pcm_bytes = self.to_pcm16_bytes()
+            buf = io.BytesIO()
+            with wave.open(buf, "wb") as wav_file:
+                wav_file.setnchannels(1)      # Mono
+                wav_file.setsampwidth(2)      # 16-bit (2 bytes)
+                wav_file.setframerate(self.sample_rate)
+                wav_file.writeframes(pcm_bytes)
+            return buf.getvalue()
+        except Exception as e:
+            raise TTSAudioEncodingError(f"Failed to encode WAV buffer: {e}") from e
+
+    def save(self, filepath: str) -> str:
+        """Save the audio buffer to a WAV file on disk."""
+        wav_data = self.to_wav_bytes()
+        try:
+            with open(filepath, "wb") as f:
+                f.write(wav_data)
+            return filepath
+        except Exception as e:
+            raise TTSAudioEncodingError(f"Failed to save WAV to '{filepath}': {e}") from e

termux_tts-1.1.3/termux_tts/cli.py

@@ -0,0 +1,82 @@
+"""
+Command-Line Interface for termux-tts:
+- termux-tts synth : Option A Deep Learning Neural Synthesis to File
+- termux-tts speak : Option B Android System Native Immediate Voice Output
+- termux-tts doctor: 12-Stage Vulkan GPU Hardware Diagnostics
+"""
+
+import argparse
+from .engine import load, doctor
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="termux-tts",
+        description="Termux Neural & Native Text-to-Speech Engine"
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Sub-commands")
+
+    # 1. Synth (Option A: DSP Formant or ONNX Neural Vocoder to File)
+    synth_parser = subparsers.add_parser("synth", help="Synthesize text to audio WAV file (DSP / ONNX)")
+    synth_parser.add_argument("-t", "--text", required=True, help="Input text to synthesize")
+    synth_parser.add_argument("-o", "--output", default="output.wav", help="Output WAV filepath")
+    synth_parser.add_argument("-l", "--lang", default="ko", help="Language code (ko, en)")
+    synth_parser.add_argument("-e", "--engine", default="auto", choices=["auto", "dsp", "onnx"], help="Synthesis engine (dsp=zero-dependency, onnx=deep learning)")
+    synth_parser.add_argument("-m", "--model", default=None, help="Path to .onnx model file (required for onnx engine)")
+    synth_parser.add_argument("-p", "--preset", default="balanced", choices=["fast", "balanced", "expressive", "ultra"])
+    synth_parser.add_argument("-d", "--device", default="auto", choices=["auto", "gpu", "vulkan", "cpu"])
+    synth_parser.add_argument("-s", "--speed", type=float, default=1.0, help="Speech speed multiplier (0.5 to 2.0)")
+
+    # 2. Speak (Option B: Native Samsung/Google System Voice)
+    speak_parser = subparsers.add_parser("speak", help="Speak text directly through device speaker (Option B: Native)")
+    speak_parser.add_argument("-t", "--text", required=True, help="Input text to speak")
+    speak_parser.add_argument("-l", "--lang", default="ko", help="Language code (ko, en)")
+    speak_parser.add_argument("-s", "--stream", default="MUSIC", help="Audio stream (MUSIC, NOTIFICATION, ALARM)")
+
+    # 3. Doctor (Diagnostics)
+    subparsers.add_parser("doctor", help="Run 12-stage Vulkan GPU hardware diagnostics")
+
+    # ── AMEVA Component Protocol v1 ─────────────────────────────────────────
+    _protocol_available = False
+    try:
+        from ameva_component.cli_support import build_protocol_subcommands
+        build_protocol_subcommands(subparsers)
+        _protocol_available = True
+    except ImportError:
+        pass
+    # ────────────────────────────────────────────────────────────────────────
+
+    args = parser.parse_args()
+
+    if args.command == "synth":
+        with load(model=args.model, language=args.lang, preset=args.preset, device=args.device, engine=args.engine) as engine:
+            res = engine.synthesize(args.text, output=args.output, speed=args.speed)
+            print(f"[SUCCESS] Synthesized via {res.backend} ({res.model_name}) -> {args.output}")
+            print(f"  Duration: {res.duration_sec:.2f}s | Elapsed: {res.elapsed_ms:.1f}ms | RTF: {res.rtf:.4f}x")
+
+    elif args.command == "speak":
+        with load(language=args.lang) as engine:
+            res = engine.speak(args.text, stream=args.stream)
+            print(f"[SUCCESS] Spoken via {res.engine_name} on stream {args.stream} ({res.elapsed_ms:.1f}ms)")
+
+    elif args.command == "doctor":
+        diag = doctor()
+        print("=" * 60)
+        print("   TERMUX-TTS 12-STAGE VULKAN HARDWARE DIAGNOSTICS")
+        print("=" * 60)
+        for k, v in diag.items():
+            print(f"  - {k:30s}: {v}")
+        print("=" * 60)
+
+    elif args.command in ("component", "model", "instance") and _protocol_available:
+        from ameva_component.cli_support import dispatch_protocol
+        from termux_tts.control import TTSControl
+        dispatch_protocol(args, TTSControl())
+    elif args.command in ("component", "model", "instance"):
+        print("[ERROR] ameva-component-sdk not installed.", file=sys.stderr)
+        sys.exit(1)
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()
+

termux_tts-1.1.3/termux_tts/control/__init__.py

@@ -0,0 +1,4 @@
+"""termux_tts.control — AMEVA Component Protocol v1."""
+from .component import TTSControl
+from .status import TTSStatusWriter
+__all__ = ["TTSControl", "TTSStatusWriter"]