wyoming-piper 1.6.3__tar.gz → 2.1.2__tar.gz

{wyoming_piper-1.6.3/wyoming_piper.egg-info → wyoming_piper-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wyoming-piper
-Version: 1.6.3
+Version: 2.1.2
 Summary: Wyoming Server for Piper
 Author-email: Michael Hansen <mike@rhasspy.org>
 License: MIT
@@ -8,30 +8,30 @@ Project-URL: Homepage, http://github.com/rhasspy/wyoming-piper
 Keywords: rhasspy,wyoming,piper,tts
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
-Classifier: Topic :: Text Processing :: Linguistic
-Classifier: Programming Language :: Python :: 3.8
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
-Requires-Dist: wyoming<1.8,>=1.7.2
-Requires-Dist: regex==2024.11.6
+Requires-Dist: wyoming<2,>=1.8
+Requires-Dist: regex>=2024.11.6
+Requires-Dist: piper-tts<2,>=1.3.0
+Requires-Dist: sentence-stream<2,>=1.2.0
 Provides-Extra: dev
-Requires-Dist: black==22.12.0; extra == "dev"
-Requires-Dist: flake8==6.0.0; extra == "dev"
-Requires-Dist: isort==5.11.3; extra == "dev"
-Requires-Dist: mypy==0.991; extra == "dev"
-Requires-Dist: pylint==2.15.9; extra == "dev"
-Requires-Dist: pytest==7.4.4; extra == "dev"
-Requires-Dist: pytest-asyncio==0.23.3; extra == "dev"
-Requires-Dist: build==1.2.2.post1; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pylint; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: build; extra == "dev"
 Requires-Dist: scipy<2,>=1.10; extra == "dev"
 Requires-Dist: numpy<2,>=1.20; extra == "dev"
-Requires-Dist: python-speech-features==0.6; extra == "dev"
+Requires-Dist: python-speech-features<1,>=0.6; extra == "dev"
 Dynamic: license-file
 
 # Wyoming Piper

{wyoming_piper-1.6.3 → wyoming_piper-2.1.2}/pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "wyoming-piper"
-version = "1.6.3"
+version = "2.1.2"
 description = "Wyoming Server for Piper"
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 license = {text = "MIT"}
 authors = [
     {name = "Michael Hansen", email = "mike@rhasspy.org"}
@@ -12,8 +12,7 @@ keywords = ["rhasspy", "wyoming", "piper", "tts"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",
-    "Topic :: Text Processing :: Linguistic",
-    "Programming Language :: Python :: 3.8",
+    "Topic :: Multimedia :: Sound/Audio :: Speech",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
@@ -21,8 +20,10 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
-    "wyoming>=1.7.2,<1.8",
-    "regex==2024.11.6",
+    "wyoming>=1.8,<2",
+    "regex>=2024.11.6",
+    "piper-tts>=1.3.0,<2",
+    "sentence-stream>=1.2.0,<2",
 ]
 
 [project.urls]
@@ -57,15 +58,14 @@ disallow_untyped_defs = true
 
 [project.optional-dependencies]
 dev = [
-    "black==22.12.0",
-    "flake8==6.0.0",
-    "isort==5.11.3",
-    "mypy==0.991",
-    "pylint==2.15.9",
-    "pytest==7.4.4",
-    "pytest-asyncio==0.23.3",
-    "build==1.2.2.post1",
+    "black",
+    "flake8",
+    "mypy",
+    "pylint",
+    "pytest",
+    "pytest-asyncio",
+    "build",
     "scipy>=1.10,<2",
     "numpy>=1.20,<2",
-    "python-speech-features==0.6",
+    "python-speech-features>=0.6,<1",
 ]

{wyoming_piper-1.6.3 → wyoming_piper-2.1.2}/tests/test_piper.py

@@ -2,11 +2,9 @@
 
 import asyncio
 import sys
-import tarfile
 import wave
 from asyncio.subprocess import PIPE
 from pathlib import Path
-from urllib.request import urlopen
 
 import numpy as np
 import pytest
@@ -20,36 +18,17 @@ from .dtw import compute_optimal_path
 
 _DIR = Path(__file__).parent
 _LOCAL_DIR = _DIR.parent / "local"
-_PIPER_URL = (
-    "https://github.com/rhasspy/piper/releases/download/v1.2.0/piper_amd64.tar.gz"
-)
 _TIMEOUT = 60
 
 
-def download_piper() -> None:
-    """Downloads a binary version of Piper."""
-    piper_path = _LOCAL_DIR / "piper"
-    if piper_path.exists():
-        return
-
-    _LOCAL_DIR.mkdir(parents=True, exist_ok=True)
-    with urlopen(_PIPER_URL) as response:
-        with tarfile.open(fileobj=response, mode="r|*") as piper_file:
-            piper_file.extractall(_LOCAL_DIR)
-
-
 @pytest.mark.asyncio
 async def test_piper() -> None:
-    download_piper()
-
     proc = await asyncio.create_subprocess_exec(
         sys.executable,
         "-m",
         "wyoming_piper",
         "--uri",
         "stdio://",
-        "--piper",
-        str(_LOCAL_DIR / "piper" / "piper"),
         "--voice",
         "en_US-ryan-low",
         "--data-dir",

{wyoming_piper-1.6.3 → wyoming_piper-2.1.2}/wyoming_piper/__main__.py

@@ -8,12 +8,11 @@ from pathlib import Path
 from typing import Any, Dict, Set
 
 from wyoming.info import Attribution, Info, TtsProgram, TtsVoice, TtsVoiceSpeaker
-from wyoming.server import AsyncServer
+from wyoming.server import AsyncServer, AsyncTcpServer
 
 from . import __version__
-from .download import find_voice, get_voices
+from .download import ensure_voice_exists, find_voice, get_voices
 from .handler import PiperEventHandler
-from .process import PiperProcessManager
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -21,17 +20,20 @@ _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(
+        "--zeroconf",
+        nargs="?",
+        const="piper",
+        help="Enable discovery over zeroconf with optional name (default: piper)",
+    )
+    #
     parser.add_argument(
         "--data-dir",
         required=True,
@@ -48,22 +50,18 @@ async def main() -> None:
     )
     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(
+        "--noise-w-scale", "--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(
-        "--streaming",
+        "--no-streaming",
         action="store_true",
-        help="Enable audio streaming on sentence boundaries",
+        help="Disable audio streaming on sentence boundaries",
     )
     #
     parser.add_argument(
@@ -72,6 +70,12 @@ async def main() -> None:
         help="Download latest voices.json during startup",
     )
     #
+    parser.add_argument(
+        "--use-cuda",
+        action="store_true",
+        help="Use CUDA if available (requires onnxruntime-gpu)",
+    )
+    #
     parser.add_argument("--debug", action="store_true", help="Log DEBUG messages")
     parser.add_argument(
         "--log-format", default=logging.BASIC_FORMAT, help="Format for log messages"
@@ -187,27 +191,41 @@ async def main() -> None:
                 installed=True,
                 voices=sorted(voices, key=lambda v: v.name),
                 version=__version__,
-                supports_synthesize_streaming=args.streaming,
+                supports_synthesize_streaming=(not args.no_streaming),
             )
         ],
     )
 
-    process_manager = PiperProcessManager(args, voices_info)
+    # Ensure default voice is downloaded
+    voice_info = voices_info.get(args.voice, {})
+    voice_name = voice_info.get("key", args.voice)
+    assert voice_name is not None
 
-    # Make sure default voice is loaded.
-    # Other voices will be loaded on-demand.
-    await process_manager.get_process()
+    ensure_voice_exists(voice_name, args.data_dir, args.download_dir, voices_info)
 
     # Start server
     server = AsyncServer.from_uri(args.uri)
 
+    if args.zeroconf:
+        if not isinstance(server, AsyncTcpServer):
+            raise ValueError("Zeroconf requires tcp:// uri")
+
+        from wyoming.zeroconf import HomeAssistantZeroconf
+
+        tcp_server: AsyncTcpServer = server
+        hass_zeroconf = HomeAssistantZeroconf(
+            name=args.zeroconf, port=tcp_server.port, host=tcp_server.host
+        )
+        await hass_zeroconf.register_server()
+        _LOGGER.debug("Zeroconf discovery enabled")
+
     _LOGGER.info("Ready")
     await server.run(
         partial(
             PiperEventHandler,
             wyoming_info,
             args,
-            process_manager,
+            voices_info,
         )
     )
 

{wyoming_piper-1.6.3 → wyoming_piper-2.1.2}/wyoming_piper/download.py

@@ -9,8 +9,6 @@ from urllib.error import URLError
 from urllib.parse import quote, urlsplit, urlunsplit
 from urllib.request import urlopen
 
-from .file_hash import get_file_hash
-
 URL_FORMAT = "https://huggingface.co/rhasspy/piper-voices/resolve/main/{file}"
 
 _DIR = Path(__file__).parent
@@ -89,8 +87,7 @@ def ensure_voice_exists(
     for data_dir in data_dirs:
         data_dir = Path(data_dir)
 
-        # Check sizes/hashes
-        for file_path, file_info in voice_files.items():
+        for file_path, _file_info in voice_files.items():
             if file_path in verified_files:
                 # Already verified this file in a different data directory
                 continue
@@ -101,34 +98,37 @@ def ensure_voice_exists(
 
             data_file_path = data_dir / file_name
             _LOGGER.debug("Checking %s", data_file_path)
-            if not data_file_path.exists():
+            if (not data_file_path.exists()) or (data_file_path.stat().st_size == 0):
                 _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
+            # Don't bother validating sizes or hashes.
+            # This causes more problems than its worth.
+            #
+            # 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
 
             # File exists and has been verified
             verified_files.add(file_path)
@@ -151,9 +151,10 @@ def ensure_voice_exists(
             download_file_path.parent.mkdir(parents=True, exist_ok=True)
 
             _LOGGER.debug("Downloading %s to %s", file_url, download_file_path)
-            with urlopen(_quote_url(file_url)) as response, open(
-                download_file_path, "wb"
-            ) as download_file:
+            with (
+                urlopen(_quote_url(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)

wyoming_piper-2.1.2/wyoming_piper/handler.py

@@ -0,0 +1,275 @@
+"""Event handler for clients of the server."""
+
+import argparse
+import asyncio
+import logging
+import math
+import tempfile
+import wave
+from typing import Any, Dict, Optional
+
+from piper import PiperVoice, SynthesisConfig
+from sentence_stream import SentenceBoundaryDetector
+from wyoming.audio import AudioChunk, AudioStart, AudioStop
+from wyoming.error import Error
+from wyoming.event import Event
+from wyoming.info import Describe, Info
+from wyoming.server import AsyncEventHandler
+from wyoming.tts import (
+    Synthesize,
+    SynthesizeChunk,
+    SynthesizeStart,
+    SynthesizeStop,
+    SynthesizeStopped,
+)
+
+from .download import ensure_voice_exists, find_voice
+
+_LOGGER = logging.getLogger(__name__)
+
+# Keep the most recently used voice loaded
+_VOICE: Optional[PiperVoice] = None
+_VOICE_NAME: Optional[str] = None
+_VOICE_LOCK = asyncio.Lock()
+
+
+class PiperEventHandler(AsyncEventHandler):
+    def __init__(
+        self,
+        wyoming_info: Info,
+        cli_args: argparse.Namespace,
+        voices_info: Dict[str, Any],
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+
+        self.cli_args = cli_args
+        self.wyoming_info_event = wyoming_info.event()
+        self.voices_info = voices_info
+        self.is_streaming: Optional[bool] = None
+        self.sbd = SentenceBoundaryDetector()
+        self._synthesize: Optional[Synthesize] = None
+
+    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
+
+        try:
+            if Synthesize.is_type(event.type):
+                if self.is_streaming:
+                    # Ignore since this is only sent for compatibility reasons.
+                    # For streaming, we expect:
+                    # [synthesize-start] -> [synthesize-chunk]+ -> [synthesize]? -> [synthesize-stop]
+                    return True
+
+                # Sent outside a stream, so we must process it
+                synthesize = Synthesize.from_event(event)
+                self._synthesize = Synthesize(text="", voice=synthesize.voice)
+                self.sbd = SentenceBoundaryDetector()
+                start_sent = False
+                for i, sentence in enumerate(self.sbd.add_chunk(synthesize.text)):
+                    self._synthesize.text = sentence
+                    await self._handle_synthesize(
+                        self._synthesize, send_start=(i == 0), send_stop=False
+                    )
+                    start_sent = True
+
+                self._synthesize.text = self.sbd.finish()
+                if self._synthesize.text:
+                    # Last sentence
+                    await self._handle_synthesize(
+                        self._synthesize, send_start=(not start_sent), send_stop=True
+                    )
+                else:
+                    # No final sentence
+                    await self.write_event(AudioStop().event())
+
+                return True
+
+            if self.cli_args.no_streaming:
+                # Streaming is not enabled
+                return True
+
+            if SynthesizeStart.is_type(event.type):
+                # Start of a stream
+                stream_start = SynthesizeStart.from_event(event)
+                self.is_streaming = True
+                self.sbd = SentenceBoundaryDetector()
+                self._synthesize = Synthesize(text="", voice=stream_start.voice)
+                _LOGGER.debug("Text stream started: voice=%s", stream_start.voice)
+                return True
+
+            if SynthesizeChunk.is_type(event.type):
+                assert self._synthesize is not None
+                stream_chunk = SynthesizeChunk.from_event(event)
+                for sentence in self.sbd.add_chunk(stream_chunk.text):
+                    _LOGGER.debug("Synthesizing stream sentence: %s", sentence)
+                    self._synthesize.text = sentence
+                    await self._handle_synthesize(self._synthesize)
+
+                return True
+
+            if SynthesizeStop.is_type(event.type):
+                assert self._synthesize is not None
+                self._synthesize.text = self.sbd.finish()
+                if self._synthesize.text:
+                    # Final audio chunk(s)
+                    await self._handle_synthesize(self._synthesize)
+
+                # End of audio
+                await self.write_event(SynthesizeStopped().event())
+
+                _LOGGER.debug("Text stream stopped")
+                return True
+
+            if not Synthesize.is_type(event.type):
+                return True
+
+            synthesize = Synthesize.from_event(event)
+            return await self._handle_synthesize(synthesize)
+        except Exception as err:
+            await self.write_event(
+                Error(text=str(err), code=err.__class__.__name__).event()
+            )
+            raise err
+
+    async def _handle_synthesize(
+        self, synthesize: Synthesize, send_start: bool = True, send_stop: bool = True
+    ) -> bool:
+        global _VOICE, _VOICE_NAME
+
+        _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]
+
+        # Resolve voice
+        _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
+
+        if voice_name is None:
+            # Default voice
+            voice_name = self.cli_args.voice
+
+        if voice_name == self.cli_args.voice:
+            # Default speaker
+            voice_speaker = voice_speaker or self.cli_args.speaker
+
+        assert voice_name is not None
+
+        # Resolve alias
+        voice_info = self.voices_info.get(voice_name, {})
+        voice_name = voice_info.get("key", voice_name)
+        assert voice_name is not None
+
+        with tempfile.NamedTemporaryFile(mode="wb+", suffix=".wav") as output_file:
+            async with _VOICE_LOCK:
+                if voice_name != _VOICE_NAME:
+                    # Load new voice
+                    _LOGGER.debug("Loading voice: %s", _VOICE_NAME)
+                    ensure_voice_exists(
+                        voice_name,
+                        self.cli_args.data_dir,
+                        self.cli_args.download_dir,
+                        self.voices_info,
+                    )
+                    model_path, config_path = find_voice(
+                        voice_name, self.cli_args.data_dir
+                    )
+                    _VOICE = PiperVoice.load(
+                        model_path, config_path, use_cuda=self.cli_args.use_cuda
+                    )
+                    _VOICE_NAME = voice_name
+
+                assert _VOICE is not None
+
+                syn_config = SynthesisConfig()
+                if voice_speaker is not None:
+                    syn_config.speaker_id = _VOICE.config.speaker_id_map.get(
+                        voice_speaker
+                    )
+                    if syn_config.speaker_id is None:
+                        try:
+                            # Try to interpret as an id
+                            syn_config.speaker_id = int(voice_speaker)
+                        except ValueError:
+                            pass
+
+                    if syn_config.speaker_id is None:
+                        _LOGGER.warning(
+                            "No speaker '%s' for voice '%s'", voice_speaker, voice_name
+                        )
+
+                if self.cli_args.length_scale is not None:
+                    syn_config.length_scale = self.cli_args.length_scale
+
+                if self.cli_args.noise_scale is not None:
+                    syn_config.noise_scale = self.cli_args.noise_scale
+
+                if self.cli_args.noise_w_scale is not None:
+                    syn_config.noise_w_scale = self.cli_args.noise_w_scale
+
+                wav_writer: wave.Wave_write = wave.open(output_file, "wb")
+                with wav_writer:
+                    _VOICE.synthesize_wav(text, wav_writer, syn_config)
+
+            output_file.seek(0)
+
+            wav_file: wave.Wave_read = wave.open(output_file, "rb")
+            with wav_file:
+                rate = wav_file.getframerate()
+                width = wav_file.getsampwidth()
+                channels = wav_file.getnchannels()
+
+                if send_start:
+                    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(),
+                    )
+
+            if send_stop:
+                await self.write_event(AudioStop().event())
+
+        return True