num2words2 0.1.0.dev1__py3-none-any.whl

num2words2/lang_MS.py

@@ -0,0 +1,293 @@
+# -*- 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 decimal import Decimal
+
+from .base import Num2Word_Base
+from .currency import parse_currency_parts
+
+
+class Num2Word_MS(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'MYR': (
+            ('ringgit', 'ringgit'), ('sen', 'sen')
+        ),
+        'SGD': (
+            ('dolar', 'dolar'), ('sen', 'sen')
+        ),
+        'USD': (
+            ('dolar', 'dolar'), ('sen', 'sen')
+        ),
+        'EUR': (
+            ('euro', 'euro'), ('sen', 'sen')
+        ),
+        'GBP': (
+            ('paun', 'paun'), ('peni', 'peni')
+        ),
+        'IDR': (
+            ('rupiah', 'rupiah'), ('sen', 'sen')
+        ),
+        'BND': (
+            ('dolar', 'dolar'), ('sen', 'sen')
+        ),
+    }
+
+    def __init__(self):
+        super(Num2Word_MS, self).__init__()
+
+        self.ones = [
+            '',
+            'satu',
+            'dua',
+            'tiga',
+            'empat',
+            'lima',
+            'enam',
+            'tujuh',
+            'lapan',
+            'sembilan'
+        ]
+
+        self.tens = [
+            '',
+            'sepuluh',
+            'dua puluh',
+            'tiga puluh',
+            'empat puluh',
+            'lima puluh',
+            'enam puluh',
+            'tujuh puluh',
+            'lapan puluh',
+            'sembilan puluh'
+        ]
+
+        self.teens = {
+            11: 'sebelas',
+            12: 'dua belas',
+            13: 'tiga belas',
+            14: 'empat belas',
+            15: 'lima belas',
+            16: 'enam belas',
+            17: 'tujuh belas',
+            18: 'lapan belas',
+            19: 'sembilan belas'
+        }
+
+        self.scale = {
+            100: 'ratus',
+            1000: 'ribu',
+            1000000: 'juta',
+            1000000000: 'bilion',
+            1000000000000: 'trilion'
+        }
+
+        self.ordinals = [
+            '',
+            'pertama',
+            'kedua',
+            'ketiga',
+            'keempat',
+            'kelima',
+            'keenam',
+            'ketujuh',
+            'kelapan',
+            'kesembilan',
+            'kesepuluh'
+        ]
+
+        self.negword = "negatif "
+        self.pointword = "titik"
+
+    def _setup(self):
+        super(Num2Word_MS, self)._setup()
+
+    def _int_to_word(self, n):
+        """
+        Converts a number to words in Malay.
+        """
+        if n == 0:
+            return 'kosong'
+
+        parts = []
+
+        # Handle trillions
+        if n >= 1000000000000:
+            trillions = n // 1000000000000
+            if trillions == 1:
+                parts.append('satu trilion')
+            else:
+                parts.append(self._int_to_word(trillions) + ' trilion')
+            n %= 1000000000000
+
+        # Handle billions
+        if n >= 1000000000:
+            billions = n // 1000000000
+            if billions == 1:
+                parts.append('satu bilion')
+            else:
+                parts.append(self._int_to_word(billions) + ' bilion')
+            n %= 1000000000
+
+        # Handle millions
+        if n >= 1000000:
+            millions = n // 1000000
+            if millions == 1:
+                parts.append('satu juta')
+            else:
+                parts.append(self._int_to_word(millions) + ' juta')
+            n %= 1000000
+
+        # Handle thousands
+        if n >= 1000:
+            thousands = n // 1000
+            if thousands == 1:
+                parts.append('seribu')
+            else:
+                parts.append(self._int_to_word(thousands) + ' ribu')
+            n %= 1000
+
+        # Handle hundreds
+        if n >= 100:
+            hundreds = n // 100
+            if hundreds == 1:
+                parts.append('seratus')
+            else:
+                parts.append(self.ones[hundreds] + ' ratus')
+            n %= 100
+
+        # Handle special case for teens (11-19)
+        if 10 < n < 20:
+            parts.append(self.teens[n])
+        else:
+            # Handle tens
+            if n >= 10:
+                if n == 10:
+                    parts.append('sepuluh')
+                else:
+                    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 'kosong'
+
+        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 'kosong'
+
+        # Special cases for first ten ordinals
+        if n <= 10:
+            return self.ordinals[n]
+
+        # For other numbers, use "ke-" prefix
+        return 'ke-' + self._int_to_cardinal(n)
+
+    def to_cardinal(self, n):
+        try:
+            if isinstance(n, str):
+                n = int(n)
+
+            return self._int_to_cardinal(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)
+
+            # In Malay, ordinal numbers use "ke-" prefix
+            return 'ke-' + str(n)
+        except BaseException:
+            return 'ke-' + str(n)
+
+    def to_currency(self, n, currency='MYR'):
+        try:
+            # Check if value has fractional cents
+            decimal_val = Decimal(str(n))
+            has_fractional_cents = (decimal_val * 100) % 1 != 0
+
+            left, right, is_negative = parse_currency_parts(n)
+
+            if currency not in self.CURRENCY_FORMS:
+                raise NotImplementedError(
+                    'Currency code "%s" not implemented for "%s"' %
+                    (currency, self.__class__.__name__))
+
+            cr_major, cr_minor = self.CURRENCY_FORMS[currency]
+
+            result = []
+
+            if is_negative:
+                result.append(self.negword.strip())
+
+            left_words = self._int_to_cardinal(left)
+            result.append(left_words)
+            result.append(cr_major[0])
+
+            # Handle cents if non-zero
+            if right > 0:
+                if has_fractional_cents:
+                    # For fractional cents, use float representation
+                    fractional_cents = right / 100.0
+                    right_words = self.to_cardinal(fractional_cents)
+                else:
+                    right_words = self._int_to_cardinal(right)
+                result.append(right_words)
+                result.append(cr_minor[0])
+
+            return ' '.join(result)
+        except NotImplementedError:
+            raise
+        except BaseException:
+            return str(n) + ' ' + 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 -> "seribu sembilan ratus sembilan puluh
+            # sembilan"
+            return self._int_to_cardinal(n)
+        else:
+            # Years like 2023 -> "dua ribu dua puluh tiga"
+            return self._int_to_cardinal(n)

num2words2/lang_MT.py

@@ -0,0 +1,159 @@
+# -*- 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
+
+
+# Maltese language support
+class Num2Word_MT(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'EUR': (('ewro', 'ewro'), ('ċenteżmu', 'ċenteżmi')),
+        'USD': (('dollar', 'dollars'), ('cent', 'cents'))
+    }
+
+    def setup(self):
+        self.negword = "minus "
+        self.pointword = "point"
+        self.ones = ['', 'wieħed', 'tnejn', 'tlieta', 'erbgħa', 'ħamsa', 'sitta', 'sebgħa', 'tmienja', 'disgħa']
+        self.tens = ['', 'għaxra', 'għoxrin', 'tletin', 'erbgħin', 'ħamsin', 'sittin', 'sebgħin', 'tmenin', 'disgħin']
+        self.hundred = "mija"
+        self.thousand = "elf"
+        self.million = "miljun"
+
+    def to_cardinal(self, number):
+        """Convert a number to its word representation in Maltese."""
+        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 Maltese."""
+        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 Maltese.
+
+        Maltese ordinals have specific forms for each number.
+        """
+        if number == 1:
+            return "l-ewwel"  # first
+        elif number == 2:
+            return "it-tieni"  # second
+        elif number == 3:
+            return "it-tielet"  # third
+        elif number == 4:
+            return "ir-raba'"  # fourth
+        elif number == 5:
+            return "il-ħames"  # fifth
+        elif number == 6:
+            return "is-sitt"  # sixth
+        elif number == 7:
+            return "is-seba'"  # seventh
+        elif number == 8:
+            return "it-tmien"  # eighth
+        elif number == 9:
+            return "id-disa'"  # ninth
+        elif number == 10:
+            return "l-għaxar"  # tenth
+        else:
+            # For larger numbers, use "l-" prefix + cardinal
+            cardinal = self.to_cardinal(number)
+            return "l-" + 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 Maltese."""
+        return self.to_cardinal(val)
+
+    def to_currency(self, val, currency='EUR', cents=True, separator=' ', adjective=False):
+        """Convert to currency in Maltese."""
+        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_MY.py

@@ -0,0 +1,152 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from .base import Num2Word_Base
+
+
+class Num2Word_MY(Num2Word_Base):
+    """Myanmar/Burmese language number to words conversion."""
+
+    CURRENCY_FORMS = {
+        'MMK': (('ကျပ်', 'ကျပ်'), ('ပြား', 'ပြား')),
+        'USD': (('ဒေါ်လာ', 'ဒေါ်လာ'), ('ဆင့်', 'ဆင့်')),
+        'EUR': (('ယူရို', 'ယူရို'), ('ဆင့်', 'ဆင့်')),
+    }
+
+    def setup(self):
+        self.negword = "အနုတ် "
+        self.pointword = "ဒသမ"
+
+        # Myanmar numbers 0-9
+        self.ones = [
+            'သုည',      # 0
+            'တစ်',       # 1
+            'နှစ်',       # 2
+            'သုံး',       # 3
+            'လေး',       # 4
+            'ငါး',        # 5
+            'ခြောက်',     # 6
+            'ခုနစ်',      # 7
+            'ရှစ်',       # 8
+            'ကိုး',       # 9
+        ]
+
+    def to_cardinal(self, number):
+        """Convert a number to its word representation in Myanmar."""
+        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 Myanmar."""
+        if number == 0:
+            return self.ones[0]
+
+        if number < 0:
+            return self.negword + self._int_to_word(abs(number))
+        elif number < 10:
+            return self.ones[number]
+        elif number == 10:
+            return "တစ်ဆယ်"
+        elif number < 20:
+            return "တစ်ဆယ့်" + self.ones[number - 10]
+        elif number < 100:
+            tens_val = number // 10
+            ones_val = number % 10
+            tens_word = self.ones[tens_val] + "ဆယ်"
+            if ones_val == 0:
+                return tens_word
+            else:
+                return tens_word + "့" + self.ones[ones_val]
+        elif number < 1000:
+            hundreds_val = number // 100
+            remainder = number % 100
+            result = self.ones[hundreds_val] + "ရာ"  # hundred
+            if remainder:
+                result += "့" + self._int_to_word(remainder)
+            return result
+        elif number < 10000:
+            thousands_val = number // 1000
+            remainder = number % 1000
+            result = self.ones[thousands_val] + "ထောင်"  # thousand
+            if remainder:
+                result += "့" + self._int_to_word(remainder)
+            return result
+        elif number < 100000:
+            ten_thousands_val = number // 10000
+            remainder = number % 10000
+            result = self.ones[ten_thousands_val] + "သောင်း"  # ten thousand
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+        elif number < 1000000:
+            hundred_thousands_val = number // 100000
+            remainder = number % 100000
+            result = self.ones[hundred_thousands_val] + "သိန်း"  # hundred thousand
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+        elif number < 10000000:
+            millions_val = number // 1000000
+            remainder = number % 1000000
+            result = self.ones[millions_val] + "သန်း"  # million
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+        elif number < 1000000000:
+            ten_millions_val = number // 10000000
+            remainder = number % 10000000
+            result = self._int_to_word(ten_millions_val) + " ကုဋေ"  # ten 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 Myanmar."""
+        cardinal = self.to_cardinal(number)
+        return cardinal + "မြောက်"  # ordinal suffix
+
+    def to_ordinal_num(self, number):
+        """Convert to abbreviated ordinal."""
+        return str(number) + "မြောက်"
+
+    def to_year(self, val, longval=True):
+        """Convert to year in Myanmar."""
+        return self.to_cardinal(val) + " ခုနှစ်"
+
+    def to_currency(self, val, currency='MMK', cents=True, separator=' ', adjective=False):
+        """Convert to currency in Myanmar."""
+        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['MMK'])
+
+        left_str = self._int_to_word(left)
+        result = left_str + " " + cr1[0]
+
+        if cents and right:
+            cents_str = self._int_to_word(right)
+            result += separator + cents_str + " " + cr2[0]
+
+        return (self.negword if is_negative else "") + result