num2words2 0.1.0.dev1__py3-none-any.whl

num2words2/lang_PS.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
+
+
+# Pashto language support
+class Num2Word_PS(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'AFN': (('افغانۍ', 'افغانۍ'), ('پول', 'پول')),
+        'USD': (('dollar', 'dollars'), ('cent', 'cents')),
+        'EUR': (('euro', 'euros'), ('cent', 'cents'))
+    }
+
+    def setup(self):
+        self.negword = "minus "
+        self.pointword = "point"
+        self.ones = ['', 'یو', 'دوه', 'درې', 'څلور', 'پنځه', 'شپږ', 'اووه', 'اته', 'نهه']
+        self.tens = ['', 'لس', 'شل', 'دېرش', 'څلوېښت', 'پنځوس', 'شپېته', 'اویا', 'اتیا', 'نوي']
+        self.hundred = "سل"
+        self.thousand = "زره"
+        self.million = "میلیون"
+
+    def to_cardinal(self, number):
+        """Convert a number to its word representation in Pashto."""
+        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 Pashto."""
+        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 Pashto."""
+        cardinal = self.to_cardinal(number)
+        # Language-specific ordinal suffix
+        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 Pashto."""
+        return self.to_cardinal(val)
+
+    def to_currency(self, val, currency='AFN', cents=True, separator=' ', adjective=False):
+        """Convert to currency in Pashto."""
+        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_PT.py

@@ -0,0 +1,280 @@
+# -*- 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, unicode_literals
+
+import re
+
+from .lang_EUR import Num2Word_EUR
+
+DOLLAR = ('dólar', 'dólares')
+CENTS = ('cêntimo', 'cêntimos')
+
+
+class Num2Word_PT(Num2Word_EUR):
+
+    CURRENCY_FORMS = {
+        'AUD': (DOLLAR, CENTS),
+        'BRL': (('real', 'reais'), ('centavo', 'centavos')),
+        'CAD': (DOLLAR, CENTS),
+        'EUR': (('euro', 'euros'), CENTS),
+        'GBP': (('libra', 'libras'), ('péni', 'pence')),
+        'USD': (DOLLAR, CENTS),
+    }
+
+    GIGA_SUFFIX = None
+    MEGA_SUFFIX = "ilião"
+
+    def setup(self):
+        super(Num2Word_PT, self).setup()
+        lows = ["quatr", "tr", "b", "m"]
+        self.high_numwords = self.gen_high_numwords([], [], lows)
+        self.negword = "menos "
+        self.pointword = "vírgula"
+        self.exclude_title = ["e", "vírgula", "menos"]
+
+        self.mid_numwords = [
+            (1000, "mil"), (100, "cem"), (90, "noventa"),
+            (80, "oitenta"), (70, "setenta"), (60, "sessenta"),
+            (50, "cinquenta"), (40, "quarenta"), (30, "trinta")
+        ]
+        self.low_numwords = [
+            "vinte", "dezanove", "dezoito", "dezassete", "dezasseis",
+            "quinze", "catorze", "treze", "doze", "onze", "dez",
+            "nove", "oito", "sete", "seis", "cinco", "quatro", "três", "dois",
+            "um", "zero"
+        ]
+        self.ords = [
+            {
+                0: "",
+                1: "primeiro",
+                2: "segundo",
+                3: "terceiro",
+                4: "quarto",
+                5: "quinto",
+                6: "sexto",
+                7: "sétimo",
+                8: "oitavo",
+                9: "nono",
+            },
+            {
+                0: "",
+                1: "décimo",
+                2: "vigésimo",
+                3: "trigésimo",
+                4: "quadragésimo",
+                5: "quinquagésimo",
+                6: "sexagésimo",
+                7: "septuagésimo",
+                8: "octogésimo",
+                9: "nonagésimo",
+            },
+            {
+                0: "",
+                1: "centésimo",
+                2: "ducentésimo",
+                3: "tricentésimo",
+                4: "quadrigentésimo",
+                5: "quingentésimo",
+                6: "seiscentésimo",
+                7: "septigentésimo",
+                8: "octigentésimo",
+                9: "nongentésimo",
+            },
+        ]
+        self.thousand_separators = {
+            3: "milésimo",
+            6: "milionésimo",
+            9: "milésimo milionésimo",
+            12: "bilionésimo",
+            15: "milésimo bilionésimo"
+        }
+        self.hundreds = {
+            1: "cento",
+            2: "duzentos",
+            3: "trezentos",
+            4: "quatrocentos",
+            5: "quinhentos",
+            6: "seiscentos",
+            7: "setecentos",
+            8: "oitocentos",
+            9: "novecentos",
+        }
+
+    def merge(self, curr, next):
+        ctext, cnum, ntext, nnum = curr + next
+
+        if cnum == 1:
+            if nnum < 1000000:
+                return next
+            ctext = "um"
+        elif cnum == 100 and not nnum % 1000 == 0:
+            ctext = "cento"
+
+        if nnum < cnum:
+            if cnum < 100:
+                return ("%s e %s" % (ctext, ntext), cnum + nnum)
+            return ("%s e %s" % (ctext, ntext), cnum + nnum)
+
+        elif (not nnum % 1000000000) and cnum > 1:
+            ntext = ntext[:-4] + "liões"
+        elif (not nnum % 1000000) and cnum > 1:
+            ntext = ntext[:-4] + "lhões"
+        # correct "milião" to "milhão"
+        if ntext == 'milião':
+            ntext = 'milhão'
+        if nnum == 100:
+            ctext = self.hundreds[cnum]
+            ntext = ""
+
+        else:
+            ntext = " " + ntext
+
+        return (ctext + ntext, cnum * nnum)
+
+    def to_cardinal(self, value):
+        result = super(Num2Word_PT, self).to_cardinal(value)
+
+        # Transforms "mil e cento e catorze" into "mil cento e catorze"
+        # Transforms "cem milhões e duzentos mil e duzentos e dez" em "cem
+        # milhões duzentos mil duzentos e dez" but "cem milhões e duzentos
+        # mil e duzentos" in "cem milhões duzentos mil e duzentos" and not in
+        # "cem milhões duzentos mil duzentos"
+        for ext in (
+                'mil', 'milhão', 'milhões', 'mil milhões',
+                'bilião', 'biliões', 'mil biliões'):
+            if re.match('.*{} e \\w*entos? (?=.*e)'.format(ext), result):
+                result = result.replace(
+                    '{} e'.format(ext), '{}'.format(ext)
+                )
+
+        return result
+
+    # for the ordinal conversion the code is similar to pt_BR code,
+    # although there are other rules that are probably more correct in
+    # Portugal. Concerning numbers from 2000th on, saying "dois
+    # milésimos" instead of "segundo milésimo" (the first number
+    # would be used in the cardinal form instead of the ordinal) is better.
+    # This was not implemented.
+    # source:
+    # https://ciberduvidas.iscte-iul.pt/consultorio/perguntas/a-forma-por-extenso-de-2000-e-de-outros-ordinais/16428
+    def to_ordinal(self, value):
+        # Before changing this function remember this is used by pt-BR
+        # so act accordingly
+        self.verify_ordinal(value)
+
+        result = []
+        value = str(value)
+        thousand_separator = ''
+
+        for idx, char in enumerate(value[::-1]):
+            if idx and idx % 3 == 0:
+                thousand_separator = self.thousand_separators[idx]
+
+            if char != '0' and thousand_separator:
+                # avoiding "segundo milionésimo milésimo" for 6000000,
+                # for instance
+                result.append(thousand_separator)
+                thousand_separator = ''
+
+            result.append(self.ords[idx % 3][int(char)])
+
+        result = ' '.join(result[::-1])
+        result = result.strip()
+        result = re.sub('\\s+', ' ', result)
+
+        if result.startswith('primeiro') and value != '1':
+            # avoiding "primeiro milésimo", "primeiro milionésimo" and so on
+            result = result[9:]
+
+        return result
+
+    def to_ordinal_num(self, value):
+        # Before changing this function remember this is used by pt-BR
+        # so act accordingly
+        self.verify_ordinal(value)
+        return "%sº" % (value)
+
+    def to_year(self, val, longval=True):
+        # Before changing this function remember this is used by pt-BR
+        # so act accordingly
+        if val < 0:
+            return self.to_cardinal(abs(val)) + ' antes de Cristo'
+        return self.to_cardinal(val)
+
+    def to_currency(self, val, currency='EUR', cents=True, separator=' e',
+                    adjective=False):
+        # Track if input was originally an integer (not float)
+        is_integer = isinstance(val, int)
+
+        # Handle integers specially - just add currency name without cents
+        if is_integer:
+            try:
+                cr1, cr2 = self.CURRENCY_FORMS[currency]
+            except KeyError:
+                return self.to_cardinal(val)
+
+            # change negword for currency
+            backup_negword = self.negword
+            self.negword = self.negword[:-1]
+
+            minus_str = "%s " % self.negword.strip() if val < 0 else ""
+            abs_val = abs(int(val) if isinstance(val, float) else val)
+            money_str = self.to_cardinal(abs_val)
+
+            # restore negword
+            self.negword = backup_negword
+
+            # Proper pluralization for currency
+            if abs_val == 1:
+                currency_str = cr1[0]  # singular
+            else:
+                currency_str = cr1[1] if len(cr1) > 1 else cr1[0]  # plural
+
+            result = "%s%s %s" % (minus_str, money_str, currency_str)
+
+            # transforms "milhões euros" em "milhões de euros"
+            for ext in ('milhão', 'milhões', 'bilião', 'biliões', 'trilião', 'triliões'):
+                if re.match('.*{} (?={})'.format(ext, currency_str), result):
+                    result = result.replace(
+                        '{}'.format(ext), '{} de'.format(ext), 1
+                    )
+
+            return result.strip()
+
+        # For floats with non-zero decimal part, use the parent class implementation
+        backup_negword = self.negword
+        self.negword = self.negword[:-1]
+        result = super(Num2Word_PT, self).to_currency(
+            val, currency=currency, cents=cents, separator=separator,
+            adjective=adjective)
+        # undo the change on negword
+        self.negword = backup_negword
+
+        # transforms "milhões euros" em "milhões de euros"
+        cr1, _ = self.CURRENCY_FORMS[currency]
+
+        for ext in (
+                'milhão', 'milhões', 'bilião',
+                'biliões', 'trilião', 'triliões'):
+            if re.match('.*{} (?={})'.format(ext, cr1[1]), result):
+                result = result.replace(
+                    '{}'.format(ext), '{} de'.format(ext), 1
+                )
+        # For floats, keep "e zero cêntimos" to show it's a precise amount
+        # Only remove for integers (but we handle integers separately now)
+        return result

num2words2/lang_PT_BR.py

@@ -0,0 +1,224 @@
+# -*- 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
+
+import re
+
+from . import lang_PT
+
+
+def negativeword(self):
+    return self.negword
+
+
+class Num2Word_PT_BR(lang_PT.Num2Word_PT):
+    negword = 'menos '
+
+    CURRENCY_FORMS = {
+        'BRL': (('real', 'reais'), ('centavo', 'centavos')),
+        'EUR': (('euro', 'euros'), ('cêntimo', 'cêntimos')),
+        'USD': (('dólar', 'dólares'), ('centavo', 'centavos')),
+    }
+
+    def __init__(self):
+        super(Num2Word_PT_BR, self).__init__()
+        self.negword = 'menos '
+
+    def setup(self):
+        # First call parent setup
+        super(Num2Word_PT_BR, self).setup()
+
+        # Brazilian Portuguese uses different spelling for 16, 17, 19
+        self.low_numwords = [
+            "vinte", "dezenove", "dezoito", "dezessete", "dezesseis",
+            "quinze", "catorze", "treze", "doze", "onze", "dez",
+            "nove", "oito", "sete", "seis", "cinco", "quatro", "três", "dois",
+            "um", "zero"
+        ]
+
+        # Override thousand separators for Brazilian Portuguese ordinals
+        # Brazilian uses short scale: bilhão = 10^9, trilhão = 10^12
+        self.thousand_separators = {
+            3: "milésimo",
+            6: "milionésimo",
+            9: "bilionésimo",  # Brazilian billion = 10^9
+            12: "trilionésimo",  # Brazilian trillion = 10^12
+            15: "quatrilionésimo"  # Brazilian quadrillion = 10^15
+        }
+
+    def merge(self, curr, next):
+        ctext, cnum, ntext, nnum = curr + next
+
+        if cnum == 1:
+            if nnum < 1000000:
+                return (ntext, cnum * nnum)
+            ctext = "um"
+        elif cnum == 100 and nnum > 0 and nnum < 1000:
+            # In Brazilian Portuguese, 100 + any number up to 999 becomes "cento"
+            # But 100 * 1000 = 100000 stays as "cem mil"
+            ctext = "cento"
+
+        if nnum > cnum:
+            # Multiplicative case (e.g., "dois mil")
+            if (not nnum % 1000000) and cnum > 1:
+                # Handle Brazilian scale for millions
+                if nnum == 1000000:
+                    ntext = "milhões"
+                else:
+                    ntext = ntext[:-4] + "lhões"
+
+            if nnum == 100:
+                ctext = self.hundreds[cnum]
+                ntext = ""
+            else:
+                ntext = " " + ntext
+
+            return (ctext + ntext, cnum * nnum)
+        else:
+            # Additive case (e.g., "vinte e dois")
+            return ("%s e %s" % (ctext, ntext), cnum + nnum)
+
+    def to_cardinal(self, value):
+        # Handle negative numbers
+        if value < 0:
+            return "%s%s" % (self.negword, self.to_cardinal(-value))
+
+        # Handle billions and trillions specially for Brazilian Portuguese short scale
+        # Brazil uses: bilhão = 10^9, trilhão = 10^12 (short scale)
+        # Parent PT uses: bilião = 10^12, trilião = 10^18 (European long scale)
+
+        if value >= 1000000000:
+            # Handle trillions (10^12)
+            if value >= 1000000000000:
+                trillions, remainder = divmod(value, 1000000000000)
+                if trillions == 1:
+                    result = "um trilhão"
+                else:
+                    # Recursively convert the number of trillions
+                    result = "%s trilhões" % self.to_cardinal(trillions)
+
+                if remainder:
+                    if remainder >= 1000000000:
+                        # Has billions
+                        billions, rest = divmod(remainder, 1000000000)
+                        if billions == 1:
+                            result += ", um bilhão"
+                        else:
+                            result += ", %s bilhões" % self.to_cardinal(billions)
+                        if rest:
+                            # Call parent for the rest (millions and below)
+                            rest_str = super(Num2Word_PT_BR, self).to_cardinal(rest)
+                            # Fix "milião" to "milhão" if it appears
+                            rest_str = rest_str.replace("milião", "milhão").replace("miliões", "milhões")
+                            result += " e %s" % rest_str
+                    else:
+                        # No billions, just add remainder
+                        remainder_str = super(Num2Word_PT_BR, self).to_cardinal(remainder)
+                        # Fix "milião" to "milhão" if it appears
+                        remainder_str = remainder_str.replace("milião", "milhão").replace("miliões", "milhões")
+                        result += " e %s" % remainder_str
+                return result
+
+            # Handle billions (10^9)
+            else:
+                billions, remainder = divmod(value, 1000000000)
+                if billions == 1:
+                    result = "um bilhão"
+                else:
+                    # Recursively convert the number of billions
+                    result = "%s bilhões" % self.to_cardinal(billions)
+
+                if remainder:
+                    remainder_str = super(Num2Word_PT_BR, self).to_cardinal(remainder)
+                    # Fix "milião" to "milhão" if it appears
+                    remainder_str = remainder_str.replace("milião", "milhão").replace("miliões", "milhões")
+                    # Use comma if remainder starts with hundreds (i.e., >= 100000)
+                    if remainder >= 100000:
+                        result += ", %s" % remainder_str
+                    else:
+                        result += " e %s" % remainder_str
+                return result
+        else:
+            # For values below 1 billion but above million, handle specially
+            if value >= 1000000:
+                millions, remainder = divmod(value, 1000000)
+                if millions == 1:
+                    result = "um milhão"
+                else:
+                    result = "%s milhões" % super(Num2Word_PT_BR, self).to_cardinal(millions)
+
+                if remainder:
+                    # Use our own to_cardinal for remainder to ensure proper formatting
+                    remainder_str = self.to_cardinal(remainder)
+                    # Use comma if remainder starts with hundreds (i.e., >= 100)
+                    if remainder >= 100:
+                        result += ", %s" % remainder_str
+                    else:
+                        result += " e %s" % remainder_str
+                return result
+            else:
+                # For values below 1 million, use parent implementation
+                result = super(Num2Word_PT_BR, self).to_cardinal(value)
+                # Fix "milião" to "milhão" throughout (shouldn't happen but just in case)
+                result = result.replace("milião", "milhão").replace("miliões", "milhões")
+
+        # Transforms "mil e cento e catorze" into "mil, cento e catorze"
+        for ext in (
+                'mil', 'milhão', 'milhões', 'bilhão', 'bilhões',
+                'trilhão', 'trilhões', 'quatrilhão', 'quatrilhões'):
+            # Check if pattern is "thousand-word hundreds-word e something"
+            if re.search('{} \\w*ento'.format(ext), result):
+                result = re.sub(
+                    '({}) (\\w*entos?)'.format(ext), r'\1, \2', result, count=1
+                )
+
+        return result
+
+    def to_currency(self, val, currency='BRL', cents=True, separator=' e', adjective=False):
+        from decimal import Decimal
+
+        # Check if this is a whole number (integer or decimal with .00)
+        if isinstance(val, Decimal):
+            if val % 1 == 0:
+                # Convert to integer if it's a whole number
+                val = int(val)
+        elif isinstance(val, float):
+            if val == int(val):
+                val = int(val)
+
+        # Use parent class implementation with our currency forms
+        result = super(Num2Word_PT_BR, self).to_currency(
+            val, currency=currency, cents=cents, separator=separator, adjective=adjective
+        )
+
+        # For Brazilian Portuguese, we need to add "de" after millions/billions/trillions
+        # when they are round numbers (no thousands/hundreds after)
+        if isinstance(val, int):
+            try:
+                cr1, cr2 = self.CURRENCY_FORMS[currency]
+                currency_str = cr1[1] if abs(val) != 1 and len(cr1) > 1 else cr1[0]
+                # Add "de" for Brazilian terms (milhão/milhões, bilhão/bilhões, trilhão/trilhões)
+                for ext in ('milhão', 'milhões', 'bilhão', 'bilhões', 'trilhão', 'trilhões'):
+                    if re.match('.*{} (?={})'.format(ext, currency_str), result):
+                        result = result.replace(
+                            '{}'.format(ext), '{} de'.format(ext), 1
+                        )
+            except KeyError:
+                pass  # Currency not in our forms, use parent's result as-is
+
+        return result