num2words2 0.1.0.dev1__py3-none-any.whl

num2words2/README.md

@@ -0,0 +1,69 @@
+# Add new language
+
+for each new language you must create a file `lang_NN.py` where `NN` is the
+ISO 639-1 or ISO 639-3 [language code](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes).
+
+This class must be a subclass of `Num2Word_EUR` and implement at least the following methods
+
+```
+to_cardinal(self, number)
+to_ordinal(self, number)
+```
+
+To integrate your language into the `num2words` module, add the name of  your file
+to the import list in [num2words/__init__.py](num2words/__init__.py) (top of the file),
+and `'nn': lang_NN.Num2Word_NN()` to the `CONVERTER_CLASSES` list in the same file.
+Do not forget to remplace `NN` by the appropriate ISO 639 language code.
+
+The following is a template for a new language class
+
+```
+from .lang_EUR import Num2Word_EUR
+
+class Num2Word_CY(Num2Word_EUR):
+    def setup(self):
+        Num2Word_EUR.setup(self)
+
+    def __init__(self):
+        pass
+
+    def to_ordinal(self, number):
+	# implement here your code. number is the integer to be transformed into an ordinal
+        # as a word (str)
+	# which is returned
+	return "NOT IMPLEMENTED"
+
+    def to_cardinal(self, number):
+	# implement here your code. number is the integer to be transformed into an cardinal
+        # as a word (str)
+	# which is returned
+	return "NOT IMPLEMENTED"
+```
+
+You can use as manu auxiliary methods as you need to make your code efficient and readable.
+If you need further options like Gender, Formal/Informal, add those parameters to the methods,
+e.g.
+
+```
+    def to_ordinal(self, number, gender="fem", informal=True)
+	# your code
+	pass
+```
+
+More inspiration can be found in existing `num2words/lang_NN.py` files
+
+## Code validation
+
+In order to get your contribution merged into the main project, your code must test the validation tests.
+For this install the packages needed to test
+
+```
+pip install -r requirements-test.txt
+```
+
+run `tox` and `coverage` to check that the code is well formated and all parts of the code are tested
+
+```
+tox
+python3 -m coverage report -m
+```

num2words2/__init__.py

@@ -0,0 +1,196 @@
+# -*- 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 . import (lang_AF, lang_AM, lang_AR, lang_AS, lang_AZ, lang_BA, lang_BE,
+               lang_BG, lang_BN, lang_BO, lang_BR, lang_BS, lang_CA, lang_CE,
+               lang_CS, lang_CY, lang_DA, lang_DE, lang_EL, lang_EN,
+               lang_EN_IN, lang_EN_NG, lang_EO, lang_ES, lang_ES_CO,
+               lang_ES_CR, lang_ES_GT, lang_ES_NI, lang_ES_VE, lang_ET,
+               lang_EU, lang_FA, lang_FI, lang_FO, lang_FR, lang_FR_BE,
+               lang_FR_CH, lang_FR_DZ, lang_GL, lang_GU, lang_HA, lang_HAW,
+               lang_HE, lang_HI, lang_HR, lang_HT, lang_HU, lang_HY, lang_ID,
+               lang_IS, lang_IT, lang_JA, lang_JW, lang_KA, lang_KK, lang_KM,
+               lang_KN, lang_KO, lang_KZ, lang_LA, lang_LB, lang_LN, lang_LO,
+               lang_LT, lang_LV, lang_MG, lang_MI, lang_MK, lang_ML, lang_MN,
+               lang_MR, lang_MS, lang_MT, lang_MY, lang_NE, lang_NL, lang_NN,
+               lang_NO, lang_OC, lang_PA, lang_PL, lang_PS, lang_PT,
+               lang_PT_BR, lang_RO, lang_RU, lang_SA, lang_SD, lang_SI,
+               lang_SK, lang_SL, lang_SN, lang_SO, lang_SQ, lang_SR, lang_SU,
+               lang_SV, lang_SW, lang_TA, lang_TE, lang_TET, lang_TG, lang_TH,
+               lang_TK, lang_TL, lang_TR, lang_TT, lang_UK, lang_UR, lang_UZ,
+               lang_VI, lang_WO, lang_YI, lang_YO, lang_ZH_CN, lang_ZH_HK,
+               lang_ZH_TW)
+
+# Version information
+try:
+    from ._version import __version__, __version_tuple__
+except ImportError:
+    # Package is not installed, provide defaults
+    __version__ = "unknown"
+    __version_tuple__ = (0, 0, 0, "unknown", 0)
+
+
+CONVERTER_CLASSES = {
+    'af': lang_AF.Num2Word_AF(),
+    'am': lang_AM.Num2Word_AM(),
+    'ar': lang_AR.Num2Word_AR(),
+    'az': lang_AZ.Num2Word_AZ(),
+    'be': lang_BE.Num2Word_BE(),
+    'bg': lang_BG.Num2Word_BG(),
+    'bn': lang_BN.Num2Word_BN(),
+    'ca': lang_CA.Num2Word_CA(),
+    'ce': lang_CE.Num2Word_CE(),
+    'cs': lang_CS.Num2Word_CS(),
+    'cy': lang_CY.Num2Word_CY(),
+    'da': lang_DA.Num2Word_DA(),
+    'de': lang_DE.Num2Word_DE(),
+    'el': lang_EL.Num2Word_EL(),
+    'en': lang_EN.Num2Word_EN(),
+    'en_IN': lang_EN_IN.Num2Word_EN_IN(),
+    'en_NG': lang_EN_NG.Num2Word_EN_NG(),
+    'eo': lang_EO.Num2Word_EO(),
+    'es': lang_ES.Num2Word_ES(),
+    'es_CO': lang_ES_CO.Num2Word_ES_CO(),
+    'es_CR': lang_ES_CR.Num2Word_ES_CR(),
+    'es_GT': lang_ES_GT.Num2Word_ES_GT(),
+    'es_NI': lang_ES_NI.Num2Word_ES_NI(),
+    'es_VE': lang_ES_VE.Num2Word_ES_VE(),
+    'et': lang_ET.Num2Word_ET(),
+    'fa': lang_FA.Num2Word_FA(),
+    'fi': lang_FI.Num2Word_FI(),
+    'fr': lang_FR.Num2Word_FR(),
+    'fr_BE': lang_FR_BE.Num2Word_FR_BE(),
+    'fr_CH': lang_FR_CH.Num2Word_FR_CH(),
+    'fr_DZ': lang_FR_DZ.Num2Word_FR_DZ(),
+    'ha': lang_HA.Num2Word_HA(),
+    'he': lang_HE.Num2Word_HE(),
+    'hi': lang_HI.Num2Word_HI(),
+    'hr': lang_HR.Num2Word_HR(),
+    'hu': lang_HU.Num2Word_HU(),
+    'hy': lang_HY.Num2Word_HY(),
+    'id': lang_ID.Num2Word_ID(),
+    'is': lang_IS.Num2Word_IS(),
+    'it': lang_IT.Num2Word_IT(),
+    'ja': lang_JA.Num2Word_JA(),
+    'kn': lang_KN.Num2Word_KN(),
+    'ko': lang_KO.Num2Word_KO(),
+    'kz': lang_KZ.Num2Word_KZ(),
+    'lt': lang_LT.Num2Word_LT(),
+    'lv': lang_LV.Num2Word_LV(),
+    'mn': lang_MN.Num2Word_MN(),
+    'ms': lang_MS.Num2Word_MS(),
+    'nl': lang_NL.Num2Word_NL(),
+    'no': lang_NO.Num2Word_NO(),
+    'pl': lang_PL.Num2Word_PL(),
+    'pt': lang_PT.Num2Word_PT(),
+    'pt_BR': lang_PT_BR.Num2Word_PT_BR(),
+    'ro': lang_RO.Num2Word_RO(),
+    'ru': lang_RU.Num2Word_RU(),
+    'sk': lang_SK.Num2Word_SK(),
+    'sl': lang_SL.Num2Word_SL(),
+    'sn': lang_SN.Num2Word_SN(),
+    'sq': lang_SQ.Num2Word_SQ(),
+    'sr': lang_SR.Num2Word_SR(),
+    'sv': lang_SV.Num2Word_SV(),
+    'sw': lang_SW.Num2Word_SW(),
+    'ta': lang_TA.Num2Word_TA(),
+    'te': lang_TE.Num2Word_TE(),
+    'tet': lang_TET.Num2Word_TET(),
+    'tg': lang_TG.Num2Word_TG(),
+    'th': lang_TH.Num2Word_TH(),
+    'tr': lang_TR.Num2Word_TR(),
+    'uk': lang_UK.Num2Word_UK(),
+    'vi': lang_VI.Num2Word_VI(),
+    'zh': lang_ZH_CN.Num2Word_ZH_CN(),  # Default 'zh' to simplified Chinese
+    'zh_CN': lang_ZH_CN.Num2Word_ZH_CN(),
+    'zh_HK': lang_ZH_HK.Num2Word_ZH_HK(),
+    'zh_TW': lang_ZH_TW.Num2Word_ZH_TW(),
+    'as': lang_AS.Num2Word_AS(),
+    'ba': lang_BA.Num2Word_BA(),
+    'bo': lang_BO.Num2Word_BO(),
+    'br': lang_BR.Num2Word_BR(),
+    'bs': lang_BS.Num2Word_BS(),
+    'eu': lang_EU.Num2Word_EU(),
+    'fo': lang_FO.Num2Word_FO(),
+    'gl': lang_GL.Num2Word_GL(),
+    'gu': lang_GU.Num2Word_GU(),
+    'haw': lang_HAW.Num2Word_HAW(),
+    'ht': lang_HT.Num2Word_HT(),
+    'jw': lang_JW.Num2Word_JW(),
+    'ka': lang_KA.Num2Word_KA(),
+    'kk': lang_KK.Num2Word_KK(),
+    'km': lang_KM.Num2Word_KM(),
+    'la': lang_LA.Num2Word_LA(),
+    'lb': lang_LB.Num2Word_LB(),
+    'ln': lang_LN.Num2Word_LN(),
+    'lo': lang_LO.Num2Word_LO(),
+    'mg': lang_MG.Num2Word_MG(),
+    'mi': lang_MI.Num2Word_MI(),
+    'mk': lang_MK.Num2Word_MK(),
+    'ml': lang_ML.Num2Word_ML(),
+    'mr': lang_MR.Num2Word_MR(),
+    'mt': lang_MT.Num2Word_MT(),
+    'my': lang_MY.Num2Word_MY(),
+    'ne': lang_NE.Num2Word_NE(),
+    'nn': lang_NN.Num2Word_NN(),
+    'oc': lang_OC.Num2Word_OC(),
+    'pa': lang_PA.Num2Word_PA(),
+    'ps': lang_PS.Num2Word_PS(),
+    'sa': lang_SA.Num2Word_SA(),
+    'sd': lang_SD.Num2Word_SD(),
+    'si': lang_SI.Num2Word_SI(),
+    'so': lang_SO.Num2Word_SO(),
+    'su': lang_SU.Num2Word_SU(),
+    'tk': lang_TK.Num2Word_TK(),
+    'tl': lang_TL.Num2Word_TL(),
+    'tt': lang_TT.Num2Word_TT(),
+    'ur': lang_UR.Num2Word_UR(),
+    'uz': lang_UZ.Num2Word_UZ(),
+    'wo': lang_WO.Num2Word_WO(),
+    'yi': lang_YI.Num2Word_YI(),
+    'yo': lang_YO.Num2Word_YO(),
+    # Language code aliases
+    'jp': lang_JA.Num2Word_JA(),  # Alias for Japanese
+    'cn': lang_ZH_CN.Num2Word_ZH_CN(),  # Alias for Chinese (Simplified)
+}
+
+CONVERTES_TYPES = ['cardinal', 'ordinal', 'ordinal_num', 'year', 'currency']
+CONVERTER_TYPES = CONVERTES_TYPES  # Alias for compatibility
+
+
+def num2words(number, ordinal=False, lang='en', to='cardinal', **kwargs):
+    # We try the full language first
+    if lang not in CONVERTER_CLASSES:
+        # ... and then try only the first 2 letters
+        lang = lang[:2]
+    if lang not in CONVERTER_CLASSES:
+        raise NotImplementedError()
+    converter = CONVERTER_CLASSES[lang]
+
+    if isinstance(number, str):
+        number = converter.str_to_number(number)
+
+    # backwards compatible
+    if ordinal:
+        to = 'ordinal'
+
+    if to not in CONVERTES_TYPES:
+        raise NotImplementedError()
+
+    return getattr(converter, 'to_{}'.format(to))(number, **kwargs)

num2words2/_version.py

@@ -0,0 +1,3 @@
+# Auto-generated version file
+__version__ = "0.1.0.dev1"
+__version_tuple__ = (0, 1, 0, 'dev1')

num2words2/base.py

@@ -0,0 +1,377 @@
+# -*- 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
+
+import math
+from collections import OrderedDict
+from decimal import Decimal
+
+from .compat import to_s
+from .currency import parse_currency_parts, prefix_currency
+
+
+class Num2Word_Base(object):
+    CURRENCY_FORMS = {}
+    CURRENCY_ADJECTIVES = {}
+
+    def __init__(self):
+        self.is_title = False
+        self.precision = 2
+        self.exclude_title = []
+        self.negword = "(-) "
+        self.pointword = "(.)"
+        self.errmsg_nonnum = "type(%s) not in [long, int, float]"
+        self.errmsg_floatord = "Cannot treat float %s as ordinal."
+        self.errmsg_negord = "Cannot treat negative num %s as ordinal."
+        self.errmsg_toobig = "abs(%s) must be less than %s."
+
+        self.setup()
+
+        # uses cards
+        if any(hasattr(self, field) for field in
+               ['high_numwords', 'mid_numwords', 'low_numwords']):
+            self.cards = OrderedDict()
+            self.set_numwords()
+            self.MAXVAL = 1000 * list(self.cards.keys())[0]
+
+    def set_numwords(self):
+        self.set_high_numwords(self.high_numwords)
+        self.set_mid_numwords(self.mid_numwords)
+        self.set_low_numwords(self.low_numwords)
+
+    def set_high_numwords(self, *args):
+        raise NotImplementedError
+
+    def set_mid_numwords(self, mid):
+        for key, val in mid:
+            self.cards[key] = val
+
+    def set_low_numwords(self, numwords):
+        for word, n in zip(numwords, range(len(numwords) - 1, -1, -1)):
+            self.cards[n] = word
+
+    def splitnum(self, value):
+        for elem in self.cards:
+            if elem > value:
+                continue
+
+            out = []
+            if value == 0:
+                div, mod = 1, 0
+            else:
+                div, mod = divmod(value, elem)
+
+            if div == 1:
+                out.append((self.cards[1], 1))
+            else:
+                if div == value:  # The system tallies, eg Roman Numerals
+                    return [(div * self.cards[elem], div * elem)]
+                out.append(self.splitnum(div))
+
+            out.append((self.cards[elem], elem))
+
+            if mod:
+                out.append(self.splitnum(mod))
+
+            return out
+
+    def parse_minus(self, num_str):
+        """Detach minus and return it as symbol with new num_str."""
+        if num_str.startswith('-'):
+            # Extra spacing to compensate if there is no minus.
+            return '%s ' % self.negword.strip(), num_str[1:]
+        return '', num_str
+
+    def str_to_number(self, value):
+        return Decimal(value)
+
+    def to_cardinal(self, value):
+        try:
+            assert int(value) == value
+        except (ValueError, TypeError, AssertionError):
+            return self.to_cardinal_float(value)
+
+        out = ""
+        if value < 0:
+            value = abs(value)
+            out = "%s " % self.negword.strip()
+
+        if value >= self.MAXVAL:
+            raise OverflowError(self.errmsg_toobig % (value, self.MAXVAL))
+
+        val = self.splitnum(value)
+        words, num = self.clean(val)
+        return self.title(out + words)
+
+    def float2tuple(self, value):
+        pre = int(value)
+
+        # Simple way of finding decimal places to update the precision
+        self.precision = abs(Decimal(str(value)).as_tuple().exponent)
+
+        post = abs(value - pre) * 10**self.precision
+        if abs(round(post) - post) < 0.01:
+            # We generally floor all values beyond our precision (rather than
+            # rounding), but in cases where we have something like 1.239999999,
+            # which is probably due to python's handling of floats, we actually
+            # want to consider it as 1.24 instead of 1.23
+            post = int(round(post))
+        else:
+            post = int(math.floor(post))
+
+        return pre, post
+
+    def to_cardinal_float(self, value):
+        try:
+            float(value) == value
+        except (ValueError, TypeError, AssertionError, AttributeError):
+            raise TypeError(self.errmsg_nonnum % value)
+
+        pre, post = self.float2tuple(float(value))
+
+        post = str(post)
+        post = '0' * (self.precision - len(post)) + post
+
+        out = [self.to_cardinal(pre)]
+        if value < 0 and pre == 0:
+            out = [self.negword.strip()] + out
+
+        if self.precision:
+            out.append(self.title(self.pointword))
+
+        for i in range(self.precision):
+            curr = int(post[i])
+            out.append(to_s(self.to_cardinal(curr)))
+
+        return " ".join(out)
+
+    def merge(self, curr, next):
+        raise NotImplementedError
+
+    def clean(self, val):
+        out = val
+        while len(val) != 1:
+            out = []
+            left, right = val[:2]
+            if isinstance(left, tuple) and isinstance(right, tuple):
+                out.append(self.merge(left, right))
+                if val[2:]:
+                    out.append(val[2:])
+            else:
+                for elem in val:
+                    if isinstance(elem, list):
+                        if len(elem) == 1:
+                            out.append(elem[0])
+                        else:
+                            out.append(self.clean(elem))
+                    else:
+                        out.append(elem)
+            val = out
+        return out[0]
+
+    def title(self, value):
+        if self.is_title:
+            out = []
+            value = value.split()
+            for word in value:
+                if word in self.exclude_title:
+                    out.append(word)
+                else:
+                    out.append(word[0].upper() + word[1:])
+            value = " ".join(out)
+        return value
+
+    def verify_ordinal(self, value):
+        if not value == int(value):
+            raise TypeError(self.errmsg_floatord % value)
+        if not abs(value) == value:
+            raise TypeError(self.errmsg_negord % value)
+
+    def to_ordinal(self, value):
+        return self.to_cardinal(value)
+
+    def to_ordinal_num(self, value):
+        return value
+
+    # Trivial version
+    def inflect(self, value, text):
+        text = text.split("/")
+        if value == 1:
+            return text[0]
+        return "".join(text)
+
+    # //CHECK: generalise? Any others like pounds/shillings/pence?
+    def to_splitnum(self, val, hightxt="", lowtxt="", jointxt="",
+                    divisor=100, longval=True, cents=True):
+        out = []
+
+        if isinstance(val, float):
+            high, low = self.float2tuple(val)
+        else:
+            try:
+                high, low = val
+            except TypeError:
+                high, low = divmod(val, divisor)
+
+        if high:
+            hightxt = self.title(self.inflect(high, hightxt))
+            out.append(self.to_cardinal(high))
+            if low:
+                if longval:
+                    if hightxt:
+                        out.append(hightxt)
+                    if jointxt:
+                        out.append(self.title(jointxt))
+            elif hightxt:
+                out.append(hightxt)
+
+        if low:
+            if cents:
+                out.append(self.to_cardinal(low))
+            else:
+                out.append("%02d" % low)
+            if lowtxt and longval:
+                out.append(self.title(self.inflect(low, lowtxt)))
+
+        return " ".join(out)
+
+    def to_year(self, value, **kwargs):
+        return self.to_cardinal(value)
+
+    def pluralize(self, n, forms):
+        """
+        Should resolve gettext form:
+        http://docs.translatehouse.org/projects/localization-guide/en/latest/l10n/pluralforms.html
+        """
+        raise NotImplementedError
+
+    def _money_verbose(self, number, currency):
+        return self.to_cardinal(number)
+
+    def _cents_verbose(self, number, currency):
+        return self.to_cardinal(number)
+
+    def _cents_terse(self, number, currency):
+        return "%02d" % number
+
+    def to_currency(self, val, currency='EUR', cents=True, separator=',',
+                    adjective=False):
+        """
+        Args:
+            val: Numeric value
+            currency (str): Currency code
+            cents (bool): Verbose cents
+            separator (str): Cent separator
+            adjective (bool): Prefix currency name with adjective
+        Returns:
+            str: Formatted string
+
+        Handles whole numbers and decimal numbers differently
+        """
+        # Handle integers separately - no cents shown
+        if isinstance(val, int):
+            try:
+                cr1, cr2 = self.CURRENCY_FORMS[currency]
+            except KeyError:
+                raise NotImplementedError(
+                    'Currency code "%s" not implemented for "%s"' %
+                    (currency, self.__class__.__name__))
+
+            if adjective and currency in self.CURRENCY_ADJECTIVES:
+                cr1 = prefix_currency(self.CURRENCY_ADJECTIVES[currency], cr1)
+
+            minus_str = "%s " % self.negword.strip() if val < 0 else ""
+            money_str = self._money_verbose(abs(val), currency)
+
+            return u'%s%s %s' % (
+                minus_str,
+                money_str,
+                self.pluralize(abs(val), cr1)
+            )
+
+        # For floats, show full currency with cents
+        # Check if value has more than 2 decimal places
+        from decimal import Decimal
+        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)
+
+        try:
+            cr1, cr2 = self.CURRENCY_FORMS[currency]
+
+        except KeyError:
+            raise NotImplementedError(
+                'Currency code "%s" not implemented for "%s"' %
+                (currency, self.__class__.__name__))
+
+        if adjective and currency in self.CURRENCY_ADJECTIVES:
+            cr1 = prefix_currency(self.CURRENCY_ADJECTIVES[currency], cr1)
+
+        minus_str = "%s " % self.negword.strip() if is_negative else ""
+        money_str = self._money_verbose(left, currency)
+
+        # Explicitly check if input has decimal point or non-zero cents
+        has_decimal = isinstance(val, float) or str(val).find('.') != -1
+
+        # Only include cents if:
+        # 1. Input has decimal point OR
+        # 2. Cents are non-zero
+        if has_decimal or (isinstance(right, Decimal) and right > 0) or (isinstance(right, int) and right > 0):
+            # Handle fractional cents
+            if isinstance(right, Decimal):
+                # Split into whole cents and fraction
+                whole_cents = int(right)
+                fractional_part = right - whole_cents
+
+                if fractional_part > 0:
+                    # Convert fractional cents (e.g., 65.3 cents)
+                    cents_str = self.to_cardinal(float(right))
+                    return u'%s%s %s%s %s %s' % (
+                        minus_str,
+                        money_str,
+                        self.pluralize(left, cr1),
+                        separator,
+                        cents_str,
+                        cr2[1] if isinstance(cr2, tuple) and len(cr2) > 1 else cr2
+                    )
+                else:
+                    # No fractional part, use normal processing
+                    right = whole_cents
+
+            cents_str = self._cents_verbose(right, currency) \
+                if cents else self._cents_terse(right, currency)
+
+            return u'%s%s %s%s %s %s' % (
+                minus_str,
+                money_str,
+                self.pluralize(left, cr1),
+                separator,
+                cents_str,
+                self.pluralize(right, cr2)
+            )
+        else:
+            return u'%s%s %s' % (
+                minus_str,
+                money_str,
+                self.pluralize(left, cr1)
+            )
+
+    def setup(self):
+        pass

num2words2/compat.py

@@ -0,0 +1,29 @@
+# -*- 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
+
+
+try:
+    strtype = basestring
+except NameError:
+    strtype = str
+
+
+def to_s(val):
+    try:
+        return unicode(val)
+    except NameError:
+        return str(val)