wyoming-piper 1.5.3__py3-none-any.whl → 2.1.2__py3-none-any.whl

wyoming_piper/__init__.py

@@ -1,4 +1,5 @@
 """Wyoming server for piper."""
+
 from importlib.metadata import version
 
 __version__ = version("wyoming_piper")

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,17 +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)",
+        "--no-streaming",
+        action="store_true",
+        help="Disable audio streaming on sentence boundaries",
     )
     #
     parser.add_argument(
@@ -67,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"
@@ -113,12 +122,14 @@ async def main() -> None:
                     voice_info.get("espeak", {}).get("voice", voice_name.split("_")[0]),
                 )
             ],
-            speakers=[
-                TtsVoiceSpeaker(name=speaker_name)
-                for speaker_name in voice_info["speaker_id_map"]
-            ]
-            if voice_info.get("speaker_id_map")
-            else None,
+            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 voices_info.items()
         if not voice_info.get("_is_alias", False)
@@ -180,26 +191,41 @@ async def main() -> None:
                 installed=True,
                 voices=sorted(voices, key=lambda v: v.name),
                 version=__version__,
+                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/download.py

@@ -1,4 +1,5 @@
 """Utility for downloading Piper voices."""
+
 import json
 import logging
 import shutil
@@ -8,9 +9,7 @@ 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/v1.0.0/{file}"
+URL_FORMAT = "https://huggingface.co/rhasspy/piper-voices/resolve/main/{file}"
 
 _DIR = Path(__file__).parent
 _LOGGER = logging.getLogger(__name__)
@@ -47,20 +46,21 @@ def get_voices(
         except Exception:
             _LOGGER.exception("Failed to update voices list")
 
+    voices_embedded = _DIR / "voices.json"
+    _LOGGER.debug("Loading %s", voices_embedded)
+    with open(voices_embedded, "r", encoding="utf-8") as voices_file:
+        voices = json.load(voices_file)
+
     # Prefer downloaded file to embedded
     if voices_download.exists():
         try:
             _LOGGER.debug("Loading %s", voices_download)
             with open(voices_download, "r", encoding="utf-8") as voices_file:
-                return json.load(voices_file)
+                voices.update(json.load(voices_file))
         except Exception:
             _LOGGER.exception("Failed to load %s", voices_download)
 
-    # Fall back to embedded
-    voices_embedded = _DIR / "voices.json"
-    _LOGGER.debug("Loading %s", voices_embedded)
-    with open(voices_embedded, "r", encoding="utf-8") as voices_file:
-        return json.load(voices_file)
+    return voices
 
 
 def ensure_voice_exists(
@@ -87,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
@@ -99,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)
@@ -149,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/handler.py

@@ -1,30 +1,44 @@
 """Event handler for clients of the server."""
+
 import argparse
-import json
+import asyncio
 import logging
 import math
-import os
+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
+from wyoming.tts import (
+    Synthesize,
+    SynthesizeChunk,
+    SynthesizeStart,
+    SynthesizeStop,
+    SynthesizeStopped,
+)
 
-from .process import PiperProcessManager
+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,
-        process_manager: PiperProcessManager,
+        voices_info: Dict[str, Any],
         *args,
         **kwargs,
     ) -> None:
@@ -32,7 +46,10 @@ class PiperEventHandler(AsyncEventHandler):
 
         self.cli_args = cli_args
         self.wyoming_info_event = wyoming_info.event()
-        self.process_manager = process_manager
+        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):
@@ -40,20 +57,90 @@ class PiperEventHandler(AsyncEventHandler):
             _LOGGER.debug("Sent info")
             return True
 
-        if not Synthesize.is_type(event.type):
-            _LOGGER.warning("Unexpected event: %s", event)
-            return True
-
         try:
-            return await self._handle_event(event)
+            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_event(self, event: Event) -> bool:
-        synthesize = Synthesize.from_event(event)
+    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
@@ -72,75 +159,117 @@ class PiperEventHandler(AsyncEventHandler):
             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
+        # 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
 
-            _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()
+                assert _VOICE is not None
 
-            output_path = (await piper_proc.proc.stdout.readline()).decode().strip()
-            _LOGGER.debug(output_path)
+                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
 
-        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()
+                    if syn_config.speaker_id is None:
+                        _LOGGER.warning(
+                            "No speaker '%s' for voice '%s'", voice_speaker, voice_name
+                        )
 
-            await self.write_event(
-                AudioStart(
-                    rate=rate,
-                    width=width,
-                    channels=channels,
-                ).event(),
-            )
+                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(),
+                    )
 
-            # 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)
+            if send_stop:
+                await self.write_event(AudioStop().event())
 
         return True