num2words2 0.1.0.dev1__py3-none-any.whl

num2words2/lang_IS.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 division, print_function, unicode_literals
+
+from . import lang_EUR
+
+# Genders
+KK = 0  # Karlkyn (male)
+KVK = 1  # Kvenkyn (female)
+HK = 2  # Hvorugkyn (neuter)
+
+GENDERS = {
+    "einn": ("einn", "ein", "eitt"),
+    "tveir": ("tveir", "tvær", "tvö"),
+    "þrír": ("þrír", "þrjár", "þrjú"),
+    "fjórir": ("fjórir", "fjórar", "fjögur"),
+}
+
+PLURALS = {
+    "hundrað": ("hundrað", "hundruð"),
+}
+
+
+class Num2Word_IS(lang_EUR.Num2Word_EUR):
+
+    CURRENCY_FORMS = {
+        'ISK': (('króna', 'krónur'), ('eyrir', 'aurar')),
+        'EUR': (('evra', 'evrur'), ('sent', 'sent')),
+        'USD': (('dalur', 'dalir'), ('sent', 'sent')),
+    }
+
+    GIGA_SUFFIX = "illjarður"
+    MEGA_SUFFIX = "illjón"
+
+    def setup(self):
+        lows = ["okt", "sept", "sext", "kvint", "kvaðr", "tr", "b", "m"]
+        self.high_numwords = self.gen_high_numwords([], [], lows)
+
+        self.negword = "mínus "
+        self.pointword = "komma"
+
+        # All words should be excluded, title case is not used in Icelandic
+        self.exclude_title = ["og", "komma", "mínus"]
+
+        self.mid_numwords = [(1000, "þúsund"), (100, "hundrað"),
+                             (90, "níutíu"), (80, "áttatíu"), (70, "sjötíu"),
+                             (60, "sextíu"), (50, "fimmtíu"), (40, "fjörutíu"),
+                             (30, "þrjátíu")]
+        self.low_numwords = ["tuttugu", "nítján", "átján", "sautján",
+                             "sextán", "fimmtán", "fjórtán", "þrettán",
+                             "tólf", "ellefu", "tíu", "níu", "átta",
+                             "sjö", "sex", "fimm", "fjórir", "þrír",
+                             "tveir", "einn", "núll"]
+        self.ords = {"einn": "fyrsti",
+                     "tveir": "annar",
+                     "þrír": "þriðji",
+                     "fjórir": "fjórði",
+                     "fimm": "fimmti",
+                     "sex": "sjötti",
+                     "sjö": "sjöundi",
+                     "átta": "áttundi",
+                     "níu": "níundi",
+                     "tíu": "tíundi",
+                     "ellefu": "ellefti",
+                     "tólf": "tólfti"}
+
+    def pluralize(self, n, noun):
+        form = 0 if (n % 10 == 1 and n % 100 != 11) else 1
+        if form == 0:
+            return noun
+        elif self.GIGA_SUFFIX in noun:
+            return noun.replace(self.GIGA_SUFFIX, "illjarðar")
+        elif self.MEGA_SUFFIX in noun:
+            return noun.replace(self.MEGA_SUFFIX, "illjónir")
+        elif noun not in PLURALS:
+            return noun
+        return PLURALS[noun][form]
+
+    def genderize(self, adj, noun):
+        last = adj.split()[-1]
+        if last not in GENDERS:
+            return adj
+        gender = KK
+        if "hund" in noun or "þús" in noun:
+            gender = HK
+        elif "illjarð" in noun:
+            gender = KK
+        elif "illjón" in noun:
+            gender = KVK
+        return adj.replace(last, GENDERS[last][gender])
+
+    def merge(self, lpair, rpair):
+        ltext, lnum = lpair
+        rtext, rnum = rpair
+
+        if lnum == 1 and rnum < 100:
+            return (rtext, rnum)
+        elif lnum < rnum:
+            rtext = self.pluralize(lnum, rtext)
+            ltext = self.genderize(ltext, rtext)
+            return ("%s %s" % (ltext, rtext), lnum * rnum)
+        elif lnum > rnum and rnum in self.cards:
+            rtext = self.pluralize(lnum, rtext)
+            ltext = self.genderize(ltext, rtext)
+            return ("%s og %s" % (ltext, rtext), lnum + rnum)
+        return ("%s %s" % (ltext, rtext), lnum + rnum)
+
+    def to_ordinal(self, value):
+        # Use the ordinal dictionary defined in setup
+        try:
+            number = int(value)
+        except (ValueError, TypeError):
+            return str(value)
+
+        # Get cardinal form first
+        cardinal = self.to_cardinal(number)
+
+        # Check if we have a direct mapping
+        if cardinal in self.ords:
+            return self.ords[cardinal]
+
+        # For numbers beyond our mapping, use generic suffix
+        # In Icelandic, ordinals typically end with -asti, -undi, etc.
+        if number == 20:
+            return "tuttugasti"
+        elif 20 < number < 30:
+            return "tuttugasti og " + self.ords.get(self.to_cardinal(number % 10), self.to_cardinal(number % 10))
+        elif number == 30:
+            return "þrítugasti"
+        elif number == 40:
+            return "fertugasti"
+        elif number == 50:
+            return "fimmtugasti"
+        elif number == 60:
+            return "sextugasti"
+        elif number == 70:
+            return "sjötugasti"
+        elif number == 80:
+            return "áttugasti"
+        elif number == 90:
+            return "nítugasti"
+        elif number == 100:
+            return "hundraðasti"
+        elif number == 1000:
+            return "þúsundasti"
+        else:
+            # For composite numbers, just append 'asti' to the cardinal
+            # This is a simplified implementation
+            return cardinal + "asti"
+
+    def to_ordinal_num(self, value):
+        # Just add a period after the number for ordinal numbers in Icelandic
+        return str(value) + "."
+
+    def to_year(self, val, suffix=None, longval=True):
+        # For Icelandic, years are typically read as cardinal numbers
+        # For example: 2024 would be "tvö þúsund tuttugu og fjórir"
+        return self.to_cardinal(val)
+
+    def pluralize_currency(self, count, forms):
+        """Return the proper plural form for Icelandic currency"""
+        if count == 1:
+            return forms[0]
+        return forms[1] if len(forms) > 1 else forms[0]
+
+    def to_currency(self, val, currency='ISK', cents=True, separator=',',
+                    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_IS, 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_IS, self).to_currency(
+            val, currency=currency, cents=cents, separator=separator,
+            adjective=adjective)

num2words2/lang_IT.py

@@ -0,0 +1,265 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2018-2019, Filippo Costa.  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 .lang_EUR import Num2Word_EUR
+
+# Globals
+# -------
+
+ZERO = "zero"
+
+CARDINAL_WORDS = [
+    ZERO, "uno", "due", "tre", "quattro", "cinque", "sei", "sette", "otto",
+    "nove", "dieci", "undici", "dodici", "tredici", "quattordici", "quindici",
+    "sedici", "diciassette", "diciotto", "diciannove"
+]
+
+ORDINAL_WORDS = [
+    ZERO, "primo", "secondo", "terzo", "quarto", "quinto", "sesto", "settimo",
+    "ottavo", "nono", "decimo", "undicesimo", "dodicesimo", "tredicesimo",
+    "quattordicesimo", "quindicesimo", "sedicesimo", "diciassettesimo",
+    "diciottesimo", "diciannovesimo"
+]
+
+# The script can extrapolate the missing numbers from the base forms.
+STR_TENS = {2: "venti", 3: "trenta", 4: "quaranta", 6: "sessanta"}
+
+# These prefixes are used for extremely big numbers.
+EXPONENT_PREFIXES = [
+    ZERO, "m", "b", "tr", "quadr", "quint", "sest", "sett", "ott", "nov", "dec"
+]
+
+EXPONENT = EXPONENT_PREFIXES  # Alias for backward compatibility
+
+
+GENERIC_DOLLARS = ('dollaro', 'dollari')
+GENERIC_CENTS = ('centesimo', 'centesimi')
+CURRENCIES_UNA = ('GBP')
+
+
+# Helper functions
+def omitt_if_zero(number_to_string):
+    return "" if number_to_string == ZERO else number_to_string
+
+
+def accentuate(string):
+    # This is inefficient: it may do several rewritings when deleting
+    # half-sentence accents. However, it is the easiest method and speed is
+    # not crucial (duh), so...
+    return " ".join(
+        # Deletes half-sentence accents and accentuates the last "tre"
+        [w.replace("tré", "tre")[:-3] + "tré"
+         # We shouldn't accentuate a single "tre": is has to be a composite
+         # word.                ~~~~~~~~~~
+         if w[-3:] == "tre" and len(w) > 3
+         # Deletes half-sentence accents anyway
+         #     ~~~~~~~~~~~~~~~~~~~~~~
+         else w.replace("tré", "tre")
+         for w in string.split()
+         ])
+
+
+def phonetic_contraction(string):
+    return (string
+            .replace("oo", "o")  # ex. "centootto"
+            .replace("ao", "o")  # ex. "settantaotto"
+            .replace("io", "o")  # ex. "ventiotto"
+            .replace("au", "u")  # ex. "trentauno"
+            .replace("iu", "u")  # ex. "ventiunesimo"
+            )
+
+
+def exponent_length_to_string(exponent_length):
+    # We always get an exponent length of the form 3n, n>=1
+    prefix = EXPONENT[(exponent_length // 6) % 5]
+
+    if exponent_length == 3:
+        return "mila"
+    elif exponent_length % 6 == 0:
+        return prefix + "ilione"
+    else:
+        return prefix + "iliardo"
+
+
+# Main class
+# ==========
+
+class Num2Word_IT(Num2Word_EUR):
+    CURRENCY_FORMS = {
+        'EUR': (('euro', 'euro'), GENERIC_CENTS),
+        'USD': (GENERIC_DOLLARS, GENERIC_CENTS),
+        'GBP': (('sterlina', 'sterline'), ('penny', 'penny')),
+        'CNY': (('yuan', 'yuan'), ('fen', 'fen')),
+        'CHF': (('franco', 'franchi'), GENERIC_CENTS),
+    }
+    MINUS_PREFIX_WORD = "meno "
+    FLOAT_INFIX_WORD = " virgola "
+
+    def setup(self):
+        Num2Word_EUR.setup(self)
+        self.negword = "meno"
+
+    def __init__(self):
+        self.setup()
+
+    def float_to_words(self, float_number, ordinal=False):
+        if ordinal:
+            prefix = self.to_ordinal(int(float_number))
+        else:
+            prefix = self.to_cardinal(int(float_number))
+        float_part = str(float_number).split('.')[1]
+        postfix = " ".join(
+            # Drops the trailing zero and comma
+            [self.to_cardinal(int(c)) for c in float_part]
+        )
+        return prefix + Num2Word_IT.FLOAT_INFIX_WORD + postfix
+
+    def tens_to_cardinal(self, number):
+        tens = number // 10
+        units = number % 10
+        if tens in STR_TENS:
+            prefix = STR_TENS[tens]
+        else:
+            prefix = CARDINAL_WORDS[tens][:-1] + "anta"
+        postfix = omitt_if_zero(CARDINAL_WORDS[units])
+        return phonetic_contraction(prefix + postfix)
+
+    def hundreds_to_cardinal(self, number):
+        hundreds = number // 100
+        prefix = "cento"
+        if hundreds != 1:
+            prefix = CARDINAL_WORDS[hundreds] + prefix
+        postfix = omitt_if_zero(self.to_cardinal(number % 100))
+        return phonetic_contraction(prefix + postfix)
+
+    def thousands_to_cardinal(self, number):
+        thousands = number // 1000
+        if thousands == 1:
+            prefix = "mille"
+        else:
+            prefix = self.to_cardinal(thousands) + "mila"
+        postfix = omitt_if_zero(self.to_cardinal(number % 1000))
+        # "mille" and "mila" don't need any phonetic contractions
+        return prefix + postfix
+
+    def big_number_to_cardinal(self, number):
+        digits = [c for c in str(number)]
+        length = len(digits)
+        if length >= 66:
+            raise NotImplementedError("The given number is too large.")
+        # This is how many digits come before the "illion" term.
+        #   cento miliardi => 3
+        #   dieci milioni => 2
+        #   un miliardo => 1
+        predigits = length % 3 or 3
+        multiplier = digits[:predigits]
+        exponent = digits[predigits:]
+        # Default infix string: "milione", "biliardo", "sestilione", ecc.
+        infix = exponent_length_to_string(len(exponent))
+        if multiplier == ["1"]:
+            prefix = "un "
+        else:
+            prefix = self.to_cardinal(int("".join(multiplier)))
+            # Plural form      ~~~~~~~~~~~
+            infix = " " + infix[:-1] + "i"
+        # Read as: Does the value of exponent equal 0?
+        if set(exponent) != set("0"):
+            postfix = self.to_cardinal(int("".join(exponent)))
+            if " e " in postfix:
+                infix += ", "
+            else:
+                infix += " e "
+        else:
+            postfix = ""
+        return prefix + infix + postfix
+
+    def to_cardinal(self, number):
+        if number < 0:
+            # Apply accentuation to the positive part, then add minus prefix
+            positive_part = self.to_cardinal(-number)
+            string = Num2Word_IT.MINUS_PREFIX_WORD + positive_part
+        elif int(number) != number:
+            string = self.float_to_words(number)
+        elif number < 20:
+            string = CARDINAL_WORDS[int(number)]
+        elif number < 100:
+            string = self.tens_to_cardinal(int(number))
+        elif number < 1000:
+            string = self.hundreds_to_cardinal(int(number))
+        elif number < 1000000:
+            string = self.thousands_to_cardinal(int(number))
+        else:
+            string = self.big_number_to_cardinal(number)
+        # Only apply accentuate for non-negative numbers (already done for negative)
+        return string if number < 0 else accentuate(string)
+
+    def to_ordinal(self, number):
+        tens = number % 100
+        # Italian grammar is poorly defined here ¯\_(ツ)_/¯:
+        #   centodecimo VS centodieciesimo VS centesimo decimo?
+        is_outside_teens = not 10 < tens < 20
+        if number < 0:
+            return Num2Word_IT.MINUS_PREFIX_WORD + self.to_ordinal(-number)
+        elif number % 1 != 0:
+            return self.float_to_words(number, ordinal=True)
+        elif number < 20:
+            return ORDINAL_WORDS[int(number)]
+        elif is_outside_teens and tens % 10 == 3:
+            # Gets rid of the accent
+            return self.to_cardinal(number)[:-1] + "eesimo"
+        elif is_outside_teens and tens % 10 == 6:
+            return self.to_cardinal(number) + "esimo"
+        else:
+            string = self.to_cardinal(number)[:-1]
+            if string[-3:] == "mil":
+                string += "l"
+            return string + "esimo"
+
+    def to_currency(self, val, currency='EUR', cents=True, separator=' e',
+                    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_IT, self).to_currency(
+                    val, currency=currency, cents=cents, separator=separator,
+                    adjective=adjective)
+
+            minus_str = "meno" 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)
+
+            # Build result with proper spacing
+            if minus_str:
+                result = "%s %s %s" % (minus_str, money_str, currency_str)
+            else:
+                result = "%s %s" % (money_str, currency_str)
+            return result.strip()
+
+        # For floats, use the parent class implementation
+        return super(Num2Word_IT, self).to_currency(
+            val, currency=currency, cents=cents, separator=separator,
+            adjective=adjective)