num2words2 0.1.0.dev1__py3-none-any.whl

num2words2/lang_LT.py

@@ -0,0 +1,283 @@
+# -*- 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
+from .utils import get_digits, splitbyx
+
+ZERO = ('nulis',)
+
+ONES_FEMININE = {
+    1: ('viena',),
+    2: ('dvi',),
+    3: ('trys',),
+    4: ('keturios',),
+    5: ('penkios',),
+    6: ('šešios',),
+    7: ('septynios',),
+    8: ('aštuonios',),
+    9: ('devynios',),
+}
+
+ONES = {
+    1: ('vienas',),
+    2: ('du',),
+    3: ('trys',),
+    4: ('keturi',),
+    5: ('penki',),
+    6: ('šeši',),
+    7: ('septyni',),
+    8: ('aštuoni',),
+    9: ('devyni',),
+}
+
+TENS = {
+    0: ('dešimt',),
+    1: ('vienuolika',),
+    2: ('dvylika',),
+    3: ('trylika',),
+    4: ('keturiolika',),
+    5: ('penkiolika',),
+    6: ('šešiolika',),
+    7: ('septyniolika',),
+    8: ('aštuoniolika',),
+    9: ('devyniolika',),
+}
+
+TWENTIES = {
+    2: ('dvidešimt',),
+    3: ('trisdešimt',),
+    4: ('keturiasdešimt',),
+    5: ('penkiasdešimt',),
+    6: ('šešiasdešimt',),
+    7: ('septyniasdešimt',),
+    8: ('aštuoniasdešimt',),
+    9: ('devyniasdešimt',),
+}
+
+HUNDRED = ('šimtas', 'šimtai')
+
+THOUSANDS = {
+    1: ('tūkstantis', 'tūkstančiai', 'tūkstančių'),
+    2: ('milijonas', 'milijonai', 'milijonų'),
+    3: ('milijardas', 'milijardai', 'milijardų'),
+    4: ('trilijonas', 'trilijonai', 'trilijonų'),
+    5: ('kvadrilijonas', 'kvadrilijonai', 'kvadrilijonų'),
+    6: ('kvintilijonas', 'kvintilijonai', 'kvintilijonų'),
+    7: ('sikstilijonas', 'sikstilijonai', 'sikstilijonų'),
+    8: ('septilijonas', 'septilijonai', 'septilijonų'),
+    9: ('oktilijonas', 'oktilijonai', 'oktilijonų'),
+    10: ('naintilijonas', 'naintilijonai', 'naintilijonų'),
+}
+
+GENERIC_CENTS = ('centas', 'centai', 'centų')
+
+
+class Num2Word_LT(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'LTL': (('litas', 'litai', 'litų'), GENERIC_CENTS),
+        'EUR': (('euras', 'eurai', 'eurų'), GENERIC_CENTS),
+        'USD': (('doleris', 'doleriai', 'dolerių'), GENERIC_CENTS),
+        'GBP': (
+            ('svaras sterlingų', 'svarai sterlingų', 'svarų sterlingų'),
+            ('pensas', 'pensai', 'pensų')
+        ),
+        'PLN': (
+            ('zlotas', 'zlotai', 'zlotų'),
+            ('grašis', 'grašiai', 'grašių')),
+        'RUB': (
+            ('rublis', 'rubliai', 'rublių'),
+            ('kapeika', 'kapeikos', 'kapeikų')
+        ),
+    }
+
+    def setup(self):
+        self.negword = "minus"
+        self.pointword = "kablelis"
+
+    def pluralize(self, n, forms):
+        n1, n2, n3 = get_digits(n)
+        if n2 == 1 or n1 == 0 or n == 0:
+            return forms[2]
+        elif n1 == 1:
+            return forms[0]
+        else:
+            return forms[1]
+
+    def to_cardinal(self, number):
+        n = str(number).replace(',', '.')
+        base_str, n = self.parse_minus(n)
+        if '.' in n:
+            left, right = n.split('.')
+            leading_zero_count = len(right) - len(right.lstrip('0'))
+            decimal_part = ((ZERO[0] + ' ') * leading_zero_count +
+                            self._int2word(int(right)))
+            return '%s%s %s %s' % (
+                base_str,
+                self._int2word(int(left)),
+                self.pointword,
+                decimal_part
+            )
+        else:
+            return "%s%s" % (base_str, self._int2word(int(n)))
+
+    def to_ordinal(self, number):
+        """Convert to Lithuanian ordinal numbers."""
+        try:
+            num = int(number)
+        except (ValueError, TypeError):
+            return str(number)
+
+        # Lithuanian ordinals
+        ordinals = {
+            1: 'pirmas',
+            2: 'antras',
+            3: 'trečias',
+            4: 'ketvirtas',
+            5: 'penktas',
+            6: 'šeštas',
+            7: 'septintas',
+            8: 'aštuntas',
+            9: 'devintas',
+            10: 'dešimtas',
+            11: 'vienuoliktas',
+            12: 'dvyliktas',
+            13: 'tryliktas',
+            14: 'keturioliktas',
+            15: 'penkioliktas',
+            16: 'šešioliktas',
+            17: 'septynioliktas',
+            18: 'aštuonioliktas',
+            19: 'devynioliktas',
+            20: 'dvidešimtas',
+            30: 'trisdešimtas',
+            40: 'keturiasdešimtas',
+            50: 'penkiasdešimtas',
+            60: 'šešiasdešimtas',
+            70: 'septyniasdešimtas',
+            80: 'aštuoniasdešimtas',
+            90: 'devyniasdešimtas',
+            100: 'šimtasis',
+            1000: 'tūkstantas',
+        }
+
+        if num in ordinals:
+            return ordinals[num]
+
+        # For other numbers, add 'as' suffix to the cardinal
+        # This is a simplified implementation
+        cardinal = self.to_cardinal(num)
+        return cardinal + 'as'
+
+    def to_currency(self, val, currency='EUR', cents=True, separator='',
+                    adjective=False):
+        if isinstance(val, int):
+            left = abs(val)
+            right = 0
+            is_negative = val < 0
+            is_float = False
+        else:
+            from decimal import Decimal
+
+            from .currency import parse_currency_parts
+
+            # Check if value has fractional cents
+            decimal_val = Decimal(str(val))
+            has_fractional_cents = (decimal_val * 100) % 1 != 0
+
+            left, right, is_negative = parse_currency_parts(val, is_int_with_cents=False,
+                                                            keep_precision=has_fractional_cents)
+            is_float = True
+
+        try:
+            cr1, cr2 = self.CURRENCY_FORMS[currency]
+        except KeyError:
+            raise NotImplementedError(
+                'Currency code "%s" not implemented for "%s"' %
+                (currency, self.__class__.__name__))
+
+        minus_str = "%s " % self.negword.strip() if is_negative else ""
+        money_str = self.to_cardinal(left)
+
+        # Show cents if right > 0 OR if input was a float (even if 0 cents)
+        if right > 0 or is_float:
+            if right == 0:
+                cents_str = self.to_cardinal(0) if cents else '0'
+            else:
+                # Handle fractional cents
+                from decimal import Decimal
+                if isinstance(right, Decimal):
+                    # Convert fractional cents (e.g., 65.3 cents)
+                    cents_str = self.to_cardinal_float(float(right)) if cents else str(float(right))
+                else:
+                    cents_str = self.to_cardinal(right) if cents else str(right)
+            # Always add comma before cents if no separator specified
+            sep = separator if separator else ', '
+            return u'%s%s %s%s%s %s' % (
+                minus_str,
+                money_str,
+                self.pluralize(left, cr1),
+                sep,
+                cents_str,
+                self.pluralize(right, cr2)
+            )
+        else:
+            return u'%s%s %s' % (
+                minus_str,
+                money_str,
+                self.pluralize(left, cr1)
+            )
+
+    def _int2word(self, n, feminine=False):
+        if n == 0:
+            return ZERO[0]
+
+        words = []
+        chunks = list(splitbyx(str(n), 3))
+        i = len(chunks)
+
+        for x in chunks:
+            i -= 1
+
+            if x == 0:
+                continue
+
+            n1, n2, n3 = get_digits(x)
+
+            if n3 > 0:
+                words.append(ONES[n3][0])
+                if n3 > 1:
+                    words.append(HUNDRED[1])
+                else:
+                    words.append(HUNDRED[0])
+
+            if n2 > 1:
+                words.append(TWENTIES[n2][0])
+
+            if n2 == 1:
+                words.append(TENS[n1][0])
+            elif n1 > 0:
+                if (i == 1 or feminine and i == 0) and n < 1000:
+                    words.append(ONES_FEMININE[n1][0])
+                else:
+                    words.append(ONES[n1][0])
+
+            if i > 0:
+                words.append(self.pluralize(x, THOUSANDS[i]))
+
+        return ' '.join(words)

num2words2/lang_LV.py

@@ -0,0 +1,266 @@
+# -*- 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
+from .utils import get_digits, splitbyx
+
+ZERO = ('nulle',)
+
+ONES = {
+    1: ('viens',),
+    2: ('divi',),
+    3: ('trīs',),
+    4: ('četri',),
+    5: ('pieci',),
+    6: ('seši',),
+    7: ('septiņi',),
+    8: ('astoņi',),
+    9: ('deviņi',),
+}
+
+TENS = {
+    0: ('desmit',),
+    1: ('vienpadsmit',),
+    2: ('divpadsmit',),
+    3: ('trīspadsmit',),
+    4: ('četrpadsmit',),
+    5: ('piecpadsmit',),
+    6: ('sešpadsmit',),
+    7: ('septiņpadsmit',),
+    8: ('astoņpadsmit',),
+    9: ('deviņpadsmit',),
+}
+
+TWENTIES = {
+    2: ('divdesmit',),
+    3: ('trīsdesmit',),
+    4: ('četrdesmit',),
+    5: ('piecdesmit',),
+    6: ('sešdesmit',),
+    7: ('septiņdesmit',),
+    8: ('astoņdesmit',),
+    9: ('deviņdesmit',),
+}
+
+HUNDRED = ('simts', 'simti', 'simtu')
+
+THOUSANDS = {
+    1: ('tūkstotis', 'tūkstoši', 'tūkstošu'),
+    2: ('miljons', 'miljoni', 'miljonu'),
+    3: ('miljards', 'miljardi', 'miljardu'),
+    4: ('triljons', 'triljoni', 'triljonu'),
+    5: ('kvadriljons', 'kvadriljoni', 'kvadriljonu'),
+    6: ('kvintiljons', 'kvintiljoni', 'kvintiljonu'),
+    7: ('sikstiljons', 'sikstiljoni', 'sikstiljonu'),
+    8: ('septiljons', 'septiljoni', 'septiljonu'),
+    9: ('oktiljons', 'oktiljoni', 'oktiljonu'),
+    10: ('nontiljons', 'nontiljoni', 'nontiljonu'),
+}
+
+GENERIC_DOLLARS = ('dolārs', 'dolāri', 'dolāru')
+GENERIC_CENTS = ('cents', 'centi', 'centu')
+
+GENERIC_KRONA = ('krona', 'kronas', 'kronu')
+GENERIC_ERA = ('ēre', 'ēras', 'ēru')
+
+
+class Num2Word_LV(Num2Word_Base):
+    """
+    Sadly we have a legal form (used in legal and finance documents):
+    http://www.eiro.lv/files/upload/files/Eiro_rakstiba-1.pdf
+    https://likumi.lv/doc.php?id=254741
+    http://eur-lex.europa.eu/legal-content/LV/TXT/HTML/?uri=CELEX:31998R0974&from=LV
+
+    Source: http://publications.europa.eu/code/lv/lv-5000500.htm
+    """
+    CURRENCY_FORMS = {
+        'AUD': (GENERIC_DOLLARS, GENERIC_CENTS),
+        'CAD': (GENERIC_DOLLARS, GENERIC_CENTS),
+        # repalced by EUR
+        'EEK': (GENERIC_KRONA, GENERIC_CENTS),
+        'EUR': (('eiro', 'eiro', 'eiro'), GENERIC_CENTS),
+        'EUR_LEGAL': (('euro', 'euro', 'euro'), GENERIC_CENTS),
+        'GBP': (
+            ('sterliņu mārciņa', 'sterliņu mārciņas', 'sterliņu mārciņu'),
+            ('penss', 'pensi', 'pensu')),
+        # replaced by EUR
+        'LTL': (('lits', 'liti', 'litu'), GENERIC_CENTS),
+        # replaced by EUR
+        'LVL': (('lats', 'lati', 'latu'),
+                ('santīms', 'santīmi', 'santīmu')),
+        'USD': (GENERIC_DOLLARS, GENERIC_CENTS),
+        'RUB': (('rublis', 'rubļi', 'rubļu'),
+                ('kapeika', 'kapeikas', 'kapeiku')),
+        'SEK': (GENERIC_KRONA, GENERIC_ERA),
+        'NOK': (GENERIC_KRONA, GENERIC_ERA),
+        'PLN': (('zlots', 'zloti', 'zlotu'),
+                ('grasis', 'graši', 'grašu')),
+    }
+
+    CURRENCY_ADJECTIVES = {
+        'AUD': 'Austrālijas',
+        'CAD': 'Kanādas',
+        'EEK': 'Igaunijas',
+        'USD': 'ASV',
+        'RUB': 'Kreivijas',
+        'SEK': 'Zviedrijas',
+        'NOK': 'Norvēģijas',
+    }
+
+    def setup(self):
+        self.negword = "mīnus"
+        self.pointword = "komats"
+
+    def to_cardinal(self, number):
+        n = str(number).replace(',', '.')
+        base_str, n = self.parse_minus(n)
+        if '.' in n:
+            left, right = n.split('.')
+            leading_zero_count = len(right) - len(right.lstrip('0'))
+            decimal_part = ((ZERO[0] + ' ') * leading_zero_count +
+                            self._int2word(int(right)))
+            return '%s%s %s %s' % (
+                base_str,
+                self._int2word(int(left)),
+                self.pointword,
+                decimal_part
+            )
+        else:
+            return "%s%s" % (base_str, self._int2word(int(n)))
+
+    def pluralize(self, n, forms):
+        form = 0 if (n % 10 == 1 and n % 100 != 11) else 1 if n != 0 else 2
+        return forms[form]
+
+    def to_currency(self, val, currency='EUR', 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_LV, 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_LV, self).to_currency(
+            val, currency=currency, cents=cents, separator=separator,
+            adjective=adjective)
+
+    def to_ordinal(self, number):
+        """Convert to Latvian ordinal numbers."""
+        try:
+            num = int(number)
+        except (ValueError, TypeError):
+            return str(number)
+
+        # Latvian ordinals
+        ordinals = {
+            1: 'pirmais',
+            2: 'otrais',
+            3: 'trešais',
+            4: 'ceturtais',
+            5: 'piektais',
+            6: 'sestais',
+            7: 'septītais',
+            8: 'astotais',
+            9: 'devītais',
+            10: 'desmitais',
+            11: 'vienpadsmitais',
+            12: 'divpadsmitais',
+            13: 'trīspadsmitais',
+            14: 'četrpadsmitais',
+            15: 'piecpadsmitais',
+            16: 'sešpadsmitais',
+            17: 'septiņpadsmitais',
+            18: 'astoņpadsmitais',
+            19: 'deviņpadsmitais',
+            20: 'divdesmitais',
+            30: 'trīsdesmitais',
+            40: 'četrdesmitais',
+            50: 'piecdesmitais',
+            60: 'sešdesmitais',
+            70: 'septiņdesmitais',
+            80: 'astoņdesmitais',
+            90: 'deviņdesmitais',
+            100: 'simtais',
+            1000: 'tūkstošais',
+        }
+
+        if num in ordinals:
+            return ordinals[num]
+
+        # For other numbers, add 'ais' suffix to the cardinal
+        # This is a simplified implementation
+        cardinal = self.to_cardinal(num)
+        # Remove trailing 's' if present and add 'ais'
+        if cardinal.endswith('s'):
+            return cardinal[:-1] + 'ais'
+        return cardinal + 'ais'
+
+    def _int2word(self, n):
+        if n == 0:
+            return ZERO[0]
+
+        words = []
+        chunks = list(splitbyx(str(n), 3))
+        i = len(chunks)
+        for x in chunks:
+            i -= 1
+
+            if x == 0:
+                continue
+
+            n1, n2, n3 = get_digits(x)
+
+            if n3 > 0:
+                if n3 == 1 and n2 == 0 and n1 > 0:
+                    words.append(HUNDRED[2])
+                elif n3 > 1:
+                    words.append(ONES[n3][0])
+                    words.append(HUNDRED[1])
+                else:
+                    words.append(HUNDRED[0])
+
+            if n2 > 1:
+                words.append(TWENTIES[n2][0])
+
+            if n2 == 1:
+                words.append(TENS[n1][0])
+            elif n1 > 0 and not (i > 0 and x == 1):
+                words.append(ONES[n1][0])
+
+            if i > 0:
+                words.append(self.pluralize(x, THOUSANDS[i]))
+
+        return ' '.join(words)

num2words2/lang_MG.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 unicode_literals
+
+from .base import Num2Word_Base
+
+
+# Malagasy language support
+class Num2Word_MG(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'MGA': (('ariary', 'ariary'), ('iraimbilanja', 'iraimbilanja')),
+        'USD': (('dollar', 'dollars'), ('cent', 'cents')),
+        'EUR': (('euro', 'euros'), ('cent', 'cents'))
+    }
+
+    def setup(self):
+        self.negword = "minus "
+        self.pointword = "point"
+        self.ones = ['', 'iray', 'roa', 'telo', 'efatra', 'dimy', 'enina', 'fito', 'valo', 'sivy']
+        self.tens = ['', 'folo', 'roapolo', 'telopolo', 'efapolo', 'dimampolo', 'enimpolo', 'fitopolo', 'valopolo', 'sivifolo']
+        self.hundred = "zato"
+        self.thousand = "arivo"
+        self.million = "tapitrisa"
+
+    def to_cardinal(self, number):
+        """Convert a number to its word representation in Malagasy."""
+        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 Malagasy."""
+        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 Malagasy.
+
+        Malagasy ordinals use 'faha-' prefix for most numbers.
+        Special form exists for 1st (voalohany).
+        """
+        if number == 1:
+            return "voalohany"  # first
+        else:
+            # For other numbers, use "faha-" prefix + cardinal
+            cardinal = self.to_cardinal(number)
+            return "faha-" + 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 Malagasy."""
+        return self.to_cardinal(val)
+
+    def to_currency(self, val, currency='MGA', cents=True, separator=' ', adjective=False):
+        """Convert to currency in Malagasy."""
+        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()