num2words2 0.1.0.dev1__py3-none-any.whl

num2words2/lang_GU.py

@@ -0,0 +1,172 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2003, Taro Ogawa.  All Rights Reserved.
+# Copyright (c) 2013, Savoir-faire Linux inc.  All Rights Reserved.
+
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+# MA 02110-1301 USA
+
+from __future__ import unicode_literals
+
+from .base import Num2Word_Base
+
+
+# Gujarati language support
+class Num2Word_GU(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'INR': (('રૂપિયો', 'રૂપિયા'), ('પૈસો', 'પૈસા')),
+        'USD': (('ડોલર', 'ડોલર'), ('સેન્ટ', 'સેન્ટ')),
+        'EUR': (('યૂરો', 'યૂરો'), ('સેન્ટ', 'સેન્ટ')),
+        'GBP': (('પાઉન્ડ', 'પાઉન્ડ'), ('પેન્સ', 'પેન્સ')),
+    }
+
+    def setup(self):
+        self.negword = "ઋણ "
+        self.pointword = "દશાંશ"
+
+    def to_cardinal(self, number):
+        """Convert a number to its word representation in Gujarati."""
+        n = str(number).strip()
+
+        if n.startswith('-'):
+            n = n[1:]
+            ret = self.negword
+        else:
+            ret = ""
+
+        if '.' in n:
+            left, right = n.split('.', 1)
+            ret += self._int_to_word(int(left)) + " " + self.pointword + " "
+            ret += " ".join(self._int_to_word(int(d)) for d in right)
+            return ret.strip()
+        else:
+            return (ret + self._int_to_word(int(n))).strip()
+
+    def _int_to_word(self, number):
+        """Convert an integer to its word representation in Gujarati."""
+        if number == 0:
+            return "શૂન્ય"
+
+        # Gujarati number words
+        ones = ["", "એક", "બે", "ત્રણ", "ચાર", "પાંચ", "છ", "સાત", "આઠ", "નવ"]
+        tens = ["", "દસ", "વીસ", "ત્રીસ", "ચાલીસ", "પચાસ", "સાઠ", "સિત્તેર", "એંસી", "નેવું"]
+        teens = ["દસ", "અગિયાર", "બાર", "તેર", "ચૌદ", "પંદર", "સોળ", "સત્તર", "અઢાર", "ઓગણીસ"]
+
+        # Handle special numbers
+        if number < 0:
+            return self.negword + self._int_to_word(abs(number))
+        elif number < 10:
+            return ones[number]
+        elif number < 20:
+            return teens[number - 10]
+        elif number < 100:
+            result = tens[number // 10]
+            if number % 10:
+                result += " " + ones[number % 10]
+            return result
+        elif number < 1000:
+            result = ones[number // 100] + " સો"
+            remainder = number % 100
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+        elif number < 100000:  # Indian lakh system
+            result = self._int_to_word(number // 1000) + " હજાર"
+            remainder = number % 1000
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+        elif number < 10000000:  # 1 crore
+            result = self._int_to_word(number // 100000) + " લાખ"
+            remainder = number % 100000
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+        elif number < 1000000000:  # Less than 100 crore
+            result = self._int_to_word(number // 10000000) + " કરોડ"
+            remainder = number % 10000000
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+        elif number < 100000000000:  # Arab
+            result = self._int_to_word(number // 1000000000) + " અબજ"
+            remainder = number % 1000000000
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+        else:  # Kharab
+            result = self._int_to_word(number // 100000000000) + " ખર્વ"
+            remainder = number % 100000000000
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+
+    def to_ordinal(self, number):
+        """Convert to ordinal in Gujarati."""
+        cardinal = self.to_cardinal(number)
+
+        # Gujarati ordinal suffixes
+        if number == 1:
+            return "પહેલો"
+        elif number == 2:
+            return "બીજો"
+        elif number == 3:
+            return "ત્રીજો"
+        elif number == 4:
+            return "ચોથો"
+        elif number == 6:
+            return "છઠ્ઠો"
+        else:
+            return cardinal + "મો"
+
+    def to_ordinal_num(self, number):
+        """Convert to abbreviated ordinal."""
+        if number == 1:
+            return "૧લો"
+        elif number == 2:
+            return "૨જો"
+        elif number == 3:
+            return "૩જો"
+        else:
+            return str(number) + "મો"
+
+    def to_year(self, val, longval=True):
+        """Convert to year in Gujarati."""
+        if val < 0:
+            return "ઈસવીસન પૂર્વે " + self.to_cardinal(abs(val))
+        else:
+            return "સન " + self.to_cardinal(val)
+
+    def to_currency(self, val, currency='INR', cents=True, separator=' અને ', adjective=False):
+        """Convert to currency in Gujarati."""
+        is_negative = False
+        if val < 0:
+            is_negative = True
+            val = abs(val)
+
+        parts = str(val).split('.')
+        left = int(parts[0]) if parts[0] else 0
+        right = int(parts[1][:2].ljust(2, '0')) if len(parts) > 1 and parts[1] else 0
+
+        cr1, cr2 = self.CURRENCY_FORMS.get(currency, self.CURRENCY_FORMS['INR'])
+
+        left_str = self._int_to_word(left)
+        result = left_str + " " + (cr1[1] if left != 1 else cr1[0])
+
+        if cents and right:
+            cents_str = self._int_to_word(right)
+            result += separator + cents_str + " " + (cr2[1] if right != 1 else cr2[0])
+
+        if is_negative:
+            result = self.negword + result
+
+        return result.strip()

num2words2/lang_HA.py

@@ -0,0 +1,293 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2003, Taro Ogawa.  All Rights Reserved.
+# Copyright (c) 2013, Savoir-faire Linux inc.  All Rights Reserved.
+
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+# MA 02110-1301 USA
+
+from __future__ import unicode_literals
+
+from .base import Num2Word_Base
+
+
+class Num2Word_HA(Num2Word_Base):
+    """
+    Hausa number-to-words converter.
+
+    Supports cardinal numbers, ordinal numbers, currency conversion,
+    and year representation in Hausa language.
+    """
+
+    CURRENCY_FORMS = {
+        'NGN': (('naira', 'naira'), ('kobo', 'kobo')),
+        'USD': (('dala', 'dala'), ('cent', 'cent')),
+        'EUR': (('yuro', 'yuro'), ('cent', 'cent')),
+        'GBP': (('fam', 'fam'), ('pence', 'pence')),
+        'JPY': (('yen', 'yen'), ('sen', 'sen')),
+        'CNY': (('yuan', 'yuan'), ('fen', 'fen')),
+    }
+
+    # Hausa numerals
+    ONES = {
+        0: 'sifiri',
+        1: 'ɗaya',
+        2: 'biyu',
+        3: 'uku',
+        4: 'huɗu',
+        5: 'biyar',
+        6: 'shida',
+        7: 'bakwai',
+        8: 'takwas',
+        9: 'tara'
+    }
+
+    TEENS = {
+        10: 'goma',
+        11: 'sha ɗaya',
+        12: 'sha biyu',
+        13: 'sha uku',
+        14: 'sha huɗu',
+        15: 'sha biyar',
+        16: 'sha shida',
+        17: 'sha bakwai',
+        18: 'sha takwas',
+        19: 'sha tara'
+    }
+
+    TENS = {
+        2: 'ashirin',
+        3: 'talatin',
+        4: 'arba\'in',
+        5: 'hamsin',
+        6: 'sittin',
+        7: 'saba\'in',
+        8: 'tamanin',
+        9: 'casa\'in'
+    }
+
+    SCALE = {
+        100: 'ɗari',
+        1000: 'dubu',
+        1000000: 'miliyan',
+        1000000000: 'biliyan',
+        1000000000000: 'tiriliyan'
+    }
+
+    def setup(self):
+        """Setup the converter with Hausa-specific settings."""
+        self.negword = "ban "
+        self.pointword = "wajen"
+        self.exclude_title = ["da", "wajen", "ban"]
+
+    def to_cardinal(self, value):
+        """Convert a number to its Hausa cardinal representation."""
+        if value == 0:
+            return self.ONES[0]
+
+        if value < 0:
+            return self.negword + self.to_cardinal(abs(value))
+
+        # Handle floating point numbers
+        if isinstance(value, float):
+            return self.float_to_words(value)
+
+        return self._int_to_hausa(value)
+
+    def _int_to_hausa(self, number):
+        """Convert an integer to Hausa words."""
+        if number == 0:
+            return ""
+
+        if number < 10:
+            return self.ONES[number]
+
+        if number < 20:
+            return self.TEENS[number]
+
+        if number < 100:
+            tens, units = divmod(number, 10)
+            result = self.TENS[tens]
+            if units > 0:
+                result += " da " + self.ONES[units]
+            return result
+
+        if number < 1000:
+            hundreds, remainder = divmod(number, 100)
+            result = ""
+            if hundreds == 1:
+                result = "ɗari"
+            else:
+                result = "ɗari " + self.ONES[hundreds]
+
+            if remainder > 0:
+                if remainder < 10:
+                    result += " da " + self._int_to_hausa(remainder)
+                else:
+                    result += " " + self._int_to_hausa(remainder)
+            return result
+
+        # Handle thousands and above
+        for scale_value in sorted(self.SCALE.keys(), reverse=True):
+            if number >= scale_value:
+                quotient, remainder = divmod(number, scale_value)
+                result = ""
+
+                if scale_value == 100:
+                    if quotient == 1:
+                        result = "ɗari"
+                    else:
+                        result = "ɗari " + self._int_to_hausa(quotient)
+                elif scale_value == 1000:
+                    if quotient == 1:
+                        result = "dubu"
+                    else:
+                        result = "dubu " + self._int_to_hausa(quotient)
+                else:
+                    # For millions, billions, etc.
+                    scale_name = self.SCALE[scale_value]
+                    if quotient == 1:
+                        result = scale_name
+                    else:
+                        result = scale_name + " " + self._int_to_hausa(quotient)
+
+                if remainder > 0:
+                    if remainder < 10:
+                        result += " da " + self._int_to_hausa(remainder)
+                    else:
+                        result += " " + self._int_to_hausa(remainder)
+
+                return result
+
+        return str(number)  # Fallback for very large numbers
+
+    def to_ordinal(self, value):
+        """Convert a number to its Hausa ordinal representation."""
+        if value == 1:
+            return "na farko"
+
+        cardinal = self.to_cardinal(value)
+        return "na " + cardinal
+
+    def to_ordinal_num(self, value):
+        """Convert a number to its ordinal representation with Arabic numerals."""
+        # Using English-style ordinal suffixes as commonly used in Hausa contexts
+
+        if 10 <= value % 100 <= 20:
+            suffix = "th"
+        else:
+            last_digit = value % 10
+            if last_digit == 1:
+                suffix = "st"
+            elif last_digit == 2:
+                suffix = "nd"
+            elif last_digit == 3:
+                suffix = "rd"
+            else:
+                suffix = "th"
+
+        return str(value) + suffix
+
+    def to_year(self, value):
+        """Convert a number to its Hausa year representation."""
+        return self.to_cardinal(value)
+
+    def to_currency(self, value, currency='NGN', cents=True):
+        """Convert a value to its Hausa currency representation."""
+        if currency not in self.CURRENCY_FORMS:
+            currency = 'NGN'  # Default to Nigerian Naira
+
+        result = []
+        is_negative = value < 0
+        value = abs(value)
+
+        # Check if value has fractional cents
+        from decimal import Decimal
+        decimal_val = Decimal(str(value))
+        has_fractional_cents = (decimal_val * 100) % 1 != 0
+
+        if cents:
+            if has_fractional_cents:
+                # Keep precision for fractional cents
+                major_units = int(decimal_val)
+                minor_units = decimal_val * 100 - (major_units * 100)
+            else:
+                # Convert to cents for processing
+                cents_value = int(round(value * 100))
+                major_units, minor_units = divmod(cents_value, 100)
+        else:
+            major_units = int(value)
+            minor_units = 0
+
+        currency_forms = self.CURRENCY_FORMS[currency]
+
+        # Major currency unit
+        if major_units > 0:
+            major_name = currency_forms[0][0]  # Use singular form
+            if major_units == 1:
+                result.append(major_name + " " + self.to_cardinal(major_units))
+            else:
+                result.append(major_name + " " + self.to_cardinal(major_units))
+
+        # Minor currency unit
+        if minor_units > 0:
+            minor_name = currency_forms[1][0]  # Use singular form
+            # Handle fractional minor units
+            from decimal import Decimal
+            if isinstance(minor_units, Decimal):
+                # Convert fractional cents (e.g., 65.3 kobo)
+                minor_words = self.to_cardinal(float(minor_units))
+            else:
+                minor_words = self.to_cardinal(minor_units)
+
+            if major_units > 0:
+                result.append("da " + minor_name + " " + minor_words)
+            else:
+                result.append(minor_name + " " + minor_words)
+
+        if not result:
+            # Handle zero case
+            major_name = currency_forms[0][0]
+            result.append(major_name + " sifiri")
+
+        if is_negative:
+            result.insert(0, self.negword)
+
+        return " ".join(result)
+
+    def pluralize(self, n, forms):
+        """Handle Hausa pluralization rules."""
+        # Hausa doesn't have complex pluralization like some other languages
+        # Generally use the first form provided
+        if forms and len(forms) > 0:
+            return forms[0]
+        return ""
+
+    def float_to_words(self, value):
+        """Convert a floating point number to Hausa words."""
+        if value == int(value):
+            return self.to_cardinal(int(value))
+
+        integer_part = int(value)
+        decimal_part = value - integer_part
+
+        # Get decimal digits
+        decimal_str = str(decimal_part)[2:]  # Remove "0."
+
+        result = self.to_cardinal(integer_part)
+        result += " " + self.pointword + " "
+
+        # Convert decimal digits
+        decimal_num = int(decimal_str)
+        result += self.to_cardinal(decimal_num)
+
+        return result

num2words2/lang_HAW.py

@@ -0,0 +1,144 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2003, Taro Ogawa.  All Rights Reserved.
+# Copyright (c) 2013, Savoir-faire Linux inc.  All Rights Reserved.
+
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+# MA 02110-1301 USA
+
+from __future__ import unicode_literals
+
+from .base import Num2Word_Base
+
+
+# Hawaiian language support
+class Num2Word_HAW(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'USD': (('kālā', 'kālā'), ('keneka', 'keneka')),
+        'EUR': (('euro', 'euros'), ('cent', 'cents'))
+    }
+
+    def setup(self):
+        self.negword = "minus "
+        self.pointword = "point"
+        self.ones = ['', "'ekahi", "'elua", "'ekolu", "'ehā", "'elima", "'eono", "'ehiku", "'ewalu", "'eiwa"]
+        self.tens = ['', "'umi", 'iwakālua', 'kanakolu', 'kanahā', 'kanalima', 'kanaono', 'kanahiku', 'kanawalu', 'kanaiwa']
+        self.hundred = "haneli"
+        self.thousand = "kaukani"
+        self.million = "miliona"
+
+    def to_cardinal(self, number):
+        """Convert a number to its word representation in Hawaiian."""
+        n = str(number).strip()
+
+        if n.startswith('-'):
+            n = n[1:]
+            ret = self.negword
+        else:
+            ret = ""
+
+        if '.' in n:
+            left, right = n.split('.', 1)
+            ret += self._int_to_word(int(left)) + " " + self.pointword + " "
+            for digit in right:
+                ret += self._int_to_word(int(digit)) + " "
+            return ret.strip()
+        else:
+            return (ret + self._int_to_word(int(n))).strip()
+
+    def _int_to_word(self, number):
+        """Convert an integer to its word representation in Hawaiian."""
+        if number == 0:
+            return self.ones[0] if self.ones[0] else "zero"
+
+        if number < 0:
+            return self.negword + self._int_to_word(abs(number))
+        elif number < 10:
+            return self.ones[number]
+        elif number < 100:
+            tens_val = number // 10
+            ones_val = number % 10
+            if ones_val == 0:
+                return self.tens[tens_val]
+            else:
+                return self.tens[tens_val] + " " + self.ones[ones_val]
+        elif number < 1000:
+            hundreds_val = number // 100
+            remainder = number % 100
+            result = self.ones[hundreds_val] + " " + self.hundred
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+        elif number < 1000000:
+            thousands_val = number // 1000
+            remainder = number % 1000
+            result = self._int_to_word(thousands_val) + " " + self.thousand
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+        elif number < 1000000000:
+            millions_val = number // 1000000
+            remainder = number % 1000000
+            result = self._int_to_word(millions_val) + " " + self.million
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+        else:
+            return str(number)  # Fallback for very large numbers
+
+    def to_ordinal(self, number):
+        """Convert to ordinal in Hawaiian.
+
+        Hawaiian ordinals use 'ka' prefix for most numbers.
+        Special forms exist for 1st (ka mua) and 2nd (ka lua).
+        """
+        if number == 1:
+            return "ka mua"  # first
+        elif number == 2:
+            return "ka lua"  # second
+        else:
+            # For other numbers, use "ka" + cardinal
+            cardinal = self.to_cardinal(number)
+            return "ka " + cardinal
+
+    def to_ordinal_num(self, number):
+        """Convert to abbreviated ordinal."""
+        return str(number) + "."
+
+    def to_year(self, val, longval=True):
+        """Convert to year in Hawaiian."""
+        return self.to_cardinal(val)
+
+    def to_currency(self, val, currency='USD', cents=True, separator=' ', adjective=False):
+        """Convert to currency in Hawaiian."""
+        is_negative = False
+        if val < 0:
+            is_negative = True
+            val = abs(val)
+
+        parts = str(val).split('.')
+        left = int(parts[0]) if parts[0] else 0
+        right = int(parts[1][:2].ljust(2, '0')) if len(parts) > 1 and parts[1] else 0
+
+        cr1, cr2 = self.CURRENCY_FORMS.get(currency, list(self.CURRENCY_FORMS.values())[0])
+
+        left_str = self._int_to_word(left)
+        result = left_str + " " + (cr1[1] if left != 1 else cr1[0])
+
+        if cents and right:
+            cents_str = self._int_to_word(right)
+            result += separator + cents_str + " " + (cr2[1] if right != 1 else cr2[0])
+
+        if is_negative:
+            result = self.negword + result
+
+        return result.strip()