wyoming-piper 1.6.3__py3-none-any.whl → 2.2.0__py3-none-any.whl

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,20 @@ 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(
-        "--auto-punctuation", default=".?!", help="Automatically add punctuation"
+        "--noise-w-scale", "--noise-w", type=float, help="Phoneme width noise"
     )
-    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)",
+        "--auto-punctuation",
+        default=".?!。？！．؟",
+        help="Automatically add punctuation",
     )
+    parser.add_argument("--samples-per-chunk", type=int, default=1024)
     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 +72,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 +193,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/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/handler.py

@@ -1,13 +1,15 @@
 """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
@@ -21,18 +23,22 @@ from wyoming.tts import (
     SynthesizeStopped,
 )
 
-from .process import PiperProcessManager
-from .sentence_boundary import SentenceBoundaryDetector, remove_asterisks
+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:
@@ -40,9 +46,9 @@ class PiperEventHandler(AsyncEventHandler):
 
         self.cli_args = cli_args
         self.wyoming_info_event = wyoming_info.event()
-        self.process_manager = process_manager
-        self.sbd = SentenceBoundaryDetector()
+        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:
@@ -61,10 +67,29 @@ class PiperEventHandler(AsyncEventHandler):
 
                 # Sent outside a stream, so we must process it
                 synthesize = Synthesize.from_event(event)
-                synthesize.text = remove_asterisks(synthesize.text)
-                return await self._handle_synthesize(synthesize)
+                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 not self.cli_args.streaming:
+            if self.cli_args.no_streaming:
                 # Streaming is not enabled
                 return True
 
@@ -111,7 +136,11 @@ class PiperEventHandler(AsyncEventHandler):
             )
             raise err
 
-    async def _handle_synthesize(self, synthesize: Synthesize) -> bool:
+    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
@@ -130,75 +159,118 @@ 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()
-
-            output_path = (await piper_proc.proc.stdout.readline()).decode().strip()
-            _LOGGER.debug(output_path)
+                assert _VOICE is not None
 
-        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()
+                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(),
+                    )
 
-            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