PyThaiTTS 0.3.0__tar.gz → 0.4.0__tar.gz

pythaitts-0.4.0/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: PyThaiTTS
+Version: 0.4.0
+Summary: Open Source Thai Text-to-speech library in Python
+Home-page: https://github.com/pythainlp/pythaitts
+Author: Wannaphong
+Author-email: wannaphong@yahoo.com
+License: Apache Software License 2.0
+Project-URL: Documentation, https://github.com/pythainlp/pythaitts
+Project-URL: Source, https://github.com/pythainlp/pythaitts
+Project-URL: Bug Reports, https://github.com/pythainlp/pythaitts/issues
+Keywords: Thai,NLP,natural language processing,text analytics,text processing,localization,computational linguistics,text-to-speech
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Text Processing :: General
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: huggingface_hub
+Requires-Dist: numpy>=1.22
+Requires-Dist: onnxruntime
+Requires-Dist: vachanatts
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# PyThaiTTS
+Open Source Thai Text-to-speech library in Python
+
+[Google Colab](https://colab.research.google.com/github/PyThaiNLP/PyThaiTTS/blob/dev/notebook/use_lunarlist_model.ipynb) | [Docs](https://pythainlp.github.io/PyThaiTTS/) | [Notebooks](https://github.com/PyThaiNLP/PyThaiTTS/tree/dev/notebook)
+<a href="https://pepy.tech/project/pythaitts"><img alt="Download" src="https://pepy.tech/badge/pythaitts/month"/></a>
+
+License: [Apache-2.0 License](https://github.com/PyThaiNLP/pythaitts/blob/main/LICENSE)
+
+## Install
+
+Install by pip:
+
+> pip install pythaitts
+
+## Usage
+
+### Basic Usage
+
+```python
+from pythaitts import TTS
+
+tts = TTS()
+file = tts.tts("ภาษาไทย ง่าย มาก มาก", filename="cat.wav") # It will get wav file path.
+wave = tts.tts("ภาษาไทย ง่าย มาก มาก",return_type="waveform") # It will get waveform.
+```
+
+### Using Different TTS Models
+
+PyThaiTTS supports multiple TTS models. You can specify which model to use:
+
+```python
+from pythaitts import TTS
+
+# Use VachanaTTS (default voices: th_f_1, th_m_1, th_f_2, th_m_2)
+tts = TTS(pretrained="vachana")
+file = tts.tts("สวัสดีครับ", speaker_idx="th_f_1", filename="output.wav")
+
+# Use Lunarlist ONNX (default)
+tts = TTS(pretrained="lunarlist_onnx")
+file = tts.tts("ภาษาไทย ง่าย มาก", filename="output.wav")
+
+# Use KhanomTan
+tts = TTS(pretrained="khanomtan")
+file = tts.tts("ภาษาไทย", speaker_idx="Linda", filename="output.wav")
+```
+
+### Text Preprocessing
+
+PyThaiTTS includes automatic text preprocessing to improve TTS quality:
+- **Number to Thai text conversion**: Converts digits (e.g., "123") to Thai text (e.g., "หนึ่งร้อยยี่สิบสาม")
+- **Mai yamok (ๆ) expansion**: Expands the Thai repetition character (e.g., "ดีๆ" becomes "ดีดี")
+
+Preprocessing is enabled by default:
+
+```python
+from pythaitts import TTS
+
+tts = TTS()
+# Automatic preprocessing: "มี 5 คนๆ" becomes "มี ห้า คนคน"
+file = tts.tts("มี 5 คนๆ", filename="output.wav")
+```
+
+You can disable preprocessing if needed:
+
+```python
+file = tts.tts("มี 5 คนๆ", preprocess=False, filename="output.wav")
+```
+
+You can also use preprocessing functions directly:
+
+```python
+from pythaitts import num_to_thai, expand_maiyamok, preprocess_text
+
+# Convert numbers to Thai text
+print(num_to_thai("123"))  # Output: หนึ่งร้อยยี่สิบสาม
+
+# Expand mai yamok
+print(expand_maiyamok("ดีๆ"))  # Output: ดีดี
+
+# Full preprocessing
+print(preprocess_text("มี 5 คนๆ"))  # Output: มี ห้า คนคน
+```
+
+You can see more at [https://pythainlp.github.io/PyThaiTTS/](https://pythainlp.github.io/PyThaiTTS/).

pythaitts-0.4.0/PyThaiTTS.egg-info/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: PyThaiTTS
+Version: 0.4.0
+Summary: Open Source Thai Text-to-speech library in Python
+Home-page: https://github.com/pythainlp/pythaitts
+Author: Wannaphong
+Author-email: wannaphong@yahoo.com
+License: Apache Software License 2.0
+Project-URL: Documentation, https://github.com/pythainlp/pythaitts
+Project-URL: Source, https://github.com/pythainlp/pythaitts
+Project-URL: Bug Reports, https://github.com/pythainlp/pythaitts/issues
+Keywords: Thai,NLP,natural language processing,text analytics,text processing,localization,computational linguistics,text-to-speech
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Text Processing :: General
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: huggingface_hub
+Requires-Dist: numpy>=1.22
+Requires-Dist: onnxruntime
+Requires-Dist: vachanatts
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# PyThaiTTS
+Open Source Thai Text-to-speech library in Python
+
+[Google Colab](https://colab.research.google.com/github/PyThaiNLP/PyThaiTTS/blob/dev/notebook/use_lunarlist_model.ipynb) | [Docs](https://pythainlp.github.io/PyThaiTTS/) | [Notebooks](https://github.com/PyThaiNLP/PyThaiTTS/tree/dev/notebook)
+<a href="https://pepy.tech/project/pythaitts"><img alt="Download" src="https://pepy.tech/badge/pythaitts/month"/></a>
+
+License: [Apache-2.0 License](https://github.com/PyThaiNLP/pythaitts/blob/main/LICENSE)
+
+## Install
+
+Install by pip:
+
+> pip install pythaitts
+
+## Usage
+
+### Basic Usage
+
+```python
+from pythaitts import TTS
+
+tts = TTS()
+file = tts.tts("ภาษาไทย ง่าย มาก มาก", filename="cat.wav") # It will get wav file path.
+wave = tts.tts("ภาษาไทย ง่าย มาก มาก",return_type="waveform") # It will get waveform.
+```
+
+### Using Different TTS Models
+
+PyThaiTTS supports multiple TTS models. You can specify which model to use:
+
+```python
+from pythaitts import TTS
+
+# Use VachanaTTS (default voices: th_f_1, th_m_1, th_f_2, th_m_2)
+tts = TTS(pretrained="vachana")
+file = tts.tts("สวัสดีครับ", speaker_idx="th_f_1", filename="output.wav")
+
+# Use Lunarlist ONNX (default)
+tts = TTS(pretrained="lunarlist_onnx")
+file = tts.tts("ภาษาไทย ง่าย มาก", filename="output.wav")
+
+# Use KhanomTan
+tts = TTS(pretrained="khanomtan")
+file = tts.tts("ภาษาไทย", speaker_idx="Linda", filename="output.wav")
+```
+
+### Text Preprocessing
+
+PyThaiTTS includes automatic text preprocessing to improve TTS quality:
+- **Number to Thai text conversion**: Converts digits (e.g., "123") to Thai text (e.g., "หนึ่งร้อยยี่สิบสาม")
+- **Mai yamok (ๆ) expansion**: Expands the Thai repetition character (e.g., "ดีๆ" becomes "ดีดี")
+
+Preprocessing is enabled by default:
+
+```python
+from pythaitts import TTS
+
+tts = TTS()
+# Automatic preprocessing: "มี 5 คนๆ" becomes "มี ห้า คนคน"
+file = tts.tts("มี 5 คนๆ", filename="output.wav")
+```
+
+You can disable preprocessing if needed:
+
+```python
+file = tts.tts("มี 5 คนๆ", preprocess=False, filename="output.wav")
+```
+
+You can also use preprocessing functions directly:
+
+```python
+from pythaitts import num_to_thai, expand_maiyamok, preprocess_text
+
+# Convert numbers to Thai text
+print(num_to_thai("123"))  # Output: หนึ่งร้อยยี่สิบสาม
+
+# Expand mai yamok
+print(expand_maiyamok("ดีๆ"))  # Output: ดีดี
+
+# Full preprocessing
+print(preprocess_text("มี 5 คนๆ"))  # Output: มี ห้า คนคน
+```
+
+You can see more at [https://pythainlp.github.io/PyThaiTTS/](https://pythainlp.github.io/PyThaiTTS/).

{PyThaiTTS-0.3.0 → pythaitts-0.4.0}/PyThaiTTS.egg-info/SOURCES.txt

@@ -8,7 +8,12 @@ PyThaiTTS.egg-info/not-zip-safe
 PyThaiTTS.egg-info/requires.txt
 PyThaiTTS.egg-info/top_level.txt
 pythaitts/__init__.py
+pythaitts/preprocess.py
 pythaitts/pretrained/__init__.py
 pythaitts/pretrained/khanomtan_tts.py
 pythaitts/pretrained/lunarlist_model.py
-pythaitts/pretrained/lunarlist_onnx.py
+pythaitts/pretrained/lunarlist_onnx.py
+pythaitts/pretrained/vachana_tts.py
+tests/__init__.py
+tests/test_preprocess.py
+tests/test_vachana.py

{PyThaiTTS-0.3.0 → pythaitts-0.4.0}/PyThaiTTS.egg-info/requires.txt

@@ -1,3 +1,4 @@
 huggingface_hub
 numpy>=1.22
 onnxruntime
+vachanatts

{PyThaiTTS-0.3.0 → pythaitts-0.4.0}/PyThaiTTS.egg-info/top_level.txt

@@ -1 +1,2 @@
 pythaitts
+tests

pythaitts-0.4.0/README.md

@@ -0,0 +1,84 @@
+# PyThaiTTS
+Open Source Thai Text-to-speech library in Python
+
+[Google Colab](https://colab.research.google.com/github/PyThaiNLP/PyThaiTTS/blob/dev/notebook/use_lunarlist_model.ipynb) | [Docs](https://pythainlp.github.io/PyThaiTTS/) | [Notebooks](https://github.com/PyThaiNLP/PyThaiTTS/tree/dev/notebook)
+<a href="https://pepy.tech/project/pythaitts"><img alt="Download" src="https://pepy.tech/badge/pythaitts/month"/></a>
+
+License: [Apache-2.0 License](https://github.com/PyThaiNLP/pythaitts/blob/main/LICENSE)
+
+## Install
+
+Install by pip:
+
+> pip install pythaitts
+
+## Usage
+
+### Basic Usage
+
+```python
+from pythaitts import TTS
+
+tts = TTS()
+file = tts.tts("ภาษาไทย ง่าย มาก มาก", filename="cat.wav") # It will get wav file path.
+wave = tts.tts("ภาษาไทย ง่าย มาก มาก",return_type="waveform") # It will get waveform.
+```
+
+### Using Different TTS Models
+
+PyThaiTTS supports multiple TTS models. You can specify which model to use:
+
+```python
+from pythaitts import TTS
+
+# Use VachanaTTS (default voices: th_f_1, th_m_1, th_f_2, th_m_2)
+tts = TTS(pretrained="vachana")
+file = tts.tts("สวัสดีครับ", speaker_idx="th_f_1", filename="output.wav")
+
+# Use Lunarlist ONNX (default)
+tts = TTS(pretrained="lunarlist_onnx")
+file = tts.tts("ภาษาไทย ง่าย มาก", filename="output.wav")
+
+# Use KhanomTan
+tts = TTS(pretrained="khanomtan")
+file = tts.tts("ภาษาไทย", speaker_idx="Linda", filename="output.wav")
+```
+
+### Text Preprocessing
+
+PyThaiTTS includes automatic text preprocessing to improve TTS quality:
+- **Number to Thai text conversion**: Converts digits (e.g., "123") to Thai text (e.g., "หนึ่งร้อยยี่สิบสาม")
+- **Mai yamok (ๆ) expansion**: Expands the Thai repetition character (e.g., "ดีๆ" becomes "ดีดี")
+
+Preprocessing is enabled by default:
+
+```python
+from pythaitts import TTS
+
+tts = TTS()
+# Automatic preprocessing: "มี 5 คนๆ" becomes "มี ห้า คนคน"
+file = tts.tts("มี 5 คนๆ", filename="output.wav")
+```
+
+You can disable preprocessing if needed:
+
+```python
+file = tts.tts("มี 5 คนๆ", preprocess=False, filename="output.wav")
+```
+
+You can also use preprocessing functions directly:
+
+```python
+from pythaitts import num_to_thai, expand_maiyamok, preprocess_text
+
+# Convert numbers to Thai text
+print(num_to_thai("123"))  # Output: หนึ่งร้อยยี่สิบสาม
+
+# Expand mai yamok
+print(expand_maiyamok("ดีๆ"))  # Output: ดีดี
+
+# Full preprocessing
+print(preprocess_text("มี 5 คนๆ"))  # Output: มี ห้า คนคน
+```
+
+You can see more at [https://pythainlp.github.io/PyThaiTTS/](https://pythainlp.github.io/PyThaiTTS/).

{PyThaiTTS-0.3.0 → pythaitts-0.4.0}/pythaitts/__init__.py

@@ -4,14 +4,16 @@ PyThaiTTS
 """
 __version__ = "0.3.0"
 
+from pythaitts.preprocess import preprocess_text, num_to_thai, expand_maiyamok
+
 
 class TTS:
     def __init__(self, pretrained="lunarlist_onnx", mode="last_checkpoint", version="1.0", device:str="cpu") -> None:
         """
-        :param str pretrained: TTS pretrained (lunarlist_onnx, khanomtan, lunarlist)
-        :param str mode: pretrained mode (lunarlist_onnx don't support)
+        :param str pretrained: TTS pretrained (lunarlist_onnx, khanomtan, lunarlist, vachana)
+        :param str mode: pretrained mode (lunarlist_onnx and vachana don't support)
         :param str version: model version (default is 1.0 or 1.1)
-        :param str device: device for running model. (lunarlist_onnx support CPU only.)
+        :param str device: device for running model. (lunarlist_onnx and vachana support CPU only.)
 
         **Options for mode**
             * *last_checkpoint* (default) - last checkpoint of model
@@ -26,6 +28,8 @@ class TTS:
         For lunarlist_onnx tts model, \
         You can see more about lunarlist tts at `https://github.com/PyThaiNLP/thaitts-onnx <https://github.com/PyThaiNLP/thaitts-onnx>`_
 
+        For vachana tts model, \
+        You can see more about vachana tts at `https://github.com/VYNCX/VachanaTTS2 <https://github.com/VYNCX/VachanaTTS2>`_
 
         
         """
@@ -47,23 +51,34 @@ class TTS:
         elif self.pretrained == "lunarlist":
             from pythaitts.pretrained.lunarlist_model import LunarlistModel
             self.model = LunarlistModel(mode=self.mode, device=self.device)
+        elif self.pretrained == "vachana":
+            from pythaitts.pretrained.vachana_tts import VachanaTTS
+            self.model = VachanaTTS()
         else:
-            raise NotImplemented(
+            raise NotImplementedError(
                 "PyThaiTTS doesn't support %s pretrained." % self.pretrained
             )
 
-    def tts(self, text: str, speaker_idx: str = "Linda", language_idx: str = "th-th", return_type: str = "file", filename: str = None):
+    def tts(self, text: str, speaker_idx: str = "Linda", language_idx: str = "th-th", return_type: str = "file", filename: str = None, preprocess: bool = True):
         """
         speech synthesis
 
         :param str text: text
-        :param str speaker_idx: speaker (default is Linda)
+        :param str speaker_idx: speaker (default is Linda for khanomtan, th_f_1 for vachana)
         :param str language_idx: language (default is th-th)
         :param str return_type: return type (default is file)
         :param str filename: path filename for save wav file if return_type is file.
+        :param bool preprocess: whether to preprocess text (convert numbers to Thai text and expand ๆ). Default is True.
         """
+        # Preprocess text if requested
+        if preprocess:
+            from pythaitts.preprocess import preprocess_text
+            text = preprocess_text(text)
+        
         if self.pretrained == "lunarlist" or self.pretrained == "lunarlist_onnx":
             return self.model(text=text,return_type=return_type,filename=filename)
+        elif self.pretrained == "vachana":
+            return self.model(text=text,speaker_idx=speaker_idx,return_type=return_type,filename=filename)
         return self.model(
             text=text,
             speaker_idx=speaker_idx,

pythaitts-0.4.0/pythaitts/preprocess.py

@@ -0,0 +1,254 @@
+# -*- coding: utf-8 -*-
+"""
+Thai Text Preprocessing for TTS
+
+This module provides text preprocessing functions for Thai Text-to-Speech,
+including number to Thai text conversion and handling of Thai repetition character (ๆ).
+"""
+import re
+
+
+# Thai number words
+THAI_ONES = ["", "หนึ่ง", "สอง", "สาม", "สี่", "ห้า", "หก", "เจ็ด", "แปด", "เก้า"]
+THAI_TENS = ["", "สิบ", "ยี่สิบ", "สามสิบ", "สี่สิบ", "ห้าสิบ", "หกสิบ", "เจ็ดสิบ", "แปดสิบ", "เก้าสิบ"]
+
+
+def _num_to_thai_under_hundred(num: int) -> str:
+    """
+    Convert numbers 0-99 to Thai text.
+    
+    :param int num: Number to convert (0-99)
+    :return: Thai text representation
+    :rtype: str
+    """
+    if num == 0:
+        return "ศูนย์"
+    elif num < 10:
+        return THAI_ONES[num]
+    elif num < 20:
+        if num == 10:
+            return "สิบ"
+        elif num == 11:
+            return "สิบเอ็ด"
+        else:
+            return "สิบ" + THAI_ONES[num % 10]
+    elif num < 100:
+        tens = num // 10
+        ones = num % 10
+        result = THAI_TENS[tens]
+        if ones == 1:
+            result += "เอ็ด"
+        elif ones > 1:
+            result += THAI_ONES[ones]
+        return result
+    return ""
+
+
+def _num_to_thai_under_thousand(num: int) -> str:
+    """
+    Convert numbers 0-999 to Thai text.
+    
+    :param int num: Number to convert (0-999)
+    :return: Thai text representation
+    :rtype: str
+    """
+    if num < 100:
+        return _num_to_thai_under_hundred(num)
+    
+    hundreds = num // 100
+    remainder = num % 100
+    
+    if hundreds == 1:
+        result = "หนึ่งร้อย"
+    elif hundreds == 2:
+        result = "สองร้อย"
+    else:
+        result = THAI_ONES[hundreds] + "ร้อย"
+    
+    if remainder > 0:
+        result += _num_to_thai_under_hundred(remainder)
+    
+    return result
+
+
+def num_to_thai(num_str: str) -> str:
+    """
+    Convert number string to Thai text.
+    Supports integers and decimals.
+    
+    :param str num_str: Number string to convert (e.g., "123", "1234", "12.5")
+    :return: Thai text representation
+    :rtype: str
+    
+    Examples:
+        >>> num_to_thai("0")
+        'ศูนย์'
+        >>> num_to_thai("123")
+        'หนึ่งร้อยยี่สิบสาม'
+        >>> num_to_thai("1000")
+        'หนึ่งพัน'
+    """
+    # Handle decimal numbers
+    if '.' in num_str:
+        integer_part, decimal_part = num_str.split('.')
+        result = num_to_thai(integer_part) + "จุด"
+        for digit in decimal_part:
+            result += THAI_ONES[int(digit)] if int(digit) > 0 else "ศูนย์"
+        return result
+    
+    # Convert to integer
+    try:
+        num = int(num_str)
+    except ValueError:
+        return num_str  # Return original if cannot convert
+    
+    if num == 0:
+        return "ศูนย์"
+    
+    if num < 0:
+        return "ลบ" + num_to_thai(str(-num))
+    
+    # Handle numbers by magnitude
+    if num < 1000:
+        return _num_to_thai_under_thousand(num)
+    elif num < 10000:
+        thousands = num // 1000
+        remainder = num % 1000
+        result = THAI_ONES[thousands] + "พัน"
+        if remainder > 0:
+            result += _num_to_thai_under_thousand(remainder)
+        return result
+    elif num < 100000:
+        ten_thousands = num // 10000
+        remainder = num % 10000
+        if ten_thousands == 1:
+            result = "หนึ่งหมื่น"
+        elif ten_thousands == 2:
+            result = "สองหมื่น"
+        else:
+            result = THAI_ONES[ten_thousands] + "หมื่น"
+        if remainder > 0:
+            thousands = remainder // 1000
+            if thousands > 0:
+                result += THAI_ONES[thousands] + "พัน"
+            remainder = remainder % 1000
+            if remainder > 0:
+                result += _num_to_thai_under_thousand(remainder)
+        return result
+    elif num < 1000000:
+        hundred_thousands = num // 100000
+        remainder = num % 100000
+        result = THAI_ONES[hundred_thousands] + "แสน"
+        if remainder > 0:
+            ten_thousands = remainder // 10000
+            if ten_thousands > 0:
+                result += THAI_ONES[ten_thousands] + "หมื่น"
+            remainder = remainder % 10000
+            thousands = remainder // 1000
+            if thousands > 0:
+                result += THAI_ONES[thousands] + "พัน"
+            remainder = remainder % 1000
+            if remainder > 0:
+                result += _num_to_thai_under_thousand(remainder)
+        return result
+    elif num < 10000000:
+        millions = num // 1000000
+        remainder = num % 1000000
+        result = THAI_ONES[millions] + "ล้าน"
+        if remainder > 0:
+            result += num_to_thai(str(remainder))
+        return result
+    else:
+        # For very large numbers, use a simple approach
+        millions = num // 1000000
+        remainder = num % 1000000
+        result = num_to_thai(str(millions)) + "ล้าน"
+        if remainder > 0:
+            result += num_to_thai(str(remainder))
+        return result
+
+
+def expand_maiyamok(text: str) -> str:
+    """
+    Expand Thai repetition character (ๆ) by repeating the previous word or syllable.
+    
+    The mai yamok (ๆ) is a Thai repetition mark that indicates the previous 
+    word or syllable should be repeated.
+    
+    :param str text: Text containing ๆ character
+    :return: Text with ๆ expanded
+    :rtype: str
+    
+    Examples:
+        >>> expand_maiyamok("ช้าๆ")
+        'ช้าช้า'
+        >>> expand_maiyamok("ดีๆ")
+        'ดีดี'
+    """
+    if 'ๆ' not in text:
+        return text
+    
+    result = []
+    i = 0
+    while i < len(text):
+        if text[i] == 'ๆ':
+            # Find the previous word/syllable to repeat
+            if result:
+                # Look back to find the word to repeat
+                # Thai words are typically separated by spaces or are continuous
+                # We'll repeat the last word or syllable
+                prev_text = ''.join(result)
+                
+                # Find the last word (sequence of Thai characters)
+                thai_char_pattern = r'[ก-๙]+'
+                matches = list(re.finditer(thai_char_pattern, prev_text))
+                if matches:
+                    last_match = matches[-1]
+                    word_to_repeat = last_match.group()
+                    result.append(word_to_repeat)
+                else:
+                    # If no Thai characters found, just skip the ๆ
+                    pass
+            i += 1
+        else:
+            result.append(text[i])
+            i += 1
+    
+    return ''.join(result)
+
+
+def preprocess_text(text: str, expand_numbers: bool = True, expand_maiyamok_char: bool = True) -> str:
+    """
+    Preprocess Thai text for TTS by converting numbers to text and expanding ๆ.
+    
+    :param str text: Input text to preprocess
+    :param bool expand_numbers: Whether to convert numbers to Thai text (default: True)
+    :param bool expand_maiyamok_char: Whether to expand ๆ character (default: True)
+    :return: Preprocessed text
+    :rtype: str
+    
+    Examples:
+        >>> preprocess_text("ฉันมี 123 บาท")
+        'ฉันมี หนึ่งร้อยยี่สิบสาม บาท'
+        >>> preprocess_text("ดีๆ")
+        'ดีดี'
+        >>> preprocess_text("มี 5 คนๆ")
+        'มี ห้า คนคน'
+    """
+    result = text
+    
+    # Expand mai yamok (ๆ) first
+    if expand_maiyamok_char:
+        result = expand_maiyamok(result)
+    
+    # Convert numbers to Thai text
+    if expand_numbers:
+        # Find all numbers in the text and replace them
+        def replace_number(match):
+            return num_to_thai(match.group())
+        
+        # Match integers and decimals, including optional negative sign
+        # Handles: -5, 123, 123.45
+        result = re.sub(r'-?\d+(?:\.\d+)?', replace_number, result)
+    
+    return result

pythaitts-0.4.0/pythaitts/pretrained/vachana_tts.py

@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*-
+"""
+VachanaTTS2 model
+
+VachanaTTS2 is a Thai text-to-speech model built on VITS architecture.
+It supports multiple Thai voices and is optimized for both CPU and GPU usage.
+
+See more: https://github.com/VYNCX/VachanaTTS2
+"""
+import tempfile
+import wave
+import numpy as np
+import os
+
+
+class VachanaTTS:
+    # Supported voice options
+    SUPPORTED_VOICES = ["th_f_1", "th_m_1", "th_f_2", "th_m_2"]
+    
+    def __init__(self) -> None:
+        """
+        Initialize VachanaTTS model.
+        The model will be automatically downloaded from HuggingFace on first use.
+        """
+        try:
+            from vachanatts import TTS as VachanaTTS_TTS
+            self.tts_func = VachanaTTS_TTS
+        except ImportError:
+            raise ImportError(
+                "vachanatts is not installed. Please install it with: pip install vachanatts"
+            )
+
+    def __call__(self, text: str, speaker_idx: str = "th_f_1", return_type: str = "file", filename: str = None, **kwargs):
+        """
+        Generate speech from text using VachanaTTS.
+
+        :param str text: Input text to synthesize
+        :param str speaker_idx: Voice to use (th_f_1, th_m_1, th_f_2, th_m_2). Default is "th_f_1"
+        :param str return_type: Return type ("file" or "waveform")
+        :param str filename: Output filename for the generated audio
+        :param kwargs: Additional parameters (volume, speed, noise_scale, noise_w_scale)
+        :return: File path if return_type is "file", otherwise audio waveform data
+        """
+        # Validate speaker_idx
+        if speaker_idx not in self.SUPPORTED_VOICES:
+            raise ValueError(
+                f"Unsupported voice '{speaker_idx}'. Supported voices are: {', '.join(self.SUPPORTED_VOICES)}"
+            )
+        
+        # Extract additional parameters with defaults
+        volume = kwargs.get('volume', 1.0)
+        speed = kwargs.get('speed', 1.0)
+        noise_scale = kwargs.get('noise_scale', 0.667)
+        noise_w_scale = kwargs.get('noise_w_scale', 0.8)
+
+        if return_type == "waveform":
+            # For waveform return, we need to generate to a temp file then read it
+            temp_filename = None
+            try:
+                with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as fp:
+                    temp_filename = fp.name
+                
+                # Generate the audio file
+                self.tts_func(
+                    text,
+                    voice=speaker_idx,
+                    output=temp_filename,
+                    volume=volume,
+                    speed=speed,
+                    noise_scale=noise_scale,
+                    noise_w_scale=noise_w_scale
+                )
+                
+                # Read the waveform from the file
+                with wave.open(temp_filename, 'rb') as wav_file:
+                    n_frames = wav_file.getnframes()
+                    audio_data = wav_file.readframes(n_frames)
+                    sample_width = wav_file.getsampwidth()
+                    
+                    # Convert bytes to numpy array based on sample width
+                    if sample_width == 1:
+                        waveform = np.frombuffer(audio_data, dtype=np.int8)
+                    elif sample_width == 2:
+                        waveform = np.frombuffer(audio_data, dtype=np.int16)
+                    elif sample_width == 4:
+                        waveform = np.frombuffer(audio_data, dtype=np.int32)
+                    else:
+                        raise ValueError(f"Unsupported sample width: {sample_width} bytes")
+                
+                return waveform
+            finally:
+                # Clean up temp file
+                if temp_filename and os.path.exists(temp_filename):
+                    os.unlink(temp_filename)
+        else:
+            # File output
+            if filename is None:
+                with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as fp:
+                    filename = fp.name
+            
+            self.tts_func(
+                text,
+                voice=speaker_idx,
+                output=filename,
+                volume=volume,
+                speed=speed,
+                noise_scale=noise_scale,
+                noise_w_scale=noise_w_scale
+            )
+            
+            return filename

{PyThaiTTS-0.3.0 → pythaitts-0.4.0}/setup.py

@@ -9,7 +9,7 @@ with open("requirements.txt","r",encoding="utf-8-sig") as f:
 
 setup(
     name="PyThaiTTS",
-    version="0.3.0",
+    version="0.4.0",
     description="Open Source Thai Text-to-speech library in Python",
     long_description=readme,
     long_description_content_type="text/markdown",

pythaitts-0.4.0/tests/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+Tests for PyThaiTTS
+"""

pythaitts-0.4.0/tests/test_preprocess.py

@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*-
+"""
+Unit tests for Thai text preprocessing module
+"""
+import unittest
+from pythaitts.preprocess import num_to_thai, expand_maiyamok, preprocess_text
+
+
+class TestNumToThai(unittest.TestCase):
+    """Test number to Thai text conversion"""
+    
+    def test_single_digits(self):
+        """Test single digit numbers"""
+        self.assertEqual(num_to_thai("0"), "ศูนย์")
+        self.assertEqual(num_to_thai("1"), "หนึ่ง")
+        self.assertEqual(num_to_thai("5"), "ห้า")
+        self.assertEqual(num_to_thai("9"), "เก้า")
+    
+    def test_tens(self):
+        """Test numbers 10-99"""
+        self.assertEqual(num_to_thai("10"), "สิบ")
+        self.assertEqual(num_to_thai("11"), "สิบเอ็ด")
+        self.assertEqual(num_to_thai("15"), "สิบห้า")
+        self.assertEqual(num_to_thai("20"), "ยี่สิบ")
+        self.assertEqual(num_to_thai("21"), "ยี่สิบเอ็ด")
+        self.assertEqual(num_to_thai("99"), "เก้าสิบเก้า")
+    
+    def test_hundreds(self):
+        """Test numbers 100-999"""
+        self.assertEqual(num_to_thai("100"), "หนึ่งร้อย")
+        self.assertEqual(num_to_thai("123"), "หนึ่งร้อยยี่สิบสาม")
+        self.assertEqual(num_to_thai("200"), "สองร้อย")
+        self.assertEqual(num_to_thai("999"), "เก้าร้อยเก้าสิบเก้า")
+    
+    def test_thousands(self):
+        """Test numbers 1000-9999"""
+        self.assertEqual(num_to_thai("1000"), "หนึ่งพัน")
+        self.assertEqual(num_to_thai("1234"), "หนึ่งพันสองร้อยสามสิบสี่")
+        self.assertEqual(num_to_thai("5000"), "ห้าพัน")
+    
+    def test_ten_thousands(self):
+        """Test numbers 10000-99999"""
+        self.assertEqual(num_to_thai("10000"), "หนึ่งหมื่น")
+        self.assertEqual(num_to_thai("50000"), "ห้าหมื่น")
+    
+    def test_negative_numbers(self):
+        """Test negative numbers"""
+        self.assertEqual(num_to_thai("-5"), "ลบห้า")
+        self.assertEqual(num_to_thai("-123"), "ลบหนึ่งร้อยยี่สิบสาม")
+    
+    def test_decimal_numbers(self):
+        """Test decimal numbers"""
+        result = num_to_thai("12.5")
+        self.assertIn("จุด", result)
+        self.assertIn("สิบสอง", result)
+        self.assertIn("ห้า", result)
+
+
+class TestExpandMaiyamok(unittest.TestCase):
+    """Test Thai repetition character (ๆ) expansion"""
+    
+    def test_basic_maiyamok(self):
+        """Test basic mai yamok expansion"""
+        self.assertEqual(expand_maiyamok("ดีๆ"), "ดีดี")
+        self.assertEqual(expand_maiyamok("ช้าๆ"), "ช้าช้า")
+        self.assertEqual(expand_maiyamok("คนๆ"), "คนคน")
+    
+    def test_no_maiyamok(self):
+        """Test text without mai yamok"""
+        self.assertEqual(expand_maiyamok("ภาษาไทย"), "ภาษาไทย")
+        self.assertEqual(expand_maiyamok("สวัสดี"), "สวัสดี")
+    
+    def test_maiyamok_in_sentence(self):
+        """Test mai yamok in longer sentences"""
+        result = expand_maiyamok("เดินช้าๆ")
+        self.assertNotIn("ๆ", result)
+        self.assertIn("ช้า", result)
+
+
+class TestPreprocessText(unittest.TestCase):
+    """Test full text preprocessing"""
+    
+    def test_number_conversion(self):
+        """Test number conversion in text"""
+        result = preprocess_text("ฉันมี 123 บาท")
+        self.assertNotIn("123", result)
+        self.assertIn("หนึ่งร้อยยี่สิบสาม", result)
+    
+    def test_maiyamok_expansion(self):
+        """Test mai yamok expansion in text"""
+        result = preprocess_text("ดีๆ")
+        self.assertEqual(result, "ดีดี")
+    
+    def test_combined_preprocessing(self):
+        """Test both number conversion and mai yamok expansion"""
+        result = preprocess_text("มี 5 คนๆ")
+        self.assertNotIn("5", result)
+        self.assertNotIn("ๆ", result)
+        self.assertIn("ห้า", result)
+        self.assertIn("คนคน", result)
+    
+    def test_no_preprocessing_numbers(self):
+        """Test with number preprocessing disabled"""
+        result = preprocess_text("มี 5 คน", expand_numbers=False)
+        self.assertIn("5", result)
+    
+    def test_no_preprocessing_maiyamok(self):
+        """Test with mai yamok preprocessing disabled"""
+        result = preprocess_text("ดีๆ", expand_maiyamok_char=False)
+        self.assertIn("ๆ", result)
+    
+    def test_empty_text(self):
+        """Test empty text"""
+        result = preprocess_text("")
+        self.assertEqual(result, "")
+    
+    def test_text_without_preprocessing_needs(self):
+        """Test text that doesn't need preprocessing"""
+        text = "ภาษาไทย ง่าย มาก"
+        result = preprocess_text(text)
+        self.assertEqual(result, text)
+
+
+if __name__ == '__main__':
+    unittest.main()

pythaitts-0.4.0/tests/test_vachana.py

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+"""
+Unit tests for VachanaTTS integration
+"""
+import unittest
+from unittest.mock import Mock, patch, MagicMock
+import numpy as np
+from pythaitts import TTS
+
+
+class TestVachanaIntegration(unittest.TestCase):
+    """Test VachanaTTS integration"""
+
+    @patch('pythaitts.pretrained.vachana_tts.VachanaTTS')
+    def test_vachana_model_initialization(self, mock_vachana):
+        """Test that VachanaTTS model can be initialized"""
+        # Create TTS instance with vachana model
+        tts = TTS(pretrained="vachana")
+        
+        # Verify model is loaded
+        self.assertIsNotNone(tts.model)
+        self.assertEqual(tts.pretrained, "vachana")
+
+    @patch('pythaitts.pretrained.vachana_tts.VachanaTTS')
+    def test_vachana_tts_call(self, mock_vachana_class):
+        """Test calling tts method with vachana model"""
+        # Setup mock
+        mock_instance = Mock()
+        mock_instance.return_value = "/tmp/output.wav"
+        mock_vachana_class.return_value = mock_instance
+        
+        # Create TTS instance
+        tts = TTS(pretrained="vachana")
+        
+        # Call tts method
+        result = tts.tts("สวัสดีครับ", speaker_idx="th_f_1", filename="/tmp/test.wav")
+        
+        # Verify the model was called with correct parameters
+        mock_instance.assert_called_once()
+        call_args = mock_instance.call_args
+        self.assertEqual(call_args.kwargs['text'], "สวัสดีครับ")
+        self.assertEqual(call_args.kwargs['speaker_idx'], "th_f_1")
+        self.assertEqual(call_args.kwargs['filename'], "/tmp/test.wav")
+        self.assertEqual(call_args.kwargs['return_type'], "file")
+
+    @patch('pythaitts.pretrained.vachana_tts.VachanaTTS')
+    def test_vachana_with_preprocessing(self, mock_vachana_class):
+        """Test that preprocessing works with vachana model"""
+        # Setup mock
+        mock_instance = Mock()
+        mock_instance.return_value = "/tmp/output.wav"
+        mock_vachana_class.return_value = mock_instance
+        
+        # Create TTS instance
+        tts = TTS(pretrained="vachana")
+        
+        # Call tts method with text that needs preprocessing
+        result = tts.tts("มี 5 คนๆ", speaker_idx="th_f_1", preprocess=True)
+        
+        # Verify preprocessing was applied
+        mock_instance.assert_called_once()
+        call_args = mock_instance.call_args
+        processed_text = call_args.kwargs['text']
+        
+        # Text should have numbers converted and ๆ expanded
+        self.assertNotIn("5", processed_text)
+        self.assertNotIn("ๆ", processed_text)
+        self.assertIn("ห้า", processed_text)
+        self.assertIn("คนคน", processed_text)
+
+    @patch('pythaitts.pretrained.vachana_tts.VachanaTTS')
+    def test_vachana_all_supported_voices(self, mock_vachana_class):
+        """Test that all supported voices work correctly"""
+        # Setup mock
+        mock_instance = Mock()
+        mock_instance.return_value = "/tmp/output.wav"
+        mock_vachana_class.return_value = mock_instance
+        
+        # Create TTS instance
+        tts = TTS(pretrained="vachana")
+        
+        # Test all supported voices
+        supported_voices = ["th_f_1", "th_m_1", "th_f_2", "th_m_2"]
+        for voice in supported_voices:
+            mock_instance.reset_mock()
+            result = tts.tts("สวัสดี", speaker_idx=voice)
+            
+            # Verify the voice was passed correctly
+            call_args = mock_instance.call_args
+            self.assertEqual(call_args.kwargs['speaker_idx'], voice)
+
+    @patch('pythaitts.pretrained.vachana_tts.VachanaTTS')
+    def test_vachana_waveform_return(self, mock_vachana_class):
+        """Test waveform return type functionality"""
+        # Setup mock
+        mock_instance = Mock()
+        mock_waveform = np.array([0.1, 0.2, 0.3, 0.4])
+        mock_instance.return_value = mock_waveform
+        mock_vachana_class.return_value = mock_instance
+        
+        # Create TTS instance
+        tts = TTS(pretrained="vachana")
+        
+        # Call tts method with waveform return type
+        result = tts.tts("สวัสดี", speaker_idx="th_f_1", return_type="waveform")
+        
+        # Verify the return type was set correctly
+        call_args = mock_instance.call_args
+        self.assertEqual(call_args.kwargs['return_type'], "waveform")
+
+
+if __name__ == '__main__':
+    unittest.main()

PyThaiTTS-0.3.0/PKG-INFO

@@ -1,51 +0,0 @@
-Metadata-Version: 2.1
-Name: PyThaiTTS
-Version: 0.3.0
-Summary: Open Source Thai Text-to-speech library in Python
-Home-page: https://github.com/pythainlp/pythaitts
-Author: Wannaphong
-Author-email: wannaphong@yahoo.com
-License: Apache Software License 2.0
-Project-URL: Documentation, https://github.com/pythainlp/pythaitts
-Project-URL: Source, https://github.com/pythainlp/pythaitts
-Project-URL: Bug Reports, https://github.com/pythainlp/pythaitts/issues
-Keywords: Thai,NLP,natural language processing,text analytics,text processing,localization,computational linguistics,text-to-speech
-Classifier: Development Status :: 3 - Alpha
-Classifier: Programming Language :: Python :: 3
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Classifier: Topic :: Text Processing
-Classifier: Topic :: Text Processing :: General
-Classifier: Topic :: Text Processing :: Linguistic
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: huggingface_hub
-Requires-Dist: numpy>=1.22
-Requires-Dist: onnxruntime
-
-# PyThaiTTS
-Open Source Thai Text-to-speech library in Python
-
-[Google Colab](https://colab.research.google.com/github/PyThaiNLP/PyThaiTTS/blob/dev/notebook/use_lunarlist_model.ipynb) | [Docs](https://pythainlp.github.io/PyThaiTTS/) | [Notebooks](https://github.com/PyThaiNLP/PyThaiTTS/tree/dev/notebook)
-
-License: [Apache-2.0 License](https://github.com/PyThaiNLP/pythaitts/blob/main/LICENSE)
-
-## Install
-
-Install by pip:
-
-> pip install pythaitts
-
-## Usage
-
-```python
-from pythaitts import TTS
-
-tts = TTS()
-file = tts.tts("ภาษาไทย ง่าย มาก มาก", filename="cat.wav") # It will get wav file path.
-wave = tts.tts("ภาษาไทย ง่าย มาก มาก",return_type="waveform") # It will get waveform.
-```
-
-You can see more at [https://pythainlp.github.io/PyThaiTTS/](https://pythainlp.github.io/PyThaiTTS/).

PyThaiTTS-0.3.0/PyThaiTTS.egg-info/PKG-INFO

@@ -1,51 +0,0 @@
-Metadata-Version: 2.1
-Name: PyThaiTTS
-Version: 0.3.0
-Summary: Open Source Thai Text-to-speech library in Python
-Home-page: https://github.com/pythainlp/pythaitts
-Author: Wannaphong
-Author-email: wannaphong@yahoo.com
-License: Apache Software License 2.0
-Project-URL: Documentation, https://github.com/pythainlp/pythaitts
-Project-URL: Source, https://github.com/pythainlp/pythaitts
-Project-URL: Bug Reports, https://github.com/pythainlp/pythaitts/issues
-Keywords: Thai,NLP,natural language processing,text analytics,text processing,localization,computational linguistics,text-to-speech
-Classifier: Development Status :: 3 - Alpha
-Classifier: Programming Language :: Python :: 3
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Classifier: Topic :: Text Processing
-Classifier: Topic :: Text Processing :: General
-Classifier: Topic :: Text Processing :: Linguistic
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: huggingface_hub
-Requires-Dist: numpy>=1.22
-Requires-Dist: onnxruntime
-
-# PyThaiTTS
-Open Source Thai Text-to-speech library in Python
-
-[Google Colab](https://colab.research.google.com/github/PyThaiNLP/PyThaiTTS/blob/dev/notebook/use_lunarlist_model.ipynb) | [Docs](https://pythainlp.github.io/PyThaiTTS/) | [Notebooks](https://github.com/PyThaiNLP/PyThaiTTS/tree/dev/notebook)
-
-License: [Apache-2.0 License](https://github.com/PyThaiNLP/pythaitts/blob/main/LICENSE)
-
-## Install
-
-Install by pip:
-
-> pip install pythaitts
-
-## Usage
-
-```python
-from pythaitts import TTS
-
-tts = TTS()
-file = tts.tts("ภาษาไทย ง่าย มาก มาก", filename="cat.wav") # It will get wav file path.
-wave = tts.tts("ภาษาไทย ง่าย มาก มาก",return_type="waveform") # It will get waveform.
-```
-
-You can see more at [https://pythainlp.github.io/PyThaiTTS/](https://pythainlp.github.io/PyThaiTTS/).

PyThaiTTS-0.3.0/README.md

@@ -1,24 +0,0 @@
-# PyThaiTTS
-Open Source Thai Text-to-speech library in Python
-
-[Google Colab](https://colab.research.google.com/github/PyThaiNLP/PyThaiTTS/blob/dev/notebook/use_lunarlist_model.ipynb) | [Docs](https://pythainlp.github.io/PyThaiTTS/) | [Notebooks](https://github.com/PyThaiNLP/PyThaiTTS/tree/dev/notebook)
-
-License: [Apache-2.0 License](https://github.com/PyThaiNLP/pythaitts/blob/main/LICENSE)
-
-## Install
-
-Install by pip:
-
-> pip install pythaitts
-
-## Usage
-
-```python
-from pythaitts import TTS
-
-tts = TTS()
-file = tts.tts("ภาษาไทย ง่าย มาก มาก", filename="cat.wav") # It will get wav file path.
-wave = tts.tts("ภาษาไทย ง่าย มาก มาก",return_type="waveform") # It will get waveform.
-```
-
-You can see more at [https://pythainlp.github.io/PyThaiTTS/](https://pythainlp.github.io/PyThaiTTS/).