PyThaiTTS 0.6.0__tar.gz → 0.7.0__tar.gz

{pythaitts-0.6.0 → pythaitts-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyThaiTTS
-Version: 0.6.0
+Version: 0.7.0
 Summary: Open Source Thai Text-to-speech library in Python
 Home-page: https://github.com/pythainlp/pythaitts
 Author: Wannaphong
@@ -30,6 +30,8 @@ Provides-Extra: vachanatts
 Requires-Dist: vachanatts; extra == "vachanatts"
 Provides-Extra: vachana
 Requires-Dist: vachanatts; extra == "vachana"
+Provides-Extra: realtime
+Requires-Dist: RealtimeTTS; extra == "realtime"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -101,6 +103,67 @@ tts = TTS(pretrained="khanomtan")
 file = tts.tts("ภาษาไทย", speaker_idx="Linda", filename="output.wav")
 ```
 
+### Real-time / Streaming TTS (FastThaiG2P)
+
+PyThaiTTS supports low-latency, real-time streaming speech synthesis with FastThaiG2P, making it ideal for conversational voice agents and LLM streaming:
+
+#### 1. Streaming Audio from Text
+
+Synthesize chunk-by-chunk in real time:
+
+```python
+from pythaitts import TTS
+
+tts = TTS(pretrained="fastthaig2p")
+
+# Stream audio chunks as 24kHz float32 NumPy arrays
+for audio_chunk in tts.stream("สวัสดีครับ ยินดีต้อนรับสู่ระบบเรียลไทม์ทีทีเอส"):
+    print(f"Audio chunk shape: {audio_chunk.shape}")
+
+# Stream raw 16-bit PCM bytes (for WebSockets or PyAudio)
+for pcm_bytes in tts.stream("สวัสดีครับ", return_type="bytes"):
+    # send over websocket or write to audio stream
+    pass
+```
+
+#### 2. Streaming from an LLM Token Stream
+
+Feed tokens directly from an LLM or generator into `tts.stream()`:
+
+```python
+from pythaitts import TTS
+
+tts = TTS()
+
+def token_stream():
+    tokens = ["สวัสดี", "ครับ", " ", "นี่", "คือ", "การ", "สตรีม", "มิ่ง"]
+    for tok in tokens:
+        yield tok
+
+for audio_chunk in tts.stream(token_stream()):
+    # Process or play chunk with low latency
+    pass
+```
+
+#### 3. Integration with the RealtimeTTS Library
+
+You can use FastThaiG2P as an engine with [KoljaB/RealtimeTTS](https://github.com/KoljaB/RealtimeTTS):
+
+```sh
+pip install pythaitts[realtime]
+```
+
+```python
+from RealtimeTTS import TextToAudioStream
+from pythaitts.realtime import FastThaiG2PEngine
+
+engine = FastThaiG2PEngine()
+stream = TextToAudioStream(engine)
+stream.feed("สวัสดีครับ วันนี้อากาศดีมาก")
+stream.play()
+```
+
+
 ### Text Preprocessing
 
 PyThaiTTS includes automatic text preprocessing to improve TTS quality:

{pythaitts-0.6.0 → pythaitts-0.7.0}/PyThaiTTS.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyThaiTTS
-Version: 0.6.0
+Version: 0.7.0
 Summary: Open Source Thai Text-to-speech library in Python
 Home-page: https://github.com/pythainlp/pythaitts
 Author: Wannaphong
@@ -30,6 +30,8 @@ Provides-Extra: vachanatts
 Requires-Dist: vachanatts; extra == "vachanatts"
 Provides-Extra: vachana
 Requires-Dist: vachanatts; extra == "vachana"
+Provides-Extra: realtime
+Requires-Dist: RealtimeTTS; extra == "realtime"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -101,6 +103,67 @@ tts = TTS(pretrained="khanomtan")
 file = tts.tts("ภาษาไทย", speaker_idx="Linda", filename="output.wav")
 ```
 
+### Real-time / Streaming TTS (FastThaiG2P)
+
+PyThaiTTS supports low-latency, real-time streaming speech synthesis with FastThaiG2P, making it ideal for conversational voice agents and LLM streaming:
+
+#### 1. Streaming Audio from Text
+
+Synthesize chunk-by-chunk in real time:
+
+```python
+from pythaitts import TTS
+
+tts = TTS(pretrained="fastthaig2p")
+
+# Stream audio chunks as 24kHz float32 NumPy arrays
+for audio_chunk in tts.stream("สวัสดีครับ ยินดีต้อนรับสู่ระบบเรียลไทม์ทีทีเอส"):
+    print(f"Audio chunk shape: {audio_chunk.shape}")
+
+# Stream raw 16-bit PCM bytes (for WebSockets or PyAudio)
+for pcm_bytes in tts.stream("สวัสดีครับ", return_type="bytes"):
+    # send over websocket or write to audio stream
+    pass
+```
+
+#### 2. Streaming from an LLM Token Stream
+
+Feed tokens directly from an LLM or generator into `tts.stream()`:
+
+```python
+from pythaitts import TTS
+
+tts = TTS()
+
+def token_stream():
+    tokens = ["สวัสดี", "ครับ", " ", "นี่", "คือ", "การ", "สตรีม", "มิ่ง"]
+    for tok in tokens:
+        yield tok
+
+for audio_chunk in tts.stream(token_stream()):
+    # Process or play chunk with low latency
+    pass
+```
+
+#### 3. Integration with the RealtimeTTS Library
+
+You can use FastThaiG2P as an engine with [KoljaB/RealtimeTTS](https://github.com/KoljaB/RealtimeTTS):
+
+```sh
+pip install pythaitts[realtime]
+```
+
+```python
+from RealtimeTTS import TextToAudioStream
+from pythaitts.realtime import FastThaiG2PEngine
+
+engine = FastThaiG2PEngine()
+stream = TextToAudioStream(engine)
+stream.feed("สวัสดีครับ วันนี้อากาศดีมาก")
+stream.play()
+```
+
+
 ### Text Preprocessing
 
 PyThaiTTS includes automatic text preprocessing to improve TTS quality:

{pythaitts-0.6.0 → pythaitts-0.7.0}/PyThaiTTS.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ PyThaiTTS.egg-info/requires.txt
 PyThaiTTS.egg-info/top_level.txt
 pythaitts/__init__.py
 pythaitts/preprocess.py
+pythaitts/realtime.py
 pythaitts/pretrained/__init__.py
 pythaitts/pretrained/khanomtan_tts.py
 pythaitts/pretrained/lunarlist_model.py
@@ -34,4 +35,5 @@ pythaitts/pretrained/fastthaig2p/data/fallback/thdict
 tests/__init__.py
 tests/test_fastthaig2p.py
 tests/test_preprocess.py
+tests/test_realtime.py
 tests/test_vachana.py

{pythaitts-0.6.0 → pythaitts-0.7.0}/PyThaiTTS.egg-info/requires.txt

@@ -4,6 +4,9 @@ onnxruntime
 soundfile
 pythainlp
 
+[realtime]
+RealtimeTTS
+
 [vachana]
 vachanatts
 

{pythaitts-0.6.0 → pythaitts-0.7.0}/README.md

@@ -54,6 +54,67 @@ tts = TTS(pretrained="khanomtan")
 file = tts.tts("ภาษาไทย", speaker_idx="Linda", filename="output.wav")
 ```
 
+### Real-time / Streaming TTS (FastThaiG2P)
+
+PyThaiTTS supports low-latency, real-time streaming speech synthesis with FastThaiG2P, making it ideal for conversational voice agents and LLM streaming:
+
+#### 1. Streaming Audio from Text
+
+Synthesize chunk-by-chunk in real time:
+
+```python
+from pythaitts import TTS
+
+tts = TTS(pretrained="fastthaig2p")
+
+# Stream audio chunks as 24kHz float32 NumPy arrays
+for audio_chunk in tts.stream("สวัสดีครับ ยินดีต้อนรับสู่ระบบเรียลไทม์ทีทีเอส"):
+    print(f"Audio chunk shape: {audio_chunk.shape}")
+
+# Stream raw 16-bit PCM bytes (for WebSockets or PyAudio)
+for pcm_bytes in tts.stream("สวัสดีครับ", return_type="bytes"):
+    # send over websocket or write to audio stream
+    pass
+```
+
+#### 2. Streaming from an LLM Token Stream
+
+Feed tokens directly from an LLM or generator into `tts.stream()`:
+
+```python
+from pythaitts import TTS
+
+tts = TTS()
+
+def token_stream():
+    tokens = ["สวัสดี", "ครับ", " ", "นี่", "คือ", "การ", "สตรีม", "มิ่ง"]
+    for tok in tokens:
+        yield tok
+
+for audio_chunk in tts.stream(token_stream()):
+    # Process or play chunk with low latency
+    pass
+```
+
+#### 3. Integration with the RealtimeTTS Library
+
+You can use FastThaiG2P as an engine with [KoljaB/RealtimeTTS](https://github.com/KoljaB/RealtimeTTS):
+
+```sh
+pip install pythaitts[realtime]
+```
+
+```python
+from RealtimeTTS import TextToAudioStream
+from pythaitts.realtime import FastThaiG2PEngine
+
+engine = FastThaiG2PEngine()
+stream = TextToAudioStream(engine)
+stream.feed("สวัสดีครับ วันนี้อากาศดีมาก")
+stream.play()
+```
+
+
 ### Text Preprocessing
 
 PyThaiTTS includes automatic text preprocessing to improve TTS quality:

{pythaitts-0.6.0 → pythaitts-0.7.0}/pythaitts/__init__.py

@@ -2,9 +2,19 @@
 """
 PyThaiTTS
 """
-__version__ = "0.6.0"
+__version__ = "0.7.0"
+
+from typing import Union, Iterable, Iterator
 
 from pythaitts.preprocess import preprocess_text, num_to_thai, expand_maiyamok
+from pythaitts.realtime import (
+    RealtimeTTS,
+    FastThaiG2PEngine,
+    PyThaiTTSEngine,
+    RealtimeTTSEngine,
+    chunk_text,
+    stream_text_to_chunks,
+)
 
 
 class TTS:
@@ -100,3 +110,70 @@ class TTS:
             return_type=return_type,
             filename=filename
         )
+
+    def stream(
+        self,
+        text: Union[str, Iterable[str]],
+        speaker_idx: str = "thai_som",
+        return_type: str = "waveform",
+        play: bool = False,
+        preprocess: bool = True,
+        max_phonemes: int = 400,
+        **kwargs,
+    ):
+        """
+        Stream speech synthesis in real-time.
+
+        :param Union[str, Iterable[str]] text: Input text or stream of text tokens (e.g. from LLM)
+        :param str speaker_idx: Voice to use (default: "thai_som" for fastthaig2p)
+        :param str return_type: Return format ("waveform", "bytes", "raw", "file")
+        :param bool play: Whether to play audio chunks in real-time to speakers
+        :param bool preprocess: Whether to preprocess text (numbers to words, ๆ)
+        :param int max_phonemes: Maximum phonemes per synthesized chunk
+        :param kwargs: Additional parameters passed to the model
+        :return: Generator yielding audio chunks
+        """
+        if self.pretrained in ("fastthaig2p", "FastThaiG2P"):
+            if speaker_idx in ("Linda", None):
+                speaker_idx = "thai_som"
+            return self.model.stream(
+                text=text,
+                speaker_idx=speaker_idx,
+                return_type=return_type,
+                play=play,
+                preprocess=preprocess,
+                max_phonemes=max_phonemes,
+                **kwargs,
+            )
+        else:
+            from pythaitts.realtime import stream_text_to_chunks
+
+            def _gen():
+                for chunk in stream_text_to_chunks(
+                    text, max_phonemes=max_phonemes, preprocess=preprocess
+                ):
+                    yield self.tts(
+                        text=chunk,
+                        speaker_idx=speaker_idx,
+                        return_type=return_type,
+                        preprocess=False,
+                        **kwargs,
+                    )
+
+            return _gen()
+
+    tts_stream = stream
+
+
+__all__ = [
+    "TTS",
+    "RealtimeTTS",
+    "FastThaiG2PEngine",
+    "PyThaiTTSEngine",
+    "RealtimeTTSEngine",
+    "preprocess_text",
+    "num_to_thai",
+    "expand_maiyamok",
+    "chunk_text",
+    "stream_text_to_chunks",
+]

{pythaitts-0.6.0 → pythaitts-0.7.0}/pythaitts/pretrained/fastthaig2p/__init__.py

@@ -23,7 +23,18 @@ from .kokoro import ipa_to_kokoro
 from .normalizer import normalize
 from .tokenizer import Tokenizer
 
-__all__ = ["G2P", "Tokenizer", "normalize", "ipa_to_kokoro", "TTS", "FastThaiG2P"]
+__all__ = [
+    "G2P",
+    "Tokenizer",
+    "normalize",
+    "ipa_to_kokoro",
+    "TTS",
+    "FastThaiG2P",
+    "FastThaiG2PEngine",
+    "FastThaiG2PVoice",
+    "chunk_text",
+    "stream_text_to_chunks",
+]
 
 
 def __getattr__(name):
@@ -31,5 +42,14 @@ def __getattr__(name):
         from .tts import TTS, FastThaiG2P
 
         return FastThaiG2P if name == "FastThaiG2P" else TTS
+    if name in ("FastThaiG2PEngine", "FastThaiG2PVoice", "chunk_text", "stream_text_to_chunks"):
+        from pythaitts.realtime import (
+            FastThaiG2PEngine,
+            FastThaiG2PVoice,
+            chunk_text,
+            stream_text_to_chunks,
+        )
+
+        return locals()[name]
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 

{pythaitts-0.6.0 → pythaitts-0.7.0}/pythaitts/pretrained/fastthaig2p/tts.py

@@ -32,7 +32,7 @@ import json
 import os
 import wave
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Union, Iterable, Iterator
 
 import numpy as np
 
@@ -277,6 +277,84 @@ class TTS:
             self.synthesize(text, filename)
             return str(filename)
 
+    def stream(
+        self,
+        text: Union[str, Iterable[str]],
+        speaker_idx: str = "thai_som",
+        return_type: str = "waveform",
+        play: bool = False,
+        preprocess: bool = True,
+        max_phonemes: int = 400,
+        **kwargs,
+    ):
+        """Stream Thai speech generation chunk by chunk in real-time.
+
+        :param Union[str, Iterable[str]] text: Input text or stream of text tokens (e.g. from LLM)
+        :param str speaker_idx: Voice to use (default: "thai_som" or path to custom voicepack)
+        :param str return_type: Return format ("waveform", "bytes", "raw", "file")
+        :param bool play: Whether to play audio chunks in real-time to speakers
+        :param bool preprocess: Whether to preprocess text (numbers to words, ๆ)
+        :param int max_phonemes: Maximum phonemes per synthesized chunk (default: 400)
+        :param kwargs: Additional parameters (e.g., speed)
+        :yield: Audio chunk (np.ndarray float32 waveform, int16 bytes, or wav file path)
+        """
+        if speaker_idx in ("Linda", None):
+            speaker_idx = "thai_som"
+
+        if speaker_idx not in self.SUPPORTED_VOICES and not os.path.exists(str(speaker_idx)):
+            raise ValueError(
+                f"Unsupported voice '{speaker_idx}'. Supported voices are: {', '.join(self.SUPPORTED_VOICES)}"
+            )
+
+        orig_speed = self.speed
+        if "speed" in kwargs:
+            self.speed = kwargs["speed"]
+
+        from pythaitts.realtime import _AudioPlayer, stream_text_to_chunks
+
+        player = _AudioPlayer(sample_rate=self.sample_rate) if play else None
+
+        try:
+            chunks = stream_text_to_chunks(
+                text,
+                max_phonemes=max_phonemes,
+                preprocess=preprocess,
+                g2p_converter=self._text_to_phonemes,
+            )
+            for chunk in chunks:
+                audio = self.generate(chunk)
+                if len(audio) == 0:
+                    continue
+
+                if player is not None:
+                    player.play(audio)
+
+                if return_type == "waveform":
+                    yield audio
+                elif return_type in ("bytes", "raw"):
+                    yield (np.clip(audio, -1.0, 1.0) * 32767).astype(np.int16).tobytes()
+                elif return_type == "file":
+                    import tempfile
+                    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as fp:
+                        temp_name = fp.name
+                    audio_int16 = (np.clip(audio, -1.0, 1.0) * 32767).astype(np.int16)
+                    with wave.open(temp_name, "wb") as wf:
+                        wf.setnchannels(1)
+                        wf.setsampwidth(2)
+                        wf.setframerate(self.sample_rate)
+                        wf.writeframes(audio_int16.tobytes())
+                    yield temp_name
+                else:
+                    raise ValueError(
+                        f"Unsupported return_type '{return_type}'. Choose 'waveform', 'bytes', or 'file'."
+                    )
+        finally:
+            if player is not None:
+                player.close()
+            self.speed = orig_speed
+
+    tts_stream = stream
+
 
 FastThaiG2P = TTS