num2words2 0.1.0.dev1__py3-none-any.whl

num2words2/lang_TE.py

@@ -0,0 +1,169 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import unicode_literals
+
+from .lang_EUR import Num2Word_EUR
+
+
+class Num2Word_TE(Num2Word_EUR):
+    def set_high_numwords(self, high):
+        for n, word in self.high_numwords:
+            self.cards[10**n] = word
+
+    def setup(self):
+        self.low_numwords = [
+            "తొంభై తొమ్మిది",
+            "తొంభై ఎనిమిది",
+            "తొంభై ఏడు",
+            "తొంభై ఆరు",
+            "తొంభై అయిదు",
+            "తొంభై నాలుగు",
+            "తొంభై మూడు",
+            "తొంభై రెండు",
+            "తొంభై ఒకటి",
+            "తొంభై",
+            "ఎనభై తొమ్మిది",
+            "ఎనభై ఎనిమిది",
+            "ఎనభై ఏడు",
+            "ఎనభై ఆరు",
+            "ఎనభై అయిదు",
+            "ఎనభై నాలుగు",
+            "ఎనభై మూడు",
+            "ఎనభై రెండు",
+            "ఎనభై ఒకటి",
+            "ఎనభై",
+            "డెబ్బై తొమ్మిది",
+            "డెబ్బై ఎనిమిది",
+            "డెబ్బై ఏడు",
+            "డెబ్బై ఆరు",
+            "డెబ్బై అయిదు",
+            "డెబ్బై నాలుగు",
+            "డెబ్బై మూడు",
+            "డెబ్బై రెండు",
+            "డెబ్బై ఒకటి",
+            "డెబ్బై",
+            "అరవై తొమ్మిది",
+            "అరవై ఎనిమిది",
+            "అరవై ఏడు",
+            "అరవై ఆరు",
+            "అరవై అయిదు",
+            "అరవై నాలుగు",
+            "అరవై మూడు",
+            "అరవై రెండు",
+            "అరవై ఒకటి",
+            "అరవై",
+            "యాభై తొమ్మిది",
+            "యాభై ఎనిమిది",
+            "యాభై ఏడు",
+            "యాభై ఆరు",
+            "యాభై అయిదు",
+            "యాభై నాలుగు",
+            "యాభై మూడు",
+            "యాభై రెండు",
+            "యాభై ఒకటి",
+            "యాభై ",
+            "నలభై తొమ్మిది",
+            "నలభై ఎనిమిది",
+            "నలభై ఏడు",
+            "నలభై ఆరు",
+            "నలభై అయిదు",
+            "నలభై నాలుగు",
+            "నలభై మూడు",
+            "నలభై రెండు",
+            "నలభై ఒకటి",
+            "నలభై",
+            "ముప్పై తొమ్మిది",
+            "ముప్పై ఎనిమిది",
+            "ముప్పై ఏడు",
+            "ముప్పై ఆరు",
+            "ముప్పై ఐదు",
+            "ముప్పై నాలుగు",
+            "ముప్పై మూడు",
+            "ముప్పై రెండు",
+            "ముప్పై ఒకటి",
+            "ముప్పై",
+            "ఇరవై తొమ్మిది",
+            "ఇరవై ఎనిమిది",
+            "ఇరవై ఏడు",
+            "ఇరవై ఆరు",
+            "ఇరవై అయిదు",
+            "ఇరవై నాలుగు",
+            "ఇరవై మూడు",
+            "ఇరవై రెండు",
+            "ఇరవై ఒకటి",
+            "ఇరవై",
+            "పందొమ్మిది",
+            "పధ్ధెనిమిది",
+            "పదిహేడు",
+            "పదహారు",
+            "పదునయిదు",
+            "పధ్నాలుగు",
+            "పదమూడు",
+            "పన్నెండు",
+            "పదకొండు",
+            "పది",
+            "తొమ్మిది",
+            "ఎనిమిది",
+            "ఏడు",
+            "ఆరు",
+            "అయిదు",
+            "నాలుగు",
+            "మూడు",
+            "రెండు",
+            "ఒకటి",
+            "సున్న",
+        ]
+
+        self.mid_numwords = [(100, "వంద")]
+
+        self.high_numwords = [(7, "కోట్ల"), (5, "లక్ష"), (3, "వేయి")]
+
+        self.pointword = "బిందువు "
+
+        self.modifiers = [
+            " ్  ",
+            "ా ",
+            " ి ",
+            " ీ ",
+            " ు ",
+            " ూ ",
+            " ృ ",
+            " ౄ  ",
+            " ె ",
+            " ే ",
+            " ై ",
+            " ొ",
+            " ో ",
+            " ౌ ",
+            " ఁ ",
+            " ం ",
+            " ః ",
+        ]
+
+    def merge(self, lpair, rpair):
+        ltext, lnum = lpair
+        rtext, rnum = rpair
+        if lnum == 1 and rnum < 100:
+            return (rtext, rnum)
+        elif 100 > lnum > rnum:
+            return ("%s-%s" % (ltext, rtext), lnum + rnum)
+        elif lnum >= 100 > rnum:
+            if ltext[-1] in self.modifiers:
+                return ("%s %s" % (ltext[:-1], rtext), lnum + rnum)
+            else:
+                return ("%s %s" % (ltext + "ల", rtext), lnum + rnum)
+        elif rnum > lnum:
+            return ("%s %s" % (ltext, rtext), lnum * rnum)
+        return ("%s %s" % (ltext, rtext), lnum + rnum)
+
+    def to_ordinal_num(self, value):
+        self.verify_ordinal(value)
+        return "%s%s" % (value, self.to_ordinal(value)[-1:])
+
+    def to_ordinal(self, value):
+        self.verify_ordinal(value)
+        outwords = self.to_cardinal(value)
+        if outwords[-1] in self.modifiers:
+            outwords = outwords[:-1]
+        ordinal_num = outwords + "వ"
+        return ordinal_num

num2words2/lang_TET.py

@@ -0,0 +1,285 @@
+# -*- coding: utf-8 -*-Num2Word_TET
+# 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 decimal import Decimal
+
+from num2words2.currency import parse_currency_parts
+
+from .lang_EUR import Num2Word_EUR
+
+DOLLAR = ('dolar', 'dolar')
+CENTS = ('sentavu', 'sentavu')
+
+
+class Num2Word_TET(Num2Word_EUR):
+
+    CURRENCY_FORMS = {
+        'AUD': (DOLLAR, CENTS),
+        'CAD': (DOLLAR, CENTS),
+        'EUR': (('euro', 'euros'), CENTS),
+        'GBP': (('pound sterling', 'pound sterling'), ('pence', 'pence')),
+        'USD': (DOLLAR, CENTS),
+    }
+
+    GIGA_SUFFIX = None
+    MEGA_SUFFIX = "iliaun"
+
+    def setup(self):
+        super().setup()
+        lows = ["kuatr", "tr", "b", "m"]
+        self.high_numwords = self.gen_high_numwords([], [], lows)
+        self.negword = "menus "
+        self.pointword = "vírgula"
+        self.exclude_title = ["resin", "vírgula", "menus"]
+        self.count = 0
+
+        self.mid_numwords = [
+            (1000, "rihun"), (100, "atus"), (90, "sia nulu"),
+            (80, "ualu nulu"), (70, "hitu nulu"), (60, "neen nulu"),
+            (50, "lima nulu"), (40, "haat nulu"), (30, "tolu nulu"),
+            (20, "rua nulu")
+        ]
+        self.low_numwords = [
+            "sanulu",
+            "sia", "ualu", "hitu", "neen", "lima", "haat", "tolu", "rua",
+            "ida", "mamuk"
+        ]
+        self.hundreds = {
+            1: "atus",
+            2: "atus rua",
+            3: "atus tolu",
+            4: "atus haat",
+            5: "atus lima",
+            6: "atus neen",
+            7: "atus hitu",
+            8: "atus ualu",
+            9: "atus sia",
+        }
+
+    def merge(self, curr, next):
+        ctext, cnum, ntext, nnum = curr + next
+
+        if cnum == 1 and nnum < 100:
+            return next
+
+        if nnum < cnum:
+            if nnum < 10:
+                value_str = str(cnum + nnum)
+                if int(value_str) > 100:
+                    zero_list = value_str[1:-1]
+                    all_zero = all(element == '0' for element in zero_list)
+                    if all_zero:
+                        if self.count >= 1:
+                            self.count += 0
+                            return (
+                                "ho %s %s" % (ctext, ntext),
+                                cnum + nnum
+                            )
+                        self.count += 1
+                        return ("%s %s" % (ctext, ntext), cnum + nnum)
+
+                return ("%s resin %s" % (ctext, ntext), cnum + nnum)
+            else:
+                return ("%s %s" % (ctext, ntext), cnum + nnum)
+
+        return (ntext + " " + ctext, cnum * nnum)
+
+    def ho_result(self, result, value):
+        index = result.find('ho')
+        count_ho = result.count('ho')
+
+        if index != -1 and count_ho >= 1:
+            index_rihun = result.find('rihun')
+            value_str = len(str(value))
+            if index_rihun != -1 and value_str > 7:
+                result = result.replace("rihun ho", "ho rihun")
+            lows = ["kuatr", "tr", "b", "m"]
+            MEGA_SUFFIX = "iliaun"
+            for low in lows:
+                result = result.replace(
+                    low + MEGA_SUFFIX + " ho", "ho " + low + MEGA_SUFFIX)
+            remove_first_ho = result.startswith('ho')
+            if remove_first_ho:
+                result = result[3:]
+        return result
+
+    def remove_ho(self, result, value):
+        value_str = str(value)
+        result = self.ho_result(result, value)
+        end_value = value_str[:-4]
+        end_true = end_value.endswith('0')
+        if end_true is False:
+            if value > 100:
+                if value_str[-1] != '0' and value_str[-2] == '0':
+                    result = result.replace("ho", "")
+                    result = result.replace("  ", " ")
+
+        return result
+
+    def to_cardinal(self, value):
+        result = super().to_cardinal(value)
+
+        results = self.remove_ho(result, value)
+        return results
+
+    def to_ordinal(self, value):
+        self.verify_ordinal(value)
+        out = ""
+        val = self.splitnum(value)
+        outs = val
+        while len(val) != 1:
+            outs = []
+            left, right = val[:2]
+            if isinstance(left, tuple) and isinstance(right, tuple):
+                outs.append(self.merge(left, right))
+                if val[2:]:
+                    outs.append(val[2:])
+            else:
+                for elem in val:
+                    if isinstance(elem, list):
+                        if len(elem) == 1:
+                            outs.append(elem[0])
+                        else:
+                            outs.append(self.clean(elem))
+                    else:
+                        outs.append(elem)
+            val = outs
+
+        words, num = outs[0]
+
+        words = self.remove_ho(words, value)
+
+        if num in [90, 80, 70, 60, 50, 40, 30, 20, 10, 9, 8, 7, 5, 3, 2]:
+            words = 'da' + words + 'k'
+        if num in [6, 4]:
+            words = 'da' + words
+        if num == 1:
+            words = 'dahuluk'
+        if num in [900, 800, 700, 500, 300, 200, 100]:
+            words = 'dah' + words + 'k'
+        if num in [600, 400]:
+            words = 'dah' + words
+
+        words_split = words.split()
+        if len(words_split) >= 3 and num < 100:
+            first_word = 'da' + words_split[0]
+            second_word = " ".join(words_split[1:])
+            if 'haat' in second_word or 'neen' in second_word:
+                words = first_word + " " + second_word
+            else:
+                words = first_word + " " + second_word + 'k'
+
+        word_first = 'dah' + words_split[0]
+        if word_first == 'dahatus' and len(words_split) >= 3:
+            word_second = " ".join(words_split[1:])
+            if 'haat' in word_second or 'neen' in word_second:
+                words = word_first + " " + word_second
+            else:
+                words = word_first + " " + word_second + 'k'
+
+        if len(str(num)) > 3:
+            if 'haat' in words_split[-1:] or 'neen' in words_split[-1:]:
+                words = 'da' + words
+            else:
+                words = 'da' + words + 'k'
+
+        result = self.title(out + words)
+
+        return result
+
+    def to_ordinal_num(self, value):
+        self.verify_ordinal(value)
+        return "%sº" % (value)
+
+    def to_year(self, val, longval=True):
+        if val < 0:
+            return self.to_cardinal(abs(val)) + ' antes Kristu'
+        return self.to_cardinal(val)
+
+    def to_currency(self, val, currency='USD', cents=True):
+        """
+        Args:
+            val: Numeric value
+            currency (str): Currency code
+            cents (bool): Verbose cents
+            adjective (bool): Prefix currency name with adjective
+        Returns:
+            str: Formatted string
+
+        """
+        # Check if value has fractional cents
+        decimal_val = Decimal(str(val))
+        has_fractional_cents = (decimal_val * 100) % 1 != 0
+
+        # Check if input is an integer - don't show cents for integers
+        is_integer_input = isinstance(val, int)
+
+        left, right, is_negative = parse_currency_parts(val, is_int_with_cents=False)
+
+        try:
+            cr1, cr2 = self.CURRENCY_FORMS[currency]
+
+        except KeyError:
+            raise NotImplementedError(
+                'Currency code "%s" not implemented for "%s"' %
+                (currency, self.__class__.__name__))
+
+        minus_str = "%s " % self.negword.strip() if is_negative else ""
+        money_str = self._money_verbose(left, currency)
+
+        # For integers, never show cents
+        if is_integer_input:
+            curr_name = self.pluralize(left, cr1)
+            return u'%s%s %s' % (
+                minus_str,
+                curr_name,
+                money_str
+            )
+
+        if has_fractional_cents and right > 0:
+            # Handle fractional cents using to_cardinal_float
+            fractional_cents = right / 100.0
+            cents_str = self.to_cardinal_float(fractional_cents) if hasattr(self, 'to_cardinal_float') else self.to_cardinal(fractional_cents)
+        else:
+            cents_str = self._cents_verbose(right, currency) \
+                if cents else self._cents_terse(right, currency)
+
+        if right == 0:
+            return u'%s%s %s' % (
+                minus_str,
+                self.pluralize(left, cr1),
+                money_str
+            )
+        else:
+            if has_fractional_cents:
+                # For fractional cents, use different formatting
+                return u'%s%s %s %s %s' % (
+                    minus_str,
+                    self.pluralize(left, cr1),
+                    money_str,
+                    cents_str,
+                    self.pluralize(1, cr2)  # Use singular for fractional
+                )
+            else:
+                return u'%s%s %s %s %s' % (
+                    minus_str,
+                    self.pluralize(left, cr1),
+                    money_str,
+                    self.pluralize(right, cr2),
+                    cents_str
+                )

num2words2/lang_TG.py

@@ -0,0 +1,149 @@
+# -*- 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 division, print_function, unicode_literals
+
+from . import lang_EUR
+
+GENERIC_DOLLARS = ("доллар", "доллар")
+GENERIC_CENTS = ("сент", "сент")
+
+
+class Num2Word_TG(lang_EUR.Num2Word_EUR):
+    CURRENCY_FORMS = {
+        # repalced by EUR
+        "EUR": (("евро", "евро"), GENERIC_CENTS),
+        # replaced by EUR
+        "USD": (GENERIC_DOLLARS, GENERIC_CENTS),
+        "RUB": (("рубл", "рубл"), ("копейк", "копейк")),
+        "TJS": (("сомонӣ", "сомонӣ"), ("дирам", "дирам")),
+    }
+
+    GIGA_SUFFIX = "иллиард"
+    MEGA_SUFFIX = "иллион"
+
+    def set_high_numwords(self, high):
+        cap = 3 * (len(high) + 1)
+
+        for word, n in zip(high, range(cap, 5, -3)):
+            if n == 9:
+                self.cards[10 ** n] = word + self.GIGA_SUFFIX
+
+            else:
+                self.cards[10 ** n] = word + self.MEGA_SUFFIX
+
+    def setup(self):
+        super(Num2Word_TG, self).setup()
+
+        lows = ["квинт", "квадр", "тр", "м", "м"]
+        self.high_numwords = self.gen_high_numwords([], [], lows)
+        self.negword = "минус "
+        self.pointword = "нуқта"
+        self.exclude_title = ["ва", "минус", "нуқта"]
+
+        self.mid_numwords = [
+            (1000, "ҳазор"),
+            (100, "сад"),
+            (90, "навад"),
+            (80, "ҳаштод"),
+            (70, "ҳафтод"),
+            (60, "шаст"),
+            (50, "панҷоҳ"),
+            (40, "чил"),
+            (30, "си"),
+        ]
+        self.low_numwords = [
+            "бист",
+            "нуздаҳ",
+            "ҳаждаҳ",
+            "ҳабдаҳ",
+            "шонздаҳ",
+            "понздаҳ",
+            "чордаҳ",
+            "сенздаҳ",
+            "дувоздаҳ",
+            "ёздаҳ",
+            "даҳ",
+            "нӯҳ",
+            "ҳашт",
+            "ҳафт",
+            "шаш",
+            "панҷ",
+            "чор",
+            "се",
+            "ду",
+            "як",
+            "сифр",
+        ]
+
+    def to_cardinal(self, value):
+        try:
+            assert int(value) == value
+        except (ValueError, TypeError, AssertionError):
+            return self.to_cardinal_float(value)
+
+        out = ""
+        if value < 0:
+            value = abs(value)
+            out = self.negword
+
+        if value >= self.MAXVAL:
+            raise OverflowError(self.errmsg_toobig % (value, self.MAXVAL))
+
+        if value == 100:
+            return self.title(out + "сад")
+        else:
+            val = self.splitnum(value)
+            words, num = self.clean(val)
+            return self.title(out + words)
+
+    def merge(self, lpair, rpair):
+        ltext, lnum = lpair
+        rtext, rnum = rpair
+        if lnum == 1 and rnum < 100:
+            return (rtext, rnum)
+        elif 100 > lnum > rnum:
+            if ltext == "си":
+                return ("%sю %s" % (ltext, rtext), lnum + rnum)
+            elif ltext == "панҷоҳ":
+                return ("панҷову %s" % (rtext), lnum + rnum)
+            else:
+                return ("%sу %s" % (ltext, rtext), lnum + rnum)
+        elif lnum >= 100 > rnum:
+            return ("%sу %s" % (ltext, rtext), lnum + rnum)
+        elif rnum > lnum:
+            if ltext == "яксад" and rtext not in self.low_numwords:
+                return ("сад %s" % (rtext), lnum * rnum)
+            if rtext == "сад":
+                return ("%s%s" % (ltext, rtext), lnum * rnum)
+            else:
+                return ("%s %s" % (ltext, rtext), lnum * rnum)
+        return ("%sу %s" % (ltext, rtext), lnum + rnum)
+
+    def to_ordinal(self, value):
+        self.verify_ordinal(value)
+        cardinal = self.to_cardinal(value)
+        outwords = cardinal.split(" ")
+        lastword = outwords[-1]
+        if lastword in ["ду", "се", "си"]:
+            return "%sюм" % (cardinal)
+        else:
+            return "%sум" % (cardinal)
+
+    def to_ordinal_num(self, value):
+        self.verify_ordinal(value)
+        return "%s%s" % (value, self.to_ordinal(value)[-2:])