indic-tts-preprocess 0.1.1__tar.gz

indic_tts_preprocess-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dhruv
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

indic_tts_preprocess-0.1.1/PKG-INFO

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: indic-tts-preprocess
+Version: 0.1.1
+Summary: Convert numbers and dates in Indic text to spoken words for TTS models
+Author-email: Dhruv Dornal <dhruvdornal2003@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Dhruv
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Keywords: tts,indic,hindi,marathi,nlp,text-to-speech,preprocessing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Natural Language :: Hindi
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# indic-tts-preprocess
+
+A small Python library that fixes one specific but very annoying problem with open-source Indic TTS models: **they cannot read numbers**.
+
+Models like [ai4bharat/indic-parler-tts](https://huggingface.co/ai4bharat/indic-parler-tts) hallucinate badly when the input text contains raw digits. Feed them `"1997 में"` and you get garbled audio. Feed them `"उन्नीस सौ सत्तानवे में"` and it works perfectly.
+
+This library does that conversion for you — numbers, years, dates — before the text ever reaches the tokenizer.
+
+---
+
+## Install
+
+```bash
+pip install indic-tts-preprocess
+```
+
+No dependencies. Pure Python. Works on Python 3.8 and above.
+
+---
+
+## Quick start
+
+```python
+from indic_tts_preprocess import preprocess
+
+# Hindi
+preprocess("उनका जन्म 5 अगस्त 1997 को हुआ", "hi")
+# -> "उनका जन्म पाँच अगस्त उन्नीस सौ सत्तानवे को हुआ"
+
+# Marathi
+preprocess("त्यांचा जन्म 15 ऑगस्ट 1947 रोजी झाला", "mr")
+# -> "त्यांचा जन्म पंधरा ऑगस्ट एकोणीस शे सत्तेचाळीस रोजी झाला"
+
+# English
+preprocess("He was born on 15 August 1947", "en")
+# -> "He was born on fifteen August nineteen forty seven"
+```
+
+---
+
+## Supported languages
+
+| Code | Language |
+|------|----------|
+| `hi` | Hindi    |
+| `mr` | Marathi  |
+| `en` | English  |
+
+If you pass an unsupported language code, the text comes back unchanged — nothing crashes.
+
+---
+
+## What it handles
+
+**Date formats**
+
+| Input | Language | Output |
+|-------|----------|--------|
+| `5 अगस्त 2004` | hi | `पाँच अगस्त दो हज़ार चार` |
+| `05/08/2004` | hi | `पाँच अगस्त दो हज़ार चार` |
+| `05-08-2004` | hi | `पाँच अगस्त दो हज़ार चार` |
+| `15 August 1947` | en | `fifteen August nineteen forty seven` |
+| `15/08/1947` | en | `fifteen August nineteen forty seven` |
+
+**Standalone numbers**
+
+| Input | Language | Output |
+|-------|----------|--------|
+| `73` | hi | `तिहत्तर` |
+| `1997` | hi | `उन्नीस सौ सत्तानवे` |
+| `2024` | en | `two thousand twenty four` |
+| `1905` | en | `nineteen oh five` |
+
+**Year handling** (the tricky part)
+
+Hindi and Marathi speakers say years in the 1900s differently from how you'd read them literally:
+- `1997` → `उन्नीस सौ सत्तानवे` (not `एक हज़ार नौ सौ सत्तानवे`)
+
+English speakers do the same:
+- `1997` → `nineteen ninety seven` (not `one thousand nine hundred ninety seven`)
+- `1905` → `nineteen oh five`
+
+The library handles all of these correctly.
+
+---
+
+## API reference
+
+### `preprocess(text, lang)`
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `text` | `str` | The raw input text containing digits/dates |
+| `lang` | `str` | Language code: `"hi"`, `"mr"`, or `"en"` |
+
+Returns `str` — the same text with all digits replaced by spoken words.
+
+Raises `TypeError` if `text` is not a string.
+
+---
+
+## Contributing
+
+Adding a new language is straightforward:
+
+1. Create `indic_tts_preprocess/languages/yourlang.py` — look at `hindi.py` as a template
+2. Add a `preprocess(text)` function and a `num_to_words(n)` function
+3. Add the new language code in `core.py`
+4. Add tests in `tests/test_yourlang.py`
+5. Open a pull request
+
+---
+
+## License
+
+MIT

indic_tts_preprocess-0.1.1/README.md

@@ -0,0 +1,116 @@
+# indic-tts-preprocess
+
+A small Python library that fixes one specific but very annoying problem with open-source Indic TTS models: **they cannot read numbers**.
+
+Models like [ai4bharat/indic-parler-tts](https://huggingface.co/ai4bharat/indic-parler-tts) hallucinate badly when the input text contains raw digits. Feed them `"1997 में"` and you get garbled audio. Feed them `"उन्नीस सौ सत्तानवे में"` and it works perfectly.
+
+This library does that conversion for you — numbers, years, dates — before the text ever reaches the tokenizer.
+
+---
+
+## Install
+
+```bash
+pip install indic-tts-preprocess
+```
+
+No dependencies. Pure Python. Works on Python 3.8 and above.
+
+---
+
+## Quick start
+
+```python
+from indic_tts_preprocess import preprocess
+
+# Hindi
+preprocess("उनका जन्म 5 अगस्त 1997 को हुआ", "hi")
+# -> "उनका जन्म पाँच अगस्त उन्नीस सौ सत्तानवे को हुआ"
+
+# Marathi
+preprocess("त्यांचा जन्म 15 ऑगस्ट 1947 रोजी झाला", "mr")
+# -> "त्यांचा जन्म पंधरा ऑगस्ट एकोणीस शे सत्तेचाळीस रोजी झाला"
+
+# English
+preprocess("He was born on 15 August 1947", "en")
+# -> "He was born on fifteen August nineteen forty seven"
+```
+
+---
+
+## Supported languages
+
+| Code | Language |
+|------|----------|
+| `hi` | Hindi    |
+| `mr` | Marathi  |
+| `en` | English  |
+
+If you pass an unsupported language code, the text comes back unchanged — nothing crashes.
+
+---
+
+## What it handles
+
+**Date formats**
+
+| Input | Language | Output |
+|-------|----------|--------|
+| `5 अगस्त 2004` | hi | `पाँच अगस्त दो हज़ार चार` |
+| `05/08/2004` | hi | `पाँच अगस्त दो हज़ार चार` |
+| `05-08-2004` | hi | `पाँच अगस्त दो हज़ार चार` |
+| `15 August 1947` | en | `fifteen August nineteen forty seven` |
+| `15/08/1947` | en | `fifteen August nineteen forty seven` |
+
+**Standalone numbers**
+
+| Input | Language | Output |
+|-------|----------|--------|
+| `73` | hi | `तिहत्तर` |
+| `1997` | hi | `उन्नीस सौ सत्तानवे` |
+| `2024` | en | `two thousand twenty four` |
+| `1905` | en | `nineteen oh five` |
+
+**Year handling** (the tricky part)
+
+Hindi and Marathi speakers say years in the 1900s differently from how you'd read them literally:
+- `1997` → `उन्नीस सौ सत्तानवे` (not `एक हज़ार नौ सौ सत्तानवे`)
+
+English speakers do the same:
+- `1997` → `nineteen ninety seven` (not `one thousand nine hundred ninety seven`)
+- `1905` → `nineteen oh five`
+
+The library handles all of these correctly.
+
+---
+
+## API reference
+
+### `preprocess(text, lang)`
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `text` | `str` | The raw input text containing digits/dates |
+| `lang` | `str` | Language code: `"hi"`, `"mr"`, or `"en"` |
+
+Returns `str` — the same text with all digits replaced by spoken words.
+
+Raises `TypeError` if `text` is not a string.
+
+---
+
+## Contributing
+
+Adding a new language is straightforward:
+
+1. Create `indic_tts_preprocess/languages/yourlang.py` — look at `hindi.py` as a template
+2. Add a `preprocess(text)` function and a `num_to_words(n)` function
+3. Add the new language code in `core.py`
+4. Add tests in `tests/test_yourlang.py`
+5. Open a pull request
+
+---
+
+## License
+
+MIT

indic_tts_preprocess-0.1.1/indic_tts_preprocess/__init__.py

@@ -0,0 +1,25 @@
+"""
+indic-tts-preprocess
+--------------------
+Converts numbers and dates in Indic text into spoken words,
+so that open-source TTS models like ai4bharat/indic-parler-tts
+stop hallucinating when they see raw digits.
+
+Basic usage:
+
+    from indic_tts_preprocess import preprocess
+
+    clean = preprocess("उनका जन्म 5 अगस्त 1997 को हुआ", "hi")
+    # -> "उनका जन्म पाँच अगस्त उन्नीस सौ सत्तानवे को हुआ"
+
+Supported languages:
+    "hi"  - Hindi
+    "mr"  - Marathi
+    "en"  - English
+"""
+
+from indic_tts_preprocess.core import preprocess, SUPPORTED_LANGUAGES
+
+__version__ = "0.1.1"
+__author__ = "Dhruv Dornal"
+__all__ = ["preprocess", "SUPPORTED_LANGUAGES"]

indic_tts_preprocess-0.1.1/indic_tts_preprocess/core.py

@@ -0,0 +1,56 @@
+"""
+core.py
+
+The main entry point. This is the only function most people will ever need to call.
+It figures out which language to use and sends the text to the right preprocessor.
+"""
+
+from indic_tts_preprocess.languages import hindi, marathi, english
+
+# All the language codes we support right now.
+# If someone passes something not in this list, we just return their text unchanged.
+SUPPORTED_LANGUAGES = {"hi", "mr", "en"}
+
+
+def preprocess(text: str, lang: str) -> str:
+    """
+    Clean up text so Indic TTS models can read numbers and dates correctly.
+
+    The models hallucinate badly when they see raw digits like "1997" or "73".
+    This function converts them into the spoken form before the text hits the model.
+
+    Parameters
+    ----------
+    text : str
+        The raw input text with digits/dates in it.
+    lang : str
+        Language code. Use "hi" for Hindi, "mr" for Marathi, "en" for English.
+
+    Returns
+    -------
+    str
+        The same text but with all numbers replaced by spoken words.
+
+    Examples
+    --------
+    >>> from indic_tts_preprocess import preprocess
+    >>> preprocess("उनका जन्म 5 अगस्त 1997 को हुआ", "hi")
+    'उनका जन्म पाँच अगस्त उन्नीस सौ सत्तानवे को हुआ'
+
+    >>> preprocess("He was born on 15 August 1947", "en")
+    'He was born on fifteen August nineteen forty seven'
+    """
+    if not isinstance(text, str):
+        raise TypeError(f"text must be a string, got {type(text).__name__}")
+
+    lang = lang.strip().lower()
+
+    if lang == "hi":
+        return hindi.preprocess(text)
+    if lang == "mr":
+        return marathi.preprocess(text)
+    if lang == "en":
+        return english.preprocess(text)
+
+    # Unknown language - just return the text as-is so nothing breaks downstream
+    return text

indic_tts_preprocess-0.1.1/indic_tts_preprocess/languages/english.py

@@ -0,0 +1,124 @@
+"""
+english.py
+
+English number/date cleanup for TTS.
+Handles years the way English speakers actually say them out loud.
+"""
+
+import re
+
+# Numbers 1-19 don't follow any pattern, so just list them
+ONES = [
+    "", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten",
+    "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen",
+]
+
+# Tens: twenty, thirty, etc.
+TENS = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"]
+
+# Month number -> English month name
+MONTHS = {
+    1: "January", 2: "February", 3: "March", 4: "April",
+    5: "May", 6: "June", 7: "July", 8: "August",
+    9: "September", 10: "October", 11: "November", 12: "December",
+}
+
+# Regex string of all month names (used to match written dates like "5 August 2004")
+MONTHS_RE = "|".join(MONTHS.values())
+
+
+def _under_100(n: int) -> str:
+    """Convert any number under 100 to English words."""
+    if n < 20:
+        return ONES[n]
+    tens, ones = n // 10, n % 10
+    if ones == 0:
+        return TENS[tens]
+    return TENS[tens] + " " + ONES[ones]
+
+
+def num_to_words(n: int) -> str:
+    """
+    Turn any whole number into spoken English.
+
+    Years have their own rules because people say them differently:
+    - 1900-1999: "nineteen oh five", "nineteen ninety two"
+    - 2000-2099: "two thousand", "two thousand twenty four"
+    Everything else uses standard hundred/thousand structure.
+    """
+    if n == 0:
+        return "zero"
+    if n < 0:
+        return "minus " + num_to_words(-n)
+
+    # 1900s - 1600s: "nineteen ninety two" not "one thousand nine hundred ninety two"
+    if 1900 <= n <= 1999:
+        second = n - 1900
+        if second == 0:
+            return "nineteen hundred"
+        if second < 10:
+            return "nineteen oh " + ONES[second]  # "nineteen oh five"
+        return "nineteen " + _under_100(second)
+    
+    if 1800 <= n <= 1899:
+        second = n - 1800
+        if second == 0:
+            return "eighteen hundred"
+        if second < 10:
+            return "eighteen oh " + ONES[second]  # "eighteen oh five"
+        return "eightteen " + _under_100(second)
+    
+    if 1700 <= n <= 1799:
+        second = n - 1700
+        if second == 0:
+            return "seventeen hundred"
+        if second < 10:
+            return "seventeen oh " + ONES[second]  # "seventeen oh five"
+        return "seventeen " + _under_100(second)
+
+    # 2000s: "two thousand", "two thousand twenty four"
+    if 2000 <= n <= 2099:
+        second = n - 2000
+        if second == 0:
+            return "two thousand"
+        return "two thousand " + _under_100(second)
+
+    parts = []
+    if n >= 1000:
+        parts.append(num_to_words(n // 1000) + " thousand")
+        n %= 1000
+    if n >= 100:
+        parts.append(ONES[n // 100] + " hundred")
+        n %= 100
+    if n > 0:
+        parts.append(_under_100(n))
+    return " ".join(parts)
+
+
+def preprocess(text: str) -> str:
+    """
+    Takes raw English text and replaces all numbers/dates with spoken English words.
+    """
+    # Handle "5 August 2004" or "5 august 2004" (case-insensitive)
+    def _written_date(m):
+        day, month_name, year = int(m.group(1)), m.group(2), int(m.group(3))
+        return f"{_under_100(day)} {month_name} {num_to_words(year)}"
+
+    text = re.sub(
+        rf"(\d{{1,2}})\s+({MONTHS_RE})\s+(\d{{4}})",
+        _written_date, text, flags=re.IGNORECASE
+    )
+
+    # Handle "05/08/2004" or "05-08-2004"
+    def _numeric_date(m):
+        day, month, year = int(m.group(1)), int(m.group(2)), int(m.group(3))
+        if 1 <= month <= 12 and 1 <= day <= 31:
+            return f"{_under_100(day)} {MONTHS[month]} {num_to_words(year)}"
+        return m.group(0)
+
+    text = re.sub(r"(\d{1,2})[\/\-](\d{1,2})[\/\-](\d{4})", _numeric_date, text)
+
+    # Anything else that's still a number
+    text = re.sub(r"\d+", lambda m: num_to_words(int(m.group(0))), text)
+
+    return text

indic_tts_preprocess-0.1.1/indic_tts_preprocess/languages/hindi.py

@@ -0,0 +1,121 @@
+"""
+hindi.py
+
+All the Hindi-specific stuff lives here:
+- Word lists for numbers 0-99
+- Month name mappings
+- The actual function that cleans up Hindi text for TTS
+"""
+
+import re
+
+# Every number from 0 to 99 written out in Hindi.
+# Index position = the number itself. So ONES[5] = "पाँच".
+# Index 0 is blank because we never say "zero" in the middle of a date.
+ONES = [
+    "", "एक", "दो", "तीन", "चार", "पाँच", "छह", "सात", "आठ", "नौ", "दस",
+    "ग्यारह", "बारह", "तेरह", "चौदह", "पंद्रह", "सोलह", "सत्रह", "अठारह", "उन्नीस", "बीस",
+    "इक्कीस", "बाईस", "तेईस", "चौबीस", "पच्चीस", "छब्बीस", "सत्ताईस", "अट्ठाईस", "उनतीस", "तीस",
+    "इकतीस", "बत्तीस", "तैंतीस", "चौंतीस", "पैंतीस", "छत्तीस", "सैंतीस", "अड़तीस", "उनतालीस", "चालीस",
+    "इकतालीस", "बयालीस", "तैंतालीस", "चौंतालीस", "पैंतालीस", "छियालीस", "सैंतालीस", "अड़तालीस", "उनचास", "पचास",
+    "इक्यावन", "बावन", "तिरपन", "चौवन", "पचपन", "छप्पन", "सत्तावन", "अट्ठावन", "उनसठ", "साठ",
+    "इकसठ", "बासठ", "तिरसठ", "चौंसठ", "पैंसठ", "छियासठ", "सड़सठ", "अड़सठ", "उनहत्तर", "सत्तर",
+    "इकहत्तर", "बहत्तर", "तिहत्तर", "चौहत्तर", "पचहत्तर", "छिहत्तर", "सतहत्तर", "अठहत्तर", "उनासी", "अस्सी",
+    "इक्यासी", "बयासी", "तिरासी", "चौरासी", "पचासी", "छियासी", "सत्तासी", "अट्ठासी", "नवासी", "नब्बे",
+    "इक्यानबे", "बानबे", "तिरानबे", "चौरानबे", "पचानबे", "छियानबे", "सत्तानवे", "अट्ठानवे", "निन्यानवे",
+]
+
+# Month number -> Hindi month name
+MONTHS = {
+    1: "जनवरी", 2: "फरवरी", 3: "मार्च", 4: "अप्रैल",
+    5: "मई", 6: "जून", 7: "जुलाई", 8: "अगस्त",
+    9: "सितंबर", 10: "अक्टूबर", 11: "नवंबर", 12: "दिसंबर",
+}
+
+# Flip it so we can go from month name -> number too
+MONTH_TO_NUM = {v: k for k, v in MONTHS.items()}
+
+
+def num_to_words(n: int) -> str:
+    """
+    Turn any whole number into how a Hindi speaker would say it out loud.
+
+    The 1900s get special treatment: Hindi speakers say "उन्नीस सौ सत्तानवे"
+    (nineteen hundred ninety-seven) not "एक हज़ार नौ सौ सत्तानवे".
+    This matters a lot for birth years, historical dates, etc.
+    """
+    if n == 0:
+        return "शून्य"
+    if n < 0:
+        return "माइनस " + num_to_words(-n)
+
+    # Years in the 1900s - say it the natural way
+    if 1900 <= n <= 1999:
+        remainder = n - 1900
+        if remainder == 0:
+            return "उन्नीस सौ"
+        return "उन्नीस सौ " + ONES[remainder]
+    
+    # 1800s
+    if 1800 <= n <= 1899:
+        remainder = n - 1800
+        if remainder == 0:
+            return "अठारह सौ"
+        return "अठारह सौ " + ONES[remainder]
+
+    # 1700s
+    if 1700 <= n <= 1799:
+        remainder = n - 1700
+        if remainder == 0:
+            return "सत्रह सौ"
+        return "सत्रह सौ " + ONES[remainder]
+
+    parts = []
+    if n >= 1000:
+        parts.append(num_to_words(n // 1000) + " हज़ार")
+        n %= 1000
+    if n >= 100:
+        parts.append(ONES[n // 100] + " सौ")
+        n %= 100
+    if n > 0:
+        parts.append(ONES[n])
+    return " ".join(parts)
+
+
+def preprocess(text: str) -> str:
+    """
+    Takes raw Hindi text and replaces all numbers/dates with spoken Hindi words.
+
+    Three patterns it handles:
+    1. "5 अगस्त 2004" -> day in Hindi words + month name + year in words
+    2. "05/08/2004" or "05-08-2004" -> same thing but from numeric format
+    3. Any leftover numbers like "73" -> "तिहत्तर"
+    """
+    # Build a pattern that matches any Hindi month name
+    month_pat = "|".join(MONTH_TO_NUM.keys())
+
+    # Handle "5 अगस्त 2004" or "5 अगस्त, 2004"
+    def _named_date(m):
+        day = int(m.group(1))
+        month = MONTH_TO_NUM[m.group(2)]
+        year = int(m.group(3))
+        return f"{ONES[day]} {MONTHS[month]} {num_to_words(year)}"
+
+    text = re.sub(
+        rf"(\d{{1,2}})\s+({month_pat})[,\s]+(\d{{4}})",
+        _named_date, text
+    )
+
+    # Handle "05/08/2004" or "05-08-2004"
+    def _numeric_date(m):
+        day, month, year = int(m.group(1)), int(m.group(2)), int(m.group(3))
+        if 1 <= month <= 12 and 1 <= day <= 31:
+            return f"{ONES[day]} {MONTHS[month]} {num_to_words(year)}"
+        return m.group(0)  # not a valid date, leave it alone
+
+    text = re.sub(r"(\d{1,2})[\/\-](\d{1,2})[\/\-](\d{4})", _numeric_date, text)
+
+    # Anything else that's still a number
+    text = re.sub(r"\d+", lambda m: num_to_words(int(m.group())), text)
+
+    return text

indic_tts_preprocess-0.1.1/indic_tts_preprocess/languages/marathi.py

@@ -0,0 +1,112 @@
+"""
+marathi.py
+
+All the Marathi-specific stuff lives here.
+Same structure as hindi.py but with Marathi words throughout.
+"""
+
+import re
+
+# Every number from 0 to 99 written out in Marathi.
+# Same idea as Hindi - index = the number. ONES[3] = "तीन".
+ONES = [
+    "", "एक", "दोन", "तीन", "चार", "पाच", "सहा", "सात", "आठ", "नऊ", "दहा",
+    "अकरा", "बारा", "तेरा", "चौदा", "पंधरा", "सोळा", "सतरा", "अठरा", "एकोणीस", "वीस",
+    "एकवीस", "बावीस", "तेवीस", "चोवीस", "पंचवीस", "सव्वीस", "सत्तावीस", "अठ्ठावीस", "एकोणतीस", "तीस",
+    "एकतीस", "बत्तीस", "तेहेतीस", "चौतीस", "पस्तीस", "छत्तीस", "सदतीस", "अडतीस", "एकोणचाळीस", "चाळीस",
+    "एकेचाळीस", "बेचाळीस", "त्रेचाळीस", "चव्वेचाळीस", "पंचेचाळीस", "सेहेचाळीस", "सत्तेचाळीस", "अठ्ठेचाळीस", "एकोणपन्नास", "पन्नास",
+    "एक्याण्णव", "बावन्न", "त्रेपन्न", "चोपन्न", "पंचावन्न", "छप्पन्न", "सत्तावन्न", "अठ्ठावन्न", "एकोणसाठ", "साठ",
+    "एकसष्ट", "बासष्ट", "त्रेसष्ट", "चौसष्ट", "पासष्ट", "सहासष्ट", "सदुसष्ट", "अडुसष्ट", "एकोणसत्तर", "सत्तर",
+    "एकाहत्तर", "बहात्तर", "त्र्याहत्तर", "चौऱ्याहत्तर", "पंच्याहत्तर", "शहात्तर", "सत्याहत्तर", "अठ्ठ्याहत्तर", "एकोणऐंशी", "ऐंशी",
+    "एक्याऐंशी", "ब्याऐंशी", "त्र्याऐंशी", "चौऱ्याऐंशी", "पंच्याऐंशी", "शहाऐंशी", "सत्याऐंशी", "अठ्ठ्याऐंशी", "नव्याऐंशी", "नव्वद",
+    "एक्याण्णव", "बाण्णव", "त्र्याण्णव", "चौऱ्याण्णव", "पंच्याण्णव", "शहाण्णव", "सत्त्याण्णव", "अठ्ठ्याण्णव", "नव्याण्णव",
+]
+
+# Month number -> Marathi month name
+MONTHS = {
+    1: "जानेवारी", 2: "फेब्रुवारी", 3: "मार्च", 4: "एप्रिल",
+    5: "मे", 6: "जून", 7: "जुलै", 8: "ऑगस्ट",
+    9: "सप्टेंबर", 10: "ऑक्टोबर", 11: "नोव्हेंबर", 12: "डिसेंबर",
+}
+
+# Flip it so we can go from month name -> number
+MONTH_TO_NUM = {v: k for k, v in MONTHS.items()}
+
+
+def num_to_words(n: int) -> str:
+    """
+    Turn any whole number into how a Marathi speaker would say it out loud.
+
+    Same 1900s special case as Hindi: "एकोणीस शे ..." instead of the long form.
+    Marathi uses "शे" for hundred and "हजार" for thousand.
+    """
+    if n == 0:
+        return "शून्य"
+    if n < 0:
+        return "वजा " + num_to_words(-n)
+
+    # Years in the 1900s - say it the natural way
+    if 1900 <= n <= 1999:
+        remainder = n - 1900
+        if remainder == 0:
+            return "एकोणीस शे"
+        return "एकोणीस शे " + ONES[remainder]
+
+    # 1800s
+    if 1800 <= n <= 1899:
+        remainder = n - 1800
+        if remainder == 0:
+            return "अठरा शे"
+        return "अठरा शे " + ONES[remainder]
+    
+    # 1700s
+    if 1700 <= n <= 1799:
+        remainder = n - 1700
+        if remainder == 0:
+            return "सतरा शे"
+        return "सतरा शे " + ONES[remainder]
+
+    parts = []
+    if n >= 1000:
+        parts.append(num_to_words(n // 1000) + " हजार")
+        n %= 1000
+    if n >= 100:
+        parts.append(ONES[n // 100] + " शे")
+        n %= 100
+    if n > 0:
+        parts.append(ONES[n])
+    return " ".join(parts)
+
+
+def preprocess(text: str) -> str:
+    """
+    Takes raw Marathi text and replaces all numbers/dates with spoken Marathi words.
+    Same three patterns as Hindi - just uses Marathi words.
+    """
+    month_pat = "|".join(MONTH_TO_NUM.keys())
+
+    # Handle "5 ऑगस्ट 2004" or "5 ऑगस्ट, 2004"
+    def _named_date(m):
+        day = int(m.group(1))
+        month = MONTH_TO_NUM[m.group(2)]
+        year = int(m.group(3))
+        return f"{ONES[day]} {MONTHS[month]} {num_to_words(year)}"
+
+    text = re.sub(
+        rf"(\d{{1,2}})\s+({month_pat})[,\s]+(\d{{4}})",
+        _named_date, text
+    )
+
+    # Handle "05/08/2004" or "05-08-2004"
+    def _numeric_date(m):
+        day, month, year = int(m.group(1)), int(m.group(2)), int(m.group(3))
+        if 1 <= month <= 12 and 1 <= day <= 31:
+            return f"{ONES[day]} {MONTHS[month]} {num_to_words(year)}"
+        return m.group(0)
+
+    text = re.sub(r"(\d{1,2})[\/\-](\d{1,2})[\/\-](\d{4})", _numeric_date, text)
+
+    # Anything else that's still a number
+    text = re.sub(r"\d+", lambda m: num_to_words(int(m.group())), text)
+
+    return text

indic_tts_preprocess-0.1.1/indic_tts_preprocess.egg-info/PKG-INFO

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: indic-tts-preprocess
+Version: 0.1.1
+Summary: Convert numbers and dates in Indic text to spoken words for TTS models
+Author-email: Dhruv Dornal <dhruvdornal2003@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Dhruv
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Keywords: tts,indic,hindi,marathi,nlp,text-to-speech,preprocessing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Natural Language :: Hindi
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# indic-tts-preprocess
+
+A small Python library that fixes one specific but very annoying problem with open-source Indic TTS models: **they cannot read numbers**.
+
+Models like [ai4bharat/indic-parler-tts](https://huggingface.co/ai4bharat/indic-parler-tts) hallucinate badly when the input text contains raw digits. Feed them `"1997 में"` and you get garbled audio. Feed them `"उन्नीस सौ सत्तानवे में"` and it works perfectly.
+
+This library does that conversion for you — numbers, years, dates — before the text ever reaches the tokenizer.
+
+---
+
+## Install
+
+```bash
+pip install indic-tts-preprocess
+```
+
+No dependencies. Pure Python. Works on Python 3.8 and above.
+
+---
+
+## Quick start
+
+```python
+from indic_tts_preprocess import preprocess
+
+# Hindi
+preprocess("उनका जन्म 5 अगस्त 1997 को हुआ", "hi")
+# -> "उनका जन्म पाँच अगस्त उन्नीस सौ सत्तानवे को हुआ"
+
+# Marathi
+preprocess("त्यांचा जन्म 15 ऑगस्ट 1947 रोजी झाला", "mr")
+# -> "त्यांचा जन्म पंधरा ऑगस्ट एकोणीस शे सत्तेचाळीस रोजी झाला"
+
+# English
+preprocess("He was born on 15 August 1947", "en")
+# -> "He was born on fifteen August nineteen forty seven"
+```
+
+---
+
+## Supported languages
+
+| Code | Language |
+|------|----------|
+| `hi` | Hindi    |
+| `mr` | Marathi  |
+| `en` | English  |
+
+If you pass an unsupported language code, the text comes back unchanged — nothing crashes.
+
+---
+
+## What it handles
+
+**Date formats**
+
+| Input | Language | Output |
+|-------|----------|--------|
+| `5 अगस्त 2004` | hi | `पाँच अगस्त दो हज़ार चार` |
+| `05/08/2004` | hi | `पाँच अगस्त दो हज़ार चार` |
+| `05-08-2004` | hi | `पाँच अगस्त दो हज़ार चार` |
+| `15 August 1947` | en | `fifteen August nineteen forty seven` |
+| `15/08/1947` | en | `fifteen August nineteen forty seven` |
+
+**Standalone numbers**
+
+| Input | Language | Output |
+|-------|----------|--------|
+| `73` | hi | `तिहत्तर` |
+| `1997` | hi | `उन्नीस सौ सत्तानवे` |
+| `2024` | en | `two thousand twenty four` |
+| `1905` | en | `nineteen oh five` |
+
+**Year handling** (the tricky part)
+
+Hindi and Marathi speakers say years in the 1900s differently from how you'd read them literally:
+- `1997` → `उन्नीस सौ सत्तानवे` (not `एक हज़ार नौ सौ सत्तानवे`)
+
+English speakers do the same:
+- `1997` → `nineteen ninety seven` (not `one thousand nine hundred ninety seven`)
+- `1905` → `nineteen oh five`
+
+The library handles all of these correctly.
+
+---
+
+## API reference
+
+### `preprocess(text, lang)`
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `text` | `str` | The raw input text containing digits/dates |
+| `lang` | `str` | Language code: `"hi"`, `"mr"`, or `"en"` |
+
+Returns `str` — the same text with all digits replaced by spoken words.
+
+Raises `TypeError` if `text` is not a string.
+
+---
+
+## Contributing
+
+Adding a new language is straightforward:
+
+1. Create `indic_tts_preprocess/languages/yourlang.py` — look at `hindi.py` as a template
+2. Add a `preprocess(text)` function and a `num_to_words(n)` function
+3. Add the new language code in `core.py`
+4. Add tests in `tests/test_yourlang.py`
+5. Open a pull request
+
+---
+
+## License
+
+MIT

indic_tts_preprocess-0.1.1/indic_tts_preprocess.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+indic_tts_preprocess/__init__.py
+indic_tts_preprocess/core.py
+indic_tts_preprocess.egg-info/PKG-INFO
+indic_tts_preprocess.egg-info/SOURCES.txt
+indic_tts_preprocess.egg-info/dependency_links.txt
+indic_tts_preprocess.egg-info/top_level.txt
+indic_tts_preprocess/languages/__init__.py
+indic_tts_preprocess/languages/english.py
+indic_tts_preprocess/languages/hindi.py
+indic_tts_preprocess/languages/marathi.py
+tests/test_core.py
+tests/test_english.py
+tests/test_hindi.py
+tests/test_marathi.py

indic_tts_preprocess-0.1.1/indic_tts_preprocess.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

indic_tts_preprocess-0.1.1/indic_tts_preprocess.egg-info/top_level.txt

@@ -0,0 +1 @@
+indic_tts_preprocess

indic_tts_preprocess-0.1.1/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "indic-tts-preprocess"
+version = "0.1.1"
+description = "Convert numbers and dates in Indic text to spoken words for TTS models"
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [
+    { name = "Dhruv Dornal", email = "dhruvdornal2003@gmail.com" }
+]
+keywords = ["tts", "indic", "hindi", "marathi", "nlp", "text-to-speech", "preprocessing"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Text Processing :: Linguistic",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Natural Language :: Hindi",
+]
+requires-python = ">=3.8"
+dependencies = []
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["indic_tts_preprocess*"]

indic_tts_preprocess-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

indic_tts_preprocess-0.1.1/tests/test_core.py

@@ -0,0 +1,44 @@
+"""
+Tests for the top-level preprocess() function.
+This is the main thing users will call.
+"""
+
+import pytest
+from indic_tts_preprocess import preprocess, SUPPORTED_LANGUAGES
+
+
+class TestPreprocess:
+    def test_hindi_routing(self):
+        result = preprocess("1997", "hi")
+        assert result == "उन्नीस सौ सत्तानवे"
+
+    def test_marathi_routing(self):
+        result = preprocess("1997", "mr")
+        assert result == "एकोणीस शे सत्त्याण्णव"
+
+    def test_english_routing(self):
+        result = preprocess("1997", "en")
+        assert result == "nineteen ninety seven"
+
+    def test_unknown_lang_returns_text_unchanged(self):
+        # Should not crash, just return as-is
+        result = preprocess("hello 123", "xx")
+        assert result == "hello 123"
+
+    def test_lang_is_case_insensitive(self):
+        # "HI" and "Hi" and "hi" should all work
+        assert preprocess("5", "HI") == preprocess("5", "hi")
+        assert preprocess("5", "Hi") == preprocess("5", "hi")
+
+    def test_raises_on_non_string_input(self):
+        with pytest.raises(TypeError):
+            preprocess(12345, "hi")
+
+    def test_supported_languages_constant(self):
+        assert "hi" in SUPPORTED_LANGUAGES
+        assert "mr" in SUPPORTED_LANGUAGES
+        assert "en" in SUPPORTED_LANGUAGES
+
+    def test_empty_string(self):
+        assert preprocess("", "hi") == ""
+        assert preprocess("", "en") == ""

indic_tts_preprocess-0.1.1/tests/test_english.py

@@ -0,0 +1,60 @@
+"""
+Tests for the English preprocessor.
+"""
+
+import pytest
+from indic_tts_preprocess.languages.english import preprocess, num_to_words
+
+
+class TestNumToWords:
+    def test_zero(self):
+        assert num_to_words(0) == "zero"
+
+    def test_teens(self):
+        assert num_to_words(15) == "fifteen"
+
+    def test_two_digit(self):
+        assert num_to_words(42) == "forty two"
+
+    def test_1900s_year(self):
+        assert num_to_words(1997) == "nineteen ninety seven"
+
+    def test_1900s_oh_year(self):
+        # 1905 should be "nineteen oh five"
+        assert num_to_words(1905) == "nineteen oh five"
+
+    def test_1900_exact(self):
+        assert num_to_words(1900) == "nineteen hundred"
+
+    def test_2000(self):
+        assert num_to_words(2000) == "two thousand"
+
+    def test_2000s(self):
+        assert num_to_words(2024) == "two thousand twenty four"
+
+    def test_negative(self):
+        assert num_to_words(-10) == "minus ten"
+
+
+class TestPreprocess:
+    def test_written_date(self):
+        result = preprocess("15 August 1747")
+        assert result == "fifteen August seventeen forty seven"
+
+    def test_written_date_case_insensitive(self):
+        result = preprocess("15 august 1947")
+        assert "fifteen" in result
+        assert "nineteen forty seven" in result
+
+    def test_numeric_date(self):
+        result = preprocess("15/08/1947")
+        assert "fifteen" in result
+        assert "August" in result
+
+    def test_standalone_year(self):
+        result = preprocess("The year was 1947")
+        assert "nineteen forty seven" in result
+
+    def test_text_without_numbers_unchanged(self):
+        text = "Hello world"
+        assert preprocess(text) == text

indic_tts_preprocess-0.1.1/tests/test_hindi.py

@@ -0,0 +1,72 @@
+"""
+Tests for the Hindi preprocessor.
+Run with: python -m pytest tests/
+"""
+
+import pytest
+from indic_tts_preprocess.languages.hindi import preprocess, num_to_words
+
+
+class TestNumToWords:
+    def test_zero(self):
+        assert num_to_words(0) == "शून्य"
+
+    def test_single_digit(self):
+        assert num_to_words(5) == "पाँच"
+
+    def test_two_digit(self):
+        assert num_to_words(73) == "तिहत्तर"
+
+    def test_hundred(self):
+        assert num_to_words(100) == "एक सौ"
+
+    def test_1900s_year(self):
+        # The special case - should say "उन्नीस सौ" not "एक हज़ार नौ सौ"
+        assert num_to_words(1997) == "उन्नीस सौ सत्तानवे"
+
+    def test_1900_exact(self):
+        assert num_to_words(1900) == "उन्नीस सौ"
+
+    def test_2000s_year(self):
+        assert num_to_words(2004) == "दो हज़ार चार"
+
+    def test_negative(self):
+        assert num_to_words(-5) == "माइनस पाँच"
+
+
+class TestPreprocess:
+    def test_named_date(self):
+        result = preprocess("5 अगस्त 2004")
+        assert result == "पाँच अगस्त दो हज़ार चार"
+
+    def test_named_date_with_comma(self):
+        result = preprocess("5 अगस्त, 2004")
+        assert result == "पाँच अगस्त दो हज़ार चार"
+
+    def test_numeric_date_slash(self):
+        result = preprocess("05/08/2004")
+        assert result == "पाँच अगस्त दो हज़ार चार"
+
+    def test_numeric_date_dash(self):
+        result = preprocess("05-08-2004")
+        assert result == "पाँच अगस्त दो हज़ार चार"
+
+    def test_standalone_number_in_sentence(self):
+        result = preprocess("उसके पास 73 किताबें हैं")
+        assert "तिहत्तर" in result
+
+    def test_1900s_year_in_sentence(self):
+        result = preprocess("उनका जन्म 1947 में हुआ")
+        assert "उन्नीस सौ सैंतालीस" in result
+
+    def test_text_without_numbers_unchanged(self):
+        text = "यह एक साधारण वाक्य है"
+        assert preprocess(text) == text
+    
+    def test_1800s_year_in_sentence(self):
+        result = preprocess("उनका जन्म 1803 में हुआ")
+        assert "अठारह सौ तीन" in result
+    
+    def test_1700s_year_in_sentence(self):
+        result = preprocess("उनका जन्म 1709 में हुआ")
+        assert "सत्रह सौ नौ" in result

indic_tts_preprocess-0.1.1/tests/test_marathi.py

@@ -0,0 +1,50 @@
+"""
+Tests for the Marathi preprocessor.
+"""
+
+import pytest
+from indic_tts_preprocess.languages.marathi import preprocess, num_to_words
+
+
+class TestNumToWords:
+    def test_zero(self):
+        assert num_to_words(0) == "शून्य"
+
+    def test_single_digit(self):
+        assert num_to_words(5) == "पाच"
+
+    def test_1900s_year(self):
+        # Marathi uses "एकोणीस शे" for the 1900s
+        assert num_to_words(1997) == "एकोणीस शे सत्त्याण्णव"
+
+    def test_1900_exact(self):
+        assert num_to_words(1900) == "एकोणीस शे"
+
+    def test_negative(self):
+        assert num_to_words(-3) == "वजा तीन"
+
+
+class TestPreprocess:
+    def test_named_date(self):
+        result = preprocess("5 ऑगस्ट 2004")
+        assert result == "पाच ऑगस्ट दोन हजार चार"
+
+    def test_numeric_date(self):
+        result = preprocess("05/08/2004")
+        assert "ऑगस्ट" in result
+
+    def test_standalone_number(self):
+        result = preprocess("त्याच्याकडे 10 पुस्तके आहेत")
+        assert "दहा" in result
+
+    def test_text_without_numbers_unchanged(self):
+        text = "हे एक साधे वाक्य आहे"
+        assert preprocess(text) == text
+    
+    def test_1800s_year_in_sentence_marathi(self):
+        result = preprocess("त्यांचा जन्म 1807 मध्ये झाला")
+        assert "अठरा शे सात" in result
+
+    def test_1700s_year_in_sentence_marathi(self):
+        result = preprocess("त्यांचा जन्म 1702 मध्ये झाला")
+        assert "सतरा शे दोन" in result