termux-tts 1.5.0 → 1.5.2

package/setup.py

@@ -1,38 +0,0 @@
-import os
-from setuptools import setup, find_packages
-
-setup(
-    name="termux-tts",
-    version="1.5.0",
-    description="Ultra-Fast On-Device 4-Tier Text-to-Speech Framework (DSP Synth, Android Native, C++ Sherpa-ONNX Neural & Expressive)",
-    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-runtime>=2.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",
-    ],
-)

package/termux_tts/__init__.py

@@ -1,70 +0,0 @@
-"""
-termux-tts: Production-Grade 4-Tier TTS Framework for Android Termux.
-- Tier 1: Parametric DSP Formant Synthesizer Engine (0MB Zero-Dependency)
-- Tier 2: Android System Native Voice Engine Bridge (Samsung / Google Voice)
-- Tier 3: Authentic C++ Subprocess-Isolated Sherpa-ONNX Neural Vocoder (VITS Deep Learning)
-- Tier 4: Pure On-Device Expressive Emotional Synthesizer (Conversational Tags)
-"""
-
-from .engine import TTSEngine, load, doctor
-from .engine_native import NativeAndroidEngine, NativeResult
-from .engine_sherpa import SherpaNeuralEngine, SherpaResult
-from .engine_vulkan import VulkanNeuralEngine, VulkanResult
-from .engine_expressive import ExpressiveEngine, ExpressiveResult
-from .engine_multilingual import MultilingualNeuralEngine, MultilingualResult
-from .engine_sherpa_capi import SherpaResidentManager, SherpaCapiSession
-from .script_classifier import MultilingualTokenizer, ScriptRegistry, LanguageChunk
-from .installer import run_installation
-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
-)
-
-# Backward-compatibility alias
-ONNXNeuralEngine = SherpaNeuralEngine
-ONNXResult = SherpaResult
-
-__version__ = "1.5.0"
-__all__ = [
-    "TTSEngine",
-    "load",
-    "doctor",
-    "NativeAndroidEngine",
-    "NativeResult",
-    "SherpaNeuralEngine",
-    "SherpaResult",
-    "VulkanNeuralEngine",
-    "VulkanResult",
-    "ExpressiveEngine",
-    "ExpressiveResult",
-    "MultilingualNeuralEngine",
-    "MultilingualResult",
-    "SherpaResidentManager",
-    "SherpaCapiSession",
-    "MultilingualTokenizer",
-    "ScriptRegistry",
-    "LanguageChunk",
-    "run_installation",
-    "ONNXNeuralEngine",
-    "ONNXResult",
-    "QUALITY_PRESETS",
-    "PhoneticTokenizer",
-    "KoreanG2PEngine",
-    "korean_text_to_phonemes",
-    "EXPRESSIVE_TAGS",
-    "AudioBuffer",
-    "TTSError",
-    "TTSModelLoadError",
-    "TTSInferenceError",
-    "VulkanInitializationError",
-    "TTSAudioEncodingError",
-    "TTSLanguageNotSupportedError"
-]
-

package/termux_tts/adapter.py

@@ -1,202 +0,0 @@
-"""
-termux_tts.adapter
-===================
-AMEVA Component Protocol v1 — Orchestrator Adapter (v0.8.1 호환)
-
-P0-2: infer() fallback yield _not_supported → raise OperationNotSupported
-P0-4: except Exception → retryable 분류, 원본 오류 코드 보존
-"""
-from __future__ import annotations
-
-from typing import Any, AsyncIterator
-
-from ameva_component.adapter_base import BaseOrchestratorAdapter
-from ameva_component.exceptions import (
-    ComponentError,
-    OperationNotSupported,
-    redact_details,
-    redact_text,
-)
-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"
-
-    _RETRYABLE_CODES: frozenset[str] = frozenset({
-        "REMOTE_TIMEOUT",
-        "MODEL_BUSY",
-        "TEMPORARY_RESOURCE_UNAVAILABLE",
-    })
-    _NON_RETRYABLE_CODES: frozenset[str] = frozenset({
-        "VOICE_NOT_FOUND",
-        "TEXT_TOO_LONG",
-        "UNSUPPORTED_LANGUAGE",
-        "OUTPUT_PATH_FORBIDDEN",
-        "ENCODING_FAILED",
-    })
-
-    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", "ok": False, "error": {...}}
-        """
-        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 not hasattr(self._control, "synthesize"):
-            # P0-2: fallback yield → raise
-            raise OperationNotSupported(operation="infer.synthesize", component_id=self.COMPONENT_ID)
-
-        try:
-            result = await self._control.synthesize(request)
-
-            if not isinstance(result, dict):
-                raise ValueError(f"synthesize() must return dict, got {type(result).__name__}")
-
-            if result.get("ok") is not True:
-                err_payload = result.get("error") if isinstance(result.get("error"), dict) else {}
-                yield {
-                    "type": "error",
-                    "ok": False,
-                    "error": {
-                        "code": err_payload.get("code", "ADAPTER_RESULT_NOT_SUCCESS"),
-                        "message": err_payload.get("message", "synthesize() did not return ok=True"),
-                        "operation": "infer",
-                        "component_id": self.COMPONENT_ID,
-                        "retryable": False,
-                        "details": {"result_keys": sorted(result.keys())},
-                    },
-                }
-                return
-
-            audio_path = result.get("audio_path")
-            if not audio_path:
-                raise ValueError("synthesize() result missing required field 'audio_path'")
-            if not isinstance(audio_path, str):
-                raise TypeError(f"synthesize() audio_path must be str, got {type(audio_path).__name__}")
-
-            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 ComponentError as component_err:
-            # HIGH 1: ComponentError public_message와 redact_details로 외부 노출 보안 격리
-            import logging
-            logging.getLogger(__name__).exception(
-                "TTS component operation failed",
-                extra={
-                    "component_id": self.COMPONENT_ID,
-                    "operation": "infer",
-                    "code": getattr(component_err, "code", "COMPONENT_ERROR"),
-                },
-            )
-            if hasattr(component_err, "to_public_dict"):
-                err_dict = component_err.to_public_dict()
-            else:
-                err_dict = {
-                    "code": getattr(component_err, "code", "COMPONENT_ERROR"),
-                    "message": redact_text(getattr(component_err, "public_message", "Component operation failed")),
-                    "retryable": getattr(component_err, "retryable", False),
-                    "details": redact_details(getattr(component_err, "details", {})),
-                }
-            yield {
-                "type": "error",
-                "ok": False,
-                "error": {
-                    **err_dict,
-                    "operation": "infer",
-                    "component_id": self.COMPONENT_ID,
-                    "retryable": self._classify_retryable(
-                        err_dict.get("code", ""), default=err_dict.get("retryable", False)
-                    ),
-                },
-            }
-
-        except (ValueError, TypeError) as contract_err:
-            # P0-3/4 & HIGH 1: 계약 위반 (str(contract_err) 직접 노출 금지, 내부 로그 격리)
-            import logging
-            logging.getLogger(__name__).exception("TTS contract validation error during infer: %s", contract_err)
-            yield {
-                "type": "error",
-                "ok": False,
-                "error": {
-                    "code": "ADAPTER_CONTRACT_ERROR",
-                    "message": "Adapter contract validation failed",
-                    "operation": "infer",
-                    "component_id": self.COMPONENT_ID,
-                    "retryable": False,
-                    "details": {
-                        "cause_type": type(contract_err).__name__,
-                        "operation": "infer",
-                    },
-                },
-            }
-
-        except Exception as unexpected_err:
-            import logging
-            logging.getLogger(__name__).exception("TTS adapter unexpected error during infer: %s", unexpected_err)
-            code = getattr(unexpected_err, "code", "ADAPTER_INTERNAL_ERROR")
-            yield {
-                "type": "error",
-                "ok": False,
-                "error": {
-                    "code": code if isinstance(code, str) else "ADAPTER_INTERNAL_ERROR",
-                    "message": "Unexpected adapter failure",
-                    "operation": "infer",
-                    "component_id": self.COMPONENT_ID,
-                    "retryable": False,
-                    "details": {
-                        "cause_type": type(unexpected_err).__name__,
-                        "operation": "infer",
-                    },
-                },
-            }
-
-    def _classify_retryable(self, code: str, *, default: bool = False) -> bool:
-        if code in self._RETRYABLE_CODES:
-            return True
-        if code in self._NON_RETRYABLE_CODES:
-            return False
-        return default
-
-
-def create_adapter() -> TTSOrchestratorAdapter:
-    """Entry Point Factory."""
-    return TTSOrchestratorAdapter()

package/termux_tts/audio.py

@@ -1,101 +0,0 @@
-"""
-Zero-Dependency Audio Buffer and RIFF WAV Stream Encoder.
-Handles 16-bit Linear PCM formatting with soft-clipping protection.
-"""
-
-import io
-import wave
-from pathlib import Path
-from typing import Union
-import numpy as np
-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."""
-        clean = np.nan_to_num(self.samples, nan=0.0, posinf=1.0, neginf=-1.0)
-        clipped = np.clip(clean, -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 pad_silence(self, lead_in_ms: int = 200, lead_out_ms: int = 150) -> "AudioBuffer":
-        """Prepend and append true zero-amplitude silence to prevent Android DAC ramp-up clipping."""
-        lead_in_samples = int(self.sample_rate * (lead_in_ms / 1000.0))
-        lead_out_samples = int(self.sample_rate * (lead_out_ms / 1000.0))
-        zeros_in = np.zeros(lead_in_samples, dtype=np.float32)
-        zeros_out = np.zeros(lead_out_samples, dtype=np.float32)
-        padded = np.concatenate([zeros_in, self.samples, zeros_out])
-        return AudioBuffer(padded, sample_rate=self.sample_rate)
-
-    @classmethod
-    def from_wav_file(cls, filepath: str) -> "AudioBuffer":
-        """Load an AudioBuffer directly from a WAV file on disk."""
-        try:
-            with wave.open(filepath, "rb") as wf:
-                sr = wf.getframerate()
-                frames = wf.readframes(wf.getnframes())
-                pcm16 = np.frombuffer(frames, dtype=np.int16)
-                samples = (pcm16 / 32767.0).astype(np.float32)
-                return cls(samples, sample_rate=sr)
-        except Exception as e:
-            raise TTSAudioEncodingError(f"Failed to read WAV file '{filepath}': {e}") from e
-
-    def save(self, filepath: str) -> str:
-        """Save the audio buffer to a WAV file on disk."""
-        target = Path(filepath).expanduser().resolve()
-        wav_data = self.to_wav_bytes()
-        try:
-            target.parent.mkdir(parents=True, exist_ok=True)
-            with open(target, "wb") as f:
-                f.write(wav_data)
-            return str(target)
-        except Exception as e:
-            raise TTSAudioEncodingError(f"Failed to save WAV to '{filepath}': {e}") from e

package/termux_tts/cli.py

@@ -1,156 +0,0 @@
-"""
-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 os
-import sys
-import argparse
-from .engine import load, doctor
-
-def main():
-    # Route to default subcommand 'synth' if no recognized subcommand is given
-    KNOWN_COMMANDS = {"synth", "speak", "doctor", "install", "component", "model", "instance"}
-    raw_args = sys.argv[1:]
-    if raw_args and raw_args[0] not in KNOWN_COMMANDS and raw_args[0] not in ("-h", "--help", "-v", "--version"):
-        sys.argv.insert(1, "synth")
-
-    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 (4-Tier Speech Synthesis)
-    synth_parser = subparsers.add_parser("synth", help="Synthesize text to audio WAV file (Synth, Neural, Expressive)")
-    synth_parser.add_argument("text_pos", nargs="*", default=[], help="Input text to synthesize (positional)")
-    synth_parser.add_argument("-t", "--text", default=None, help="Input text to synthesize (flag)")
-    synth_parser.add_argument("-o", "--output", default="output.wav", help="Output WAV filepath")
-    synth_parser.add_argument("-l", "--lang", default="auto", help="Language code (auto=Multi-language auto switch, ko/kor=Korean only, en/eng=English only, ja/jpn=Japanese only)")
-    synth_parser.add_argument(
-        "-e", "--engine", default="auto",
-        choices=["auto", "vulkan", "ncnn", "gpu", "native", "neural", "onnx", "expressive", "multilingual", "hybrid", "kokoro", "melo", "supertonic"],
-        help="Synthesis engine tier (auto=Smart Routing, vulkan=GPU NCNN, native=Android voice, neural=VITS C++, kokoro=StyleTTS2 82M, melo=MeloTTS Bilingual, supertonic=Supertonic On-Device)"
-    )
-    synth_parser.add_argument("-m", "--model", default=None, help="Path to model file or directory")
-    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"], help="Compute target device")
-    synth_parser.add_argument("-b", "--backend", dest="device", choices=["auto", "gpu", "vulkan", "cpu"], help="Alias for --device")
-    synth_parser.add_argument("--gpu", dest="device", action="store_const", const="gpu", help="Enable hardware GPU acceleration")
-    synth_parser.add_argument("--cpu", dest="device", action="store_const", const="cpu", help="Force CPU compute mode")
-    synth_parser.add_argument("--tier", default=None, choices=["high", "medium", "balanced", "fast", "ultra"], help="Target model tier (high=Studio FP16, medium=Balanced)")
-    synth_parser.add_argument("-s", "--speed", type=float, default=1.0, help="Speech speed multiplier (0.5 to 2.0)")
-    synth_parser.add_argument("--mode", default="unified", choices=["unified", "stitch"], help="Multilingual synthesis mode (unified=Single-pass G2P transliteration [BigTech Standard], stitch=Multi-model chunk concatenation)")
-    synth_parser.add_argument("--threads", type=int, default=4, help="Compute worker threads (ARM NEON)")
-    synth_parser.add_argument("--volume", type=int, default=None, help="Set Android media volume (1 to 15)")
-    synth_parser.add_argument("--play", action="store_true", help="Play synthesized audio through physical speaker immediately")
-
-    # 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)")
-    speak_parser.add_argument("--volume", type=int, default=None, help="Set Android media volume (1 to 15)")
-
-    # 3. Doctor (Diagnostics)
-    subparsers.add_parser("doctor", help="Run 12-stage Vulkan GPU hardware diagnostics")
-
-    # 4. Install (One-Click Automated Provisioner)
-    install_parser = subparsers.add_parser("install", help="1-Click download and provision precompiled Vulkan binary & VITS studio models")
-    install_parser.add_argument("--tier", default="high", choices=["high", "medium"], help="Model resolution tier (high=57MB Studio FP16, medium=25MB Fast)")
-    install_parser.add_argument(
-        "--models", default="default",
-        help="Language model packages to provision: default (Korean & English only), or specific code: hi, ja, zh, ru, es, fr, de, or 'all'"
-    )
-    install_parser.add_argument("--force", action="store_true", help="Force overwrite existing binary and model assets")
-    install_parser.add_argument("--no-play", action="store_true", help="Skip playback verification during self-test")
-
-    # ── 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 as _proto_err:
-        _protocol_available = False
-    # ────────────────────────────────────────────────────────────────────────
-
-    args = parser.parse_args()
-
-    import subprocess
-    import shutil
-
-    if getattr(args, "volume", None) is not None:
-        if shutil.which("termux-volume"):
-            subprocess.run(["termux-volume", "music", str(args.volume)], check=False)
-
-    if args.command == "synth":
-        pos_text = " ".join(args.text_pos).strip() if getattr(args, "text_pos", None) else None
-        target_text = args.text or (pos_text if pos_text else None)
-        if not target_text:
-            synth_parser.error("the following arguments are required: text (as positional arguments or -t/--text)")
-
-        out_path = os.path.expanduser(args.output) if args.output else None
-        with load(
-            model=args.model,
-            language=args.lang,
-            preset=args.preset,
-            device=args.device,
-            threads=args.threads,
-            engine=args.engine,
-            tier=getattr(args, "tier", None),
-        ) as engine:
-            res = engine.synthesize(
-                target_text,
-                output=out_path,
-                speed=args.speed,
-                language=args.lang,
-                mode=getattr(args, "mode", "unified")
-            )
-            backend_name = getattr(res, "backend", "UNKNOWN")
-            model_name = getattr(res, "model_name", "model")
-            dur = getattr(res, "duration_sec", 0.0)
-            elapsed = getattr(res, "elapsed_ms", 0.0)
-            rtf = getattr(res, "rtf", 0.0)
-            print(f"[SUCCESS] Synthesized via {backend_name} ({model_name}) -> {out_path or args.output}")
-            print(f"  Duration: {dur:.2f}s | Elapsed: {elapsed:.1f}ms | RTF: {rtf:.4f}x")
-
-            if args.play and out_path and os.path.exists(out_path):
-                if shutil.which("termux-media-player"):
-                    subprocess.run(["termux-media-player", "play", out_path], check=False)
-                elif shutil.which("play-audio"):
-                    subprocess.run(["play-audio", out_path], check=False)
-
-    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 == "install":
-        from .installer import run_installation
-        run_installation(tier=args.tier, models=getattr(args, "models", "all"), force=args.force, play=not args.no_play)
-
-    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()
-

package/termux_tts/control/__init__.py

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