num2words2 0.1.0.dev1__py3-none-any.whl

num2words2/lang_AZ.py

@@ -0,0 +1,208 @@
+# -*- 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_AZ(Num2Word_Base):
+    DIGITS = {
+        0: u"sıfır",
+        1: u"bir",
+        2: u"iki",
+        3: u"üç",
+        4: u"dörd",
+        5: u"beş",
+        6: u"altı",
+        7: u"yeddi",
+        8: u"səkkiz",
+        9: u"doqquz",
+    }
+
+    DECIMALS = {
+        1: u"on",
+        2: u"iyirmi",
+        3: u"otuz",
+        4: u"qırx",
+        5: u"əlli",
+        6: u"altmış",
+        7: u"yetmiş",
+        8: u"səksən",
+        9: u"doxsan",
+    }
+
+    POWERS_OF_TEN = {
+        2: u"yüz",
+        3: u"min",
+        6: u"milyon",
+        9: u"milyard",
+        12: u"trilyon",
+        15: u"katrilyon",
+        18: u"kentilyon",
+        21: u"sekstilyon",
+        24: u"septilyon",
+        27: u"oktilyon",
+        30: u"nonilyon",
+        33: u"desilyon",
+        36: u"undesilyon",
+        39: u"dodesilyon",
+        42: u"tredesilyon",
+        45: u"katordesilyon",
+        48: u"kendesilyon",
+        51: u"seksdesilyon",
+        54: u"septendesilyon",
+        57: u"oktodesilyon",
+        60: u"novemdesilyon",
+        63: u"vigintilyon",
+    }
+
+    VOWELS = u"aıoueəiöü"
+    VOWEL_TO_CARDINAL_SUFFIX_MAP = {
+        **dict.fromkeys(["a", "ı"], "ıncı"),
+        **dict.fromkeys(["e", "ə", "i"], "inci"),
+        **dict.fromkeys(["o", "u"], "uncu"),
+        **dict.fromkeys(["ö", "ü"], "üncü"),
+    }
+
+    VOWEL_TO_CARDINAL_NUM_SUFFIX_MAP = {
+        **dict.fromkeys(["a", "ı"], "cı"),
+        **dict.fromkeys(["e", "ə", "i"], "ci"),
+        **dict.fromkeys(["o", "u"], "cu"),
+        **dict.fromkeys(["ö", "ü"], "cü"),
+    }
+
+    CURRENCY_INTEGRAL = ('manat', 'manat')
+    CURRENCY_FRACTION = ('qəpik', 'qəpik')
+    CURRENCY_FORMS = {
+        'AZN': (CURRENCY_INTEGRAL, CURRENCY_FRACTION),
+        'EUR': (('avro', 'avro'), ('sent', 'sent')),
+        'USD': (('dollar', 'dollar'), ('sent', 'sent')),
+    }
+
+    def setup(self):
+        super().setup()
+
+        self.negword = u"mənfi"
+        self.pointword = u"nöqtə"
+
+    def to_cardinal(self, value):
+        value_str = str(value)
+        parts = value_str.split(".")
+        integral_part = parts[0]
+        fraction_part = parts[1] if len(parts) > 1 else ""
+
+        if integral_part.startswith("-"):
+            integral_part = integral_part[1:]  # ignore minus sign here
+
+        integral_part_in_words = self.int_to_word(integral_part)
+        fraction_part_in_words = "" if not fraction_part else self.int_to_word(
+            fraction_part, leading_zeros=True)
+
+        value_in_words = integral_part_in_words
+        if fraction_part:
+            value_in_words = " ".join(
+                [
+                    integral_part_in_words,
+                    self.pointword,
+                    fraction_part_in_words
+                ]
+            )
+
+        if value < 0:
+            value_in_words = " ".join([self.negword, value_in_words])
+
+        return value_in_words
+
+    def to_ordinal(self, value):
+        assert int(value) == value
+
+        cardinal = self.to_cardinal(value)
+        last_vowel = self._last_vowel(cardinal)
+        assert last_vowel is not None
+        suffix = self.VOWEL_TO_CARDINAL_SUFFIX_MAP[last_vowel]
+
+        if cardinal.endswith(tuple(self.VOWELS)):
+            cardinal = cardinal[:-1]
+
+        ordinal = "".join([cardinal, suffix])
+
+        return ordinal
+
+    def to_ordinal_num(self, value):
+        assert int(value) == value
+
+        cardinal = self.to_cardinal(value)
+        last_vowel = self._last_vowel(cardinal)
+        assert last_vowel is not None
+        suffix = self.VOWEL_TO_CARDINAL_NUM_SUFFIX_MAP[last_vowel]
+        ordinal_num = "-".join([str(value), suffix])
+
+        return ordinal_num
+
+    def to_year(self, value):
+        assert int(value) == value
+
+        year = self.to_cardinal(abs(value))
+        if value < 0:
+            year = " ".join(["e.ə.", year])
+
+        return year
+
+    def pluralize(self, n, forms):
+        form = 0 if n == 1 else 1
+        return forms[form]
+
+    def int_to_word(self, num_str, leading_zeros=False):
+        words = []
+        reversed_str = list(reversed(num_str))
+
+        for index, digit in enumerate(reversed_str):
+            digit_int = int(digit)
+            # calculate remainder after dividing index by 3
+            # because number is parsed by three digit chunks
+            remainder_to_3 = index % 3
+            if remainder_to_3 == 0:
+                if index > 0:
+                    if set(reversed_str[index:index + 3]) != {'0'}:
+                        words.insert(0, self.POWERS_OF_TEN[index])
+                if digit_int > 0:
+                    # we say "min" not "bir min"
+                    if not (digit_int == 1 and index == 3):
+                        words.insert(0, self.DIGITS[digit_int])
+            elif remainder_to_3 == 1:
+                if digit_int != 0:
+                    words.insert(0, self.DECIMALS[digit_int])
+            else:  # remainder is 2
+                if digit_int > 0:
+                    words.insert(0, self.POWERS_OF_TEN[2])  # "yüz"
+                if digit_int > 1:
+                    words.insert(0, self.DIGITS[digit_int])
+
+        if num_str == '0':
+            words.append(self.DIGITS[0])
+
+        if leading_zeros:
+            zeros_count = len(num_str) - len(str(int(num_str)))
+            words[:0] = zeros_count * [self.DIGITS[0]]
+
+        return " ".join(words)
+
+    def _last_vowel(self, value):
+        for char in value[::-1]:
+            if char in self.VOWELS:
+                return char

num2words2/lang_BA.py

@@ -0,0 +1,119 @@
+# -*- 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
+
+
+# Bashkir language support
+class Num2Word_BA(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'RUB': (('һум', 'һум'), ('тин', 'тин')),
+        'USD': (('доллар', 'доллар'), ('цент', 'цент')),
+        'EUR': (('евро', 'евро'), ('цент', 'цент')),
+    }
+
+    def setup(self):
+        self.negword = "минус "
+        self.pointword = "өтөр"
+
+    def to_cardinal(self, number):
+        """Convert a number to its word representation in Bashkir."""
+        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
+        else:
+            return ret + self._int_to_word(int(n))
+
+    def _int_to_word(self, number):
+        """Convert an integer to its word representation in Bashkir."""
+        if number == 0:
+            return "нуль"
+
+        ones = ["", "бер", "ике", "өс", "дүрт", "биш", "алты", "ете", "һигеҙ", "туғыҙ"]
+        tens = ["", "", "егерме", "утыҙ", "ҡырҡ", "илле", "алтмыш", "етмеш", "һикһән", "туҡһан"]
+        teens = ["ун", "ун бер", "ун ике", "ун өс", "ун дүрт", "ун биш", "ун алты", "ун ете", "ун һигеҙ", "ун туғыҙ"]
+
+        if number < 10:
+            return ones[number]
+        elif number < 20:
+            return teens[number - 10]
+        elif number < 100:
+            return tens[number // 10] + (" " + ones[number % 10] if number % 10 else "")
+        elif number < 1000:
+            return ones[number // 100] + " йөҙ" + (" " + self._int_to_word(number % 100) if number % 100 else "")
+        elif number < 1000000:
+            return self._int_to_word(number // 1000) + " мең" + (" " + self._int_to_word(number % 1000) if number % 1000 else "")
+        elif number < 1000000000:
+            return self._int_to_word(number // 1000000) + " миллион" + (" " + self._int_to_word(number % 1000000) if number % 1000000 else "")
+        else:
+            return self._int_to_word(number // 1000000000) + " миллиард" + (" " + self._int_to_word(number % 1000000000) if number % 1000000000 else "")
+
+    def to_ordinal(self, number):
+        """Convert to ordinal."""
+        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."""
+        return self.to_cardinal(val) + " йыл"
+
+    def to_currency(self, val, currency='RUB', cents=True, separator=' һәм ', adjective=False):
+        """Convert to currency."""
+        try:
+            left, right, is_negative = self.parse_currency(val)
+        except AttributeError:
+            is_negative = False
+            if val < 0:
+                is_negative = True
+                val = abs(val)
+
+            left, right = self._split_currency(val)
+
+        cr1, cr2 = self.CURRENCY_FORMS.get(currency, self.CURRENCY_FORMS['RUB'])
+
+        left_str = self._int_to_word(int(left))
+        cents_str = self._int_to_word(int(right)) if cents and right else ""
+
+        result = left_str + " " + cr1[0]
+
+        if cents_str:
+            result += separator + cents_str + " " + cr2[0]
+
+        return self.negword + result if is_negative else result
+
+    def _split_currency(self, n):
+        """Split currency into whole and fraction parts."""
+        parts = str(n).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
+        return left, right

num2words2/lang_BE.py

@@ -0,0 +1,356 @@
+# Copyright (c) 2003, Taro Ogawa.  All Rights Reserved.
+# Copyright (c) 2013, Savoir-faire Linux inc.  All Rights Reserved.
+# Copyright (c) 2022, Sergei Ruzki.  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
+from .utils import get_digits, splitbyx
+
+ZERO = "нуль"
+
+ONES_FEMININE = {
+    1: "адна",
+    2: "дзве",
+    3: "тры",
+    4: "чатыры",
+    5: "пяць",
+    6: "шэсць",
+    7: "сем",
+    8: "восем",
+    9: "дзевяць",
+}
+
+ONES = {
+    "f": {
+        1: "адна",
+        2: "дзве",
+        3: "тры",
+        4: "чатыры",
+        5: "пяць",
+        6: "шэсць",
+        7: "сем",
+        8: "восем",
+        9: "дзевяць",
+    },
+    "m": {
+        1: "адзін",
+        2: "два",
+        3: "тры",
+        4: "чатыры",
+        5: "пяць",
+        6: "шэсць",
+        7: "сем",
+        8: "восем",
+        9: "дзевяць",
+    },
+    "n": {
+        1: "адно",
+        2: "два",
+        3: "тры",
+        4: "чатыры",
+        5: "пяць",
+        6: "шэсць",
+        7: "сем",
+        8: "восем",
+        9: "дзевяць",
+    },
+}
+
+TENS = {
+    0: "дзесяць",
+    1: "адзінаццаць",
+    2: "дванаццаць",
+    3: "трынаццаць",
+    4: "чатырнаццаць",
+    5: "пятнаццаць",
+    6: "шаснаццаць",
+    7: "сямнаццаць",
+    8: "васямнаццаць",
+    9: "дзевятнаццаць",
+}
+
+TWENTIES = {
+    2: "дваццаць",
+    3: "трыццаць",
+    4: "сорак",
+    5: "пяцьдзясят",
+    6: "шэсцьдзясят",
+    7: "семдзесят",
+    8: "восемдзесят",
+    9: "дзевяноста",
+}
+
+TWENTIES_ORD = (
+    ("дваццаць", "дваццаці"),
+    ("трыццаць", "трыццаці"),
+    ("сорак", "сарака"),
+    ("пяцьдзясят", "пяцідзясяці"),
+    ("шэсцьдзясят", "шaсцідзясяці"),
+    ("семдзесят", "сямідзесяці"),
+    ("восемдзесят", "васьмідзесяці"),
+    ("дзевяноста", "дзевяноста"),
+)
+
+HUNDREDS = {
+    1: "сто",
+    2: "дзвесце",
+    3: "трыста",
+    4: "чатырыста",
+    5: "пяцьсот",
+    6: "шэсцьсот",
+    7: "семсот",
+    8: "восемсот",
+    9: "дзевяцьсот",
+}
+
+THOUSANDS = {
+    1: ("тысяча", "тысячы", "тысяч"),  # 10^3
+    2: ("мільён", "мільёны", "мільёнаў"),  # 10^6
+    3: ("мільярд", "мільярды", "мільярдаў"),  # 10^9
+    4: ("трыльён", "трыльёны", "трыльёнаў"),  # 10^12
+    5: ("квадрыльён", "квадрыльёны", "квадрыльёнаў"),  # 10^15
+    6: ("квінтыльён", "квінтыльёны", "квінтыльёнаў"),  # 10^18
+    7: ("секстыльён", "секстыльёны", "секстыльёнаў"),  # 10^21
+    8: ("сэптыльён", "сэптыльёны", "сэптыльёнаў"),  # 10^24
+    9: ("актыльён", "актыльёны", "актыльёнаў"),  # 10^27
+    10: ("нанільён", "нанільёны", "нанільёнаў"),  # 10^30
+}
+
+
+class Num2Word_BE(Num2Word_Base):
+    CURRENCY_FORMS = {
+        "RUB": (
+            ("расійскі рубель", "расійскія рублі", "расійскіх рублёў"),
+            ("капейка", "капейкі", "капеек"),
+        ),
+        "EUR": (("еўра", "еўра", "еўра"), ("цэнт", "цэнты", "цэнтаў")),
+        "USD": (("долар", "долары", "долараў"), ("цэнт", "цэнты", "цэнтаў")),
+        "UAH": (
+            ("грыўна", "грыўны", "грыўнаў"),
+            ("капейка", "капейкі", "капеек"),
+        ),
+        "KZT": (("тэнге", "тэнге", "тэнге"), ("тыйін", "тыйіны", "тыйінаў")),
+        "BYN": (
+            ("беларускі рубель", "беларускія рублі", "беларускіх рублёў"),
+            ("капейка", "капейкі", "капеек"),
+        ),
+        "UZS": (("сум", "сумы", "сумаў"), ("тыйін", "тыйіны", "тыйінаў")),
+        "PLN": (("злоты", "злотых", "злотых"), ("грош", "грошы", "грошаў")),
+    }
+
+    def setup(self):
+        self.negword = "мінус"
+        self.pointword = "коска"
+        self.ords = {
+            "нуль": "нулявы",
+            "адзін": "першы",
+            "два": "другі",
+            "тры": "трэці",
+            "чатыры": "чацвёрты",
+            "пяць": "пяты",
+            "шэсць": "шосты",
+            "сем": "сёмы",
+            "восем": "восьмы",
+            "дзевяць": "дзявяты",
+            "сто": "соты",
+            "тысяча": "тысячны",
+        }
+
+        self.ords_adjective = {
+            "адзін": "адна",
+            "адна": "адна",
+            "дзве": "двух",
+            "тры": "трох",
+            "чатыры": "чатырох",
+            "пяць": "пяці",
+            "шэсць": "шасці",
+            "сем": "сямі",
+            "восем": "васьмі",
+            "дзевяць": "дзевяцi",
+            "сто": "ста",
+        }
+
+    def to_cardinal(self, number, gender="m"):
+        n = str(number).replace(",", ".")
+        if "." in n:
+            is_negative = n.startswith('-')
+            abs_n = n[1:] if is_negative else n
+            left, right = abs_n.split(".")
+            if set(right) == {"0"}:
+                leading_zero_count = 0
+            else:
+                leading_zero_count = len(right) - len(right.lstrip("0"))
+
+            decimal_part = (ZERO + " ") * leading_zero_count + self._int2word(
+                int(right), gender
+            )
+            result = "{} {} {}".format(
+                self._int2word(int(left), gender), self.pointword, decimal_part
+            )
+            if is_negative:
+                result = self.negword + " " + result
+            return result
+        else:
+            return self._int2word(int(n), gender)
+
+    def pluralize(self, n, forms):
+        if n % 100 < 10 or n % 100 > 20:
+            if n % 10 == 1:
+                form = 0
+            elif 5 > n % 10 > 1:
+                form = 1
+            else:
+                form = 2
+        else:
+            form = 2
+        return forms[form]
+
+    def to_ordinal(self, number, gender="m"):
+        self.verify_ordinal(number)
+        if isinstance(gender, bool) and gender:
+            gender = "f"
+        outwords = self.to_cardinal(number, gender).split(" ")
+        lastword = outwords[-1].lower()
+        try:
+            if len(outwords) > 1:
+                if outwords[-2] in self.ords_adjective:
+                    outwords[-2] = self.ords_adjective.get(
+                        outwords[-2], outwords[-2]
+                    )
+                elif outwords[-2] == "дзесяць":
+                    outwords[-2] = outwords[-2][:-1] + "і"
+            if len(outwords) == 3:
+                if outwords[-3] in ["адзін", "адна"]:
+                    outwords[-3] = ""
+            lastword = self.ords[lastword]
+        except KeyError:
+            if lastword[:-3] in self.ords_adjective:
+                lastword = (
+                    self.ords_adjective.get(lastword[:-3], lastword) + "соты"
+                )
+            elif lastword[-7:] == "дзесяць":
+                lastword = "дзясяты"
+            elif lastword[-9:] == "семдзесят":
+                lastword = "сямідзясяты"
+            elif lastword[-1] == "ь" or lastword[-2] == "ц":
+                lastword = lastword[:-2] + "ты"
+            elif lastword[-1] == "к":
+                lastword = lastword.replace("о", "а") + "авы"
+
+            elif lastword[-2] == "ч" or lastword[-1] == "ч":
+                if lastword[-2] == "ч":
+                    lastword = lastword[:-1] + "ны"
+                if lastword[-1] == "ч":
+                    lastword = lastword + "ны"
+
+            elif lastword[-1] == "н" or lastword[-2] == "н":
+                lastword = lastword[: lastword.rfind("н") + 1] + "ны"
+            elif lastword[-3:] == "наў":
+                lastword = lastword[: lastword.rfind("н") + 1] + "ны"
+            elif lastword[-1] == "д" or lastword[-2] == "д":
+                lastword = lastword[: lastword.rfind("д") + 1] + "ны"
+
+        if gender == "f":
+            if lastword[-2:] in [
+                "ці",
+            ]:
+                lastword = lastword[:-2] + "цяя"
+            else:
+                lastword = lastword[:-1] + "ая"
+
+        if gender == "n":
+            if lastword[-2:] in ["ці", "ца"]:
+                lastword = lastword[:-2] + "цяе"
+            else:
+                lastword = lastword[:-1] + "ае"
+
+        outwords[-1] = self.title(lastword)
+        if len(outwords) == 2 and "адна" in outwords[-2]:
+            outwords[-2] = outwords[-1]
+            del outwords[-1]
+
+        if len(outwords) > 1 and (
+            (any(x[0] in outwords[-1] for x in THOUSANDS.values()))
+            or "тысяч" in outwords[-1]
+        ):
+            new_outwords = []
+            for _w in outwords:
+                replacement = next(
+                    (x for x in TWENTIES_ORD if x[0] in _w), None
+                )
+                if replacement:
+                    _w = _w.replace(replacement[0], replacement[1])
+                new_outwords.append(_w)
+            outwords = ["".join(new_outwords)]
+
+        return " ".join(outwords).strip()
+
+    def _money_verbose(self, number, currency):
+        gender = "m"
+        if currency == "UAH":
+            gender = "f"
+
+        return self._int2word(number, gender)
+
+    def _cents_verbose(self, number, currency):
+        if currency in ("UAH", "RUB", "BYN"):
+            gender = "f"
+        else:
+            gender = "m"
+
+        return self._int2word(number, gender)
+
+    def _int2word(self, n, gender="m"):
+        if n < 0:
+            return " ".join([self.negword, self._int2word(abs(n), gender)])
+
+        if n == 0:
+            return ZERO
+
+        words = []
+        chunks = list(splitbyx(str(n), 3))
+        i = len(chunks)
+        for x in chunks:
+            i -= 1
+
+            if x == 0:
+                continue
+
+            n1, n2, n3 = get_digits(x)
+
+            if n3 > 0:
+                words.append(HUNDREDS[n3])
+
+            if n2 > 1:
+                words.append(TWENTIES[n2])
+
+            if n2 == 1:
+                words.append(TENS[n1])
+            elif n1 > 0:
+                if i == 0:
+                    ones = ONES[gender]
+                elif i == 1:
+                    ones = ONES["f"]  # Thousands are feminine
+                else:
+                    ones = ONES["m"]
+
+                words.append(ones[n1])
+
+            if i > 0:
+                words.append(self.pluralize(x, THOUSANDS[i]))
+
+        return " ".join(words)