num2words2 0.1.0.dev1__py3-none-any.whl

num2words2/lang_SQ.py

@@ -0,0 +1,252 @@
+# -*- 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_SQ(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'ALL': (('lek', 'lekë'), ('qindarkë', 'qindarkë')),
+        'EUR': (('euro', 'euro'), ('cent', 'centë')),
+        'USD': (('dollar', 'dollarë'), ('cent', 'centë')),
+        'GBP': (('paund', 'paund'), ('peni', 'pence')),
+        'CHF': (('frank zviceran', 'franka zvicer'), ('centim', 'centimë')),
+        'JPY': (('jen', 'jenë'), ('sen', 'senë')),
+        'RUB': (('rubël', 'rubla'), ('kopek', 'kopekë')),
+    }
+
+    def setup(self):
+        self.negword = "minus "
+        self.pointword = "presje"
+        self.exclude_title = ["e", "presje", "minus"]
+
+        self.high_numwords = ["trilion", "miliard", "milion"]
+
+        self.mid_numwords = [
+            (1000, "mijë"),
+            (100, "qind"),
+            (90, "nëntëdhjetë"),
+            (80, "tetëdhjetë"),
+            (70, "shtatëdhjetë"),
+            (60, "gjashtëdhjetë"),
+            (50, "pesëdhjetë"),
+            (40, "dyzet"),
+            (30, "tridhjetë"),
+            (20, "njëzet"),
+        ]
+
+        self.low_numwords = [
+            "nëntëmbëdhjetë",  # 19
+            "tetëmbëdhjetë",   # 18
+            "shtatëmbëdhjetë",  # 17
+            "gjashtëmbëdhjetë",  # 16
+            "pesëmbëdhjetë",   # 15
+            "katërmbëdhjetë",  # 14
+            "trembëdhjetë",    # 13
+            "dymbëdhjetë",     # 12
+            "njëmbëdhjetë",    # 11
+            "dhjetë",          # 10
+            "nëntë",           # 9
+            "tetë",            # 8
+            "shtatë",          # 7
+            "gjashtë",         # 6
+            "pesë",            # 5
+            "katër",           # 4
+            "tre",             # 3
+            "dy",              # 2
+            "një",             # 1
+            "zero"             # 0
+        ]
+
+        # Ordinal forms
+        self.ordinal_forms = {
+            0: "i zeroi",
+            1: "i pari",
+            2: "i dyti",
+            3: "i treti",
+            4: "i katërti",
+            5: "i pesti",
+            6: "i gjashti",
+            7: "i shtati",
+            8: "i teti",
+            9: "i nënti",
+            10: "i dhjeti",
+            20: "i njezeti",
+            100: "i njëqindi",
+            1000: "i një mijti",
+        }
+
+    def set_high_numwords(self, high):
+        max = 3 + 3 * len(high)
+        for word, n in zip(high, range(max, 3, -3)):
+            self.cards[10 ** n] = word
+
+    def merge(self, curr, next):
+        ctext, cnum, ntext, nnum = curr + next
+
+        if cnum == 1:
+            if nnum == 1000:
+                return ("një mijë", 1000)
+            if nnum == 100:
+                return ("njëqind", 100)  # Combined as one word
+            if nnum < 100:
+                return next
+            ctext = "një"
+
+        if nnum > cnum:
+            if nnum >= 1000000:
+                return ("%s %s" % (ctext, ntext), cnum * nnum)
+            elif nnum >= 1000:
+                return ("%s %s" % (ctext, ntext), cnum * nnum)
+            elif nnum == 100:
+                return ("%s %s" % (ctext, ntext), cnum * nnum)
+
+        if nnum < cnum:
+            if cnum >= 1000:
+                # For thousands, always use "e" connector for smaller numbers
+                return ("%s e %s" % (ctext, ntext), cnum + nnum)
+            elif cnum >= 100:
+                # For hundreds, use "e" for anything smaller
+                return ("%s e %s" % (ctext, ntext), cnum + nnum)
+            else:
+                # For tens (20, 30, etc.), use "e" for units
+                if cnum >= 20 and nnum < 10:
+                    return ("%s e %s" % (ctext, ntext), cnum + nnum)
+                return ("%s%s" % (ctext, ntext), cnum + nnum)
+
+        return ("%s %s" % (ctext, ntext), cnum + nnum)
+
+    def to_cardinal(self, value):
+        if value == 0:
+            return 'zero'
+
+        result = super(Num2Word_SQ, self).to_cardinal(value)
+        return result
+
+    def to_ordinal(self, value):
+        if value in self.ordinal_forms:
+            return self.ordinal_forms[value]
+
+        # For compound ordinals, use pattern "i + cardinal + suffix"
+        if value <= 10:
+            return self.ordinal_forms.get(value, "i " + self.to_cardinal(value))
+
+        elif value == 20:
+            return "i njezeti"
+        elif value == 100:
+            return "i njëqindi"
+        elif value == 1000:
+            return "i një mijti"
+        else:
+            # For other numbers, use pattern
+            cardinal = self.to_cardinal(value)
+            return "i " + cardinal
+
+    def to_ordinal_num(self, value):
+        self.verify_ordinal(value)
+
+        # Albanian ordinal suffixes based on ending
+        if value % 10 == 1 and value % 100 != 11:
+            suffix = "-shi"
+        elif value % 10 == 2 and value % 100 != 12:
+            suffix = "-ri"
+        elif value % 10 == 3 and value % 100 != 13:
+            suffix = "-ti"
+        else:
+            suffix = "-ti"
+
+        return str(value) + suffix
+
+    def pluralize(self, n, forms):
+        """Albanian plural rules"""
+        if not forms:
+            return ''
+
+        if len(forms) == 1:
+            return forms[0]
+
+        if len(forms) >= 2:
+            # In Albanian, use singular for 1, plural for everything else
+            if n == 1:
+                return forms[0]
+            else:
+                return forms[1]
+
+        return forms[0]
+
+    def to_currency(self, val, currency='ALL', cents=True, separator=',',
+                    adjective=False):
+        """
+        Convert a value to Albanian currency format.
+        """
+        result = []
+        is_negative = val < 0
+        val = abs(val)
+
+        if currency in self.CURRENCY_FORMS:
+            # Check if value has fractional cents
+            from decimal import Decimal
+            decimal_val = Decimal(str(val))
+            has_fractional_cents = (decimal_val * 100) % 1 != 0
+
+            if isinstance(val, float):
+                # Handle decimal values
+                if has_fractional_cents:
+                    # Keep precision for fractional cents
+                    whole = int(decimal_val)
+                    cents_value = decimal_val * 100 - (whole * 100)
+                else:
+                    whole = int(val)
+                    cents_value = int(round((val - whole) * 100))
+            else:
+                whole = int(val)
+                cents_value = 0
+
+            # Add the main currency
+            if whole > 0:
+                result.append(self.to_cardinal(whole))
+                result.append(self.pluralize(whole, self.CURRENCY_FORMS[currency][0]))
+
+            # Add cents if present and cents=True
+            if cents_value > 0 and cents:
+                if whole > 0:
+                    # Join the main currency part first, then add separator
+                    main_part = ' '.join(result)
+                    result = [main_part + separator]
+                # Handle fractional cents
+                from decimal import Decimal
+                if isinstance(cents_value, Decimal):
+                    # Convert fractional cents (e.g., 65.3 cents)
+                    result.append(self.to_cardinal_float(float(cents_value)))
+                    result.append(self.pluralize(int(cents_value), self.CURRENCY_FORMS[currency][1]))
+                else:
+                    result.append(self.to_cardinal(cents_value))
+                    result.append(self.pluralize(cents_value, self.CURRENCY_FORMS[currency][1]))
+
+            if is_negative:
+                result.insert(0, self.negword.strip())
+
+            return ' '.join(result)
+        else:
+            # Fallback for unknown currency
+            return self.to_cardinal(val)
+
+    def to_year(self, value, **kwargs):
+        """Convert number to year format (same as cardinal for Albanian)."""
+        return self.to_cardinal(value)

num2words2/lang_SR.py

@@ -0,0 +1,254 @@
+# -*- 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
+from .currency import parse_currency_parts
+from .utils import get_digits, splitbyx
+
+ZERO = ('нула',)
+
+ONES = {
+    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: ('деведесет',),
+}
+
+HUNDREDS = {
+    1: ('сто',),
+    2: ('двеста',),
+    3: ('триста',),
+    4: ('четиристо',),
+    5: ('петсто',),
+    6: ('шесто',),
+    7: ('седамсто',),
+    8: ('осамсто',),
+    9: ('деветсто',),
+}
+
+SCALE = {
+    0: ('', '', '', False),
+    1: ('хиљада', 'хиљаде', 'хиљада', True),  # 10^3
+    2: ('милион', 'милиона', 'милиона', False),  # 10^6
+    3: ('милијарда', 'милијарде', 'милијарди', True),  # 10^9 - using long scale
+    4: ('билион', 'билиона', 'билиона', False),  # 10^12
+    5: ('билијарда', 'билијарде', 'билијарди', True),  # 10^15
+    6: ('трилион', 'трилиона', 'трилиона', False),  # 10^18
+    7: ('трилијарда', 'трилијарде', 'трилијарди', True),  # 10^21
+    8: ('квадрилион', 'квадрилиона', 'квадрилиона', False),  # 10^24
+    9: ('квадрилијарда', 'квадрилијарде', 'квадрилијарди', True),  # 10^27
+    10: ('квинтилион', 'квинтилиона', 'квинтилиона', False),  # 10^30
+}
+
+
+class Num2Word_SR(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'RUB': (
+            ('rublja', 'rublje', 'rublji', True),
+            ('kopejka', 'kopejke', 'kopejki', True)
+        ),
+        'EUR': (
+            ('evro', 'evra', 'evra', False),
+            ('cent', 'centa', 'centi', False)
+        ),
+        'RSD': (
+            ('dinar', 'dinara', 'dinara', False),
+            ('para', 'pare', 'para', True)
+        ),
+    }
+
+    def setup(self):
+        self.negword = "минус"
+        self.pointword = "запета"
+
+    def to_cardinal(self, number, feminine=False):
+        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('.')
+            leading_zero_count = len(right) - len(right.lstrip('0'))
+            decimal_part = ((ZERO[0] + ' ') * leading_zero_count +
+                            self._int2word(int(right), feminine))
+            result = u'%s %s %s' % (
+                self._int2word(int(left), feminine),
+                self.pointword,
+                decimal_part
+            )
+            if is_negative:
+                result = self.negword + ' ' + result
+            return result
+        else:
+            return self._int2word(int(n), feminine)
+
+    def pluralize(self, number, forms):
+        if number % 100 < 10 or number % 100 > 20:
+            if number % 10 == 1:
+                form = 0
+            elif 1 < number % 10 < 5:
+                form = 1
+            else:
+                form = 2
+        else:
+            form = 2
+        return forms[form]
+
+    def to_ordinal(self, number):
+        """Convert to Serbian ordinal numbers (Cyrillic)."""
+        try:
+            num = int(number)
+        except (ValueError, TypeError):
+            return str(number)
+
+        # Serbian ordinals in Cyrillic
+        ordinals = {
+            1: 'први',
+            2: 'други',
+            3: 'трећи',
+            4: 'четврти',
+            5: 'пети',
+            6: 'шести',
+            7: 'седми',
+            8: 'осми',
+            9: 'девети',
+            10: 'десети',
+            11: 'једанаести',
+            12: 'дванаести',
+            13: 'тринаести',
+            14: 'четрнаести',
+            15: 'петнаести',
+            16: 'шеснаести',
+            17: 'седамнаести',
+            18: 'осамнаести',
+            19: 'деветнаести',
+            20: 'двадесети',
+            30: 'тридесети',
+            40: 'четрдесети',
+            50: 'педесети',
+            60: 'шездесети',
+            70: 'седамдесети',
+            80: 'осамдесети',
+            90: 'деведесети',
+            100: 'стоти',
+            1000: 'хиљадити',
+        }
+
+        if num in ordinals:
+            return ordinals[num]
+
+        # For other numbers, add 'и' suffix to the cardinal
+        # This is a simplified implementation
+        cardinal = self.to_cardinal(num)
+        return cardinal + 'и'
+
+    def _cents_verbose(self, number, currency):
+        return self._int2word(
+            number,
+            self.CURRENCY_FORMS[currency][1][-1]
+        )
+
+    def _int2word(self, number, feminine=False):
+        if number < 0:
+            return ' '.join([self.negword, self._int2word(abs(number))])
+
+        if number == 0:
+            return ZERO[0]
+
+        words = []
+        chunks = list(splitbyx(str(number), 3))
+        chunk_len = len(chunks)
+        for chunk in chunks:
+            chunk_len -= 1
+            digit_right, digit_mid, digit_left = get_digits(chunk)
+
+            if digit_left > 0:
+                words.append(HUNDREDS[digit_left][0])
+
+            if digit_mid > 1:
+                words.append(TWENTIES[digit_mid][0])
+
+            if digit_mid == 1:
+                words.append(TENS[digit_right][0])
+            elif digit_right > 0:
+                # Skip 'један' for thousands (1000, 1001, etc.)
+                if not (chunk_len > 0 and chunk == 1):
+                    is_feminine = feminine or SCALE[chunk_len][-1]
+                    gender_idx = int(is_feminine)
+                    words.append(
+                        ONES[digit_right][gender_idx]
+                    )
+
+            if chunk_len > 0 and chunk != 0:
+                words.append(self.pluralize(chunk, SCALE[chunk_len]))
+
+        return ' '.join(words)
+
+    def to_currency(self, val, currency='RSD', cents=True, separator=',',
+                    adjective=False):
+        # Handle integers specially - no cents
+        if isinstance(val, int):
+            # Get major currency part only
+            left, right, is_negative = parse_currency_parts(val, is_int_with_cents=False)
+            words = []
+            if is_negative:
+                words.append('минус')
+            words.append(self.to_cardinal(left))
+
+            # Add currency name based on the number
+            if left % 10 == 1 and left % 100 != 11:
+                words.append('динар')
+            elif 2 <= left % 10 <= 4 and not (12 <= left % 100 <= 14):
+                words.append('динара')
+            else:
+                words.append('динара')
+
+            return ' '.join(words)
+
+        # For floats, use parent implementation
+        return super().to_currency(val, currency=currency, cents=cents,
+                                   separator=separator, adjective=adjective)

num2words2/lang_SU.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
+
+
+# Sundanese language support
+class Num2Word_SU(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'IDR': (('rupiah', 'rupiah'), ('sen', 'sen')),
+        'USD': (('dollar', 'dollars'), ('cent', 'cents')),
+        'EUR': (('euro', 'euros'), ('cent', 'cents'))
+    }
+
+    def setup(self):
+        self.negword = "minus "
+        self.pointword = "point"
+        self.ones = ['', 'hiji', 'dua', 'tilu', 'opat', 'lima', 'genep', 'tujuh', 'dalapan', 'salapan']
+        self.tens = ['', 'sapuluh', 'dua puluh', 'tilu puluh', 'opat puluh', 'lima puluh', 'genep puluh', 'tujuh puluh', 'dalapan puluh', 'salapan puluh']
+        self.hundred = "ratus"
+        self.thousand = "rebu"
+        self.million = "juta"
+
+    def to_cardinal(self, number):
+        """Convert a number to its word representation in Sundanese."""
+        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 Sundanese."""
+        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 Sundanese."""
+        cardinal = self.to_cardinal(number)
+        # Language-specific ordinal suffix
+        return cardinal + "-na"
+
+    def to_ordinal_num(self, number):
+        """Convert to abbreviated ordinal."""
+        return str(number) + "."
+
+    def to_year(self, val, longval=True):
+        """Convert to year in Sundanese."""
+        return self.to_cardinal(val)
+
+    def to_currency(self, val, currency='IDR', cents=True, separator=' ', adjective=False):
+        """Convert to currency in Sundanese."""
+        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()