wyoming-piper 1.3.0__py3-none-any.whl

wyoming_piper/__init__.py

@@ -0,0 +1 @@
+"""Wyoming server for piper."""

wyoming_piper/__main__.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+import argparse
+import asyncio
+import logging
+from functools import partial
+from typing import Any, Dict
+
+from wyoming.info import Attribution, Info, TtsProgram, TtsVoice, TtsVoiceSpeaker
+from wyoming.server import AsyncServer
+
+from .download import get_voices
+from .handler import PiperEventHandler
+from .process import PiperProcessManager
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def main() -> None:
+    """Main entry point."""
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--piper",
+        required=True,
+        help="Path to piper executable",
+    )
+    parser.add_argument(
+        "--voice",
+        required=True,
+        help="Default Piper voice to use (e.g., en_US-lessac-medium)",
+    )
+    parser.add_argument("--uri", default="stdio://", help="unix:// or tcp://")
+    parser.add_argument(
+        "--data-dir",
+        required=True,
+        action="append",
+        help="Data directory to check for downloaded models",
+    )
+    parser.add_argument(
+        "--download-dir",
+        required=True,
+        help="Directory to download voices into",
+    )
+    #
+    parser.add_argument(
+        "--speaker", type=str, help="Name or id of speaker for default voice"
+    )
+    parser.add_argument("--noise-scale", type=float, help="Generator noise")
+    parser.add_argument("--length-scale", type=float, help="Phoneme length")
+    parser.add_argument("--noise-w", type=float, help="Phoneme width noise")
+    #
+    parser.add_argument(
+        "--auto-punctuation", default=".?!", help="Automatically add punctuation"
+    )
+    parser.add_argument("--samples-per-chunk", type=int, default=1024)
+    parser.add_argument(
+        "--max-piper-procs",
+        type=int,
+        default=1,
+        help="Maximum number of piper process to run simultaneously (default: 1)",
+    )
+    #
+    parser.add_argument(
+        "--update-voices",
+        action="store_true",
+        help="Download latest voices.json during startup",
+    )
+    #
+    parser.add_argument("--debug", action="store_true", help="Log DEBUG messages")
+    args = parser.parse_args()
+
+    logging.basicConfig(level=logging.DEBUG if args.debug else logging.INFO)
+
+    # Load voice info
+    voices_info = get_voices(args.download_dir, update_voices=args.update_voices)
+
+    # Resolve aliases for backwards compatibility with old voice names
+    aliases_info: Dict[str, Any] = {}
+    for voice_info in voices_info.values():
+        for voice_alias in voice_info.get("aliases", []):
+            aliases_info[voice_alias] = {"_is_alias": True, **voice_info}
+
+    voices_info.update(aliases_info)
+
+    wyoming_info = Info(
+        tts=[
+            TtsProgram(
+                name="piper",
+                description="A fast, local, neural text to speech engine",
+                attribution=Attribution(
+                    name="rhasspy", url="https://github.com/rhasspy/piper"
+                ),
+                installed=True,
+                voices=[
+                    TtsVoice(
+                        name=voice_name,
+                        description=get_description(voice_info),
+                        attribution=Attribution(
+                            name="rhasspy", url="https://github.com/rhasspy/piper"
+                        ),
+                        installed=True,
+                        languages=[voice_info["language"]["code"]],
+                        #
+                        # Don't send speakers for now because it overflows StreamReader buffers
+                        # speakers=[
+                        #     TtsVoiceSpeaker(name=speaker_name)
+                        #     for speaker_name in voice_info["speaker_id_map"]
+                        # ]
+                        # if voice_info.get("speaker_id_map")
+                        # else None,
+                    )
+                    for voice_name, voice_info in sorted(
+                        voices_info.items(), key=lambda kv: kv[0]
+                    )
+                    if not voice_info.get("_is_alias", False)
+                ],
+            )
+        ],
+    )
+
+    process_manager = PiperProcessManager(args, voices_info)
+
+    # Make sure default voice is loaded.
+    # Other voices will be loaded on-demand.
+    await process_manager.get_process()
+
+    # Start server
+    server = AsyncServer.from_uri(args.uri)
+
+    _LOGGER.info("Ready")
+    await server.run(
+        partial(
+            PiperEventHandler,
+            wyoming_info,
+            args,
+            process_manager,
+        )
+    )
+
+
+# -----------------------------------------------------------------------------
+
+
+def get_description(voice_info: Dict[str, Any]):
+    """Get a human readable description for a voice."""
+    name = voice_info["name"]
+    name = " ".join(name.split("_"))
+    quality = voice_info["quality"]
+
+    return f"{name} ({quality})"
+
+
+# -----------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        pass

wyoming_piper/const.py

@@ -0,0 +1,101 @@
+WHISPER_LANGUAGES = [
+    "af",
+    "am",
+    "ar",
+    "as",
+    "az",
+    "ba",
+    "be",
+    "bg",
+    "bn",
+    "bo",
+    "br",
+    "bs",
+    "ca",
+    "cs",
+    "cy",
+    "da",
+    "de",
+    "el",
+    "en",
+    "es",
+    "et",
+    "eu",
+    "fa",
+    "fi",
+    "fo",
+    "fr",
+    "gl",
+    "gu",
+    "ha",
+    "haw",
+    "he",
+    "hi",
+    "hr",
+    "ht",
+    "hu",
+    "hy",
+    "id",
+    "is",
+    "it",
+    "ja",
+    "jw",
+    "ka",
+    "kk",
+    "km",
+    "kn",
+    "ko",
+    "la",
+    "lb",
+    "ln",
+    "lo",
+    "lt",
+    "lv",
+    "mg",
+    "mi",
+    "mk",
+    "ml",
+    "mn",
+    "mr",
+    "ms",
+    "mt",
+    "my",
+    "ne",
+    "nl",
+    "nn",
+    "no",
+    "oc",
+    "pa",
+    "pl",
+    "ps",
+    "pt",
+    "ro",
+    "ru",
+    "sa",
+    "sd",
+    "si",
+    "sk",
+    "sl",
+    "sn",
+    "so",
+    "sq",
+    "sr",
+    "su",
+    "sv",
+    "sw",
+    "ta",
+    "te",
+    "tg",
+    "th",
+    "tk",
+    "tl",
+    "tr",
+    "tt",
+    "uk",
+    "ur",
+    "uz",
+    "vi",
+    "yi",
+    "yo",
+    "zh",
+]

wyoming_piper/download.py

@@ -0,0 +1,161 @@
+"""Utility for downloading Piper voices."""
+import json
+import logging
+import shutil
+from pathlib import Path
+from typing import Any, Dict, Iterable, Set, Tuple, Union
+from urllib.request import urlopen
+
+from .file_hash import get_file_hash
+
+URL_FORMAT = "https://huggingface.co/rhasspy/piper-voices/resolve/v1.0.0/{file}"
+
+_DIR = Path(__file__).parent
+_LOGGER = logging.getLogger(__name__)
+
+_SKIP_FILES = {"MODEL_CARD"}
+
+
+class VoiceNotFoundError(Exception):
+    pass
+
+
+def get_voices(
+    download_dir: Union[str, Path], update_voices: bool = False
+) -> Dict[str, Any]:
+    """Loads available voices from downloaded or embedded JSON file."""
+    download_dir = Path(download_dir)
+    voices_download = download_dir / "voices.json"
+
+    if update_voices:
+        # Download latest voices.json
+        voices_url = URL_FORMAT.format(file="voices.json")
+        _LOGGER.debug("Downloading %s to %s", voices_url, voices_download)
+        with urlopen(voices_url) as response, open(
+            voices_download, "wb"
+        ) as download_file:
+            shutil.copyfileobj(response, download_file)
+
+    # Prefer downloaded file to embedded
+    voices_embedded = _DIR / "voices.json"
+    voices_path = voices_download if voices_download.exists() else voices_embedded
+
+    _LOGGER.debug("Loading %s", voices_path)
+    with open(voices_path, "r", encoding="utf-8") as voices_file:
+        return json.load(voices_file)
+
+
+def ensure_voice_exists(
+    name: str,
+    data_dirs: Iterable[Union[str, Path]],
+    download_dir: Union[str, Path],
+    voices_info: Dict[str, Any],
+):
+    if name not in voices_info:
+        # Try as file path to a custom voice
+        onnx_path = Path(name)
+        config_path = Path(name + ".json")
+        if onnx_path.exists():
+            if config_path.exists():
+                # Custom voice found
+                return
+
+            _LOGGER.warning("Missing custom voice config: %s", config_path)
+
+        raise VoiceNotFoundError(name)
+
+    assert data_dirs, "No data dirs"
+
+    voice_info = voices_info[name]
+    voice_files = voice_info["files"]
+    files_to_download: Set[str] = set()
+
+    for data_dir in data_dirs:
+        data_dir = Path(data_dir)
+
+        # Check sizes/hashes
+        for file_path, file_info in voice_files.items():
+            if file_path in files_to_download:
+                # Already planning to download
+                continue
+
+            file_name = Path(file_path).name
+            if file_name in _SKIP_FILES:
+                continue
+
+            data_file_path = data_dir / file_name
+            _LOGGER.debug("Checking %s", data_file_path)
+            if not data_file_path.exists():
+                _LOGGER.debug("Missing %s", data_file_path)
+                files_to_download.add(file_path)
+                continue
+
+            expected_size = file_info["size_bytes"]
+            actual_size = data_file_path.stat().st_size
+            if expected_size != actual_size:
+                _LOGGER.warning(
+                    "Wrong size (expected=%s, actual=%s) for %s",
+                    expected_size,
+                    actual_size,
+                    data_file_path,
+                )
+                files_to_download.add(file_path)
+                continue
+
+            expected_hash = file_info["md5_digest"]
+            actual_hash = get_file_hash(data_file_path)
+            if expected_hash != actual_hash:
+                _LOGGER.warning(
+                    "Wrong hash (expected=%s, actual=%s) for %s",
+                    expected_hash,
+                    actual_hash,
+                    data_file_path,
+                )
+                files_to_download.add(file_path)
+                continue
+
+    if (not voice_files) and (not files_to_download):
+        raise ValueError(f"Unable to find or download voice: {name}")
+
+    # Download missing files
+    download_dir = Path(download_dir)
+
+    for file_path in files_to_download:
+        file_name = Path(file_path).name
+        if file_name in _SKIP_FILES:
+            continue
+
+        file_url = URL_FORMAT.format(file=file_path)
+        download_file_path = download_dir / file_name
+        download_file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        _LOGGER.debug("Downloading %s to %s", file_url, download_file_path)
+        with urlopen(file_url) as response, open(
+            download_file_path, "wb"
+        ) as download_file:
+            shutil.copyfileobj(response, download_file)
+
+        _LOGGER.info("Downloaded %s (%s)", download_file_path, file_url)
+
+
+def find_voice(name: str, data_dirs: Iterable[Union[str, Path]]) -> Tuple[Path, Path]:
+    """Looks for the files for a voice.
+
+    Returns: tuple of onnx path, config path
+    """
+    for data_dir in data_dirs:
+        data_dir = Path(data_dir)
+        onnx_path = data_dir / f"{name}.onnx"
+        config_path = data_dir / f"{name}.onnx.json"
+
+        if onnx_path.exists() and config_path.exists():
+            return onnx_path, config_path
+
+    # Try as a custom voice
+    onnx_path = Path(name)
+    config_path = Path(name + ".json")
+
+    if onnx_path.exists() and config_path.exists():
+        return onnx_path, config_path
+
+    raise ValueError(f"Missing files for voice {name}")

wyoming_piper/file_hash.py

@@ -0,0 +1,46 @@
+import argparse
+import hashlib
+import json
+import sys
+from pathlib import Path
+from typing import Union
+
+
+def get_file_hash(path: Union[str, Path], bytes_per_chunk: int = 8192) -> str:
+    """Hash a file in chunks using md5."""
+    path_hash = hashlib.md5()
+    with open(path, "rb") as path_file:
+        chunk = path_file.read(bytes_per_chunk)
+        while chunk:
+            path_hash.update(chunk)
+            chunk = path_file.read(bytes_per_chunk)
+
+    return path_hash.hexdigest()
+
+
+# -----------------------------------------------------------------------------
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("file", nargs="+")
+    parser.add_argument("--dir", help="Parent directory")
+    args = parser.parse_args()
+
+    if args.dir:
+        args.dir = Path(args.dir)
+
+    hashes = {}
+    for path_str in args.file:
+        path = Path(path_str)
+        path_hash = get_file_hash(path)
+        if args.dir:
+            path = path.relative_to(args.dir)
+
+        hashes[str(path)] = path_hash
+
+    json.dump(hashes, sys.stdout)
+
+
+if __name__ == "__main__":
+    main()

wyoming_piper/handler.py

@@ -0,0 +1,136 @@
+"""Event handler for clients of the server."""
+import argparse
+import json
+import logging
+import math
+import os
+import wave
+from typing import Any, Dict, Optional
+
+from wyoming.audio import AudioChunk, AudioStart, AudioStop
+from wyoming.event import Event
+from wyoming.info import Describe, Info
+from wyoming.server import AsyncEventHandler
+from wyoming.tts import Synthesize
+
+from .process import PiperProcessManager
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class PiperEventHandler(AsyncEventHandler):
+    def __init__(
+        self,
+        wyoming_info: Info,
+        cli_args: argparse.Namespace,
+        process_manager: PiperProcessManager,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+
+        self.cli_args = cli_args
+        self.wyoming_info_event = wyoming_info.event()
+        self.process_manager = process_manager
+
+    async def handle_event(self, event: Event) -> bool:
+        if Describe.is_type(event.type):
+            await self.write_event(self.wyoming_info_event)
+            _LOGGER.debug("Sent info")
+            return True
+
+        if not Synthesize.is_type(event.type):
+            _LOGGER.warning("Unexpected event: %s", event)
+            return True
+
+        synthesize = Synthesize.from_event(event)
+        _LOGGER.debug(synthesize)
+
+        raw_text = synthesize.text
+
+        # Join multiple lines
+        text = " ".join(raw_text.strip().splitlines())
+
+        if self.cli_args.auto_punctuation and text:
+            # Add automatic punctuation (important for some voices)
+            has_punctuation = False
+            for punc_char in self.cli_args.auto_punctuation:
+                if text[-1] == punc_char:
+                    has_punctuation = True
+                    break
+
+            if not has_punctuation:
+                text = text + self.cli_args.auto_punctuation[0]
+
+        async with self.process_manager.processes_lock:
+            _LOGGER.debug("synthesize: raw_text=%s, text='%s'", raw_text, text)
+            voice_name: Optional[str] = None
+            voice_speaker: Optional[str] = None
+            if synthesize.voice is not None:
+                voice_name = synthesize.voice.name
+                voice_speaker = synthesize.voice.speaker
+
+            piper_proc = await self.process_manager.get_process(voice_name=voice_name)
+
+            assert piper_proc.proc.stdin is not None
+            assert piper_proc.proc.stdout is not None
+
+            # JSON in, file path out
+            input_obj: Dict[str, Any] = {"text": text}
+            if voice_speaker is not None:
+                speaker_id = piper_proc.get_speaker_id(voice_speaker)
+                if speaker_id is not None:
+                    input_obj["speaker_id"] = speaker_id
+                else:
+                    _LOGGER.warning(
+                        "No speaker '%s' for voice '%s'", voice_speaker, voice_name
+                    )
+
+            _LOGGER.debug("input: %s", input_obj)
+            piper_proc.proc.stdin.write(
+                (json.dumps(input_obj, ensure_ascii=False) + "\n").encode()
+            )
+            await piper_proc.proc.stdin.drain()
+
+            output_path = (await piper_proc.proc.stdout.readline()).decode().strip()
+            _LOGGER.debug(output_path)
+
+        wav_file: wave.Wave_read = wave.open(output_path, "rb")
+        with wav_file:
+            rate = wav_file.getframerate()
+            width = wav_file.getsampwidth()
+            channels = wav_file.getnchannels()
+
+            await self.write_event(
+                AudioStart(
+                    rate=rate,
+                    width=width,
+                    channels=channels,
+                ).event(),
+            )
+
+            # Audio
+            audio_bytes = wav_file.readframes(wav_file.getnframes())
+            bytes_per_sample = width * channels
+            bytes_per_chunk = bytes_per_sample * self.cli_args.samples_per_chunk
+            num_chunks = int(math.ceil(len(audio_bytes) / bytes_per_chunk))
+
+            # Split into chunks
+            for i in range(num_chunks):
+                offset = i * bytes_per_chunk
+                chunk = audio_bytes[offset : offset + bytes_per_chunk]
+                await self.write_event(
+                    AudioChunk(
+                        audio=chunk,
+                        rate=rate,
+                        width=width,
+                        channels=channels,
+                    ).event(),
+                )
+
+        await self.write_event(AudioStop().event())
+        _LOGGER.debug("Completed request")
+
+        os.unlink(output_path)
+
+        return True