num2words2 0.1.0.dev1__py3-none-any.whl

num2words2/lang_NE.py

@@ -0,0 +1,157 @@
+# -*- 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
+
+
+# Nepali language support
+class Num2Word_NE(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'NPR': (('रुपैयाँ', 'रुपैयाँ'), ('पैसा', 'पैसा')),
+        'USD': (('dollar', 'dollars'), ('cent', 'cents')),
+        'EUR': (('euro', 'euros'), ('cent', 'cents')),
+    }
+
+    def setup(self):
+        self.negword = "ऋण "
+        self.pointword = "दशमलव"
+        self.ones = ['', 'एक', 'दुई', 'तीन', 'चार', 'पाँच', 'छ', 'सात', 'आठ', 'नौ']
+        self.tens = ['', 'दस', 'बीस', 'तीस', 'चालीस', 'पचास', 'साठी', 'सत्तरी', 'असी', 'नब्बे']
+        self.teens = ['दस', 'एघार', 'बाह्र', 'तेह्र', 'चौध', 'पन्ध्र', 'सोह्र', 'सत्र', 'अठार', 'उन्नाइस']
+        self.hundred = "सय"
+        self.thousand = "हजार"
+        self.lakh = "लाख"
+        self.crore = "करोड"
+        self.zero = "शून्य"
+
+    def to_cardinal(self, number):
+        """Convert a number to its word representation in Nepali."""
+        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.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 Nepali."""
+        if number == 0:
+            return self.zero
+
+        if number < 0:
+            return self.negword + self._int_to_word(abs(number))
+        elif number < 10:
+            return self.ones[number]
+        elif number < 20:
+            return self.teens[number - 10]
+        elif number < 100:
+            result = self.tens[number // 10]
+            if number % 10:
+                result += " " + self.ones[number % 10]
+            return result
+        elif number < 1000:
+            result = self.ones[number // 100] + " " + self.hundred
+            remainder = number % 100
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+        elif number < 100000:  # Lakh
+            result = self._int_to_word(number // 1000) + " " + self.thousand
+            remainder = number % 1000
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+        elif number < 10000000:  # Crore
+            result = self._int_to_word(number // 100000) + " " + self.lakh
+            remainder = number % 100000
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+        elif number < 1000000000:
+            result = self._int_to_word(number // 10000000) + " " + self.crore
+            remainder = number % 10000000
+            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 Nepali.
+
+        Nepali ordinals use 'औं' suffix for most numbers.
+        Special forms exist for first few ordinals.
+        """
+        if number == 1:
+            return "पहिलो"  # first
+        elif number == 2:
+            return "दोस्रो"  # second
+        elif number == 3:
+            return "तेस्रो"  # third
+        elif number == 4:
+            return "चौथो"  # fourth
+        else:
+            # For other numbers, add औं suffix
+            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 in Nepali."""
+        if val < 0:
+            return "BC " + self.to_cardinal(abs(val))
+        else:
+            return "" + self.to_cardinal(val)
+
+    def to_currency(self, val, currency='NPR', cents=True, separator=' ', adjective=False):
+        """Convert to currency in Nepali."""
+        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, self.CURRENCY_FORMS['NPR'])
+
+        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()

num2words2/lang_NL.py

@@ -0,0 +1,204 @@
+# -*- 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_NL(Num2Word_EUR):
+    CURRENCY_FORMS = {
+        'EUR': (('euro', 'euro'), ('cent', 'cent')),
+        'GBP': (('pond', 'pond'), ('penny', 'pence')),
+        'USD': (('dollar', 'dollar'), ('cent', 'cent')),
+        'CNY': (('yuan', 'yuan'), ('jiao', 'fen')),
+    }
+
+    GIGA_SUFFIX = "iljard"
+    MEGA_SUFFIX = "iljoen"
+
+    def setup(self):
+        super(Num2Word_NL, self).setup()
+
+        self.negword = "min "
+        self.pointword = "komma"
+        # "Cannot treat float %s as ordinal."
+        self.errmsg_floatord = (
+            "Het zwevende puntnummer %s kan niet omgezet worden " +
+            "naar een ordernummer."
+        )
+        # "type(((type(%s)) ) not in [long, int, float]"
+        self.errmsg_nonnum = (
+            "Alleen nummers (type (%s)) kunnen naar " +
+            "woorden omgezet worden."
+        )
+        # "Cannot treat negative num %s as ordinal."
+        self.errmsg_negord = (
+            "Het negatieve getal %s kan niet omgezet " +
+            "worden naar een ordernummer."
+        )
+        # "abs(%s) must be less than %s."
+        self.errmsg_toobig = "Het getal %s moet minder zijn dan %s."
+        self.exclude_title = []
+
+        lows = ["non", "okt", "sept", "sext", "quint", "quadr", "tr", "b", "m"]
+        units = ["", "un", "duo", "tre", "quattuor", "quin", "sex", "sept",
+                 "okto", "novem"]
+        tens = ["dez", "vigint", "trigint", "quadragint", "quinquagint",
+                "sexagint", "septuagint", "oktogint", "nonagint"]
+
+        self.high_numwords = (
+            ["zend"] + self.gen_high_numwords(units, tens, lows))
+
+        self.mid_numwords = [(1000, "duizend"), (100, "honderd"),
+                             (90, "negentig"), (80, "tachtig"),
+                             (70, "zeventig"), (60, "zestig"),
+                             (50, "vijftig"), (40, "veertig"),
+                             (30, "dertig")]
+
+        self.low_numwords = ["twintig", "negentien", "achttien", "zeventien",
+                             "zestien", "vijftien", "veertien", "dertien",
+                             "twaalf", "elf", "tien", "negen", "acht", "zeven",
+                             "zes", "vijf", "vier", "drie", "twee", "één",
+                             "nul"]
+
+        # Wiktionary says it is "nulde", not "nulte" or "nule"
+        # https://en.wiktionary.org/wiki/nulde
+        self.ords = {"nul": "nuld",
+                     "één": "eerst",
+                     "twee": "tweed",
+                     "drie": "derd",
+                     "vier": "vierd",
+                     "vijf": "vijfd",
+                     "zes": "zesd",
+                     "zeven": "zevend",
+                     "acht": "achtst",
+                     "negen": "negend",
+                     "tien": "tiend",
+                     "elf": "elfd",
+                     "twaalf": "twaalfd",
+
+                     "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 < 10 ** 6:
+                return next
+            ctext = "een"
+
+        if nnum > cnum:
+            if nnum >= 10 ** 6:
+                ctext += " "
+            val = cnum * nnum
+        else:
+            if nnum < 10 < cnum < 100:
+                if nnum == 1:
+                    ntext = "een"
+
+                if ntext.endswith("e"):
+                    ntext += "ën"  # "n"
+                else:
+                    ntext += "en"
+                ntext, ctext = ctext, ntext  # + "en"
+            elif cnum >= 10 ** 6:
+                ctext += " "
+            val = cnum + nnum
+
+        word = ctext + ntext
+        return word, val
+
+    def to_currency(self, val, currency='EUR', cents=True, separator=' en',
+                    adjective=False):
+        # Handle integers specially - just add currency name without cents
+        if isinstance(val, int):
+            try:
+                cr1, cr2 = self.CURRENCY_FORMS[currency]
+            except (KeyError, AttributeError):
+                # Fallback to base implementation for unknown currency
+                return super(Num2Word_NL, self).to_currency(
+                    val, currency=currency, cents=cents, separator=separator,
+                    adjective=adjective)
+
+            minus_str = self.negword if val < 0 else ""
+            abs_val = abs(val)
+            money_str = self.to_cardinal(abs_val)
+
+            # Proper pluralization for currency
+            if abs_val == 1:
+                currency_str = cr1[0] if isinstance(cr1, tuple) else cr1
+            else:
+                currency_str = cr1[1] if isinstance(cr1, tuple) and len(cr1) > 1 else (cr1[0] if isinstance(cr1, tuple) else cr1)
+
+            return (u'%s %s %s' % (minus_str, money_str, currency_str)).strip()
+
+        # For floats, use the parent class implementation
+        return super(Num2Word_NL, self).to_currency(
+            val, currency=currency, cents=cents, separator=separator,
+            adjective=adjective)
+
+    def to_ordinal(self, value):
+        self.verify_ordinal(value)
+        outword = self.to_cardinal(value)
+        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)
+        return str(value) + "e"
+
+    def pluralize(self, n, forms):
+        """
+        :param n:
+        :param forms:
+        :return:
+
+        gettext form is nplurals=2; plural=(n != 1);
+        but this claims https://onzetaal.nl/taaladvies/euro-euros/
+        not sure if it's applied only to euro
+        """
+        return forms[0]
+
+    def to_year(self, val, longval=True):
+        # For years 1100-1999, use the "[number]honderd" form
+        # e.g. 1600 -> "zestienhonderd" not "duizendzeshonderd"
+        if 1100 <= val <= 1999:
+            hundreds = val // 100
+            remainder = val % 100
+
+            # Convert the hundreds part (11-19)
+            result = self.to_cardinal(hundreds) + "honderd"
+
+            # Add remainder if any
+            if remainder:
+                remainder_text = self.to_cardinal(remainder)
+                result = result + remainder_text
+
+            return result
+
+        # For other years, use standard logic
+        if not (val // 100) % 10:
+            return self.to_cardinal(val)
+        return self.to_splitnum(val, hightxt="honderd", longval=longval)

num2words2/lang_NN.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
+
+
+# Norwegian Nynorsk language support
+class Num2Word_NN(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'NOK': (('krone', 'kroner'), ('øre', 'øre')),
+        'USD': (('dollar', 'dollars'), ('cent', 'cents')),
+        'EUR': (('euro', 'euros'), ('cent', 'cents'))
+    }
+
+    def setup(self):
+        self.negword = "minus "
+        self.pointword = "point"
+        self.ones = ['', 'ein', 'to', 'tre', 'fire', 'fem', 'seks', 'sju', 'åtte', 'ni']
+        self.tens = ['', 'ti', 'tjue', 'tretti', 'førti', 'femti', 'seksti', 'sytti', 'åtti', 'nitti']
+        self.hundred = "hundre"
+        self.thousand = "tusen"
+        self.million = "million"
+
+    def to_cardinal(self, number):
+        """Convert a number to its word representation in Norwegian Nynorsk."""
+        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 Norwegian Nynorsk."""
+        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 Norwegian Nynorsk."""
+        cardinal = self.to_cardinal(number)
+        # Language-specific ordinal suffix
+        return cardinal + "-de"
+
+    def to_ordinal_num(self, number):
+        """Convert to abbreviated ordinal."""
+        return str(number) + "."
+
+    def to_year(self, val, longval=True):
+        """Convert to year in Norwegian Nynorsk."""
+        return self.to_cardinal(val)
+
+    def to_currency(self, val, currency='NOK', cents=True, separator=' ', adjective=False):
+        """Convert to currency in Norwegian Nynorsk."""
+        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()

num2words2/lang_NO.py

@@ -0,0 +1,143 @@
+# -*- 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_NO(lang_EUR.Num2Word_EUR):
+    GIGA_SUFFIX = "illiard"
+    MEGA_SUFFIX = "illion"
+    CURRENCY_FORMS = {
+        'NOK': (('krone', 'kroner'), ('øre', 'øre')),
+        'EUR': (('euro', 'euro'), ('cent', 'cent')),
+        'USD': (('dollar', 'dollar'), ('cent', 'cent')),
+    }
+
+    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 setup(self):
+        super(Num2Word_NO, self).setup()
+
+        self.negword = "minus "
+        self.pointword = "komma"
+        self.exclude_title = ["og", "komma", "minus"]
+
+        self.mid_numwords = [(1000, "tusen"), (100, "hundre"),
+                             (90, "nitti"), (80, "\xe5tti"), (70, "sytti"),
+                             (60, "seksti"), (50, "femti"), (40, "f\xf8rti"),
+                             (30, "tretti")]
+        self.low_numwords = ["tjue", "nitten", "atten", "sytten",
+                             "seksten", "femten", "fjorten", "tretten",
+                             "tolv", "elleve", "ti", "ni", "\xe5tte",
+                             "syv", "seks", "fem", "fire", "tre", "to",
+                             "en", "null"]
+        self.ords_pl = {"to": "andre",
+                        "tre": "tredje",
+                        "fire": "fjerde",
+                        "fem": "femte",
+                        "seks": "sjette",
+                        "syv": "syvende",
+                        "\xe5tte": "\xe5ttende",
+                        "ni": "niende",
+                        "ti": "tiende",
+                        "elleve": "ellevte",
+                        "tolv": "tolvte",
+                        "fjorten": "fjortende",
+                        "femten": "femtende",
+                        "seksten": "sekstende",
+                        "sytten": "syttende",
+                        "atten": "attende",
+                        "nitten": "nittende",
+                        "tjue": "tjuende",
+                        "hundre": "hundrede",
+                        "tusen": "tusende",
+                        "million": "millionte"}
+        # this needs to be done separately to not block 13-19 to_ordinal
+        self.ords_sg = {"en": "f\xf8rste"}
+
+    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 og %s" % (ltext, rtext), lnum + rnum)
+        elif rnum > lnum:
+            # Special case for Norwegian: use "ett" before "tusen" but not "en" before "hundre"
+            if lnum == 1 and rnum == 1000:
+                return ("ett %s" % rtext, lnum * rnum)
+            elif lnum == 100 and rnum == 1000:
+                # 100000 should be "hundre tusen" not "en hundre tusen"
+                return ("hundre tusen", 100000)
+            # Handle Norwegian plural forms for million and milliard
+            if rnum == 10**6:
+                if lnum == 1:
+                    return ("en million", lnum * rnum)
+                else:
+                    return ("%s millioner" % ltext, lnum * rnum)
+            elif rnum == 10**9:
+                if lnum == 1:
+                    return ("en milliard", lnum * rnum)
+                else:
+                    return ("%s milliarder" % ltext, lnum * rnum)
+            return ("%s %s" % (ltext, rtext), lnum * rnum)
+        return ("%s %s" % (ltext, rtext), lnum + rnum)
+
+    def to_ordinal(self, value):
+        self.verify_ordinal(value)
+        outword = self.to_cardinal(value)
+        for key in self.ords_pl:
+            if outword.endswith(key):
+                outword = outword[:len(outword) - len(key)] + self.ords_pl[key]
+                break
+        for key in self.ords_sg:
+            if outword.endswith(key):
+                outword = outword[:len(outword) - len(key)] + self.ords_sg[key]
+                break
+        return outword
+
+    def to_ordinal_num(self, value):
+        self.verify_ordinal(value)
+        return str(value) + "."
+
+    def to_year(self, val, longval=True):
+        if not (val // 100) % 10:
+            return self.to_cardinal(val)
+        return self.to_splitnum(val, hightxt="hundre", jointxt="og",
+                                longval=longval)
+
+    def to_currency(self, val, currency='NOK', cents=True, separator=' og',
+                    adjective=False):
+        result = super(Num2Word_NO, self).to_currency(
+            val, currency=currency, cents=cents, separator=separator,
+            adjective=adjective)
+
+        # do not print "og null øre"
+        result = result.replace(' og null øre', '')
+        return result