geez 1.1.0__tar.gz

geez-1.1.0/LICENSE

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

geez-1.1.0/PKG-INFO

@@ -0,0 +1,195 @@
+Metadata-Version: 2.4
+Name: geez
+Version: 1.1.0
+Summary: A Python library to convert numbers to their Ge'ez number representation
+Home-page: https://github.com/kidusmakonnen/geez-py
+Author: Kidus Makonnen
+License: MIT
+Project-URL: Homepage, https://github.com/kidusmakonnen/geez-py
+Project-URL: Bug Tracker, https://github.com/kidusmakonnen/geez-py/issues
+Project-URL: Source Code, https://github.com/kidusmakonnen/geez-py
+Keywords: geez,ethiopian,numerals,conversion
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+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: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Topic :: Utilities
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Ge'ez Utils (Python)
+
+[![MIT license](http://img.shields.io/badge/license-MIT-brightgreen.svg)](http://opensource.org/licenses/MIT)
+
+A Python library to convert numbers to their [Ge'ez number](https://en.wikipedia.org/wiki/Ge%CA%BDez_script#Numerals "Ge'ez number") representation and vice versa.
+
+Ported from the original Java implementation: [kidusmakonnen/geez](https://github.com/kidusmakonnen/geez)
+
+## Features
+
+- Convert Arabic numerals to Ge'ez numerals
+- Convert Ge'ez numerals back to Arabic numerals
+- Support for large numbers
+- Comprehensive test suite
+- Compatible with Python 3.6+
+
+## Installation
+
+You can install this package using pip:
+
+```bash
+pip install geez
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/kidusmakonnen/geez-py.git
+cd geez-py
+pip install .
+```
+
+## Usage
+
+### Converting Arabic Numerals to Ge'ez
+
+```python
+from geez import to_geez
+
+# Convert number to Ge'ez (string input)
+result = to_geez("123")
+print(result)  # Output: ፻፳፫
+
+# Convert number to Ge'ez (integer input)
+result = to_geez(123)
+print(result)  # Output: ፻፳፫
+
+# Convert large numbers
+result = to_geez(1000000)
+print(result)  # Output: ፻፼
+```
+
+### Converting Ge'ez Numerals to Arabic
+
+```python
+from geez import from_geez
+
+# Convert Ge'ez to number
+result = from_geez("፻፳፫")
+print(result)  # Output: "123"
+
+# Convert large Ge'ez numbers
+result = from_geez("፻፼")
+print(result)  # Output: "1000000"
+```
+
+### Error Handling
+
+The library raises `ValueError` for invalid inputs:
+
+```python
+from geez import to_geez, from_geez
+
+try:
+    # Invalid input (negative number)
+    to_geez("-5")
+except ValueError as e:
+    print(e)  # Output: Invalid input.
+
+try:
+    # Invalid Ge'ez number
+    from_geez("፩፩")
+except ValueError as e:
+    print(e)  # Output: Invalid Ge'ez number.
+```
+
+## Ge'ez Numerals Reference
+
+| Arabic | Ge'ez | | Arabic | Ge'ez |
+|--------|-------|-|--------|-------|
+| 1      | ፩     | | 10     | ፲     |
+| 2      | ፪     | | 20     | ፳     |
+| 3      | ፫     | | 30     | ፴     |
+| 4      | ፬     | | 40     | ፵     |
+| 5      | ፭     | | 50     | ፶     |
+| 6      | ፮     | | 60     | ፷     |
+| 7      | ፯     | | 70     | ፸     |
+| 8      | ፰     | | 80     | ፹     |
+| 9      | ፱     | | 90     | ፺     |
+| 100    | ፻     | | 10000  | ፼     |
+
+## Development
+
+### Running Tests
+
+```bash
+# Install development dependencies
+pip install -e .
+
+# Run tests
+python -m unittest discover tests
+
+# Or run specific test
+python -m unittest tests.test_geez_util
+```
+
+### Building the Package
+
+```bash
+# Install build dependencies
+pip install build
+
+# Build the package
+python -m build
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## API Reference
+
+### Functions
+
+#### `to_geez(num: Union[str, int]) -> str`
+
+Convert an Arabic numeral to Ge'ez numerals.
+
+**Parameters:**
+- `num` (str or int): String or integer representation of a number greater than 0
+
+**Returns:**
+- `str`: The converted Ge'ez number as a string
+
+**Raises:**
+- `ValueError`: If the input is invalid (not a positive number)
+
+#### `from_geez(geez_number: str) -> str`
+
+Convert Ge'ez numerals back into Arabic numerals.
+
+**Parameters:**
+- `geez_number` (str): The Ge'ez number string
+
+**Returns:**
+- `str`: The converted number as a string
+
+**Raises:**
+- `ValueError`: If the input is an invalid Ge'ez number

geez-1.1.0/README.md

@@ -0,0 +1,163 @@
+# Ge'ez Utils (Python)
+
+[![MIT license](http://img.shields.io/badge/license-MIT-brightgreen.svg)](http://opensource.org/licenses/MIT)
+
+A Python library to convert numbers to their [Ge'ez number](https://en.wikipedia.org/wiki/Ge%CA%BDez_script#Numerals "Ge'ez number") representation and vice versa.
+
+Ported from the original Java implementation: [kidusmakonnen/geez](https://github.com/kidusmakonnen/geez)
+
+## Features
+
+- Convert Arabic numerals to Ge'ez numerals
+- Convert Ge'ez numerals back to Arabic numerals
+- Support for large numbers
+- Comprehensive test suite
+- Compatible with Python 3.6+
+
+## Installation
+
+You can install this package using pip:
+
+```bash
+pip install geez
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/kidusmakonnen/geez-py.git
+cd geez-py
+pip install .
+```
+
+## Usage
+
+### Converting Arabic Numerals to Ge'ez
+
+```python
+from geez import to_geez
+
+# Convert number to Ge'ez (string input)
+result = to_geez("123")
+print(result)  # Output: ፻፳፫
+
+# Convert number to Ge'ez (integer input)
+result = to_geez(123)
+print(result)  # Output: ፻፳፫
+
+# Convert large numbers
+result = to_geez(1000000)
+print(result)  # Output: ፻፼
+```
+
+### Converting Ge'ez Numerals to Arabic
+
+```python
+from geez import from_geez
+
+# Convert Ge'ez to number
+result = from_geez("፻፳፫")
+print(result)  # Output: "123"
+
+# Convert large Ge'ez numbers
+result = from_geez("፻፼")
+print(result)  # Output: "1000000"
+```
+
+### Error Handling
+
+The library raises `ValueError` for invalid inputs:
+
+```python
+from geez import to_geez, from_geez
+
+try:
+    # Invalid input (negative number)
+    to_geez("-5")
+except ValueError as e:
+    print(e)  # Output: Invalid input.
+
+try:
+    # Invalid Ge'ez number
+    from_geez("፩፩")
+except ValueError as e:
+    print(e)  # Output: Invalid Ge'ez number.
+```
+
+## Ge'ez Numerals Reference
+
+| Arabic | Ge'ez | | Arabic | Ge'ez |
+|--------|-------|-|--------|-------|
+| 1      | ፩     | | 10     | ፲     |
+| 2      | ፪     | | 20     | ፳     |
+| 3      | ፫     | | 30     | ፴     |
+| 4      | ፬     | | 40     | ፵     |
+| 5      | ፭     | | 50     | ፶     |
+| 6      | ፮     | | 60     | ፷     |
+| 7      | ፯     | | 70     | ፸     |
+| 8      | ፰     | | 80     | ፹     |
+| 9      | ፱     | | 90     | ፺     |
+| 100    | ፻     | | 10000  | ፼     |
+
+## Development
+
+### Running Tests
+
+```bash
+# Install development dependencies
+pip install -e .
+
+# Run tests
+python -m unittest discover tests
+
+# Or run specific test
+python -m unittest tests.test_geez_util
+```
+
+### Building the Package
+
+```bash
+# Install build dependencies
+pip install build
+
+# Build the package
+python -m build
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## API Reference
+
+### Functions
+
+#### `to_geez(num: Union[str, int]) -> str`
+
+Convert an Arabic numeral to Ge'ez numerals.
+
+**Parameters:**
+- `num` (str or int): String or integer representation of a number greater than 0
+
+**Returns:**
+- `str`: The converted Ge'ez number as a string
+
+**Raises:**
+- `ValueError`: If the input is invalid (not a positive number)
+
+#### `from_geez(geez_number: str) -> str`
+
+Convert Ge'ez numerals back into Arabic numerals.
+
+**Parameters:**
+- `geez_number` (str): The Ge'ez number string
+
+**Returns:**
+- `str`: The converted number as a string
+
+**Raises:**
+- `ValueError`: If the input is an invalid Ge'ez number

geez-1.1.0/geez/__init__.py

@@ -0,0 +1,12 @@
+"""
+Ge'ez Utils - A Python library to convert numbers to their Ge'ez number representation.
+
+This package provides utilities for converting between Arabic numerals and Ge'ez numerals.
+"""
+
+from .numerals import to_geez, from_geez
+
+__version__ = "1.1.0"
+__author__ = "Kidus Makonnen"
+
+__all__ = ["to_geez", "from_geez"]

geez-1.1.0/geez/numerals.py

@@ -0,0 +1,265 @@
+"""
+Numeral conversion functions for Ge'ez script.
+
+This module provides functions to convert between Arabic numerals and Ge'ez numerals.
+"""
+
+import re
+from typing import List, Union
+
+# Ge'ez numeral constants
+GEEZ_ONES = ["", "፩", "፪", "፫", "፬", "፭", "፮", "፯", "፰", "፱"]
+GEEZ_TENS = ["", "፲", "፳", "፴", "፵", "፶", "፷", "፸", "፹", "፺"]
+GEEZ_HUNDRED = "፻"
+GEEZ_TEN_THOUSAND = "፼"
+
+# Mapping for conversion back from Ge'ez (initialized lazily)
+_GEEZ_MAP = {}
+
+
+def _initialize_geez_map():
+    """Initialize the mapping dictionary for Ge'ez to Arabic conversion."""
+    global _GEEZ_MAP
+    if not _GEEZ_MAP:  # Only initialize once
+        for i in range(1, 11):
+            _GEEZ_MAP[to_geez(str(i))] = i
+            _GEEZ_MAP[to_geez(str(i * 10))] = i * 10
+        _GEEZ_MAP[GEEZ_TEN_THOUSAND] = 10000
+
+
+def to_geez(num: Union[str, int]) -> str:
+    """
+    Convert an Arabic numeral to Ge'ez numerals.
+    
+    Args:
+        num: String or integer representation of a number greater than 0
+        
+    Returns:
+        The converted Ge'ez number as a string
+        
+    Raises:
+        ValueError: If the input is invalid (not a positive number)
+    """
+    # Convert integer to string if needed
+    if isinstance(num, int):
+        if num <= 0:
+            raise ValueError("Invalid input.")
+        num_str = str(num)
+    else:
+        num_str = str(num)
+    
+    # Strip any leading zeros
+    stripped_number = re.sub(r'^0+(?!$)', '', num_str)
+    
+    if not re.match(r'^[0-9]+$', stripped_number) or stripped_number == "0":
+        raise ValueError("Invalid input.")
+    
+    # Determine the number of digits and prepend 0 if it's odd
+    number = stripped_number if len(stripped_number) % 2 == 0 else f"0{stripped_number}"
+    
+    # Split the number string into groups of two
+    split_number = _split_and_group(number, 2)
+    
+    geez = []
+    group_length = len(split_number) - 1
+    
+    for i in range(group_length, -1, -1):
+        pair = split_number[i]
+        
+        # Convert each pair
+        tens_digit = int(pair[0])
+        ones_digit = int(pair[1])
+        converted_pair = GEEZ_TENS[tens_digit] + GEEZ_ONES[ones_digit]
+        delim = ""
+        
+        if group_length == i:
+            delim = ""
+        else:
+            if (group_length - i) % 2 == 0:
+                delim = GEEZ_TEN_THOUSAND
+                if i == 0 and pair == "01":
+                    converted_pair = ""
+            else:
+                if pair != "00":
+                    delim = GEEZ_HUNDRED
+                if pair == "01":
+                    converted_pair = ""
+        
+        geez.insert(0, converted_pair + delim)
+    
+    return "".join(geez)
+
+
+def from_geez(geez_number: str) -> str:
+    """
+    Convert Ge'ez numerals back into Arabic numerals.
+    
+    Args:
+        geez_number: The Ge'ez number string
+        
+    Returns:
+        The converted number as a string
+        
+    Raises:
+        ValueError: If the input is an invalid Ge'ez number
+    """
+    _initialize_geez_map()  # Ensure the map is initialized
+    
+    geez_num = geez_number
+    
+    # Determine the amount of GEEZ_TEN_THOUSAND characters in the string
+    amount_of_thousands = geez_num.count(GEEZ_TEN_THOUSAND)
+    
+    # From the amount_of_thousands get the max multiplier of the converted back number
+    multiplier = 10000 ** amount_of_thousands
+    
+    result = 0
+    
+    if geez_num and geez_num[0] == GEEZ_TEN_THOUSAND:
+        geez_num = GEEZ_ONES[1] + geez_num
+    
+    if GEEZ_TEN_THOUSAND not in geez_num:
+        return str(_convert_thousands(geez_num))
+    
+    multiply_next = False
+    thousand = []
+    
+    for char in geez_num:
+        if char != GEEZ_TEN_THOUSAND:
+            thousand.append(char)
+            multiply_next = True
+        else:
+            if multiply_next:
+                result += multiplier * _convert_thousands("".join(thousand))
+                multiply_next = False
+                thousand = []
+                amount_of_thousands -= 1
+                multiplier = 10000 ** amount_of_thousands
+    
+    # Convert back the remaining digits and add them back
+    if thousand:
+        result += _convert_thousands("".join(thousand))
+    
+    return str(result)
+
+
+def _convert_thousands(thousand: str) -> int:
+    """
+    Convert numbers 1 - 9999 from Ge'ez to Arabic numerals.
+    
+    Args:
+        thousand: A Ge'ez number string between 1 and 9999
+        
+    Returns:
+        The number converted to Arabic numerals
+        
+    Raises:
+        ValueError: If the input is an invalid Ge'ez number
+    """
+    if GEEZ_HUNDRED not in thousand:
+        return _convert_tens(thousand)
+    
+    amount_of_hundreds = thousand.count(GEEZ_HUNDRED)
+    
+    if amount_of_hundreds > 1:
+        raise ValueError("Invalid Ge'ez number.")
+    
+    hundreds = thousand.split(GEEZ_HUNDRED)
+    
+    if len(hundreds) == 0:
+        return 100
+    elif len(hundreds) == 1:
+        # If the string is just "፻", hundreds[0] will be empty
+        if hundreds[0] == "":
+            return 100
+        else:
+            return _convert_tens(hundreds[0]) * 100
+    else:
+        # hundreds[0] is before ፻, hundreds[1] is after ፻
+        before_hundred = _convert_tens(hundreds[0]) if hundreds[0] else 1
+        after_hundred = _convert_tens(hundreds[1]) if hundreds[1] else 0
+        return (before_hundred * 100) + after_hundred
+
+
+def _convert_tens(hundred: str) -> int:
+    """
+    Convert numbers 1 - 99 from Ge'ez to Arabic numerals.
+    
+    Args:
+        hundred: A Ge'ez number string between 1 and 99
+        
+    Returns:
+        The number converted to Arabic numerals
+        
+    Raises:
+        ValueError: If the input is an invalid Ge'ez number
+    """
+    _initialize_geez_map()  # Ensure the map is initialized
+    
+    length = len(hundred)
+    
+    if length == 0:
+        return 1
+    elif length == 1:
+        if hundred not in _GEEZ_MAP:
+            raise ValueError("Invalid Ge'ez number.")
+        return _GEEZ_MAP[hundred]
+    elif length == 2:
+        tens = hundred[0]
+        ones = hundred[1]
+        
+        if not _hundreds_valid(hundred):
+            raise ValueError("Invalid Ge'ez number.")
+        
+        tens_value = _GEEZ_MAP.get(tens, 0)
+        ones_value = _GEEZ_MAP.get(ones, 0)
+        
+        return tens_value + ones_value
+    else:
+        raise ValueError("Invalid Ge'ez number.")
+
+
+def _hundreds_valid(hundreds: str) -> bool:
+    """
+    Check for illegal combination of Ge'ez numerals (1 - 99).
+    
+    Args:
+        hundreds: The Ge'ez number parameter between 1 - 99 to be validated
+        
+    Returns:
+        True if the provided Ge'ez number is valid, False otherwise
+    """
+    if len(hundreds) != 2:
+        return False
+        
+    tens = hundreds[0]
+    ones = hundreds[1]
+    
+    # Check if tens position has a ones digit (invalid)
+    for geez_one in GEEZ_ONES:
+        if tens == geez_one:
+            return False
+    
+    # Check if ones position has a tens digit (invalid)
+    for geez_ten in GEEZ_TENS:
+        if ones == geez_ten:
+            return False
+    
+    return True
+
+
+def _split_and_group(text: str, split_length: int) -> List[str]:
+    """
+    Split a string into chunks of specified length.
+    
+    Args:
+        text: The text to be split
+        split_length: The length of each chunk
+        
+    Returns:
+        A list of split strings
+    """
+    parts = []
+    for i in range(0, len(text), split_length):
+        parts.append(text[i:i + split_length])
+    return parts

geez-1.1.0/geez.egg-info/PKG-INFO

@@ -0,0 +1,195 @@
+Metadata-Version: 2.4
+Name: geez
+Version: 1.1.0
+Summary: A Python library to convert numbers to their Ge'ez number representation
+Home-page: https://github.com/kidusmakonnen/geez-py
+Author: Kidus Makonnen
+License: MIT
+Project-URL: Homepage, https://github.com/kidusmakonnen/geez-py
+Project-URL: Bug Tracker, https://github.com/kidusmakonnen/geez-py/issues
+Project-URL: Source Code, https://github.com/kidusmakonnen/geez-py
+Keywords: geez,ethiopian,numerals,conversion
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+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: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Topic :: Utilities
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Ge'ez Utils (Python)
+
+[![MIT license](http://img.shields.io/badge/license-MIT-brightgreen.svg)](http://opensource.org/licenses/MIT)
+
+A Python library to convert numbers to their [Ge'ez number](https://en.wikipedia.org/wiki/Ge%CA%BDez_script#Numerals "Ge'ez number") representation and vice versa.
+
+Ported from the original Java implementation: [kidusmakonnen/geez](https://github.com/kidusmakonnen/geez)
+
+## Features
+
+- Convert Arabic numerals to Ge'ez numerals
+- Convert Ge'ez numerals back to Arabic numerals
+- Support for large numbers
+- Comprehensive test suite
+- Compatible with Python 3.6+
+
+## Installation
+
+You can install this package using pip:
+
+```bash
+pip install geez
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/kidusmakonnen/geez-py.git
+cd geez-py
+pip install .
+```
+
+## Usage
+
+### Converting Arabic Numerals to Ge'ez
+
+```python
+from geez import to_geez
+
+# Convert number to Ge'ez (string input)
+result = to_geez("123")
+print(result)  # Output: ፻፳፫
+
+# Convert number to Ge'ez (integer input)
+result = to_geez(123)
+print(result)  # Output: ፻፳፫
+
+# Convert large numbers
+result = to_geez(1000000)
+print(result)  # Output: ፻፼
+```
+
+### Converting Ge'ez Numerals to Arabic
+
+```python
+from geez import from_geez
+
+# Convert Ge'ez to number
+result = from_geez("፻፳፫")
+print(result)  # Output: "123"
+
+# Convert large Ge'ez numbers
+result = from_geez("፻፼")
+print(result)  # Output: "1000000"
+```
+
+### Error Handling
+
+The library raises `ValueError` for invalid inputs:
+
+```python
+from geez import to_geez, from_geez
+
+try:
+    # Invalid input (negative number)
+    to_geez("-5")
+except ValueError as e:
+    print(e)  # Output: Invalid input.
+
+try:
+    # Invalid Ge'ez number
+    from_geez("፩፩")
+except ValueError as e:
+    print(e)  # Output: Invalid Ge'ez number.
+```
+
+## Ge'ez Numerals Reference
+
+| Arabic | Ge'ez | | Arabic | Ge'ez |
+|--------|-------|-|--------|-------|
+| 1      | ፩     | | 10     | ፲     |
+| 2      | ፪     | | 20     | ፳     |
+| 3      | ፫     | | 30     | ፴     |
+| 4      | ፬     | | 40     | ፵     |
+| 5      | ፭     | | 50     | ፶     |
+| 6      | ፮     | | 60     | ፷     |
+| 7      | ፯     | | 70     | ፸     |
+| 8      | ፰     | | 80     | ፹     |
+| 9      | ፱     | | 90     | ፺     |
+| 100    | ፻     | | 10000  | ፼     |
+
+## Development
+
+### Running Tests
+
+```bash
+# Install development dependencies
+pip install -e .
+
+# Run tests
+python -m unittest discover tests
+
+# Or run specific test
+python -m unittest tests.test_geez_util
+```
+
+### Building the Package
+
+```bash
+# Install build dependencies
+pip install build
+
+# Build the package
+python -m build
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## API Reference
+
+### Functions
+
+#### `to_geez(num: Union[str, int]) -> str`
+
+Convert an Arabic numeral to Ge'ez numerals.
+
+**Parameters:**
+- `num` (str or int): String or integer representation of a number greater than 0
+
+**Returns:**
+- `str`: The converted Ge'ez number as a string
+
+**Raises:**
+- `ValueError`: If the input is invalid (not a positive number)
+
+#### `from_geez(geez_number: str) -> str`
+
+Convert Ge'ez numerals back into Arabic numerals.
+
+**Parameters:**
+- `geez_number` (str): The Ge'ez number string
+
+**Returns:**
+- `str`: The converted number as a string
+
+**Raises:**
+- `ValueError`: If the input is an invalid Ge'ez number

geez-1.1.0/geez.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+geez/__init__.py
+geez/numerals.py
+geez.egg-info/PKG-INFO
+geez.egg-info/SOURCES.txt
+geez.egg-info/dependency_links.txt
+geez.egg-info/not-zip-safe
+geez.egg-info/top_level.txt
+tests/__init__.py
+tests/fromGeezData.csv
+tests/test_geez_util.py
+tests/toGeezData.csv

geez-1.1.0/geez.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

geez-1.1.0/geez.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

geez-1.1.0/geez.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+geez
+tests

geez-1.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "geez"
+version = "1.1.0"
+description = "A Python library to convert numbers to their Ge'ez number representation"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [
+    {name = "Kidus Makonnen"}
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.6",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Text Processing :: Linguistic",
+    "Topic :: Utilities",
+]
+keywords = ["geez", "ethiopian", "numerals", "conversion"]
+requires-python = ">=3.6"
+
+[project.urls]
+Homepage = "https://github.com/kidusmakonnen/geez-py"
+"Bug Tracker" = "https://github.com/kidusmakonnen/geez-py/issues"
+"Source Code" = "https://github.com/kidusmakonnen/geez-py"

geez-1.1.0/setup.cfg

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

geez-1.1.0/setup.py

@@ -0,0 +1,50 @@
+"""
+Setup configuration for the geez package.
+"""
+
+from setuptools import setup, find_packages
+import os
+
+# Read the contents of README file
+this_directory = os.path.abspath(os.path.dirname(__file__))
+with open(os.path.join(this_directory, 'README.md'), encoding='utf-8') as f:
+    long_description = f.read()
+
+setup(
+    name="geez",
+    version="1.1.0",
+    author="Kidus Makonnen",
+    description="A Python library to convert numbers to their Ge'ez number representation",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/kidusmakonnen/geez-py",
+    project_urls={
+        "Bug Tracker": "https://github.com/kidusmakonnen/geez-py/issues",
+        "Source Code": "https://github.com/kidusmakonnen/geez-py",
+    },
+    packages=find_packages(),
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "Topic :: Text Processing :: Linguistic",
+        "Topic :: Utilities",
+    ],
+    python_requires=">=3.6",
+    keywords="geez ethiopian numerals conversion",
+    test_suite="tests",
+    include_package_data=True,
+    package_data={
+        'tests': ['*.csv'],
+    },
+    zip_safe=False,
+)

geez-1.1.0/tests/__init__.py

@@ -0,0 +1 @@
+# Test package initialization

geez-1.1.0/tests/fromGeezData.csv

@@ -0,0 +1,90 @@
+፩,1
+፲,10
+፻,100
+፲፻,1000
+፼,10000
+፲፼,100000
+፻፼,1000000
+፲፻፼,10000000
+፼፼,100000000
+፲፼፼,1000000000
+፻፼፼,10000000000
+፲፻፼፼,100000000000
+፼፼፼,1000000000000
+፼፩፼,100010000
+፼፲፼,100100000
+፼፳፼,100200000
+፼፲፩፼,100110000
+፩,1
+፲፩,11
+፻፲፩,111
+፲፩፻፲፩,1111
+፼፲፩፻፲፩,11111
+፲፩፼፲፩፻፲፩,111111
+፻፲፩፼፲፩፻፲፩,1111111
+፲፩፻፲፩፼፲፩፻፲፩,11111111
+፼፲፩፻፲፩፼፲፩፻፲፩,111111111
+፲፩፼፲፩፻፲፩፼፲፩፻፲፩,1111111111
+፻፲፩፼፲፩፻፲፩፼፲፩፻፲፩,11111111111
+፲፩፻፲፩፼፲፩፻፲፩፼፲፩፻፲፩,111111111111
+፼፲፩፻፲፩፼፲፩፻፲፩፼፲፩፻፲፩,1111111111111
+፩,1
+፲፪,12
+፻፳፫,123
+፲፪፻፴፬,1234
+፼፳፫፻፵፭,12345
+፯፻፷፭፼፵፫፻፳፩,7654321
+፲፯፻፷፭፼፵፫፻፳፩,17654321
+፶፩፻፷፩፼፶፩፻፴፩,51615131
+፲፭፻፲፮፼፲፭፻፲፫,15161513
+፲፻፲፼፲፻፲፩,10101011
+፻፩,101
+፲፻፩,1001
+፲፻፲,1010
+፲፻፲፩,1011
+፲፩፻,1100
+፲፩፻፩,1101
+፲፩፻፲፩,1111
+፼፩,10001
+፼፲,10010
+፼፻,10100
+፼፻፩,10101
+፼፻፲,10110
+፼፻፲፩,10111
+፲፼፩,100001
+፲፼፲,100010
+፲፼፲፩,100011
+፲፼፻,100100
+፲፼፲፻፲,101010
+፻፼፩,1000001
+፻፼፻፩,1000101
+፻፼፻,1000100
+፻፩፼,1010000
+፻፩፼፩,1010001
+፻፲፼፩,1100001
+፻፩፼፻፩,1010101
+፼፻፩፼፻፩,101010101
+፼፩፼,100010000
+፼፩፼፻,100010100
+፼፻፩፼፻,101010100
+፫,3
+፴,30
+፴፫,33
+፫፻፫,303
+፴፻፫,3003
+፴፻፴,3030
+፴፻፴፫,3033
+፴፫፻,3300
+፴፫፻፫,3303
+፴፫፻፴፫,3333
+፫፼፫,30003
+፫፼፫፻፫,30303
+፴፼፫,300003
+፴፼፴፻፴,303030
+፫፻፼፫,3000003
+፫፻፼፫፻፫,3000303
+፫፻፫፼፫,3030003
+፫፻፴፼፫,3300003
+፫፻፫፼፫፻፫,3030303
+፫፼፫፻፫፼፫፻፫,303030303
+፫፼፴፫፻፴፫፼፴፫፻፴፫,333333333

geez-1.1.0/tests/test_geez_util.py

@@ -0,0 +1,164 @@
+"""
+Test cases for geez numerals module.
+
+This module contains comprehensive tests for the geez numeral conversion functions,
+including parameterized tests with CSV data and validation tests.
+"""
+
+import unittest
+import csv
+import os
+from geez import to_geez, from_geez
+
+
+class TestGeezNumerals(unittest.TestCase):
+    """Test cases for the geez numeral conversion functions."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.test_dir = os.path.dirname(__file__)
+
+    def test_to_geez_with_csv_data(self):
+        """Test to_geez function with data from toGeezData.csv."""
+        csv_file = os.path.join(self.test_dir, 'toGeezData.csv')
+        
+        with open(csv_file, 'r', encoding='utf-8') as file:
+            reader = csv.reader(file)
+            for row in reader:
+                input_num, expected = row
+                with self.subTest(input=input_num, expected=expected):
+                    result = to_geez(input_num)
+                    self.assertEqual(expected, result, 
+                                   f"Failed for input {input_num}: expected {expected}, got {result}")
+
+    def test_from_geez_with_csv_data(self):
+        """Test from_geez function with data from fromGeezData.csv."""
+        csv_file = os.path.join(self.test_dir, 'fromGeezData.csv')
+        
+        with open(csv_file, 'r', encoding='utf-8') as file:
+            reader = csv.reader(file)
+            for row in reader:
+                input_geez, expected = row
+                with self.subTest(input=input_geez, expected=expected):
+                    result = from_geez(input_geez)
+                    self.assertEqual(expected, result,
+                                   f"Failed for input {input_geez}: expected {expected}, got {result}")
+
+    def test_convert_from_geez_up_to_ten_thousand(self):
+        """Test round-trip conversion for numbers 1 to 9999."""
+        for num in range(1, 10000):
+            with self.subTest(num=num):
+                expected = str(num)
+                expected_geez = to_geez(expected)
+                result = from_geez(expected_geez)
+                self.assertEqual(expected, result,
+                               f"Round-trip failed for {num}: {expected} -> {expected_geez} -> {result}")
+
+    def test_should_throw_exception_invalid_geez_number(self):
+        """Test that invalid Ge'ez numbers throw ValueError."""
+        invalid_geez_numbers = [
+            "፩፩፩፻፻፻፻፩፩",
+            "፩፩", 
+            "፴፫፻፪፪",
+            "፭፭፭",
+            "፩፲",
+            "፲፲",
+            "፻፻",
+            "፼፼፼፼፼፻፻",
+            "፻፻፼"
+        ]
+        
+        for invalid_geez in invalid_geez_numbers:
+            with self.subTest(invalid_geez=invalid_geez):
+                with self.assertRaises(ValueError) as context:
+                    from_geez(invalid_geez)
+                self.assertEqual("Invalid Ge'ez number.", str(context.exception))
+
+    def test_should_throw_exception_on_value_less_than_one(self):
+        """Test that invalid input numbers throw ValueError."""
+        invalid_numbers = ["-23", "-1", "0", "00", "00000", "000000000000"]
+        
+        for invalid_num in invalid_numbers:
+            with self.subTest(invalid_num=invalid_num):
+                with self.assertRaises(ValueError) as context:
+                    to_geez(invalid_num)
+                self.assertEqual("Invalid input.", str(context.exception))
+
+    def test_basic_conversions(self):
+        """Test basic number conversions."""
+        test_cases = [
+            ("1", "፩"),
+            ("10", "፲"),
+            ("100", "፻"),
+            ("1000", "፲፻"),
+            ("10000", "፼"),
+            ("11", "፲፩"),
+            ("21", "፳፩"),
+            ("99", "፺፱"),
+            ("101", "፻፩"),
+            ("1111", "፲፩፻፲፩")
+        ]
+        
+        for input_num, expected_geez in test_cases:
+            with self.subTest(input=input_num):
+                # Test to_geez with string
+                result = to_geez(input_num)
+                self.assertEqual(expected_geez, result)
+                
+                # Test to_geez with integer
+                result_int = to_geez(int(input_num))
+                self.assertEqual(expected_geez, result_int)
+                
+                # Test from_geez (round-trip)
+                back_to_num = from_geez(result)
+                self.assertEqual(input_num, back_to_num)
+
+    def test_integer_input(self):
+        """Test to_geez function with integer inputs."""
+        test_cases = [
+            (1, "፩"),
+            (10, "፲"),
+            (100, "፻"),
+            (1000, "፲፻"),
+            (10000, "፼"),
+            (123, "፻፳፫"),
+            (9999, "፺፱፻፺፱")
+        ]
+        
+        for input_int, expected_geez in test_cases:
+            with self.subTest(input=input_int):
+                result = to_geez(input_int)
+                self.assertEqual(expected_geez, result)
+
+    def test_should_throw_exception_on_invalid_integer(self):
+        """Test that invalid integer inputs throw ValueError."""
+        invalid_integers = [-23, -1, 0]
+        
+        for invalid_int in invalid_integers:
+            with self.subTest(invalid_int=invalid_int):
+                with self.assertRaises(ValueError) as context:
+                    to_geez(invalid_int)
+                self.assertEqual("Invalid input.", str(context.exception))
+
+    def test_large_numbers(self):
+        """Test conversion of large numbers."""
+        test_cases = [
+            ("100000000", "፼፼"),
+            ("1000000000", "፲፼፼"),
+            ("10000000000", "፻፼፼"),
+            ("100000000000", "፲፻፼፼"),
+            ("1000000000000", "፼፼፼")
+        ]
+        
+        for input_num, expected_geez in test_cases:
+            with self.subTest(input=input_num):
+                result = to_geez(input_num)
+                self.assertEqual(expected_geez, result)
+                
+                # Test round-trip
+                back_to_num = from_geez(result)
+                self.assertEqual(input_num, back_to_num)
+
+
+if __name__ == '__main__':
+    unittest.main()

geez-1.1.0/tests/toGeezData.csv

@@ -0,0 +1,92 @@
+1,፩
+10,፲
+100,፻
+1000,፲፻
+10000,፼
+100000,፲፼
+1000000,፻፼
+10000000,፲፻፼
+100000000,፼፼
+1000000000,፲፼፼
+10000000000,፻፼፼
+100000000000,፲፻፼፼
+1000000000000,፼፼፼
+100010000,፼፩፼
+100100000,፼፲፼
+100200000,፼፳፼
+100110000,፼፲፩፼
+1,፩
+11,፲፩
+111,፻፲፩
+1111,፲፩፻፲፩
+11111,፼፲፩፻፲፩
+111111,፲፩፼፲፩፻፲፩
+1111111,፻፲፩፼፲፩፻፲፩
+11111111,፲፩፻፲፩፼፲፩፻፲፩
+111111111,፼፲፩፻፲፩፼፲፩፻፲፩
+1111111111,፲፩፼፲፩፻፲፩፼፲፩፻፲፩
+11111111111,፻፲፩፼፲፩፻፲፩፼፲፩፻፲፩
+111111111111,፲፩፻፲፩፼፲፩፻፲፩፼፲፩፻፲፩
+1111111111111,፼፲፩፻፲፩፼፲፩፻፲፩፼፲፩፻፲፩
+1,፩
+12,፲፪
+123,፻፳፫
+1234,፲፪፻፴፬
+12345,፼፳፫፻፵፭
+7654321,፯፻፷፭፼፵፫፻፳፩
+17654321,፲፯፻፷፭፼፵፫፻፳፩
+51615131,፶፩፻፷፩፼፶፩፻፴፩
+15161513,፲፭፻፲፮፼፲፭፻፲፫
+10101011,፲፻፲፼፲፻፲፩
+101,፻፩
+1001,፲፻፩
+1010,፲፻፲
+1011,፲፻፲፩
+1100,፲፩፻
+1101,፲፩፻፩
+1111,፲፩፻፲፩
+10001,፼፩
+10010,፼፲
+10100,፼፻
+10101,፼፻፩
+10110,፼፻፲
+10111,፼፻፲፩
+100001,፲፼፩
+100010,፲፼፲
+100011,፲፼፲፩
+100100,፲፼፻
+101010,፲፼፲፻፲
+1000001,፻፼፩
+1000101,፻፼፻፩
+1000100,፻፼፻
+1010000,፻፩፼
+1010001,፻፩፼፩
+1100001,፻፲፼፩
+1010101,፻፩፼፻፩
+101010101,፼፻፩፼፻፩
+100010000,፼፩፼
+100010100,፼፩፼፻
+101010100,፼፻፩፼፻
+3,፫
+30,፴
+33,፴፫
+303,፫፻፫
+3003,፴፻፫
+3030,፴፻፴
+3033,፴፻፴፫
+3300,፴፫፻
+3303,፴፫፻፫
+3333,፴፫፻፴፫
+30003,፫፼፫
+30303,፫፼፫፻፫
+300003,፴፼፫
+303030,፴፼፴፻፴
+3000003,፫፻፼፫
+3000303,፫፻፼፫፻፫
+3030003,፫፻፫፼፫
+3300003,፫፻፴፼፫
+3030303,፫፻፫፼፫፻፫
+303030303,፫፼፫፻፫፼፫፻፫
+333333333,፫፼፴፫፻፴፫፼፴፫፻፴፫
+00000000000000000333333333,፫፼፴፫፻፴፫፼፴፫፻፴፫
+00000100010100,፼፩፼፻