num2words2 0.1.0.dev1__py3-none-any.whl

num2words2/lang_ET.py

@@ -0,0 +1,393 @@
+# -*- 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
+
+
+class Num2Word_ET(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'EUR': (
+            ('euro', 'eurot'), ('sent', 'senti')
+        ),
+        'USD': (
+            ('dollar', 'dollarit'), ('sent', 'senti')
+        ),
+        'GBP': (
+            ('nael', 'naela'), ('penn', 'penni')
+        ),
+        'SEK': (
+            ('kroon', 'krooni'), ('ööri', 'ööri')
+        ),
+        'NOK': (
+            ('kroon', 'krooni'), ('ööri', 'ööri')
+        ),
+        'DKK': (
+            ('kroon', 'krooni'), ('ööri', 'ööri')
+        ),
+        'RUB': (
+            ('rubla', 'rubla'), ('kopikas', 'kopikat')
+        ),
+    }
+
+    def __init__(self):
+        super(Num2Word_ET, self).__init__()
+
+        self.ones = [
+            '',
+            'üks',
+            'kaks',
+            'kolm',
+            'neli',
+            'viis',
+            'kuus',
+            'seitse',
+            'kaheksa',
+            'üheksa'
+        ]
+
+        self.tens = [
+            '',
+            'kümme',
+            'kakskümmend',
+            'kolmkümmend',
+            'nelikümmend',
+            'viiskümmend',
+            'kuuskümmend',
+            'seitsekümmend',
+            'kaheksakümmend',
+            'üheksakümmend'
+        ]
+
+        self.scale = {
+            100: 'sada',
+            1000: 'tuhat',
+            1000000: 'miljon',
+            1000000000: 'miljard',
+            1000000000000: 'triljon'
+        }
+
+        self.ordinals_ones = [
+            '',
+            'esimene',
+            'teine',
+            'kolmas',
+            'neljas',
+            'viies',
+            'kuues',
+            'seitsmes',
+            'kaheksas',
+            'üheksas'
+        ]
+
+        self.ordinals_tens = [
+            '',
+            'kümnes',
+            'kahekümnes',
+            'kolmekümnes',
+            'nelikümnes',
+            'viiekümnes',
+            'kuuekümnes',
+            'seitsmekümnes',
+            'kaheksakümnes',
+            'üheksakümnes'
+        ]
+
+        self.negword = "miinus "
+        self.pointword = "koma"
+
+    def _setup(self):
+        super(Num2Word_ET, self)._setup()
+
+    def _int_to_word(self, n):
+        """
+        Converts a number to words in Estonian.
+        """
+        if n == 0:
+            return 'null'
+
+        parts = []
+
+        # Handle trillions
+        if n >= 1000000000000:
+            trillions = n // 1000000000000
+            if trillions == 1:
+                parts.append('üks triljon')
+            else:
+                parts.append(self._int_to_word(trillions) + ' triljonit')
+            n %= 1000000000000
+
+        # Handle billions
+        if n >= 1000000000:
+            billions = n // 1000000000
+            if billions == 1:
+                parts.append('üks miljard')
+            else:
+                parts.append(self._int_to_word(billions) + ' miljardit')
+            n %= 1000000000
+
+        # Handle millions
+        if n >= 1000000:
+            millions = n // 1000000
+            if millions == 1:
+                parts.append('üks miljon')
+            else:
+                parts.append(self._int_to_word(millions) + ' miljonit')
+            n %= 1000000
+
+        # Handle thousands
+        if n >= 1000:
+            thousands = n // 1000
+            if thousands == 1:
+                parts.append('tuhat')
+            elif thousands == 100:
+                # Special case: 100000 should be "sada tuhat" not "ükssada tuhat"
+                parts.append('sada tuhat')
+            else:
+                parts.append(self._int_to_word(thousands) + ' tuhat')
+            n %= 1000
+
+        # Handle hundreds
+        if n >= 100:
+            hundreds = n // 100
+            if hundreds == 1:
+                parts.append('ükssada')
+            elif hundreds == 2:
+                parts.append('kakssada')
+            elif hundreds == 3:
+                parts.append('kolmsada')
+            elif hundreds == 4:
+                parts.append('nelisada')
+            elif hundreds == 5:
+                parts.append('viissada')
+            elif hundreds == 6:
+                parts.append('kuussada')
+            elif hundreds == 7:
+                parts.append('seitsesada')
+            elif hundreds == 8:
+                parts.append('kaheksasada')
+            elif hundreds == 9:
+                parts.append('üheksasada')
+            n %= 100
+
+        # Handle special case for teens (11-19)
+        if 10 < n < 20:
+            teens_map = {
+                11: 'üksteist',
+                12: 'kaksteist',
+                13: 'kolmteist',
+                14: 'neliteist',
+                15: 'viisteist',
+                16: 'kuusteist',
+                17: 'seitseteist',
+                18: 'kaheksateist',
+                19: 'üheksateist'
+            }
+            parts.append(teens_map[n])
+        else:
+            # Handle tens
+            if n >= 10:
+                tens_val = n // 10
+                parts.append(self.tens[tens_val])
+                n %= 10
+
+            # Handle ones
+            if n > 0:
+                parts.append(self.ones[n])
+
+        return ' '.join(parts)
+
+    def _int_to_cardinal(self, n):
+        if n == 0:
+            return 'null'
+
+        if n < 0:
+            return self.negword + self._int_to_word(-n)
+
+        return self._int_to_word(n)
+
+    def _int_to_ordinal(self, n):
+        """Convert to ordinal number."""
+        if n == 0:
+            return 'nullis'
+
+        if n < 10:
+            return self.ordinals_ones[n]
+
+        if n == 10:
+            return 'kümnes'
+
+        if n < 20:
+            teens_ordinals = {
+                11: 'üheteistkümnes',
+                12: 'kaheteistkümnes',
+                13: 'kolmeteistkümnes',
+                14: 'neljateistkümnes',
+                15: 'viieteistkümnes',
+                16: 'kuueteistkümnes',
+                17: 'seitsmeteistkümnes',
+                18: 'kaheksateistkümnes',
+                19: 'üheksateistkümnes'
+            }
+            return teens_ordinals[n]
+
+        if n < 100:
+            tens_val = n // 10
+            ones_val = n % 10
+            if ones_val == 0:
+                return self.ordinals_tens[tens_val]
+            else:
+                # For compound numbers, make the last part ordinal
+                return self.tens[tens_val] + ' ' + self.ordinals_ones[ones_val]
+
+        if n == 100:
+            return 'sajas'
+
+        if n == 1000:
+            return 'tuhandes'
+
+        # For larger numbers, convert to cardinal and add 's' suffix
+        cardinal = self._int_to_cardinal(n)
+        return cardinal + 's'
+
+    def to_cardinal(self, n):
+        try:
+            if isinstance(n, str):
+                n = float(n)
+
+            # Handle floats with decimal places
+            if isinstance(n, float) and n != int(n):
+                pre, post = self.float2tuple(n)
+
+                # Handle negative decimals
+                if n < 0:
+                    result = self.negword
+                    pre = abs(pre)
+                else:
+                    result = ""
+
+                # Integer part
+                result += self._int_to_cardinal(pre)
+
+                # Decimal part
+                if self.precision > 0:
+                    result += " " + self.pointword
+
+                    # Convert post to string with proper padding
+                    post_str = str(post)
+                    post_str = '0' * (self.precision - len(post_str)) + post_str
+
+                    # Say each digit individually
+                    for digit in post_str:
+                        result += " " + self.ones[int(digit)]
+
+                return result.strip()
+
+            # For integers
+            return self._int_to_cardinal(int(n))
+        except BaseException:
+            return self._int_to_cardinal(int(n))
+
+    def to_ordinal(self, n):
+        try:
+            if isinstance(n, str):
+                n = int(n)
+
+            return self._int_to_ordinal(n)
+        except BaseException:
+            return self._int_to_ordinal(int(n))
+
+    def to_ordinal_num(self, n):
+        try:
+            if isinstance(n, str):
+                n = int(n)
+
+            return str(n) + '.'
+        except BaseException:
+            return str(n) + '.'
+
+    def to_currency(self, val, currency='EUR', cents=True, separator=' ja ',
+                    adjective=False):
+        """Convert a number to currency words."""
+        # Track if input was originally an integer
+        is_integer_input = isinstance(val, int)
+
+        # Check if value has fractional cents
+        if not is_integer_input:
+            from decimal import Decimal
+            decimal_val = Decimal(str(val))
+            has_fractional_cents = (decimal_val * 100) % 1 != 0
+        else:
+            has_fractional_cents = False
+
+        left, right, is_negative = parse_currency_parts(val, is_int_with_cents=False,
+                                                        keep_precision=has_fractional_cents)
+
+        try:
+            cr1, cr2 = self.CURRENCY_FORMS[currency]
+        except KeyError:
+            raise NotImplementedError(
+                'Currency "%s" not implemented for "%s"' % (
+                    currency, self.__class__.__name__))
+
+        minus_str = "miinus " if is_negative else ""
+        money_str = self._int_to_cardinal(left)
+
+        # Determine currency form based on the number
+        if left == 1:
+            currency_str = cr1[0]  # singular
+        else:
+            currency_str = cr1[1]  # plural
+
+        # For integers, don't show cents
+        if is_integer_input:
+            return "%s%s %s" % (minus_str, money_str, currency_str)
+
+        # For floats, always show cents (even if zero)
+        if cents:
+            # Handle fractional cents
+            from decimal import Decimal
+            if isinstance(right, Decimal):
+                # Convert fractional cents (e.g., 65.3 cents)
+                cents_str = self.to_cardinal(float(right)) if right > 0 else "null"
+            else:
+                cents_str = self._int_to_cardinal(right) if right > 0 else "null"
+        else:
+            cents_str = str(float(right) if isinstance(right, Decimal) else right)
+
+        # Determine cents form
+        if right == 1:
+            cents_currency = cr2[0]  # singular
+        else:
+            cents_currency = cr2[1]  # plural
+
+        return "%s%s %s%s%s %s" % (
+            minus_str, money_str, currency_str,
+            separator, cents_str, cents_currency)
+
+    def to_year(self, n):
+        """Convert to year representation."""
+        if n < 1000:
+            return self._int_to_cardinal(n)
+        elif n < 2000:
+            # Years like 1999 -> "tuhat üheksasada üheksakümmend üheksa"
+            return self._int_to_cardinal(n)
+        else:
+            # Years like 2023 -> "kaks tuhat kakskümmend kolm"
+            return self._int_to_cardinal(n)

num2words2/lang_EU.py

@@ -0,0 +1,158 @@
+# -*- 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
+
+
+# Basque language support
+class Num2Word_EU(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'EUR': (('euro', 'euro'), ('zentimo', 'zentimo')),
+        'USD': (('dolar', 'dolar'), ('zentabo', 'zentabo')),
+        'GBP': (('libera', 'libera'), ('penike', 'penike')),
+    }
+
+    def setup(self):
+        self.negword = "minus "
+        self.pointword = "koma"
+
+    def to_cardinal(self, number):
+        """Convert a number to its word representation in Basque."""
+        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 Basque."""
+        if number == 0:
+            return "zero"
+
+        ones = ["", "bat", "bi", "hiru", "lau", "bost", "sei", "zazpi", "zortzi", "bederatzi"]
+        tens = ["", "hamar", "hogei", "hogeita hamar", "berrogei", "berrogeita hamar",
+                "hirurogei", "hirurogeita hamar", "laurogei", "laurogeita hamar"]
+
+        if number < 10:
+            return ones[number]
+        elif number == 10:
+            return "hamar"
+        elif number < 20:
+            return "hama" + ones[number - 10]
+        elif number < 100:
+            ten_val = number // 10
+            one_val = number % 10
+            if one_val == 0:
+                return tens[ten_val]
+            else:
+                return tens[ten_val] + "ta " + ones[one_val]
+        elif number < 1000:
+            hundred_val = number // 100
+            remainder = number % 100
+            if hundred_val == 1:
+                result = "ehun"
+            else:
+                result = ones[hundred_val] + "ehun"
+            if remainder:
+                result += " eta " + self._int_to_word(remainder)
+            return result
+        elif number < 1000000:
+            thousand_val = number // 1000
+            remainder = number % 1000
+            if thousand_val == 1:
+                result = "mila"
+            else:
+                result = self._int_to_word(thousand_val) + " mila"
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+        elif number < 1000000000:
+            million_val = number // 1000000
+            remainder = number % 1000000
+            if million_val == 1:
+                result = "milioi bat"
+            else:
+                result = self._int_to_word(million_val) + " milioi"
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+        else:
+            billion_val = number // 1000000000
+            remainder = number % 1000000000
+            result = self._int_to_word(billion_val) + " mila milioi"
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+
+    def to_ordinal(self, number):
+        """Convert to ordinal."""
+        cardinal = self.to_cardinal(number)
+        if cardinal.endswith('t'):
+            return cardinal + "garren"
+        else:
+            return cardinal + "garren"
+
+    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) + ". urtea"
+
+    def to_currency(self, val, currency='EUR', cents=True, separator=' eta ', 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['EUR'])
+
+        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_EUR.py

@@ -0,0 +1,104 @@
+# -*- 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
+
+GENERIC_DOLLARS = ('dollar', 'dollars')
+GENERIC_CENTS = ('cent', 'cents')
+
+
+class Num2Word_EUR(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'AUD': (GENERIC_DOLLARS, GENERIC_CENTS),
+        'BYN': (('rouble', 'roubles'), ('kopek', 'kopeks')),
+        'CAD': (GENERIC_DOLLARS, GENERIC_CENTS),
+        # repalced by EUR
+        'EEK': (('kroon', 'kroons'), ('sent', 'senti')),
+        'EUR': (('euro', 'euro'), GENERIC_CENTS),
+        'GBP': (('pound sterling', 'pounds sterling'), ('penny', 'pence')),
+        # replaced by EUR
+        'LTL': (('litas', 'litas'), GENERIC_CENTS),
+        # replaced by EUR
+        'LVL': (('lat', 'lats'), ('santim', 'santims')),
+        'USD': (GENERIC_DOLLARS, GENERIC_CENTS),
+        'RUB': (('rouble', 'roubles'), ('kopek', 'kopeks')),
+        'SEK': (('krona', 'kronor'), ('öre', 'öre')),
+        'NOK': (('krone', 'kroner'), ('øre', 'øre')),
+        'PLN': (('zloty', 'zlotys', 'zlotu'), ('grosz', 'groszy')),
+        'MXN': (('peso', 'pesos'), GENERIC_CENTS),
+        'RON': (('leu', 'lei', 'de lei'), ('ban', 'bani', 'de bani')),
+        'INR': (('rupee', 'rupees'), ('paisa', 'paise')),
+        'HUF': (('forint', 'forint'), ('fillér', 'fillér')),
+        'ISK': (('króna', 'krónur'), ('aur', 'aurar')),
+        'UZS': (('sum', 'sums'), ('tiyin', 'tiyins')),
+        'SAR': (('saudi riyal', 'saudi riyals'), ('halalah', 'halalas')),
+        'JPY': (('yen', 'yen'), ('sen', 'sen')),
+        'KRW': (('won', 'won'), ('jeon', 'jeon')),
+
+    }
+
+    CURRENCY_ADJECTIVES = {
+        'AUD': 'Australian',
+        'BYN': 'Belarusian',
+        'CAD': 'Canadian',
+        'EEK': 'Estonian',
+        'USD': 'US',
+        'RUB': 'Russian',
+        'NOK': 'Norwegian',
+        'MXN': 'Mexican',
+        'RON': 'Romanian',
+        'INR': 'Indian',
+        'HUF': 'Hungarian',
+        'ISK': 'íslenskar',
+        'UZS': 'Uzbekistan',
+        'SAR': 'Saudi',
+        'JPY': 'Japanese',
+        'KRW': 'Korean',
+    }
+
+    GIGA_SUFFIX = "illiard"
+    MEGA_SUFFIX = "illion"
+
+    def set_high_numwords(self, high):
+        cap = 3 + 6 * len(high)
+
+        for word, n in zip(high, range(cap, 3, -6)):
+            if self.GIGA_SUFFIX:
+                self.cards[10 ** n] = word + self.GIGA_SUFFIX
+
+            if self.MEGA_SUFFIX:
+                self.cards[10 ** (n - 3)] = word + self.MEGA_SUFFIX
+
+    def gen_high_numwords(self, units, tens, lows):
+        out = [u + t for t in tens for u in units]
+        out.reverse()
+        return out + lows
+
+    def pluralize(self, n, forms):
+        form = 0 if n == 1 else 1
+        return forms[form]
+
+    def setup(self):
+        lows = ["non", "oct", "sept", "sext", "quint", "quadr", "tr", "b", "m"]
+        units = ["", "un", "duo", "tre", "quattuor", "quin", "sex", "sept",
+                 "octo", "novem"]
+        tens = ["dec", "vigint", "trigint", "quadragint", "quinquagint",
+                "sexagint", "septuagint", "octogint", "nonagint"]
+        self.high_numwords = ["cent"] + self.gen_high_numwords(units, tens,
+                                                               lows)