dv-normalizer 0.1.0__tar.gz

dv-normalizer-0.1.0/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 
+
+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.

dv-normalizer-0.1.0/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.1
+Name: dv-normalizer
+Version: 0.1.0
+Summary: A Python library for normalizing Dhivehi text and converting numbers to Dhivehi text format, supporting written, spoken and year forms
+Author: Alakxender
+Author-email: alakxender@gmail.com
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENCE
+
+# dv-normalize
+
+A Python library for normalizing Dhivehi text by converting numbers to Dhivehi and standardizing sentence endings.
+
+## Features
+
+- Converts numbers to Dhivehi text (both written and spoken forms)
+- Handles years (when followed by ވަނަ)
+- Handles decimal numbers
+- Normalizes formal sentence endings to colloquial form
+- Preserves proper spacing and punctuation
+
+## Installation
+
+```bash
+pip install dv-normalize
+```
+
+## Usage
+
+There are two main functions in this library:
+
+1. `int_to_dv` - This function converts numbers to Dhivehi text in written form.
+2. `spoken_dv` - This function converts dhivehi text to spoken form.
+
+### Written form
+
+```python
+
+## test case for int_to_dv
+
+from dv_normalize.dv_num import int_to_dv
+
+def main():
+    while True:
+        try:
+            num = input("Enter a number (0 to trillion) or 'q' to exit: ")
+            if num.lower() == 'q':
+                break
+                
+            num = int(num)
+            if num < 0:
+                print("Please enter a non-negative number")
+                continue
+                
+            print(f"{num:,} in Dhivehi:")
+            written = int_to_dv(num, is_spoken=False)
+            spoken = int_to_dv(num, is_spoken=True)
+            year = "Not a valid year format" if num < 1000 or num > 9999 else int_to_dv(num, is_year=True)
+            
+            print(f"Written form: {written}")
+            print(f"Spoken form: {spoken}")
+            print(f"Year form: {year}")
+            
+        except ValueError:
+            print("Please enter a valid number")
+
+if __name__ == "__main__":
+    main()
+```
+
+### Spoken form
+
+```python
+from dv_normalize.dv_sentence import spoken_dv
+
+# Test cases
+test_cases = [
+    "މިއަދު ވަރަށް ފިނިވެއެވެ.",  # Verb ending
+    "މިއީ ރީތި ފޮތެކެވެ.",        # Noun ending
+    "އޭނާ ދަނީ ސްކޫލަށެވެ.",      # Direction ending
+    "1955 މީހުން ތިބެއެވެ.",      # Number with ending
+    "2024 ވަނަ އަހަރު",            # Year
+    "12.5 ރުފިޔާ",                # Decimal
+    "1000 މީހުން",                # Regular number
+    "މިއީ ރީތި ފޮތެކެވެ.",          # Sentence ending
+    "އޭނާ ގެއަށެވެ.",              # Sentence ending
+    "ހާއްސަ އެއްބަސްވުމުގެ ދަށުން އިންޑިއާއިން ރާއްޖެއަށް ވިއްކާ ހަކުރު އޮޅުވާލައިގެން ލަންކާއަށް!", # test sentence
+    "އެ އިދާރާއިން ބަލަމުން އަންނަނީ މިދިޔަ މަހުގެ 25 ގައި އެގައުމުން ބޭރު ކުރި 64 ހާސް ޓަނުގެ ހަކުރުގެ ޝިޕްމެންޓެއްގެ މައްސަލަ އެވެ. އެ ޝިޕްމެންޓް އެގައުމުން ބޭރުކުރީ ރާއްޖެ އާއި އިންޑިއާ އާ ދެމެދު ވެފައިވާ ވިޔަފާރީގެ ހާއްސަ އެއްބަސްވުމުގެ ދަށުން ކަނޑައަޅާފައިވާ އަގުތަކުގައި ނަމަވެސް، އެއިން ބައެއް ލަންކާއަށް އެތެރެކުރިން ފަޅާއަރާފައިވާ ކަމަށް އިންޑިއާގެ ބައެއް ނޫސްތަކުގައި ރިފޯޓުކޮށްފައިވެ އެވެ." # test long sentence
+]
+
+for test in test_cases:
+    print(f"Original: {test}")
+    print(f"Normalized: {spoken_dv(test)}\n")
+
+```
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

dv-normalizer-0.1.0/README.md

@@ -0,0 +1,90 @@
+# dv-normalize
+
+A Python library for normalizing Dhivehi text by converting numbers to Dhivehi and standardizing sentence endings.
+
+## Features
+
+- Converts numbers to Dhivehi text (both written and spoken forms)
+- Handles years (when followed by ވަނަ)
+- Handles decimal numbers
+- Normalizes formal sentence endings to colloquial form
+- Preserves proper spacing and punctuation
+
+## Installation
+
+```bash
+pip install dv-normalize
+```
+
+## Usage
+
+There are two main functions in this library:
+
+1. `int_to_dv` - This function converts numbers to Dhivehi text in written form.
+2. `spoken_dv` - This function converts dhivehi text to spoken form.
+
+### Written form
+
+```python
+
+## test case for int_to_dv
+
+from dv_normalize.dv_num import int_to_dv
+
+def main():
+    while True:
+        try:
+            num = input("Enter a number (0 to trillion) or 'q' to exit: ")
+            if num.lower() == 'q':
+                break
+                
+            num = int(num)
+            if num < 0:
+                print("Please enter a non-negative number")
+                continue
+                
+            print(f"{num:,} in Dhivehi:")
+            written = int_to_dv(num, is_spoken=False)
+            spoken = int_to_dv(num, is_spoken=True)
+            year = "Not a valid year format" if num < 1000 or num > 9999 else int_to_dv(num, is_year=True)
+            
+            print(f"Written form: {written}")
+            print(f"Spoken form: {spoken}")
+            print(f"Year form: {year}")
+            
+        except ValueError:
+            print("Please enter a valid number")
+
+if __name__ == "__main__":
+    main()
+```
+
+### Spoken form
+
+```python
+from dv_normalize.dv_sentence import spoken_dv
+
+# Test cases
+test_cases = [
+    "މިއަދު ވަރަށް ފިނިވެއެވެ.",  # Verb ending
+    "މިއީ ރީތި ފޮތެކެވެ.",        # Noun ending
+    "އޭނާ ދަނީ ސްކޫލަށެވެ.",      # Direction ending
+    "1955 މީހުން ތިބެއެވެ.",      # Number with ending
+    "2024 ވަނަ އަހަރު",            # Year
+    "12.5 ރުފިޔާ",                # Decimal
+    "1000 މީހުން",                # Regular number
+    "މިއީ ރީތި ފޮތެކެވެ.",          # Sentence ending
+    "އޭނާ ގެއަށެވެ.",              # Sentence ending
+    "ހާއްސަ އެއްބަސްވުމުގެ ދަށުން އިންޑިއާއިން ރާއްޖެއަށް ވިއްކާ ހަކުރު އޮޅުވާލައިގެން ލަންކާއަށް!", # test sentence
+    "އެ އިދާރާއިން ބަލަމުން އަންނަނީ މިދިޔަ މަހުގެ 25 ގައި އެގައުމުން ބޭރު ކުރި 64 ހާސް ޓަނުގެ ހަކުރުގެ ޝިޕްމެންޓެއްގެ މައްސަލަ އެވެ. އެ ޝިޕްމެންޓް އެގައުމުން ބޭރުކުރީ ރާއްޖެ އާއި އިންޑިއާ އާ ދެމެދު ވެފައިވާ ވިޔަފާރީގެ ހާއްސަ އެއްބަސްވުމުގެ ދަށުން ކަނޑައަޅާފައިވާ އަގުތަކުގައި ނަމަވެސް، އެއިން ބައެއް ލަންކާއަށް އެތެރެކުރިން ފަޅާއަރާފައިވާ ކަމަށް އިންޑިއާގެ ބައެއް ނޫސްތަކުގައި ރިފޯޓުކޮށްފައިވެ އެވެ." # test long sentence
+]
+
+for test in test_cases:
+    print(f"Original: {test}")
+    print(f"Normalized: {spoken_dv(test)}\n")
+
+```
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

dv-normalizer-0.1.0/dv_normalize/__init__.py

@@ -0,0 +1,4 @@
+from dv_normalize.dv_sentence import spoken_dv
+from dv_normalize.dv_num import int_to_dv
+
+__all__ = ["spoken_dv", "int_to_dv"]

dv-normalizer-0.1.0/dv_normalize/dv_num.py

@@ -0,0 +1,169 @@
+def int_to_dv(num, thousands=False, is_spoken=False, is_year=False):
+    # Dictionary mapping numbers to their Dhivehi representations
+    # Format: [written_form, spoken_form]
+    d = {
+        0: ["ސުމެއް", "ސުމެއް"],
+        1: ["އެއް", "އެކެއް"],
+        2: ["ދެ", "ދޭއް"],
+        3: ["ތިން", "ތިނެއް"],
+        4: ["ހަތަރު", "ހަތަރެއް"],
+        5: ["ފަސް", "ފަހެއް"],
+        6: ["ހަ", "ހައެއް"],
+        7: ["ހަތް", "ހަތެއް"],
+        8: ["އަށް", "އަށެއް"],
+        9: ["ނުވަ", "ނުވައެއް"],
+        10: ["ދިހަ", "ދިހައެއް"],
+        11: ["އެގާރަ", "އެގާރަ"],
+        12: ["ބާރަ", "ބާރަ"],
+        13: ["ތޭރަ", "ތޭރަ"],
+        14: ["ސާދަ", "ސާދަ"],
+        15: ["ފަނަރަ", "ފަނަރަ"],
+        16: ["ސޯޅަ", "ސޯޅަ"],
+        17: ["ސަތާރަ", "ސަތާރަ"],
+        18: ["އަށާރަ", "އަށާރަ"],
+        19: ["ނަވާރަ", "ނަވާރަ"],
+        20: ["ވިހި", "ވިހި"],
+        30: ["ތިރީސް", "ތިރީސް"],
+        40: ["ސާޅީސް", "ސާޅީސް"],
+        50: ["ފަންސާސް", "ފަންސާސް"],
+        60: ["ފަސްދޮޅަސް", "ފަސްދޮޅަސް"],
+        70: ["ހައްދިހަ", "ހައްދިހަ"],
+        80: ["އައްޑިހަ", "އައްޑިހަ"],
+        90: ["ނުވަދިހަ", "ނުވަދިހަ"]
+    }
+
+    # Map for numbers before ހާސް
+    haas_map = {
+        "އެކެއް": "އެއް",
+        "ދޭއް": "ދެ",
+        "ތިނެއް": "ތިން",
+        "ހަތަރެއް": "ހަތަރު",
+        "ފަހެއް": "ފަސް",
+        "ހައެއް": "ހަ",
+        "ހަތެއް": "ހަތް",
+        "އަށެއް": "އަށް",
+        "ނުވައެއް": "ނުވަ"
+    }
+
+    # Constants for large numbers
+    k = 1000
+    m = k * 1000
+    b = m * 1000
+    t = b * 1000
+
+    if num < 0:
+        return "Invalid number"
+
+    if num == 0:
+        return "ސުމެއް"
+
+    # Special mapping for numbers with ވީސް (20-29)
+    special_vis = {
+        20: "ވީސް",
+        21: "އެކާވީސް",
+        22: "ބާވީސް",
+        23: "ތޭވީސް",
+        24: "ސައްވީސް",
+        25: "ފަންސަވީސް",
+        26: "ސައްބީސް",
+        27: "ހަތާވީސް",
+        28: "އަށާވީސް",
+        29: "ނަވާވީސް"
+    }
+
+    # Special handling for years (1000-9999)
+    if is_year and 1000 <= num <= 9999:
+        millennium = num // 1000
+        last_two_digits = num % 100
+        
+        millennium_text = f"{d[millennium][0]}ހާސް"
+        
+        if last_two_digits == 0:
+            return millennium_text
+        
+        # Use special mapping for 20-29
+        if last_two_digits in special_vis:
+            return f"{millennium_text} {special_vis[last_two_digits]}"
+        
+        # Handle other numbers...
+        if last_two_digits in d:
+            return f"{millennium_text} {d[last_two_digits][0]}"
+        else:
+            year_tens = (last_two_digits // 10) * 10
+            year_ones = last_two_digits % 10
+            
+            if year_ones == 0:
+                return f"{millennium_text} {d[year_tens][0]}"
+            else:
+                return f"{millennium_text} {d[year_tens][0]} {d[year_ones][0]}"
+
+    # Regular number handling
+    if num in d:
+        return d[num][1 if is_spoken else 0]
+
+    # Add check for special_vis numbers (20-29)
+    if num in special_vis:
+        return special_vis[num]
+
+    if num < 100:
+        if is_spoken:
+            thousands = True
+        
+        base = (num // 10) * 10
+        remainder = num % 10
+        
+        if remainder == 0:
+            return d[base][1 if is_spoken else 0]
+        
+        return f"{d[base][1 if is_spoken else 0]} {d[remainder][0 if thousands else 1]}"
+
+    if num < k:
+        hundreds = num // 100
+        remainder = num % 100
+        
+        if hundreds == 2:
+            hundreds_text = f"{d[hundreds][0]}ސައްތަ"
+        else:
+            hundreds_text = f"{d[hundreds][0]}ސަތޭކަ"
+            
+        if remainder == 0:
+            return hundreds_text
+        return f"{hundreds_text} {int_to_dv(remainder, False, is_spoken)}"
+
+    if num < m:
+        thousands = num // k
+        remainder = num % k
+        # Get the number text and convert to haas form if needed
+        thousands_text = int_to_dv(thousands, True)
+        for spoken_form, haas_form in haas_map.items():
+            if thousands_text.endswith(spoken_form):
+                thousands_text = thousands_text[:-len(spoken_form)] + haas_form
+                break
+        
+        thousands_text = f"{thousands_text}ހާސް"
+        if remainder == 0:
+            return thousands_text
+        return f"{thousands_text} {int_to_dv(remainder, False, is_spoken)}"
+
+    if num < b:
+        millions = num // m
+        remainder = num % m
+        millions_text = f"{int_to_dv(millions, True)}މިލިއަން"
+        if remainder == 0:
+            return millions_text
+        return f"{millions_text} {int_to_dv(remainder, False, is_spoken)}"
+
+    if num < t:
+        billions = num // b
+        remainder = num % b
+        billions_text = f"{int_to_dv(billions, True)}ބިލިއަން"
+        if remainder == 0:
+            return billions_text
+        return f"{billions_text} {int_to_dv(remainder, False, is_spoken)}"
+
+    trillions = num // t
+    remainder = num % t
+    trillions_text = f"{int_to_dv(trillions, True)}ޓްރިލިއަން"
+    if remainder == 0:
+        return trillions_text
+    return f"{trillions_text} {int_to_dv(remainder, False, is_spoken)}"

dv-normalizer-0.1.0/dv_normalize/dv_sentence.py

@@ -0,0 +1,133 @@
+import re
+from dv_normalize.dv_num import int_to_dv
+
+def replace_digits_with_dv(text: str) -> str:
+    """
+    Convert all numbers in text to Dhivehi, handling different formats:
+    - Regular numbers
+    - Years (when followed by ވަނަ)
+    - Decimal numbers
+    """
+    def convert_match(match):
+        full_num = match.group(0)
+        
+        # Handle decimal numbers
+        if '.' in full_num:
+            whole, decimal = full_num.split('.')
+            whole_dv = int_to_dv(int(whole), is_spoken=True)
+            decimal_dv = ' '.join(int_to_dv(int(d), is_spoken=True) for d in decimal)
+            return f"{whole_dv} ޕޮއިންޓު {decimal_dv}"
+        
+        num = int(full_num)
+        
+        # Check if next word is ވަނަ (indicates year)
+        text_after = text[match.end():].strip()
+        if text_after.startswith('ވަނަ'):
+            return int_to_dv(num, is_year=True)
+        
+        # Regular number conversion
+        return int_to_dv(num, is_spoken=True)
+
+    # Remove commas from numbers first
+    text = text.replace(',', '')
+    
+    # Convert all numbers using the pattern
+    pattern = r'\d+(?:\.\d+)?'
+    text = re.sub(pattern, convert_match, text)
+    
+    return text
+
+def normalize_sentence_end(text: str) -> str:
+    """
+    Normalize Dhivehi sentence endings using common patterns for spoken form
+    """
+    patterns = [
+        # Noun endings with އެކެވެ
+        (r'([ަ-ް]*?)އެކެވެ', r'\1އެއް'),
+        (r'([ަ-ް]*?)ކެކެވެ', r'\1ކެއް'),
+        (r'([ަ-ް]*?)ތެކެވެ', r'\1ތެއް'),
+        (r'([ަ-ް]*?)މެކެވެ', r'\1މެއް'),
+        (r'([ަ-ް]*?)ހެކެވެ', r'\1ހެއް'),
+        (r'([ަ-ް]*?)ރެކެވެ', r'\1ރެއް'),
+        (r'([ަ-ް]*?)ޅެކެވެ', r'\1ޅެއް'),
+        
+        # Endings that convert to ށް
+        (r'ށެވެ', 'ށް'),
+        (r'އަށެވެ', 'އަށް'),
+        (r'ޔަށެވެ', 'ޔަށް'),
+        (r'ކަށެވެ', 'ކަށް'),
+        (r'ތަށެވެ', 'ތަށް'),
+        (r'ޗަށެވެ', 'ޗަށް'),
+        (r'ނަށެވެ', 'ނަށް'),
+        (r'ރަށެވެ', 'ރަށް'),
+        (r'ދަށެވެ', 'ދަށް'),
+        
+        # Common verb endings
+        (r'ވެއެވެ', 'ވޭ'),
+        (r'ނެއެވެ', 'ނެ'),
+        (r'ވިއެވެ', 'ވި'),
+        (r'ދެއެވެ', 'ދޭ'),
+        (r'ޖެއެވެ', 'ޖެ'),
+        (r'ލެއެވެ', 'ލެ'),
+        (r'ހުރެއެވެ', 'ހުރޭ'),
+        (r'ބެއެވެ', 'ބޭ'),
+        (r'ރެއެވެ', 'ރޭ'),
+        
+        # Common noun endings
+        (r'ތަކެވެ', 'ތައް'),
+        (r'ގައެވެ', 'ގައި'),
+        (r'އަހެވެ', 'ވަސް'),
+        (r'ބަހެވެ', 'ބަސް'),
+        
+        # Endings that convert to ން
+        (r'އިންނެވެ', 'އިން'),
+        (r'ންނެވެ', 'ން'),
+        (r'ދުނެވެ', 'ދުން'),
+        (r'ދުމެވެ', 'ދުން'),
+        (r'ރުމެވެ', 'ރުން'),
+        (r'މުމެވެ', 'މުން'),
+        (r'ޅެމެވެ', 'ޅެން'),
+        (r'ޔުމެވެ', 'ޔުން'),
+        
+        # Special cases
+        (r'ނޫނެވެ', 'ނޫން'),
+        (r'ހުއްޓެވެ', 'ހުރި'),
+        (r'ލެވެ', 'ލު'),
+        (r'ދެވެ', 'ދު'),
+        (r'ރެވެ', 'ރު'),
+        (r'ޅެވެ', 'ޅު'),
+        
+        # Remove standalone އެވެ (should be last)
+        (r'\s*އެވެ', ''),
+    ]
+    
+    # Apply patterns
+    for pattern, replacement in patterns:
+        text = re.sub(pattern, replacement, text)
+    
+    return text.strip()
+
+def spoken_dv(text: str) -> str:
+    """
+    Normalize Dhivehi text by:
+    1. Converting numbers to spoken form (including years and decimals)
+    2. Normalizing sentence endings
+    3. Removing special characters
+    4. Cleaning up whitespace
+    """
+    if not text or not isinstance(text, str):
+        return ""
+    
+    # Pre-process
+    text = text.strip()
+    
+    # Apply normalizations
+    text = normalize_sentence_end(text)
+    text = replace_digits_with_dv(text)
+    
+    # Post-process to fix spacing
+    text = re.sub(r'(?<=[ހ-ޥ])\s+(?=[ަ-ް])', '', text)  # Fix diacritic spacing
+    text = re.sub(r'\s+([.،؟!])', r'\1', text)  # Fix punctuation spacing
+    text = re.sub(r'\s+', ' ', text)  # Normalize spaces
+    
+    return text.strip()

dv-normalizer-0.1.0/dv_normalizer.egg-info/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.1
+Name: dv-normalizer
+Version: 0.1.0
+Summary: A Python library for normalizing Dhivehi text and converting numbers to Dhivehi text format, supporting written, spoken and year forms
+Author: Alakxender
+Author-email: alakxender@gmail.com
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENCE
+
+# dv-normalize
+
+A Python library for normalizing Dhivehi text by converting numbers to Dhivehi and standardizing sentence endings.
+
+## Features
+
+- Converts numbers to Dhivehi text (both written and spoken forms)
+- Handles years (when followed by ވަނަ)
+- Handles decimal numbers
+- Normalizes formal sentence endings to colloquial form
+- Preserves proper spacing and punctuation
+
+## Installation
+
+```bash
+pip install dv-normalize
+```
+
+## Usage
+
+There are two main functions in this library:
+
+1. `int_to_dv` - This function converts numbers to Dhivehi text in written form.
+2. `spoken_dv` - This function converts dhivehi text to spoken form.
+
+### Written form
+
+```python
+
+## test case for int_to_dv
+
+from dv_normalize.dv_num import int_to_dv
+
+def main():
+    while True:
+        try:
+            num = input("Enter a number (0 to trillion) or 'q' to exit: ")
+            if num.lower() == 'q':
+                break
+                
+            num = int(num)
+            if num < 0:
+                print("Please enter a non-negative number")
+                continue
+                
+            print(f"{num:,} in Dhivehi:")
+            written = int_to_dv(num, is_spoken=False)
+            spoken = int_to_dv(num, is_spoken=True)
+            year = "Not a valid year format" if num < 1000 or num > 9999 else int_to_dv(num, is_year=True)
+            
+            print(f"Written form: {written}")
+            print(f"Spoken form: {spoken}")
+            print(f"Year form: {year}")
+            
+        except ValueError:
+            print("Please enter a valid number")
+
+if __name__ == "__main__":
+    main()
+```
+
+### Spoken form
+
+```python
+from dv_normalize.dv_sentence import spoken_dv
+
+# Test cases
+test_cases = [
+    "މިއަދު ވަރަށް ފިނިވެއެވެ.",  # Verb ending
+    "މިއީ ރީތި ފޮތެކެވެ.",        # Noun ending
+    "އޭނާ ދަނީ ސްކޫލަށެވެ.",      # Direction ending
+    "1955 މީހުން ތިބެއެވެ.",      # Number with ending
+    "2024 ވަނަ އަހަރު",            # Year
+    "12.5 ރުފިޔާ",                # Decimal
+    "1000 މީހުން",                # Regular number
+    "މިއީ ރީތި ފޮތެކެވެ.",          # Sentence ending
+    "އޭނާ ގެއަށެވެ.",              # Sentence ending
+    "ހާއްސަ އެއްބަސްވުމުގެ ދަށުން އިންޑިއާއިން ރާއްޖެއަށް ވިއްކާ ހަކުރު އޮޅުވާލައިގެން ލަންކާއަށް!", # test sentence
+    "އެ އިދާރާއިން ބަލަމުން އަންނަނީ މިދިޔަ މަހުގެ 25 ގައި އެގައުމުން ބޭރު ކުރި 64 ހާސް ޓަނުގެ ހަކުރުގެ ޝިޕްމެންޓެއްގެ މައްސަލަ އެވެ. އެ ޝިޕްމެންޓް އެގައުމުން ބޭރުކުރީ ރާއްޖެ އާއި އިންޑިއާ އާ ދެމެދު ވެފައިވާ ވިޔަފާރީގެ ހާއްސަ އެއްބަސްވުމުގެ ދަށުން ކަނޑައަޅާފައިވާ އަގުތަކުގައި ނަމަވެސް، އެއިން ބައެއް ލަންކާއަށް އެތެރެކުރިން ފަޅާއަރާފައިވާ ކަމަށް އިންޑިއާގެ ބައެއް ނޫސްތަކުގައި ރިފޯޓުކޮށްފައިވެ އެވެ." # test long sentence
+]
+
+for test in test_cases:
+    print(f"Original: {test}")
+    print(f"Normalized: {spoken_dv(test)}\n")
+
+```
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

dv-normalizer-0.1.0/dv_normalizer.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENCE
+README.md
+pyproject.toml
+setup.py
+dv_normalize/__init__.py
+dv_normalize/dv_num.py
+dv_normalize/dv_sentence.py
+dv_normalizer.egg-info/PKG-INFO
+dv_normalizer.egg-info/SOURCES.txt
+dv_normalizer.egg-info/dependency_links.txt
+dv_normalizer.egg-info/top_level.txt

dv-normalizer-0.1.0/dv_normalizer.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dv-normalizer-0.1.0/dv_normalizer.egg-info/top_level.txt

@@ -0,0 +1 @@
+dv_normalize

dv-normalizer-0.1.0/pyproject.toml

@@ -0,0 +1,6 @@
+[build-system]
+requires = ["setuptools>=45", "wheel", "setuptools_scm>=6.2"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools_scm]
+write_to = "_version.py"

dv-normalizer-0.1.0/setup.cfg

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

dv-normalizer-0.1.0/setup.py

@@ -0,0 +1,20 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r") as f:
+    long_description = f.read()
+
+setup(
+    name="dv-normalizer",
+    version="0.1.0",
+    description="A Python library for normalizing Dhivehi text and converting numbers to Dhivehi text format, supporting written, spoken and year forms",
+    author="Alakxender",
+    author_email="alakxender@gmail.com",
+    packages=find_packages(),
+    python_requires=">=3.8",
+    include_package_data=True,
+    package_data={
+        "dv_normalizer": ["*.yaml", "*.json", "configs/*"],
+    },
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+)