wyoming-microsoft-tts 1.3.3__py3-none-any.whl

wyoming_microsoft_tts/handler.py

@@ -0,0 +1,183 @@
+"""Event handler for clients of the server."""
+
+import argparse
+import logging
+import math
+import os
+import wave
+
+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 .microsoft_tts import MicrosoftTTS
+from .sentence_boundary import SentenceBoundaryDetector, remove_asterisks
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class MicrosoftEventHandler(AsyncEventHandler):
+    """Event handler for clients of the server."""
+
+    def __init__(
+        self,
+        wyoming_info: Info,
+        cli_args: argparse.Namespace,
+        *args,
+        **kwargs,
+    ) -> None:
+        """Initialize."""
+        super().__init__(*args, **kwargs)
+
+        self.cli_args = cli_args
+        self.wyoming_info_event = wyoming_info.event()
+        self.microsoft_tts = MicrosoftTTS(cli_args)
+        self.sbd = SentenceBoundaryDetector()
+        self.is_streaming: bool | None = None
+        self._synthesize: Synthesize | None = None
+
+    async def handle_event(self, event: Event) -> bool:  # noqa: C901
+        """Handle an event."""
+        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:
+                    return True
+
+                synthesize = Synthesize.from_event(event)
+                synthesize.text = remove_asterisks(synthesize.text)
+                await self._handle_synthesize(synthesize)
+
+            if self.cli_args.no_streaming:
+                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):
+        _LOGGER.debug(synthesize)
+        raw_text = synthesize.text
+
+        # Join multiple lines
+        text = " ".join(raw_text.strip().splitlines())
+
+        if synthesize.voice is None:  # Use default voice if not specified
+            voice = self.cli_args.voice
+        else:
+            voice = synthesize.voice.name
+
+        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]
+
+        _LOGGER.debug("Synthesizing: %s", text)
+        try:
+            output_path = self.microsoft_tts.synthesize(text=text, voice=voice)
+        except Exception as e:
+            _LOGGER.error("Failed to synthesize text: %s", e)
+            return False
+
+        _LOGGER.debug("Synthesized text")
+        try:
+            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(),
+                    )
+        except Exception as e:
+            _LOGGER.error("Failed to send audio: %s", e)
+            return False
+
+        await self.write_event(AudioStop().event())
+        _LOGGER.debug("Completed request")
+
+        os.unlink(output_path)
+
+        return True

wyoming_microsoft_tts/microsoft_tts.py

@@ -0,0 +1,62 @@
+"""Microsoft TTS."""
+
+import logging
+import tempfile
+import time
+from pathlib import Path
+
+import azure.cognitiveservices.speech as speechsdk
+
+from .download import get_voices
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class MicrosoftTTS:
+    """Class to handle Microsoft TTS."""
+
+    def __init__(self, args) -> None:
+        """Initialize."""
+        _LOGGER.debug("Initialize Microsoft TTS")
+        self.args = args
+        self.speech_config = speechsdk.SpeechConfig(
+            subscription=args.subscription_key, region=args.service_region
+        )
+
+        output_dir = str(tempfile.TemporaryDirectory())
+        output_dir = Path(output_dir)
+        output_dir.mkdir(parents=True, exist_ok=True)
+        self.output_dir = output_dir
+
+        self.voices = get_voices(args.download_dir)
+
+    def synthesize(self, text, voice=None):
+        """Synthesize text to speech."""
+        _LOGGER.debug(f"Requested TTS for [{text}]")
+        if voice is None:
+            voice = self.args.voice
+
+        # Convert the requested voice to the key microsoft use.
+        self.speech_config.speech_synthesis_voice_name = self.voices[voice]["key"]
+
+        file_name = self.output_dir / f"{time.monotonic_ns()}.wav"
+        audio_config = speechsdk.audio.AudioOutputConfig(filename=str(file_name))
+
+        speech_synthesizer = speechsdk.SpeechSynthesizer(
+            speech_config=self.speech_config, audio_config=audio_config
+        )
+
+        speech_synthesis_result = speech_synthesizer.speak_text_async(text).get()
+
+        if (
+            speech_synthesis_result.reason
+            == speechsdk.ResultReason.SynthesizingAudioCompleted
+        ):
+            _LOGGER.debug(f"Speech synthesized for text [{text}]")
+            return str(file_name)
+
+        elif speech_synthesis_result.reason == speechsdk.ResultReason.Canceled:
+            cancellation_details = speech_synthesis_result.cancellation_details
+            _LOGGER.warning(f"Speech synthesis canceled: {cancellation_details.reason}")
+            if cancellation_details.reason == speechsdk.CancellationReason.Error:
+                _LOGGER.warning(f"Error details: {cancellation_details.error_details}")

wyoming_microsoft_tts/sentence_boundary.py

@@ -0,0 +1,63 @@
+"""Guess the sentence boundaries in text."""
+
+from collections.abc import Iterable
+
+import regex as re
+
+SENTENCE_END = r"[.!?…]|[。！？]|[؟]|[।॥]"
+ABBREVIATION_RE = re.compile(r"\b\p{L}{1,3}\.$", re.UNICODE)
+
+SENTENCE_BOUNDARY_RE = re.compile(
+    rf"(.*?(?:{SENTENCE_END}+))(?=\s+[\p{{Lu}}\p{{Lt}}\p{{Lo}}]|(?:\s+\d+\.\s+))",
+    re.DOTALL,
+)
+WORD_ASTERISKS = re.compile(r"\*+([^\*]+)\*+")
+LINE_ASTERICKS = re.compile(r"(?<=^|\n)\s*\*+")
+
+
+class SentenceBoundaryDetector:
+    """Detect sentence boundaries in text."""
+
+    def __init__(self) -> None:
+        """Initialize the sentence boundary detector."""
+        self.remaining_text = ""
+        self.current_sentence = ""
+
+    def add_chunk(self, chunk: str) -> Iterable[str]:
+        """Add a chunk of text and yield complete sentences."""
+        self.remaining_text += chunk
+        while self.remaining_text:
+            match = SENTENCE_BOUNDARY_RE.search(self.remaining_text)
+            if not match:
+                break
+
+            match_text = match.group(0)
+
+            if not self.current_sentence:
+                self.current_sentence = match_text
+            elif ABBREVIATION_RE.search(self.current_sentence[-5:]):
+                self.current_sentence += match_text
+            else:
+                yield remove_asterisks(self.current_sentence.strip())
+                self.current_sentence = match_text
+
+            if not ABBREVIATION_RE.search(self.current_sentence[-5:]):
+                yield remove_asterisks(self.current_sentence.strip())
+                self.current_sentence = ""
+
+            self.remaining_text = self.remaining_text[match.end() :]
+
+    def finish(self) -> str:
+        """Return the remaining text as a single item."""
+        text = (self.current_sentence + self.remaining_text).strip()
+        self.remaining_text = ""
+        self.current_sentence = ""
+
+        return remove_asterisks(text)
+
+
+def remove_asterisks(text: str) -> str:
+    """Remove *asterisks* surrounding **words**."""
+    text = WORD_ASTERISKS.sub(r"\1", text)
+    text = LINE_ASTERICKS.sub("", text)
+    return text

wyoming_microsoft_tts/version.py

@@ -0,0 +1,3 @@
+"""Version information."""
+
+__version__ = "1.3.3"