num2words2 0.1.0.dev1__py3-none-any.whl

num2words2/lang_BO.py

@@ -0,0 +1,122 @@
+# -*- 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
+
+
+# Tibetan language support
+class Num2Word_BO(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'CNY': (('སྒོར་', 'སྒོར་'), ('ཕན་', 'ཕན་')),
+        'USD': (('ཌོ་ལར་', 'ཌོ་ལར་'), ('སེན་', 'སེན་')),
+        'EUR': (('ཡུ་རོ་', 'ཡུ་རོ་'), ('སེན་', 'སེན་')),
+    }
+
+    def setup(self):
+        self.negword = "མེད་ཆ་ "
+        self.pointword = "ཚེག་"
+
+    def to_cardinal(self, number):
+        """Convert a number to its word representation in Tibetan."""
+        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
+        else:
+            return ret + self._int_to_word(int(n))
+
+    def _int_to_word(self, number):
+        """Convert an integer to its word representation in Tibetan."""
+        if number == 0:
+            return "ཀླད་ཀོར་"
+
+        ones = ["", "གཅིག་", "གཉིས་", "གསུམ་", "བཞི་", "ལྔ་", "དྲུག་", "བདུན་", "བརྒྱད་", "དགུ་"]
+        tens = ["", "བཅུ་", "ཉི་ཤུ་", "སུམ་ཅུ་", "བཞི་བཅུ་", "ལྔ་བཅུ་", "དྲུག་ཅུ་", "བདུན་ཅུ་", "བརྒྱད་ཅུ་", "དགུ་བཅུ་"]
+
+        if number < 10:
+            return ones[number]
+        elif number < 100:
+            return tens[number // 10] + (ones[number % 10] if number % 10 else "")
+        elif number < 1000:
+            return ones[number // 100] + "བརྒྱ་" + (self._int_to_word(number % 100) if number % 100 else "")
+        elif number < 10000:
+            return self._int_to_word(number // 1000) + "སྟོང་" + (self._int_to_word(number % 1000) if number % 1000 else "")
+        elif number < 100000:
+            return self._int_to_word(number // 10000) + "ཁྲི་" + (self._int_to_word(number % 10000) if number % 10000 else "")
+        elif number < 1000000:
+            return self._int_to_word(number // 100000) + "འབུམ་" + (self._int_to_word(number % 100000) if number % 100000 else "")
+        elif number < 10000000:
+            return self._int_to_word(number // 1000000) + "ས་ཡ་" + (self._int_to_word(number % 1000000) if number % 1000000 else "")
+        elif number < 100000000:
+            return self._int_to_word(number // 10000000) + "བྱེ་བ་" + (self._int_to_word(number % 10000000) if number % 10000000 else "")
+        else:
+            return self._int_to_word(number // 100000000) + "དུང་ཕྱུར་" + (self._int_to_word(number % 100000000) if number % 100000000 else "")
+
+    def to_ordinal(self, number):
+        """Convert to ordinal."""
+        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."""
+        return "སྤྱི་ལོ་" + self.to_cardinal(val)
+
+    def to_currency(self, val, currency='CNY', cents=True, separator=' དང་ ', adjective=False):
+        """Convert to currency."""
+        try:
+            left, right, is_negative = self.parse_currency(val)
+        except AttributeError:
+            is_negative = False
+            if val < 0:
+                is_negative = True
+                val = abs(val)
+
+            left, right = self._split_currency(val)
+
+        cr1, cr2 = self.CURRENCY_FORMS.get(currency, self.CURRENCY_FORMS['CNY'])
+
+        left_str = self._int_to_word(int(left))
+        cents_str = self._int_to_word(int(right)) if cents and right else ""
+
+        result = left_str + " " + cr1[0]
+
+        if cents_str:
+            result += separator + cents_str + " " + cr2[0]
+
+        return self.negword + result if is_negative else result
+
+    def _split_currency(self, n):
+        """Split currency into whole and fraction parts."""
+        parts = str(n).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
+        return left, right

num2words2/lang_BR.py

@@ -0,0 +1,135 @@
+# -*- 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
+
+
+# Breton language support
+class Num2Word_BR(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'EUR': (('euro', 'euroioù'), ('sentim', 'sentimoù')),
+        'USD': (('dollar', 'dollars'), ('cent', 'cents'))
+    }
+
+    def setup(self):
+        self.negword = "minus "
+        self.pointword = "point"
+        self.ones = ['', 'unan', 'daou', 'tri', 'pevar', 'pemp', "c'hwec'h", 'seizh', 'eizh', 'nav']
+        self.tens = ['', 'dek', 'ugent', 'tregont', 'daou-ugent', 'hanter-kant', 'tri-ugent', 'dek ha tri-ugent', 'pevar-ugent', 'dek ha pevar-ugent']
+        self.hundred = "kant"
+        self.thousand = "mil"
+        self.million = "milion"
+
+    def to_cardinal(self, number):
+        """Convert a number to its word representation in Breton."""
+        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 Breton."""
+        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 Breton."""
+        cardinal = self.to_cardinal(number)
+        # Language-specific ordinal suffix
+        return cardinal + "-vet"
+
+    def to_ordinal_num(self, number):
+        """Convert to abbreviated ordinal."""
+        return str(number) + "."
+
+    def to_year(self, val, longval=True):
+        """Convert to year in Breton."""
+        return self.to_cardinal(val)
+
+    def to_currency(self, val, currency='EUR', cents=True, separator=' ', adjective=False):
+        """Convert to currency in Breton."""
+        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_BS.py

@@ -0,0 +1,189 @@
+# -*- 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
+
+
+# Bosnian language support (Latin script)
+class Num2Word_BS(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'BAM': (('marka', 'marke', 'maraka'), ('feninga', 'feninga', 'feninga')),
+        'EUR': (('euro', 'eura', 'eura'), ('cent', 'centa', 'centi')),
+        'USD': (('dolar', 'dolara', 'dolara'), ('cent', 'centa', 'centi')),
+    }
+
+    def setup(self):
+        self.negword = "minus "
+        self.pointword = "zarez"
+
+        # Bosnian numbers in Latin script
+        self.ones = [
+            '', 'jedan', 'dva', 'tri', 'četiri',
+            'pet', 'šest', 'sedam', 'osam', 'devet'
+        ]
+
+        self.tens = [
+            '', 'deset', 'dvadeset', 'trideset', 'četrdeset',
+            'pedeset', 'šezdeset', 'sedamdeset', 'osamdeset', 'devedeset'
+        ]
+
+        self.scale = {
+            100: ('sto', 'stotine', 'stotina'),
+            1000: ('hiljada', 'hiljade', 'hiljada'),
+            1000000: ('milion', 'miliona', 'miliona'),
+            1000000000: ('milijarda', 'milijarde', 'milijardi'),
+            1000000000000: ('bilion', 'biliona', 'biliona'),
+        }
+
+    def to_cardinal(self, number):
+        """Convert a number to its word representation in Bosnian."""
+        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 Bosnian."""
+        if number == 0:
+            return "nula"
+
+        if number < 0:
+            return self.negword + self._int_to_word(abs(number))
+        elif number < 10:
+            return self.ones[number]
+        elif number == 10:
+            return self.tens[1]
+        elif number < 20:
+            return self.ones[number - 10] + "aest"
+        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
+            if hundreds_val == 1:
+                result = "sto"
+            elif hundreds_val == 2:
+                result = "dvjesto"
+            elif hundreds_val == 3 or hundreds_val == 4:
+                result = self.ones[hundreds_val] + "sto"
+            else:
+                result = self.ones[hundreds_val] + "sto"
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+        elif number < 1000000:
+            thousands_val = number // 1000
+            remainder = number % 1000
+            if thousands_val == 1:
+                result = "hiljada"
+            elif thousands_val < 5:
+                result = self._int_to_word(thousands_val) + " hiljade"
+            else:
+                result = self._int_to_word(thousands_val) + " hiljada"
+            if remainder:
+                result += " " + self._int_to_word(remainder)
+            return result
+        elif number < 1000000000:
+            millions_val = number // 1000000
+            remainder = number % 1000000
+            if millions_val == 1:
+                result = "milion"
+            else:
+                result = self._int_to_word(millions_val) + " miliona"
+            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 Bosnian."""
+        # Basic implementation with ordinal suffix
+        if number == 1:
+            return "prvi"
+        elif number == 2:
+            return "drugi"
+        elif number == 3:
+            return "treći"
+        else:
+            return self.to_cardinal(number) + "."
+
+    def to_ordinal_num(self, number):
+        """Convert to abbreviated ordinal."""
+        return str(number) + "."
+
+    def to_year(self, val, longval=True):
+        """Convert to year in Bosnian."""
+        return self.to_cardinal(val)
+
+    def to_currency(self, val, currency='BAM', cents=True, separator=' ', adjective=False):
+        """Convert to currency in Bosnian."""
+        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['BAM'])
+
+        left_str = self._int_to_word(left)
+        # Select correct form based on number
+        if left == 1:
+            currency_word = cr1[0]
+        elif left % 10 in [2, 3, 4] and left % 100 not in [12, 13, 14]:
+            currency_word = cr1[1]
+        else:
+            currency_word = cr1[2]
+        result = left_str + " " + currency_word
+
+        if cents and right:
+            cents_str = self._int_to_word(right)
+            # Select correct form for cents
+            if right == 1:
+                cents_word = cr2[0]
+            elif right % 10 in [2, 3, 4] and right % 100 not in [12, 13, 14]:
+                cents_word = cr2[1]
+            else:
+                cents_word = cr2[2]
+            result += separator + cents_str + " " + cents_word
+
+        if is_negative:
+            result = self.negword + result
+
+        return result.strip()