num2words2 0.1.0.dev1__py3-none-any.whl

num2words2/lang_UR.py

@@ -0,0 +1,168 @@
+# -*- 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
+
+
+# Urdu language support
+class Num2Word_UR(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'PKR': (('روپیہ', 'روپے'), ('پیسہ', 'پیسے')),
+        'USD': (('dollar', 'dollars'), ('cent', 'cents')),
+        'EUR': (('euro', 'euros'), ('cent', 'cents')),
+    }
+
+    def setup(self):
+        self.negword = "منفی "
+        self.pointword = "اعشاریہ"
+        self.ones = ['', 'ایک', 'دو', 'تین', 'چار', 'پانچ', 'چھ', 'سات', 'آٹھ', 'نو']
+        self.tens = ['', 'دس', 'بیس', 'تیس', 'چالیس', 'پچاس', 'ساٹھ', 'ستر', 'اسی', 'نوے']
+        self.teens = ['دس', 'گیارہ', 'بارہ', 'تیرہ', 'چودہ', 'پندرہ', 'سولہ', 'سترہ', 'اٹھارہ', 'انیس']
+        self.hundred = "سو"
+        self.thousand = "ہزار"
+        self.lakh = "لاکھ"
+        self.crore = "کروڑ"
+        self.zero = "صفر"
+
+    def to_cardinal(self, number):
+        """Convert a number to its word representation in Urdu."""
+        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 Urdu."""
+        if number == 0:
+            return self.zero
+
+        if number < 0:
+            return self.negword + self._int_to_word(abs(number))
+        elif number < 10:
+            return self.ones[number]
+        elif number < 20:
+            return self.teens[number - 10]
+        elif number < 100:
+            result = self.tens[number // 10]
+            if number % 10:
+                result += " " + self.ones[number % 10]
+            return result
+        elif number < 1000:
+            result = self.ones[number // 100] + " " + self.hundred
+            remainder = number % 100
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+        elif number < 100000:  # Lakh
+            result = self._int_to_word(number // 1000) + " " + self.thousand
+            remainder = number % 1000
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+        elif number < 10000000:  # Crore
+            result = self._int_to_word(number // 100000) + " " + self.lakh
+            remainder = number % 100000
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+        elif number < 1000000000:
+            result = self._int_to_word(number // 10000000) + " " + self.crore
+            remainder = number % 10000000
+            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 Urdu.
+
+        Urdu ordinals have specific forms.
+        """
+        if number == 1:
+            return "پہلا"  # first
+        elif number == 2:
+            return "دوسرا"  # second
+        elif number == 3:
+            return "تیسرا"  # third
+        elif number == 4:
+            return "چوتھا"  # fourth
+        elif number == 5:
+            return "پانچواں"  # fifth
+        elif number == 6:
+            return "چھٹا"  # sixth
+        elif number == 7:
+            return "ساتواں"  # seventh
+        elif number == 8:
+            return "آٹھواں"  # eighth
+        elif number == 9:
+            return "نواں"  # ninth
+        elif number == 10:
+            return "دسواں"  # tenth
+        else:
+            # For larger numbers, add واں suffix
+            cardinal = self.to_cardinal(number)
+            return 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 Urdu."""
+        if val < 0:
+            return "BC " + self.to_cardinal(abs(val))
+        else:
+            return "" + self.to_cardinal(val)
+
+    def to_currency(self, val, currency='PKR', cents=True, separator=' ', adjective=False):
+        """Convert to currency in Urdu."""
+        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['PKR'])
+
+        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_UZ.py

@@ -0,0 +1,136 @@
+# -*- 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
+
+
+# Uzbek language support
+class Num2Word_UZ(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'UZS': (("so'm", "so'm"), ('tiyin', 'tiyin')),
+        'USD': (('dollar', 'dollars'), ('cent', 'cents')),
+        'EUR': (('euro', 'euros'), ('cent', 'cents'))
+    }
+
+    def setup(self):
+        self.negword = "minus "
+        self.pointword = "point"
+        self.ones = ['', 'bir', 'ikki', 'uch', "to'rt", 'besh', 'olti', 'yetti', 'sakkiz', "to'qqiz"]
+        self.tens = ['', "o'n", 'yigirma', "o'ttiz", 'qirq', 'ellik', 'oltmish', 'yetmish', 'sakson', "to'qson"]
+        self.hundred = "yuz"
+        self.thousand = "ming"
+        self.million = "million"
+
+    def to_cardinal(self, number):
+        """Convert a number to its word representation in Uzbek."""
+        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 Uzbek."""
+        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 Uzbek."""
+        cardinal = self.to_cardinal(number)
+        # Language-specific ordinal suffix
+        return cardinal + "-chi"
+
+    def to_ordinal_num(self, number):
+        """Convert to abbreviated ordinal."""
+        return str(number) + "."
+
+    def to_year(self, val, longval=True):
+        """Convert to year in Uzbek."""
+        return self.to_cardinal(val)
+
+    def to_currency(self, val, currency='UZS', cents=True, separator=' ', adjective=False):
+        """Convert to currency in Uzbek."""
+        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()

num2words2/lang_VI.py

@@ -0,0 +1,143 @@
+# -*- 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
+
+to_19 = (u'không', u'một', u'hai', u'ba', u'bốn', u'năm', u'sáu',
+         u'bảy', u'tám', u'chín', u'mười', u'mười một', u'mười hai',
+         u'mười ba', u'mười bốn', u'mười lăm', u'mười sáu', u'mười bảy',
+         u'mười tám', u'mười chín')
+tens = (u'hai mươi', u'ba mươi', u'bốn mươi', u'năm mươi',
+        u'sáu mươi', u'bảy mươi', u'tám mươi', u'chín mươi')
+denom = ('',
+         u'nghìn', u'triệu', u'tỷ', u'nghìn tỷ', u'trăm nghìn tỷ',
+         'Quintillion', 'Sextillion', 'Septillion', 'Octillion', 'Nonillion',
+         'Decillion', 'Undecillion', 'Duodecillion', 'Tredecillion',
+         'Quattuordecillion', 'Sexdecillion', 'Septendecillion',
+         'Octodecillion', 'Novemdecillion', 'Vigintillion')
+
+
+class Num2Word_VI(object):
+
+    def _convert_nn(self, val):
+        if val < 20:
+            return to_19[val]
+        for (dcap, dval) in ((k, 20 + (10 * v)) for (v, k) in enumerate(tens)):
+            if dval + 10 > val:
+                if val % 10:
+                    a = u'lăm'
+                    if to_19[val % 10] == u'một':
+                        a = u'mốt'
+                    else:
+                        a = to_19[val % 10]
+                    if to_19[val % 10] == u'năm':
+                        a = u'lăm'
+                    return dcap + ' ' + a
+                return dcap
+
+    def _convert_nnn(self, val):
+        word = ''
+        (mod, rem) = (val % 100, val // 100)
+        if rem > 0:
+            word = to_19[rem] + u' trăm'
+            if mod > 0:
+                word = word + ' '
+        if mod > 0 and mod < 10:
+            if mod == 5:
+                word = word != '' and word + u'lẻ năm' or word + u'năm'
+            else:
+                word = word != '' and word + u'lẻ ' \
+                    + self._convert_nn(mod) or word + self._convert_nn(mod)
+        if mod >= 10:
+            word = word + self._convert_nn(mod)
+        return word
+
+    def vietnam_number(self, val):
+        if val < 100:
+            return self._convert_nn(val)
+        if val < 1000:
+            return self._convert_nnn(val)
+        for (didx, dval) in ((v - 1, 1000 ** v) for v in range(len(denom))):
+            if dval > val:
+                mod = 1000 ** didx
+                lval = val // mod
+                r = val - (lval * mod)
+
+                ret = self._convert_nnn(lval) + u' ' + denom[didx]
+                if 99 >= r > 0:
+                    ret = self._convert_nnn(lval) + u' ' + denom[didx] + u' lẻ'
+                if r > 0:
+                    ret = ret + ' ' + self.vietnam_number(r)
+                return ret
+
+    def number_to_text(self, number):
+        is_negative = number < 0
+        number = abs(number)
+        number = '%.2f' % number
+        the_list = str(number).split('.')
+        start_word = self.vietnam_number(int(the_list[0]))
+        final_result = start_word
+        if len(the_list) > 1 and int(the_list[1]) > 0:
+            end_word = self.vietnam_number(int(the_list[1]))
+            final_result = final_result + ' phẩy ' + end_word
+        if is_negative:
+            final_result = 'âm ' + final_result
+        return final_result
+
+    def to_cardinal(self, number):
+        return self.number_to_text(number)
+
+    def to_ordinal(self, number):
+        return self.to_cardinal(number)
+
+    def to_ordinal_num(self, number):
+        """Convert to abbreviated ordinal form in Vietnamese"""
+        # Vietnamese typically uses "thứ" + number for ordinals
+        return "thứ " + str(number)
+
+    def to_year(self, val, longval=True):
+        """Convert number to year representation in Vietnamese"""
+        if val < 0:
+            # BC years (trước Công nguyên)
+            return "năm " + self.to_cardinal(-val) + " trước Công nguyên"
+        else:
+            # AD years (just "năm" + number)
+            return "năm " + self.to_cardinal(val)
+
+    def to_currency(self, val, currency='VND', cents=True, separator=',',
+                    adjective=False):
+        """
+        Convert amount to currency format
+        """
+        from decimal import Decimal
+
+        # Check if value has fractional cents
+        decimal_val = Decimal(str(val))
+        has_fractional_cents = (decimal_val * 100) % 1 != 0
+
+        # If input is an integer, just return the cardinal number
+        if isinstance(val, int):
+            return self.to_cardinal(val) + " đồng"
+
+        # For floats with fractional cents
+        if has_fractional_cents:
+            # Vietnamese doesn't typically use cents, but for consistency
+            # we'll handle fractional amounts
+            return self.to_cardinal_float(val) + " đồng"
+
+        # For floats, use the full currency format with dong
+        return self.to_cardinal(val) + " đồng"

num2words2/lang_WO.py

@@ -0,0 +1,136 @@
+# -*- 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
+
+
+# Wolof language support
+class Num2Word_WO(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'XOF': (('dërëm', 'dërëm'), ('santim', 'santim')),
+        'USD': (('dollar', 'dollars'), ('cent', 'cents')),
+        'EUR': (('euro', 'euros'), ('cent', 'cents'))
+    }
+
+    def setup(self):
+        self.negword = "minus "
+        self.pointword = "point"
+        self.ones = ['', 'benn', 'ñaar', 'ñett', 'ñeent', 'juróom', 'juróom-benn', 'juróom-ñaar', 'juróom-ñett', 'juróom-ñeent']
+        self.tens = ['', 'fukk', 'ñaar-fukk', 'ñett-fukk', 'ñeent-fukk', 'juróom-fukk', 'juróom-benn-fukk', 'juróom-ñaar-fukk', 'juróom-ñett-fukk', 'juróom-ñeent-fukk']
+        self.hundred = "téeméer"
+        self.thousand = "junni"
+        self.million = "tamndareet"
+
+    def to_cardinal(self, number):
+        """Convert a number to its word representation in Wolof."""
+        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 Wolof."""
+        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 Wolof."""
+        cardinal = self.to_cardinal(number)
+        # Language-specific ordinal suffix
+        return cardinal + "-eel"
+
+    def to_ordinal_num(self, number):
+        """Convert to abbreviated ordinal."""
+        return str(number) + "."
+
+    def to_year(self, val, longval=True):
+        """Convert to year in Wolof."""
+        return self.to_cardinal(val)
+
+    def to_currency(self, val, currency='XOF', cents=True, separator=' ', adjective=False):
+        """Convert to currency in Wolof."""
+        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()