num2words2 0.1.0.dev1__py3-none-any.whl

num2words2/currency.py

@@ -0,0 +1,60 @@
+# -*- 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
+
+from decimal import ROUND_HALF_UP, Decimal
+
+
+def parse_currency_parts(value, is_int_with_cents=True, keep_precision=False):
+    if isinstance(value, int):
+        if is_int_with_cents:
+            # assume cents if value is integer
+            negative = value < 0
+            value = abs(value)
+            integer, cents = divmod(value, 100)
+        else:
+            negative = value < 0
+            integer, cents = abs(value), 0
+
+    else:
+        # Convert to string first to avoid float precision issues
+        value = Decimal(str(value))
+
+        if not keep_precision:
+            # Round to 2 decimal places
+            value = value.quantize(
+                Decimal('.01'),
+                rounding=ROUND_HALF_UP
+            )
+
+        negative = value < 0
+        value = abs(value)
+        integer, fraction = divmod(value, 1)
+        integer = int(integer)
+
+        if keep_precision:
+            # Keep full precision for cents
+            cents = fraction * 100  # Keep as Decimal
+        else:
+            cents = int(fraction * 100)
+
+    return integer, cents, negative
+
+
+def prefix_currency(prefix, base):
+    return tuple("%s %s" % (prefix, i) for i in base)

num2words2/lang_AF.py

@@ -0,0 +1,202 @@
+# -*- 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 print_function, unicode_literals
+
+from .lang_EUR import Num2Word_EUR
+
+
+class Num2Word_AF(Num2Word_EUR):
+    CURRENCY_FORMS = {
+        'ZAR': (('rand', 'rand'), ('sent', 'sent')),
+        'EUR': (('euro', 'euro'), ('sent', 'sent')),
+        'GBP': (('pond', 'pond'), ('penny', 'pence')),
+        'USD': (('dollar', 'dollar'), ('sent', 'sent')),
+        'CNY': (('yuan', 'yuan'), ('jiao', 'fen')),
+    }
+
+    GIGA_SUFFIX = "iljard"
+    MEGA_SUFFIX = "iljoen"
+
+    def setup(self):
+        super(Num2Word_AF, self).setup()
+
+        self.negword = "minus "
+        self.pointword = "komma"
+
+        # Error messages in Afrikaans
+        self.errmsg_floatord = (
+            "Kan nie die desimale getal %s as 'n ordinale getal behandel nie."
+        )
+        self.errmsg_nonnum = (
+            "Slegs getalle (tipe(%s)) kan na woorde omgeskakel word."
+        )
+        self.errmsg_negord = (
+            "Kan nie die negatiewe getal %s as 'n ordinale getal behandel nie."
+        )
+        self.errmsg_toobig = "Die getal %s moet minder as %s wees."
+        self.exclude_title = []
+
+        # High number words for very large numbers
+        lows = ["non", "okt", "sept", "sext", "kwint", "kwadr", "tr", "b", "m"]
+        units = ["", "un", "duo", "tre", "kwattuor", "kwin", "seks", "sept",
+                 "okto", "novem"]
+        tens = ["des", "vigint", "trigint", "kwadragint", "kwinquagint",
+                "seksagint", "septuagint", "oktogint", "nonagint"]
+
+        self.high_numwords = (
+            ["send"] + self.gen_high_numwords(units, tens, lows))
+
+        # Mid-range numbers (thousands, hundreds, tens)
+        self.mid_numwords = [(1000, "duisend"), (100, "honderd"),
+                             (90, "negentig"), (80, "tagtig"),
+                             (70, "sewentig"), (60, "sestig"),
+                             (50, "vyftig"), (40, "veertig"),
+                             (30, "dertig")]
+
+        # Low numbers (0-20)
+        self.low_numwords = ["twintig", "negentien", "agttien", "sewentien",
+                             "sestien", "vyftien", "veertien", "dertien",
+                             "twaalf", "elf", "tien", "nege", "agt", "sewe",
+                             "ses", "vyf", "vier", "drie", "twee", "een",
+                             "nul"]
+
+        # Ordinal mappings
+        self.ords = {
+            "nul": "nulld",
+            "een": "eerst",
+            "twee": "tweed",
+            "drie": "derd",
+            "vier": "vierd",
+            "vyf": "vyfd",
+            "ses": "sesd",
+            "sewe": "sewend",
+            "agt": "agst",
+            "nege": "negend",
+            "tien": "tiend",
+            "elf": "elfd",
+            "twaalf": "twaalfd",
+
+            # Compound endings
+            "ig": "igst",
+            "erd": "erdst",
+            "end": "endst",
+            "joen": "joenst",
+            "rd": "rdst"
+        }
+
+    def merge(self, curr, next):
+        ctext, cnum, ntext, nnum = curr + next
+
+        if cnum == 1:
+            if nnum == 100 or nnum == 1000:
+                return ("een " + ntext, nnum)
+            elif nnum < 10 ** 6:
+                return next
+            ctext = "een"
+
+        if nnum > cnum:
+            if nnum >= 10 ** 6:
+                ctext += " "
+            elif nnum == 100 or nnum == 1000:
+                ctext += " "
+            val = cnum * nnum
+        else:
+            if nnum < 10 < cnum < 100:
+                if nnum == 1:
+                    ntext = "een"
+
+                # Afrikaans compound formation: vier-en-dertig
+                ntext = ntext + "-en-" + ctext
+                ctext = ""
+            elif cnum >= 10 ** 6:
+                ctext += " "
+            elif cnum >= 100:
+                ctext += " "
+            val = cnum + nnum
+
+        word = ctext + ntext
+        return word, val
+
+    def to_ordinal(self, value):
+        self.verify_ordinal(value)
+        outword = self.to_cardinal(value)
+
+        # Handle special compound ordinals
+        for key in self.ords:
+            if outword.endswith(key):
+                outword = outword[:len(outword) - len(key)] + self.ords[key]
+                break
+
+        return outword + "e"
+
+    def to_ordinal_num(self, value):
+        self.verify_ordinal(value)
+        # Afrikaans uses "de" for some ordinal numbers, "ste" for most
+        if value in [2, 3, 4, 5, 6, 7, 8]:
+            return str(value) + "de"
+        else:
+            return str(value) + "ste"
+
+    def pluralize(self, n, forms):
+        """
+        Afrikaans pluralization rules - most currencies don't change form
+        :param n: number
+        :param forms: tuple of (singular, plural) forms
+        :return: appropriate form
+        """
+        # Most Afrikaans currencies use the same form for singular and plural
+        return forms[0]
+
+    def to_currency(self, val, currency='ZAR', cents=True, separator=' en',
+                    adjective=False):
+        return super(Num2Word_AF, self).to_currency(
+            val, currency=currency, cents=cents, separator=separator,
+            adjective=adjective)
+
+    def to_year(self, val, longval=True):
+        # Handle special year cases
+        if val >= 2000:
+            if val == 2000:
+                return self.to_cardinal(val)
+            elif val < 2010:
+                # 2001-2009: "twee duisend een", etc.
+                return self.to_cardinal(2000) + " " + self.to_cardinal(val - 2000)
+
+            else:
+                # 2010+: "twintig tien", "twintig elf", etc.
+                century = val // 100
+                year_part = val % 100
+                if year_part == 0:
+                    return self.to_cardinal(century) + " honderd"
+                else:
+                    return self.to_cardinal(century) + " " + self.to_cardinal(year_part)
+        else:
+            # Pre-2000 years: "negentien nege-en-negentig" not "negentien honderd nege-en-negentig"
+
+            if val < 1000:
+                return self.to_cardinal(val)
+            elif not (val // 100) % 10:
+                return self.to_cardinal(val)
+            else:
+                # Split as century + year
+                century = val // 100
+                year_part = val % 100
+                if year_part == 0:
+                    return self.to_cardinal(century) + " honderd"
+                else:
+                    return self.to_cardinal(century) + " " + self.to_cardinal(year_part)

num2words2/lang_AM.py

@@ -0,0 +1,193 @@
+# -*- 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
+
+
+class Num2Word_AM(lang_EUR.Num2Word_EUR):
+    CURRENCY_FORMS = {'ETB': (('ብር', 'ብር'), ('ሳንቲም', 'ሳንቲም'), ' ከ'),
+                      'USD': (('ዶላር', 'ዶላር'), ('ሳንቲም', 'ሳንቲም'), ' ከ'),
+                      'JPY': (('የን', 'የን'), ('ሴን', 'ሴን'), ' ከ')}
+
+    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_AM, self).setup()
+
+        self.negword = 'ሰልቢ '
+        self.pointword = 'ነጥብ'
+        self.exclude_title = ['እና', 'ነጥብ', 'አሉታዊ']
+
+        self.mid_numwords = [(1000, 'ሺህ'), (100, 'መቶ'), (90, 'ዘጠና'),
+                             (80, 'ሰማንያ'), (70, 'ሰባ'), (60, 'ስድሳ'),
+                             (50, 'አምሳ'), (40, 'አርባ'), (30, 'ሠላሳ')]
+        self.low_numwords = ['ሃያ', 'አሥራ ዘጠኝ', 'አሥራ ስምንት', 'አሥራ ሰባት',
+                             'አስራ ስድስት', 'አሥራ አምስት', 'አሥራ አራት', 'አሥራ ሦስት',
+                             'አሥራ ሁለት', 'አሥራ አንድ', 'አሥር', 'ዘጠኝ', 'ስምንት',
+                             'ሰባት', 'ስድስት', 'አምስት', 'አራት', 'ሦስት', 'ሁለት',
+                             'አንድ', 'ዜሮ']
+        self.ords = {'አንድ': 'አንደኛ',
+                     'ሁለት': 'ሁለተኛ',
+                     'ሦስት': 'ሦስተኛ',
+                     'አራት': 'አራተኛ',
+                     'አምስት': 'አምስተኛ',
+                     'ስድስት': 'ስድስተኛ',
+                     'ሰባት': 'ሰባተኛ',
+                     'ስምንት': 'ስምንተኛ',
+                     'ዘጠኝ': 'ዘጠነኛ',
+                     'አሥር': 'አሥረኛ',
+                     'አሥራ አንድ': 'አሥራ አንደኛ',
+                     'አሥራ ሁለት': 'አሥራ ሁለተኛ',
+                     'አሥራ ሦስት': 'አሥራ ሦስተኛ',
+                     'አሥራ አራት': 'አሥራ አራተኛ',
+                     'አሥራ አምስት': 'አሥራ አምስተኛ',
+                     'አሥራ ስድስት': 'አሥራ ስድስተኛ',
+                     'አሥራ ሰባት': 'አሥራ ሰባተኛ',
+                     'አሥራ ስምንት': 'አሥራ ስምንተኛ',
+                     'አሥራ ዘጠኝ': 'አሥራ ዘጠነኛ'}
+
+    def to_cardinal(self, value):
+        try:
+            assert int(value) == value
+        except (ValueError, TypeError, AssertionError):
+            return self.to_cardinal_float(value)
+
+        # Handle negative integers
+        if value < 0:
+            return self.negword + self.to_cardinal(-value)
+
+        out = ''
+        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:
+            return '%s %s' % (ltext, rtext), lnum + rnum
+        elif lnum >= 100 > rnum:
+            return '%s %s' % (ltext, rtext), lnum + rnum
+        elif rnum > lnum:
+            return '%s %s' % (ltext, rtext), lnum * rnum
+        else:
+            # Default case: lnum > rnum, both could be >= 100
+            return '%s %s' % (ltext, rtext), lnum + rnum
+
+    def to_ordinal(self, value):
+        self.verify_ordinal(value)
+        outwords = self.to_cardinal(value).split(' ')
+        lastwords = outwords[-1].split('-')
+        lastword = lastwords[-1].lower()
+        try:
+            lastword = self.ords[lastword]
+        except KeyError:
+            lastword += 'ኛ'
+        lastwords[-1] = self.title(lastword)
+        outwords[-1] = ' '.join(lastwords)
+        return ' '.join(outwords)
+
+    def to_ordinal_num(self, value):
+        self.verify_ordinal(value)
+        return '%s%s' % (value, self.to_ordinal(value)[-1:])
+
+    def to_currency(self, val, currency='ETB', cents=True, separator=',',
+                    adjective=False):
+        # Track if input was originally an integer
+        is_integer_input = isinstance(val, int)
+
+        if is_integer_input:
+            left = abs(val)
+            right = 0
+            is_negative = val < 0
+        else:
+            from decimal import Decimal
+
+            from .currency import parse_currency_parts
+
+            # Check if value has fractional cents
+            decimal_val = Decimal(str(val))
+            has_fractional_cents = (decimal_val * 100) % 1 != 0
+
+            left, right, is_negative = parse_currency_parts(val, is_int_with_cents=False,
+                                                            keep_precision=has_fractional_cents)
+
+        try:
+            cr1, cr2, default_separator = self.CURRENCY_FORMS[currency]
+            if separator == ',':  # Use default separator if not overridden
+                separator = default_separator
+        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.to_cardinal(left)
+
+        # For floats, always show cents (even if zero)
+        # For integers, don't show cents at all
+        if not is_integer_input:
+            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(float(right)) if right > 0 else 'ዜሮ'
+                else:
+                    cents_str = self.to_cardinal(right) if right > 0 else 'ዜሮ'
+            else:
+                cents_str = str(float(right) if isinstance(right, Decimal) else right)
+            return u'%s%s %s%s %s %s' % (
+                minus_str,
+                money_str,
+                self.pluralize(left, cr1),
+                separator,
+                cents_str,
+                self.pluralize(right, cr2)
+            )
+        else:
+            # Integer: no cents
+            return u'%s%s %s' % (
+                minus_str,
+                money_str,
+                self.pluralize(left, cr1)
+            )
+
+    def to_year(self, val, longval=True):
+        if not (val // 100) % 10:
+            return self.to_cardinal(val)
+        return self.to_splitnum(val, hightxt='መቶ', longval=longval)