Update Amharic language support

README.rst

@@ -76,6 +76,7 @@ Besides the numerical argument, there are two main optional arguments.
 **lang:** The language in which to convert the number. Supported values are:
 
 * ``en`` (English, default)
+* ``am`` (Amharic)
 * ``ar`` (Arabic)
 * ``cz`` (Czech)
 * ``de`` (German)

num2words/lang_AM.py

@@ -23,45 +23,73 @@ from . import lang_EU
 class Num2Word_AM(lang_EU.Num2Word_EU):
     CURRENCY_FORMS = {'ETB': (('ብር', 'ብር'), ('ሳንቲም', 'ሳንቲም'))}
 
+    GIGA_SUFFIX = 'ቢሊዮን'
+    MEGA_SUFFIX = 'ሚሊዮን'
+
     def set_high_numwords(self, high):
-        max = 3 + 3 * len(high)
+        cap = 3 * (len(high) + 1)
-        for word, n in zip(high, range(max, 3, -3)):
+
-            self.cards[10 ** n] = word + "ሊዮን"
+        for word, n in zip(high, range(cap, 5, -3)):
+            if n == 9:
+                self.cards[10 ** n] = word + self.GIGA_SUFFIX
+            else:
+                self.cards[10 ** n] = word + self.MEGA_SUFFIX
 
     def setup(self):
         super(Num2Word_AM, self).setup()
 
-        self.negword = "አሉታዊ "
+        self.negword = 'አሉታዊ '
-        self.pointword = "ነጥብ"
+        self.pointword = 'ነጥብ'
-        self.exclude_title = ["እና", "ነጥብ", "አሉታዊ"]
+        self.exclude_title = ['እና', 'ነጥብ', 'አሉታዊ']
 
-        self.mid_numwords = [(1000, "ሺህ"), (100, "መቶ"), (90, "ዘጠና"),
+        self.mid_numwords = [(1000, 'ሺህ'), (100, 'መቶ'), (90, 'ዘጠና'),
-                             (80, "ሰማኒያ"), (70, "ሰባ"), (60, "ስድሳ"),
+                             (80, 'ሰማኒያ'), (70, 'ሰባ'), (60, 'ስድሳ'),
-                             (50, "አምሳ"), (40, "አርባ"), (30, "ሠላሳ")]
+                             (50, 'አምሳ'), (40, 'አርባ'), (30, 'ሠላሳ')]
-        self.low_numwords = ["ሃያ", "አሥራ ዘጠኝ", "አሥራ ስምንት", "አሥራ ሰባት",
+        self.low_numwords = ['ሃያ', 'አሥራ ዘጠኝ', 'አሥራ ስምንት', 'አሥራ ሰባት',
-                             "አስራ ስድስት", "አሥራ አምስት", "አሥራ አራት", "አሥራ ሦስት",
+                             'አስራ ስድስት', 'አሥራ አምስት', 'አሥራ አራት', 'አሥራ ሦስት',
-                             "አሥራ ሁለት", "አሥራ አንድ", "አሥር", "ዘጠኝ", "ስምንት",
+                             'አሥራ ሁለት', 'አሥራ አንድ', 'አሥር', 'ዘጠኝ', 'ስምንት',
-                             "ሰባት", "ስድስት", "አምስት", "አራት", "ሦስት", "ሁለት",
+                             'ሰባት', 'ስድስት', 'አምስት', 'አራት', 'ሦስት', 'ሁለት',
-                             "አንድ", "ዜሮ"]
+                             'አንድ', 'ዜሮ']
-        self.ords = {"አንድ": "አንደኛ",
+        self.ords = {'አንድ': 'አንደኛ',
-                     "ሁለት": "ሁለተኛ",
+                     'ሁለት': 'ሁለተኛ',
-                     "ሦስት": "ሦስተኛ",
+                     'ሦስት': 'ሦስተኛ',
-                     "አራት": "አራተኛ",
+                     'አራት': 'አራተኛ',
-                     "አምስት": "አምስተኛ",
+                     'አምስት': 'አምስተኛ',
-                     "ስድስት": "ስድስተኛ",
+                     'ስድስት': 'ስድስተኛ',
-                     "ሰባት": "ሰባተኛ",
+                     'ሰባት': 'ሰባተኛ',
-                     "ስምንት": "ስምንተኛ",
+                     'ስምንት': 'ስምንተኛ',
-                     "ዘጠኝ": "ዘጠነኛ",
+                     'ዘጠኝ': 'ዘጠነኛ',
-                     "አሥር": "አሥረኛ",
+                     'አሥር': 'አሥረኛ',
-                     "አሥራ አንድ": "አሥራ አንድ",
+                     'አሥራ አንድ': 'አሥራ አንድ',
-                     "አሥራ ሁለት": "አሥራ ሁለተኛ",
+                     'አሥራ ሁለት': 'አሥራ ሁለተኛ',
-                     "አሥራ ሦስት": "አሥራ ሦስተኛ",
+                     'አሥራ ሦስት': 'አሥራ ሦስተኛ',
-                     "አሥራ አራት": "አሥራ አራተኛ",
+                     'አሥራ አራት': 'አሥራ አራተኛ',
-                     "አሥራ አምስት": "አሥራ አምስተኛ",
+                     'አሥራ አምስት': 'አሥራ አምስተኛ',
-                     "አሥራ ስድስት": "አሥራ ስድስተኛ",
+                     'አሥራ ስድስት': 'አሥራ ስድስተኛ',
-                     "አሥራ ሰባት": "አሥራ ሰባተኛ",
+                     'አሥራ ሰባት': 'አሥራ ሰባተኛ',
-                     "አሥራ ስምንት": "አሥራ ስምንተኛ",
+                     'አሥራ ስምንት': 'አሥራ ስምንተኛ',
-                     "አሥራ ዘጠኝ": "አሥራ ዘጠነኛ"}
+                     'አሥራ ዘጠኝ': 'አሥራ ዘጠነኛ'}
+
+    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 = self.negword
+
+        if value >= self.MAXVAL:
+            raise OverflowError(self.errmsg_toobig % (value, self.MAXVAL))
+
+        if value == 100:
+            return self.title(out + 'መቶ')
+        else:
+            val = self.splitnum(value)
+            words, num = self.clean(val)
+            return self.title(out + words)
 
     def merge(self, lpair, rpair):
         ltext, lnum = lpair
@@ -69,31 +97,31 @@ class Num2Word_AM(lang_EU.Num2Word_EU):
         if lnum == 1 and rnum < 100:
             return (rtext, rnum)
         elif 100 > lnum > rnum:
-            return ("%s %s" % (ltext, rtext), lnum + rnum)
+            return ('%s %s' % (ltext, rtext), lnum + rnum)
         elif lnum >= 100 > rnum:
-            return ("%s %s" % (ltext, rtext), lnum + rnum)
+            return ('%s %s' % (ltext, rtext), lnum + rnum)
         elif rnum > lnum:
-            return ("%s %s" % (ltext, rtext), lnum * rnum)
+            return ('%s %s' % (ltext, rtext), lnum * rnum)
-        return ("%s, %s" % (ltext, rtext), lnum + rnum)
+        return ('%s, %s' % (ltext, rtext), lnum + rnum)
 
     def to_ordinal(self, value):
         self.verify_ordinal(value)
-        outwords = self.to_cardinal(value).split(" ")
+        outwords = self.to_cardinal(value).split(' ')
-        lastwords = outwords[-1].split("-")
+        lastwords = outwords[-1].split('-')
         lastword = lastwords[-1].lower()
         try:
             lastword = self.ords[lastword]
         except KeyError:
-            if lastword[-1] == "y":
+            if lastword[-1] == 'y':
-                lastword = lastword[:-1] + "ie"
+                lastword = lastword[:-1] + 'ie'
-            lastword += "th"
+            lastword += 'th'
         lastwords[-1] = self.title(lastword)
-        outwords[-1] = " ".join(lastwords)
+        outwords[-1] = ' '.join(lastwords)
-        return " ".join(outwords)
+        return ' '.join(outwords)
 
     def to_ordinal_num(self, value):
         self.verify_ordinal(value)
-        return "%s%s" % (value, self.to_ordinal(value)[-1:])
+        return '%s%s' % (value, self.to_ordinal(value)[-1:])
 
     def to_currency(self, val, currency='ብር', cents=True, separator=' ከ',
                     adjective=True):
@@ -105,4 +133,4 @@ class Num2Word_AM(lang_EU.Num2Word_EU):
     def to_year(self, val, longval=True):
         if not (val // 100) % 10:
             return self.to_cardinal(val)
-        return self.to_splitnum(val, hightxt="መቶ", longval=longval)
+        return self.to_splitnum(val, hightxt='መቶ', longval=longval)

tests/test_am.py

@@ -21,10 +21,15 @@ from num2words import num2words
 
 
 class Num2WordsAMTest(TestCase):
-    def test_and_join_199(self):
+    def test_cardinal(self):
-        self.assertEqual(num2words(199, lang='am'), "አንድ መቶ ዘጠና ዘጠኝ")
+        self.assertEqual(num2words(100, lang='am'), 'መቶ')
+        self.assertEqual(num2words(100000, lang='am'), 'አንድ መቶ ሺህ')
+        self.assertEqual(num2words(101, lang='am'), 'አንድ መቶ አንድ')
 
-    def test_ordinal(self):
+    def test_and_join_199(self):
+        self.assertEqual(num2words(199, lang='am'), 'አንድ መቶ ዘጠና ዘጠኝ')
+
+    def test_to_ordinal(self):
         self.assertEqual(
             num2words(1, lang='am', to='ordinal'),
             'አንደኛ'
@@ -38,38 +43,38 @@ class Num2WordsAMTest(TestCase):
             'ሃያ ሁለተኛ'
         )
 
-    def test_ordinal_num(self):
+    def test_to_ordinal_num(self):
         self.assertEqual(num2words(10, lang='am', to='ordinal_num'), '10ኛ')
         self.assertEqual(num2words(21, lang='am', to='ordinal_num'), '21ኛ')
         self.assertEqual(num2words(102, lang='am', to='ordinal_num'), '102ኛ')
 
     def test_cardinal_for_float_number(self):
-        self.assertEqual(num2words(12.5, lang='am'), "አሥራ ሁለት ነጥብ አምስት")
+        self.assertEqual(num2words(12.5, lang='am'), 'አሥራ ሁለት ነጥብ አምስት')
-        self.assertEqual(num2words(12.51, lang='am'), "አሥራ ሁለት ነጥብ አምስት አንድ")
+        self.assertEqual(num2words(12.51, lang='am'), 'አሥራ ሁለት ነጥብ አምስት አንድ')
-        self.assertEqual(num2words(12.53, lang='am'), "አሥራ ሁለት ነጥብ አምስት ሦስት")
+        self.assertEqual(num2words(12.53, lang='am'), 'አሥራ ሁለት ነጥብ አምስት ሦስት')
 
-    def test_overflow(self):
+    def test_to_overflow(self):
         with self.assertRaises(OverflowError):
-            num2words("1000000000000000000000000000000000000000000000000000000"
+            num2words('1000000000000000000000000000000000000000000000000000000'
-                      "0000000000000000000000000000000000000000000000000000000"
+                      '0000000000000000000000000000000000000000000000000000000'
-                      "0000000000000000000000000000000000000000000000000000000"
+                      '0000000000000000000000000000000000000000000000000000000'
-                      "0000000000000000000000000000000000000000000000000000000"
+                      '0000000000000000000000000000000000000000000000000000000'
-                      "0000000000000000000000000000000000000000000000000000000"
+                      '0000000000000000000000000000000000000000000000000000000'
-                      "00000000000000000000000000000000", lang='am')
+                      '00000000000000000000000000000000', lang='am')
 
     def test_to_currency(self):
         self.assertEqual(
             num2words('38.4', lang='am', to='currency', cents=False,
-                      currency='ETB'), "ሠላሳ ስምንት ብር ከ 40 ሳንቲም"
+                      currency='ETB'), 'ሠላሳ ስምንት ብር ከ 40 ሳንቲም'
         )
         self.assertEqual(
             num2words('0', lang='am', to='currency', separator=' እና',
-                      cents=True, currency='ETB'), "ዜሮ ብር እና ዜሮ ሳንቲም"
+                      cents=True, currency='ETB'), 'ዜሮ ብር እና ዜሮ ሳንቲም'
         )
 
         self.assertEqual(
             num2words('1.50', lang='am', to='currency', cents=True,
-                      currency='ETB'), "አንድ ብር ከ አምሳ ሳንቲም"
+                      currency='ETB'), 'አንድ ብር ከ አምሳ ሳንቲም'
         )
 
     def test_to_year(self):