Fix as many pep8 issues as posible

Signed-off-by: William Moreno Reyes <williamjmorenor@gmail.com>

num2words/lang_AR.py

@@ -21,9 +21,9 @@ from . import lang_EU
 
 class Num2Word_AR(lang_EU.Num2Word_EU):
     def set_high_numwords(self, high):
-        max = 3 + 3*len(high)
+        max = 3 + 3 * len(high)
         for word, n in zip(high, range(max, 3, -3)):
-            self.cards[10**n] = word + "illion"
+            self.cards[10 ** n] = word + "illion"
 
     def setup(self):
         self.negword = "سالب "
@@ -41,32 +41,32 @@ class Num2Word_AR(lang_EU.Num2Word_EU):
                              "سبعة", "ستة", "خمسة", "أربعة", "ثلاثة", "اثنين",
                              "واحد", "صفر"]
         self.ords = {"واحد": "أول",
-                      "اثنين": "ثاني",
-                      "ثلاثة": "ثالث",
-                      "أربعة": "رابع",
-                      "خمسة": "خامس",
-                      "ثمانية": "ثامن",
-                      "تسعة": "تاسع",
-                      "اثناعشر": "ثاني عشر" }
+                     "اثنين": "ثاني",
+                     "ثلاثة": "ثالث",
+                     "أربعة": "رابع",
+                     "خمسة": "خامس",
+                     "ثمانية": "ثامن",
+                     "تسعة": "تاسع",
+                     "اثناعشر": "ثاني عشر"}
 
     def merge(self, lpair, rpair):
         ltext, lnum = lpair
         rtext, rnum = rpair
         if lnum == 1 and rnum < 100:
             return (rtext, rnum)
-        elif 100 > lnum > rnum :
-            return ("%s و%s"%(rtext, ltext), rnum + lnum)
+        elif 100 > lnum > rnum:
+            return ("%s و%s" % (rtext, ltext), rnum + lnum)
         elif lnum >= 100 > rnum:
-            return ("%s و %s"%(ltext, rtext), lnum + rnum)
+            return ("%s و %s" % (ltext, rtext), lnum + rnum)
         elif rnum > lnum:
             if lnum == 1 and rnum in [100, 1000, 1000000]:
-                return ("%s"%(rtext), rnum * lnum)
+                return ("%s" % (rtext), rnum * lnum)
             if lnum == 2 and rnum == 100:
                 return ("مئتين", rnum * lnum)
             if lnum == 2 and rnum in [100, 1000]:
-                return ("%sين"%(rtext), rnum * lnum)
-            return ("%s %s"%(ltext, rtext), lnum * rnum)
-        return ("%s، %s"%(ltext, rtext), lnum + rnum)
+                return ("%sين" % (rtext), rnum * lnum)
+            return ("%s %s" % (ltext, rtext), lnum * rnum)
+        return ("%s، %s" % (ltext, rtext), lnum + rnum)
 
     def to_ordinal(self, value):
         self.verify_ordinal(value)
@@ -83,17 +83,17 @@ class Num2Word_AR(lang_EU.Num2Word_EU):
 
     def to_ordinal_num(self, value):
         self.verify_ordinal(value)
-        return "%s%s"%(value, self.to_ordinal(value)[-2:])
+        return "%s%s" % (value, self.to_ordinal(value)[-2:])
 
     def to_year(self, val, longval=True):
-        if not (val//100)%10:
+        if not (val // 100) % 10:
             return self.to_cardinal(val)
         return self.to_splitnum(val, hightxt="مئة", jointxt="و",
                                 longval=longval)
 
     def to_currency(self, val, longval=True):
         return self.to_splitnum(val, hightxt="ريال", lowtxt="هللة",
-                                jointxt="و", longval=longval, cents = True)
+                                jointxt="و", longval=longval, cents=True)
 
 
 n2w = Num2Word_AR()
@@ -104,12 +104,13 @@ to_year = n2w.to_year
 
 
 def main():
-    for val in [ 1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155,
-             180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000,
-             8280, 8291, 150000, 500000, 1000000, 2000000, 2000001,
-             -21212121211221211111, -2.121212, -1.0000100]:
+    for val in [1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155,
+                180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000,
+                8280, 8291, 150000, 500000, 1000000, 2000000, 2000001,
+                -21212121211221211111, -2.121212, -1.0000100]:
         n2w.test(val)
-    n2w.test(1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
+    n2w.test(
+        1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
     for val in [1, 120, 1000, 1120, 1800, 1976, 2000, 2010, 2099, 2171]:
         print(val, "is", n2w.to_currency(val))
         print(val, "is", n2w.to_year(val))

num2words/lang_DE.py

@@ -21,19 +21,22 @@ from .lang_EU import Num2Word_EU
 
 class Num2Word_DE(Num2Word_EU):
     def set_high_numwords(self, high):
-        max = 3 + 6*len(high)
+        max = 3 + 6 * len(high)
 
         for word, n in zip(high, range(max, 3, -6)):
-            self.cards[10**n] = word + "illiarde"
-            self.cards[10**(n-3)] = word + "illion"
+            self.cards[10 ** n] = word + "illiarde"
+            self.cards[10 ** (n - 3)] = word + "illion"
 
     def setup(self):
         self.negword = "minus "
         self.pointword = "Komma"
-        self.errmsg_floatord = "Die Gleitkommazahl %s kann nicht in eine Ordnungszahl konvertiert werden." # "Cannot treat float %s as ordinal."
-        self.errmsg_nonnum = "Nur Zahlen (type(%s)) können in Wörter konvertiert werden." # "type(((type(%s)) ) not in [long, int, float]"
-        self.errmsg_negord = "Die negative Zahl %s kann nicht in eine Ordnungszahl konvertiert werden." # "Cannot treat negative num %s as ordinal."
-        self.errmsg_toobig = "Die Zahl %s muss kleiner als %s sein." # "abs(%s) must be less than %s."
+        self.errmsg_floatord = "Die Gleitkommazahl %s kann nicht in eine Ordnungszahl konvertiert werden."
+        # "Cannot treat float %s as ordinal."
+        self.errmsg_nonnum = "Nur Zahlen (type(%s)) können in Wörter konvertiert werden."
+        # "type(((type(%s)) ) not in [long, int, float]"
+        self.errmsg_negord = "Die negative Zahl %s kann nicht in eine Ordnungszahl konvertiert werden."
+        # "Cannot treat negative num %s as ordinal."
+        self.errmsg_toobig = "Die Zahl %s muss kleiner als %s sein."  # "abs(%s) must be less than %s."
         self.exclude_title = []
 
         lows = ["non", "okt", "sept", "sext", "quint", "quadr", "tr", "b", "m"]
@@ -41,7 +44,7 @@ class Num2Word_DE(Num2Word_EU):
                  "okto", "novem"]
         tens = ["dez", "vigint", "trigint", "quadragint", "quinquagint",
                 "sexagint", "septuagint", "oktogint", "nonagint"]
-        self.high_numwords = ["zent"]+self.gen_high_numwords(units, tens, lows)
+        self.high_numwords = ["zent"] + self.gen_high_numwords(units, tens, lows)
         self.mid_numwords = [(1000, "tausend"), (100, "hundert"),
                              (90, "neunzig"), (80, "achtzig"), (70, "siebzig"),
                              (60, "sechzig"), (50, "f\xFCnfzig"), (40, "vierzig"),
@@ -67,12 +70,12 @@ class Num2Word_DE(Num2Word_EU):
         ctext, cnum, ntext, nnum = curr + next
 
         if cnum == 1:
-            if nnum < 10**6:
+            if nnum < 10 ** 6:
                 return next
             ctext = "eine"
 
         if nnum > cnum:
-            if nnum >= 10**6:
+            if nnum >= 10 ** 6:
                 if cnum > 1:
                     if ntext.endswith("e"):
                         ntext += "n"
@@ -85,7 +88,7 @@ class Num2Word_DE(Num2Word_EU):
                 if nnum == 1:
                     ntext = "ein"
                 ntext, ctext = ctext, ntext + "und"
-            elif cnum >= 10**6:
+            elif cnum >= 10 ** 6:
                 ctext += " "
             val = cnum + nnum
 
@@ -108,15 +111,16 @@ class Num2Word_DE(Num2Word_EU):
     def to_currency(self, val, longval=True, old=False):
         if old:
             return self.to_splitnum(val, hightxt="mark/s", lowtxt="pfennig/e",
-                                    jointxt="und",longval=longval)
+                                    jointxt="und", longval=longval)
         return super(Num2Word_DE, self).to_currency(val, jointxt="und",
                                                     longval=longval)
 
     def to_year(self, val, longval=True):
-        if not (val//100)%10:
+        if not (val // 100) % 10:
             return self.to_cardinal(val)
         return self.to_splitnum(val, hightxt="hundert", longval=longval)
 
+
 n2w = Num2Word_DE()
 to_card = n2w.to_cardinal
 to_ord = n2w.to_ordinal
@@ -125,9 +129,9 @@ to_ordnum = n2w.to_ordinal_num
 
 def main():
     for val in [1, 7, 8, 12, 17, 81, 91, 99, 100, 101, 102, 155,
-             180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000,
-             8280, 8291, 150000, 500000, 3000000, 1000000, 2000001, 1000000000, 2000000000,
-             -21212121211221211111, -2.121212, -1.0000100]:
+                180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000,
+                8280, 8291, 150000, 500000, 3000000, 1000000, 2000001, 1000000000, 2000000000,
+                -21212121211221211111, -2.121212, -1.0000100]:
         n2w.test(val)
 
     # n2w.test(1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
@@ -139,6 +143,6 @@ def main():
     print(n2w.to_year(1820))
     print(n2w.to_year(2001))
 
+
 if __name__ == "__main__":
     main()
-

num2words/lang_DK.py

@@ -20,10 +20,10 @@ from num2words import lang_EU
 
 class Num2Word_DK(lang_EU.Num2Word_EU):
     def set_high_numwords(self, high):
-        max = 3 + 6*len(high)
+        max = 3 + 6 * len(high)
         for word, n in zip(high, range(max, 3, -6)):
-            self.cards[10**n] = word + "illarder"
-            self.cards[10**(n-3)] = word + "illioner"
+            self.cards[10 ** n] = word + "illarder"
+            self.cards[10 ** (n - 3)] = word + "illioner"
 
     def setup(self):
         self.negword = "minus "
@@ -40,27 +40,27 @@ class Num2Word_DK(lang_EU.Num2Word_EU):
                              "tolv", "elleve", "ti", "ni", "otte",
                              "syv", "seks", "fem", "fire", "tre", "to",
                              "et", "nul"]
-        self.ords = { "nul"   : "nul",
-                      "et"    : "f\xf8rste",
-                      "to"    : "anden",
-                      "tre"  : "tredje",
-                      "fire" : "fjerde",
-                      "fem"   : "femte",
-                      "seks" : "sjette",
-                      "syv" : "syvende",
-                      "otte" : "ottende",
-                      "ni" : "niende",
-                      "ti" : "tiende",
-                      "elleve" : "ellevte",
-                      "tolv" : "tolvte",
-                      "tretten" : "trett",
-                      "fjorten" : "fjort",
-                      "femten" : "femt",
-                      "seksten" : "sekst",
-                      "sytten"  : "sytt",
-                      "atten" : "att",
-                      "nitten" : "nitt",
-                      "tyve" : "tyv"}
+        self.ords = {"nul": "nul",
+                     "et": "f\xf8rste",
+                     "to": "anden",
+                     "tre": "tredje",
+                     "fire": "fjerde",
+                     "fem": "femte",
+                     "seks": "sjette",
+                     "syv": "syvende",
+                     "otte": "ottende",
+                     "ni": "niende",
+                     "ti": "tiende",
+                     "elleve": "ellevte",
+                     "tolv": "tolvte",
+                     "tretten": "trett",
+                     "fjorten": "fjort",
+                     "femten": "femt",
+                     "seksten": "sekst",
+                     "sytten": "sytt",
+                     "atten": "att",
+                     "nitten": "nitt",
+                     "tyve": "tyv"}
 
     def merge(self, curr, next):
         ctext, cnum, ntext, nnum = curr + next
@@ -70,11 +70,11 @@ class Num2Word_DK(lang_EU.Num2Word_EU):
             next = tuple(lst)
 
         if cnum == 1:
-            if nnum < 10**6 or self.ordflag:
+            if nnum < 10 ** 6 or self.ordflag:
                 return next
             ctext = "en"
         if nnum > cnum:
-            if nnum >= 10**6:
+            if nnum >= 10 ** 6:
                 ctext += " "
             val = cnum * nnum
         else:
@@ -85,14 +85,13 @@ class Num2Word_DK(lang_EU.Num2Word_EU):
             if nnum < 10 < cnum < 100:
                 if nnum == 1:
                     ntext = "en"
-                ntext, ctext =  ctext, ntext + "og"
-            elif cnum >= 10**6:
+                ntext, ctext = ctext, ntext + "og"
+            elif cnum >= 10 ** 6:
                 ctext += " "
             val = cnum + nnum
         word = ctext + ntext
         return (word, val)
 
-
     def to_ordinal(self, value):
         self.verify_ordinal(value)
         self.ordflag = True
@@ -102,37 +101,37 @@ class Num2Word_DK(lang_EU.Num2Word_EU):
             if outword.endswith(key):
                 outword = outword[:len(outword) - len(key)] + self.ords[key]
                 break
-        if value %100 >= 30 and value %100 <= 39 or value %100 == 0:
+        if value % 100 >= 30 and value % 100 <= 39 or value % 100 == 0:
             outword += "te"
-        elif value % 100 > 12 or value %100 == 0:
+        elif value % 100 > 12 or value % 100 == 0:
             outword += "ende"
         return outword
 
     def to_ordinal_num(self, value):
         self.verify_ordinal(value)
-        vaerdte = (0,1,5,6,11,12)
-        if value %100 >= 30 and value %100 <= 39 or value % 100 in vaerdte:
+        vaerdte = (0, 1, 5, 6, 11, 12)
+        if value % 100 >= 30 and value % 100 <= 39 or value % 100 in vaerdte:
             return str(value) + "te"
         elif value % 100 == 2:
             return str(value) + "en"
         return str(value) + "ende"
 
-
     def to_currency(self, val, longval=True):
-        if val//100 == 1 or val == 1:
-             ret = self.to_splitnum(val, hightxt="kr", lowtxt="\xf8re",
-                                    jointxt="og",longval=longval)
-             return "en " + ret[3:]
+        if val // 100 == 1 or val == 1:
+            ret = self.to_splitnum(val, hightxt="kr", lowtxt="\xf8re",
+                                   jointxt="og", longval=longval)
+            return "en " + ret[3:]
         return self.to_splitnum(val, hightxt="kr", lowtxt="\xf8re",
-                                    jointxt="og",longval=longval)
+                                jointxt="og", longval=longval)
 
     def to_year(self, val, longval=True):
         if val == 1:
             return 'en'
-        if not (val//100)%10:
+        if not (val // 100) % 10:
             return self.to_cardinal(val)
         return self.to_splitnum(val, hightxt="hundrede", longval=longval)
 
+
 n2w = Num2Word_DK()
 to_card = n2w.to_cardinal
 to_ord = n2w.to_ordinal
@@ -141,16 +140,18 @@ to_year = n2w.to_year
 
 
 def main():
-    for val in [ 1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155,
-             180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000,
-             8280, 8291, 150000, 500000, 1000000, 2000000, 2000001,
-             -21212121211221211111, -2.121212, -1.0000100]:
+    for val in [1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155,
+                180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000,
+                8280, 8291, 150000, 500000, 1000000, 2000000, 2000001,
+                -21212121211221211111, -2.121212, -1.0000100]:
         n2w.test(val)
-    n2w.test(1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
-    for val in [1,120, 160, 1000,1120,1800, 1976,2000,2010,2099,2171]:
+    n2w.test(
+        1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
+    for val in [1, 120, 160, 1000, 1120, 1800, 1976, 2000, 2010, 2099, 2171]:
         print(val, "er", n2w.to_currency(val))
         print(val, "er", n2w.to_year(val))
     n2w.test(65132)
 
+
 if __name__ == "__main__":
     main()

num2words/lang_EN.py

@@ -20,9 +20,9 @@ from . import lang_EU
 
 class Num2Word_EN(lang_EU.Num2Word_EU):
     def set_high_numwords(self, high):
-        max = 3 + 3*len(high)
+        max = 3 + 3 * len(high)
         for word, n in zip(high, range(max, 3, -3)):
-            self.cards[10**n] = word + "illion"
+            self.cards[10 ** n] = word + "illion"
 
     def setup(self):
         self.negword = "minus "
@@ -39,28 +39,26 @@ class Num2Word_EN(lang_EU.Num2Word_EU):
                              "twelve", "eleven", "ten", "nine", "eight",
                              "seven", "six", "five", "four", "three", "two",
                              "one", "zero"]
-        self.ords = { "one"    : "first",
-                      "two"    : "second",
-                      "three"  : "third",
-                      "five"   : "fifth",
-                      "eight"  : "eighth",
-                      "nine"   : "ninth",
-                      "twelve" : "twelfth" }
-
+        self.ords = {"one": "first",
+                     "two": "second",
+                     "three": "third",
+                     "five": "fifth",
+                     "eight": "eighth",
+                     "nine": "ninth",
+                     "twelve": "twelfth"}
 
     def merge(self, lpair, rpair):
         ltext, lnum = lpair
         rtext, rnum = rpair
         if lnum == 1 and rnum < 100:
             return (rtext, rnum)
-        elif 100 > lnum > rnum :
-            return ("%s-%s"%(ltext, rtext), lnum + rnum)
+        elif 100 > lnum > rnum:
+            return ("%s-%s" % (ltext, rtext), lnum + rnum)
         elif lnum >= 100 > rnum:
-            return ("%s and %s"%(ltext, rtext), lnum + rnum)
+            return ("%s and %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)
@@ -77,21 +75,19 @@ class Num2Word_EN(lang_EU.Num2Word_EU):
         outwords[-1] = "-".join(lastwords)
         return " ".join(outwords)
 
-
     def to_ordinal_num(self, value):
         self.verify_ordinal(value)
-        return "%s%s"%(value, self.to_ordinal(value)[-2:])
-
+        return "%s%s" % (value, self.to_ordinal(value)[-2:])
 
     def to_year(self, val, longval=True):
-        if not (val//100)%10:
+        if not (val // 100) % 10:
             return self.to_cardinal(val)
         return self.to_splitnum(val, hightxt="hundred", jointxt="and",
                                 longval=longval)
 
     def to_currency(self, val, longval=True):
         return self.to_splitnum(val, hightxt="dollar/s", lowtxt="cent/s",
-                                jointxt="and", longval=longval, cents = True)
+                                jointxt="and", longval=longval, cents=True)
 
 
 n2w = Num2Word_EN()
@@ -102,13 +98,14 @@ to_year = n2w.to_year
 
 
 def main():
-    for val in [ 1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155,
-             180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000,
-             8280, 8291, 150000, 500000, 1000000, 2000000, 2000001,
-             -21212121211221211111, -2.121212, -1.0000100]:
+    for val in [1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155,
+                180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000,
+                8280, 8291, 150000, 500000, 1000000, 2000000, 2000001,
+                -21212121211221211111, -2.121212, -1.0000100]:
         n2w.test(val)
-    n2w.test(1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
-    for val in [1,120,1000,1120,1800, 1976,2000,2010,2099,2171]:
+    n2w.test(
+        1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
+    for val in [1, 120, 1000, 1120, 1800, 1976, 2000, 2010, 2099, 2171]:
         print(val, "is", n2w.to_currency(val))
         print(val, "is", n2w.to_year(val))
 

num2words/lang_EN_EUR.py

@@ -17,10 +17,11 @@
 from __future__ import unicode_literals, print_function
 from .lang_EN import Num2Word_EN
 
+
 class Num2Word_EN_EUR(Num2Word_EN):
     def to_currency(self, val, longval=True, cents=True, jointxt="and"):
         return self.to_splitnum(val, hightxt="euro/s", lowtxt="cents",
-                                jointxt=jointxt, longval=longval, cents = cents)
+                                jointxt=jointxt, longval=longval, cents=cents)
 
 
 n2w = Num2Word_EN_EUR()
@@ -30,16 +31,18 @@ to_ordnum = n2w.to_ordinal_num
 to_year = n2w.to_year
 to_currency = n2w.to_currency
 
+
 def main():
-    for val in [ 1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155,
-             180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000,
-             8280, 8291, 150000, 500000, 1000000, 2000000, 2000001,
-             -21212121211221211111, -2.121212, -1.0000100]:
+    for val in [1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155,
+                180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000,
+                8280, 8291, 150000, 500000, 1000000, 2000000, 2000001,
+                -21212121211221211111, -2.121212, -1.0000100]:
         n2w.test(val)
-    n2w.test(1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
-    for val in [1,120,1000,1120,1800, 1976,2000,2010,2099,2171]:
-        print (val, "is", n2w.to_currency(val))
-        print (val, "is", n2w.to_year(val))
+    n2w.test(
+        1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
+    for val in [1, 120, 1000, 1120, 1800, 1976, 2000, 2010, 2099, 2171]:
+        print(val, "is", n2w.to_currency(val))
+        print(val, "is", n2w.to_year(val))
 
 
 if __name__ == "__main__":

num2words/lang_EN_GB.py

@@ -30,14 +30,16 @@ to_ord = n2w.to_ordinal
 to_ordnum = n2w.to_ordinal_num
 to_year = n2w.to_year
 
+
 def main():
-    for val in [ 1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155,
-             180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000,
-             8280, 8291, 150000, 500000, 1000000, 2000000, 2000001,
-             -21212121211221211111, -2.121212, -1.0000100]:
+    for val in [1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155,
+                180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000,
+                8280, 8291, 150000, 500000, 1000000, 2000000, 2000001,
+                -21212121211221211111, -2.121212, -1.0000100]:
         n2w.test(val)
-    n2w.test(1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
-    for val in [1,120,1000,1120,1800, 1976,2000,2010,2099,2171]:
+    n2w.test(
+        1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
+    for val in [1, 120, 1000, 1120, 1800, 1976, 2000, 2010, 2099, 2171]:
         print(val, "is", n2w.to_currency(val))
         print(val, "is", n2w.to_year(val))
 

num2words/lang_EN_GB_old.py

@@ -17,6 +17,7 @@
 from __future__ import unicode_literals, print_function
 from .lang_EN_GB import Num2Word_EN_GB
 
+
 class Num2Word_EN_GB_old(Num2Word_EN_GB):
     def base_setup(self):
         sclass = super(Num2Word_EN_GB, self)
@@ -29,17 +30,20 @@ to_card = n2w.to_cardinal
 to_ord = n2w.to_ordinal
 to_ordnum = n2w.to_ordinal_num
 
+
 def main():
-    for val in [ 1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155,
-             180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000,
-             8280, 8291, 150000, 500000, 1000000, 2000000, 2000001,
-             -21212121211221211111, -2.121212, -1.0000100]:
+    for val in [1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155,
+                180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000,
+                8280, 8291, 150000, 500000, 1000000, 2000000, 2000001,
+                -21212121211221211111, -2.121212, -1.0000100]:
         n2w.test(val)
 
-    n2w.test(1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
-    for val in [1,120,1000,1120,1800, 1976,2000,2010,2099,2171]:
-        print (val, "is", n2w.to_currency(val))
-        print (val, "is", n2w.to_year(val))
+    n2w.test(
+        1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
+    for val in [1, 120, 1000, 1120, 1800, 1976, 2000, 2010, 2099, 2171]:
+        print(val, "is", n2w.to_currency(val))
+        print(val, "is", n2w.to_year(val))
+
 
 if __name__ == "__main__":
     main()

num2words/lang_EN_IN.py

@@ -17,10 +17,11 @@
 from __future__ import unicode_literals
 from .lang_EN import Num2Word_EN
 
+
 class Num2Word_EN_IN(Num2Word_EN):
     def set_high_numwords(self, high):
-        self.cards[10**7] = "crore"
-        self.cards[10**5] = "lakh"
+        self.cards[10 ** 7] = "crore"
+        self.cards[10 ** 5] = "lakh"
 
 
 n2w = Num2Word_EN_IN()
@@ -28,15 +29,17 @@ to_card = n2w.to_cardinal
 to_ord = n2w.to_ordinal
 to_ordnum = n2w.to_ordinal_num
 
+
 def main():
     for val in (15000,
-            15*10**5,
-            15*10**6,
-            15*10**7,
-            15*10**8,
-            15*10**9,
-            15*10**10):
+                15 * 10 ** 5,
+                15 * 10 ** 6,
+                15 * 10 ** 7,
+                15 * 10 ** 8,
+                15 * 10 ** 9,
+                15 * 10 ** 10):
         n2w.test(val)
 
+
 if __name__ == "__main__":
     main()

num2words/lang_ES.py

@@ -21,13 +21,12 @@ from .lang_EU import Num2Word_EU
 
 
 class Num2Word_ES(Num2Word_EU):
-
     # //CHECK: Is this sufficient??
     def set_high_numwords(self, high):
-        max = 3 + 6*len(high)
+        max = 3 + 6 * len(high)
 
         for word, n in zip(high, range(max, 3, -6)):
-            self.cards[10**(n-3)] = word + "illón"
+            self.cards[10 ** (n - 3)] = word + "illón"
 
     def setup(self):
         lows = ["cuatr", "tr", "b", "m"]
@@ -48,38 +47,38 @@ class Num2Word_ES(Num2Word_EU):
                              "dieciseis", "quince", "catorce", "trece", "doce",
                              "once", "diez", "nueve", "ocho", "siete", "seis",
                              "cinco", "cuatro", "tres", "dos", "uno", "cero"]
-        self.ords = { 1 : "primer",
-                      2 : "segund",
-                      3 : "tercer",
-                      4 : "cuart",
-                      5 : "quint",
-                      6 : "sext",
-                      7 : "séptim",
-                      8 : "octav",
-                      9 : "noven",
-                     10 : "décim",
-                     20 : "vigésim",
-                     30 : "trigésim",
-                     40 : "quadragésim",
-                     50 : "quincuagésim",
-                     60 : "sexagésim",
-                     70 : "septuagésim",
-                     80 : "octogésim",
-                     90 : "nonagésim",
-                    100 : "centésim",
-                    200 : "ducentésim",
-                    300 : "tricentésim",
-                    400 : "cuadrigentésim",
-                    500 : "quingentésim",
-                    600 : "sexcentésim",
-                    700 : "septigentésim",
-                    800 : "octigentésim",
-                    900 : "noningentésim",
-                    1e3 : "milésim",
-                    1e6 : "millonésim",
-                    1e9 : "billonésim",
-                   1e12 : "trillonésim",
-                   1e15 : "cuadrillonésim" }
+        self.ords = {1: "primer",
+                     2: "segund",
+                     3: "tercer",
+                     4: "cuart",
+                     5: "quint",
+                     6: "sext",
+                     7: "séptim",
+                     8: "octav",
+                     9: "noven",
+                     10: "décim",
+                     20: "vigésim",
+                     30: "trigésim",
+                     40: "quadragésim",
+                     50: "quincuagésim",
+                     60: "sexagésim",
+                     70: "septuagésim",
+                     80: "octogésim",
+                     90: "nonagésim",
+                     100: "centésim",
+                     200: "ducentésim",
+                     300: "tricentésim",
+                     400: "cuadrigentésim",
+                     500: "quingentésim",
+                     600: "sexcentésim",
+                     700: "septigentésim",
+                     800: "octigentésim",
+                     900: "noningentésim",
+                     1e3: "milésim",
+                     1e6: "millonésim",
+                     1e9: "billonésim",
+                     1e12: "trillonésim",
+                     1e15: "cuadrillonésim"}
 
     def merge(self, curr, next):
         ctext, cnum, ntext, nnum = curr + next
@@ -93,8 +92,8 @@ class Num2Word_ES(Num2Word_EU):
 
         if nnum < cnum:
             if cnum < 100:
-                return "%s y %s"%(ctext, ntext), cnum + nnum
-            return "%s %s"%(ctext, ntext), cnum + nnum
+                return "%s y %s" % (ctext, ntext), cnum + nnum
+            return "%s %s" % (ctext, ntext), cnum + nnum
         elif (not nnum % 1000000) and cnum > 1:
             ntext = ntext[:-3] + "lones"
 
@@ -170,10 +169,12 @@ def main():
                 -21212121211221211111, -2.121212, -1.0000100]:
         n2w.test(val)
 
-    n2w.test(1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
+    n2w.test(
+        1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
     print(n2w.to_currency(1222))
     print(n2w.to_currency(1222, old=True))
     print(n2w.to_year(1222))
 
+
 if __name__ == "__main__":
     main()

num2words/lang_EU.py

@@ -17,24 +17,23 @@
 from __future__ import unicode_literals
 from .base import Num2Word_Base
 
+
 class Num2Word_EU(Num2Word_Base):
     def set_high_numwords(self, high):
-        max = 3 + 6*len(high)
+        max = 3 + 6 * len(high)
 
         for word, n in zip(high, range(max, 3, -6)):
-            self.cards[10**n] = word + "illiard"
-            self.cards[10**(n-3)] = word + "illion"
-
+            self.cards[10 ** n] = word + "illiard"
+            self.cards[10 ** (n - 3)] = word + "illion"
 
     def base_setup(self):
-        lows = ["non","oct","sept","sext","quint","quadr","tr","b","m"]
+        lows = ["non", "oct", "sept", "sext", "quint", "quadr", "tr", "b", "m"]
         units = ["", "un", "duo", "tre", "quattuor", "quin", "sex", "sept",
                  "octo", "novem"]
         tens = ["dec", "vigint", "trigint", "quadragint", "quinquagint",
                 "sexagint", "septuagint", "octogint", "nonagint"]
-        self.high_numwords = ["cent"]+self.gen_high_numwords(units, tens, lows)
+        self.high_numwords = ["cent"] + self.gen_high_numwords(units, tens, lows)
 
     def to_currency(self, val, longval=True, jointxt=""):
         return self.to_splitnum(val, hightxt="Euro/s", lowtxt="Euro cent/s",
                                 jointxt=jointxt, longval=longval)
-

num2words/lang_FR.py

@@ -41,7 +41,6 @@ class Num2Word_FR(Num2Word_EU):
             "neuf": "neuvième",
         }
 
-
     def merge(self, curr, next):
         ctext, cnum, ntext, nnum = curr + next
 
@@ -49,24 +48,23 @@ class Num2Word_FR(Num2Word_EU):
             if nnum < 1000000:
                 return next
         else:
-            if (not (cnum - 80)%100 or not cnum%100) and ctext[-1] == "s":
+            if (not (cnum - 80) % 100 or not cnum % 100) and ctext[-1] == "s":
                 ctext = ctext[:-1]
             if cnum < 1000 and nnum != 1000 and ntext[-1] != "s" and not nnum % 100:
                 ntext += "s"
 
         if nnum < cnum < 100:
             if nnum % 10 == 1 and cnum != 80:
-                return ("%s et %s"%(ctext, ntext), cnum + nnum)
-            return ("%s-%s"%(ctext, ntext), cnum + nnum)
+                return ("%s et %s" % (ctext, ntext), cnum + nnum)
+            return ("%s-%s" % (ctext, ntext), cnum + nnum)
         if nnum > cnum:
-            return ("%s %s"%(ctext, ntext), cnum * nnum)
-        return ("%s %s"%(ctext, ntext), cnum + nnum)
-
+            return ("%s %s" % (ctext, ntext), cnum * nnum)
+        return ("%s %s" % (ctext, ntext), cnum + nnum)
 
     # Is this right for such things as 1001 - "mille unième" instead of
     # "mille premier"??  "millième"??
 
-    def to_ordinal(self,value):
+    def to_ordinal(self, value):
         self.verify_ordinal(value)
         if value == 1:
             return "premier"
@@ -84,7 +82,7 @@ class Num2Word_FR(Num2Word_EU):
     def to_ordinal_num(self, value):
         self.verify_ordinal(value)
         out = str(value)
-        out += {"1" : "er"}.get(out[-1], "me")
+        out += {"1": "er"}.get(out[-1], "me")
         return out
 
     def to_currency(self, val, longval=True, old=False):
@@ -94,11 +92,13 @@ class Num2Word_FR(Num2Word_EU):
         return self.to_splitnum(val, hightxt=hightxt, lowtxt="centime/s",
                                 jointxt="et", longval=longval)
 
+
 n2w = Num2Word_FR()
 to_card = n2w.to_cardinal
 to_ord = n2w.to_ordinal
 to_ordnum = n2w.to_ordinal_num
 
+
 def main():
     for val in [1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155,
                 180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000,
@@ -106,7 +106,8 @@ def main():
                 -21212121211221211111, -2.121212, -1.0000100]:
         n2w.test(val)
 
-    n2w.test(1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
+    n2w.test(
+        1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
     print(n2w.to_currency(112121))
     print(n2w.to_year(1996))
 

num2words/lang_FR_CH.py

@@ -28,7 +28,6 @@ class Num2Word_FR_CH(Num2Word_FR):
                              (50, "cinquante"), (40, "quarante"),
                              (30, "trente")]
 
-
     def merge(self, curr, next):
         ctext, cnum, ntext, nnum = curr + next
 
@@ -41,11 +40,11 @@ class Num2Word_FR_CH(Num2Word_FR):
 
         if nnum < cnum < 100:
             if nnum % 10 == 1:
-                return ("%s et %s"%(ctext, ntext), cnum + nnum)
-            return ("%s-%s"%(ctext, ntext), cnum + nnum)
+                return ("%s et %s" % (ctext, ntext), cnum + nnum)
+            return ("%s-%s" % (ctext, ntext), cnum + nnum)
         if nnum > cnum:
-            return ("%s %s"%(ctext, ntext), cnum * nnum)
-        return ("%s %s"%(ctext, ntext), cnum + nnum)
+            return ("%s %s" % (ctext, ntext), cnum * nnum)
+        return ("%s %s" % (ctext, ntext), cnum + nnum)
 
 
 n2w = Num2Word_FR_CH()
@@ -53,6 +52,7 @@ to_card = n2w.to_cardinal
 to_ord = n2w.to_ordinal
 to_ordnum = n2w.to_ordinal_num
 
+
 def main():
     for val in [1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155,
                 180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000,
@@ -60,7 +60,8 @@ def main():
                 -21212121211221211111, -2.121212, -1.0000100]:
         n2w.test(val)
 
-    n2w.test(1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
+    n2w.test(
+        1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
     print(n2w.to_currency(112121))
     print(n2w.to_year(1996))
 

num2words/lang_FR_DZ.py

@@ -31,6 +31,7 @@ to_ordnum = n2w.to_ordinal_num
 to_year = n2w.to_year
 to_currency = n2w.to_currency
 
+
 def main():
     for val in [1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155,
                 180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000,
@@ -38,7 +39,8 @@ def main():
                 -21212121211221211111, -2.121212, -1.0000100]:
         n2w.test(val)
 
-    n2w.test(1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
+    n2w.test(
+        1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
     for val in [1, 120, 1000, 1120, 1800, 1976, 2000, 2010, 2099, 2171]:
         print(val, "is", n2w.to_currency(val))
         print(val, "is", n2w.to_year(val))

num2words/lang_HE.py

@@ -69,6 +69,7 @@ THOUSANDS = {
 
 AND = u'ו'
 
+
 def splitby3(n):
     length = len(n)
     if length > 3:
@@ -76,7 +77,7 @@ def splitby3(n):
         if start > 0:
             yield int(n[:start])
         for i in range(start, length, 3):
-            yield int(n[i:i+3])
+            yield int(n[i:i + 3])
     else:
         yield int(n)
 
@@ -95,7 +96,7 @@ def pluralize(n, forms):
 
 
 def int2word(n):
-    if n > 9999: # doesn't yet work for numbers this big
+    if n > 9999:  # doesn't yet work for numbers this big
         raise NotImplementedError()
 
     if n == 0:
@@ -159,4 +160,3 @@ if __name__ == '__main__':
     nums = [1, 11, 21, 24, 99, 100, 101, 200, 211, 345, 1000, 1011]
     for num in nums:
         print(num, yo.to_cardinal(num))
-

num2words/lang_ID.py

@@ -16,8 +16,8 @@
 
 from __future__ import unicode_literals, print_function
 
-class Num2Word_ID():
 
+class Num2Word_ID():
     BASE = {0: [],
             1: ["satu"],
             2: ["dua"],
@@ -44,7 +44,7 @@ class Num2Word_ID():
     errmsg_floatord = "Cannot treat float number as ordinal"
     errmsg_negord = "Cannot treat negative number as ordinal"
     errmsg_toobig = "Too large"
-    max_num = 10**36
+    max_num = 10 ** 36
 
     def split_by_koma(self, number):
         return str(number).split('.')
@@ -69,7 +69,7 @@ class Num2Word_ID():
                 blocks += first_block,
 
             for i in range(len_of_first_block, length, 3):
-                next_block = (number[i:i+3],),
+                next_block = (number[i:i + 3],),
                 blocks += next_block
 
         return blocks
@@ -109,21 +109,21 @@ class Num2Word_ID():
         elif number == '0':
             return []
         else:
-            return self.BASE[int(number)]+['ratus']
+            return self.BASE[int(number)] + ['ratus']
 
     def puluh(self, number):
         # it is used to spell
         if number[0] == '1':
-            if number[1]== '0':
+            if number[1] == '0':
                 return ['sepuluh']
             elif number[1] == '1':
                 return ['sebelas']
             else:
-                return self.BASE[int(number[1])]+['belas']
+                return self.BASE[int(number[1])] + ['belas']
         elif number[0] == '0':
             return self.BASE[int(number[1])]
         else:
-            return self.BASE[int(number[0])]+['puluh']+ self.BASE[int(number[1])]
+            return self.BASE[int(number[0])] + ['puluh'] + self.BASE[int(number[1])]
 
     def spell_float(self, float_part):
         # spell the float number
@@ -133,7 +133,7 @@ class Num2Word_ID():
                 word_list += ['nol']
                 continue
             word_list += self.BASE[int(n)]
-        return ' '.join(['','koma']+word_list)
+        return ' '.join(['', 'koma'] + word_list)
 
     def join(self, word_blocks, float_part):
         """
@@ -142,7 +142,7 @@ class Num2Word_ID():
         :rtype: str
         """
         word_list = []
-        length = len(word_blocks)-1
+        length = len(word_blocks) - 1
         first_block = word_blocks[0],
         start = 0
 
@@ -150,15 +150,15 @@ class Num2Word_ID():
             word_list += ['seribu']
             start = 1
 
-        for i in range(start, length+1, 1):
+        for i in range(start, length + 1, 1):
             word_list += word_blocks[i][1]
             if not word_blocks[i][1]:
                 continue
             if i == length:
                 break
-            word_list += [self.TENS_TO[(length-i)*3]]
+            word_list += [self.TENS_TO[(length - i) * 3]]
 
-        return ' '.join(word_list)+float_part
+        return ' '.join(word_list) + float_part
 
     def to_cardinal(self, number):
         if number >= self.max_num:
@@ -168,7 +168,7 @@ class Num2Word_ID():
             minus = 'min '
         float_word = ''
         n = self.split_by_koma(abs(number))
-        if len(n)==2:
+        if len(n) == 2:
             float_word = self.spell_float(n[1])
         return minus + self.join(self.spell(self.split_by_3(n[0])), float_word)
 
@@ -184,7 +184,7 @@ class Num2Word_ID():
         return "ke-" + str(number)
 
     def to_currency(self, value):
-        return self.to_cardinal(value)+" rupiah"
+        return self.to_cardinal(value) + " rupiah"
 
     def to_year(self, value):
         return self.to_cardinal(value)

num2words/lang_IT.py

@@ -42,16 +42,18 @@ EXPONENT_PREFIXES = [
     ZERO, "m", "b", "tr", "quadr", "quint", "sest", "sett", "ott", "nov", "dec"
 ]
 
+
 # Utils
 # =====
 
 def phonetic_contraction(string):
     return (string
-        .replace("oo", "o") # ex. "centootto"
-        .replace("ao", "o") # ex. "settantaotto"
-        .replace("io", "o") # ex. "ventiotto"
-        .replace("au", "u") # ex. "trentauno"
-    )
+            .replace("oo", "o")  # ex. "centootto"
+            .replace("ao", "o")  # ex. "settantaotto"
+            .replace("io", "o")  # ex. "ventiotto"
+            .replace("au", "u")  # ex. "trentauno"
+            )
+
 
 def exponent_length_to_string(exponent_length):
     # We always assume `exponent` to be a multiple of 3. If it's not true, then
@@ -62,6 +64,7 @@ def exponent_length_to_string(exponent_length):
     else:
         return prefix + "iliardo"
 
+
 def accentuate(string):
     # This is inefficient: it may do several rewritings when deleting
     # half-sentence accents. However, it is the easiest method and speed is
@@ -69,23 +72,24 @@ def accentuate(string):
     return " ".join(
         # Deletes half-sentence accents and accentuates the last "tre"
         [w.replace("tré", "tre")[:-3] + "tré"
-            # We shouldn't accentuate a single "tre": is has to be a composite
-            # word.                ~~~~~~~~~~
-            if w[-3:] == "tre" and len(w) > 3
-            # Deletes half-sentence accents anyway
-            #     ~~~~~~~~~~~~~~~~~~~~~~
-            else w.replace("tré", "tre")
-            for w in string.split()
-        ])
+         # We shouldn't accentuate a single "tre": is has to be a composite
+         # word.                ~~~~~~~~~~
+         if w[-3:] == "tre" and len(w) > 3
+         # Deletes half-sentence accents anyway
+         #     ~~~~~~~~~~~~~~~~~~~~~~
+         else w.replace("tré", "tre")
+         for w in string.split()
+         ])
+
 
 def omitt_if_zero(number_to_string):
     return "" if number_to_string == ZERO else number_to_string
 
+
 # Main class
 # ==========
 
 class Num2Word_IT:
-
     MINUS_PREFIX_WORD = "meno "
     FLOAT_INFIX_WORD = " virgola "
 

num2words/lang_LT.py

@@ -153,6 +153,7 @@ CURRENCIES = {
     'EUR': ((u'euras', u'eurai', u'eurų'), (u'centas', u'centai', u'centų')),
 }
 
+
 def splitby3(n):
     length = len(n)
     if length > 3:
@@ -160,7 +161,7 @@ def splitby3(n):
         if start > 0:
             yield int(n[:start])
         for i in range(start, length, 3):
-            yield int(n[i:i+3])
+            yield int(n[i:i + 3])
     else:
         yield int(n)
 
@@ -168,6 +169,7 @@ def splitby3(n):
 def get_digits(n):
     return [int(x) for x in reversed(list(('%03d' % n)[-3:]))]
 
+
 def pluralize(n, forms):
     n1, n2, n3 = get_digits(n)
     if n2 == 1 or n1 == 0 or n == 0:
@@ -177,6 +179,7 @@ def pluralize(n, forms):
     else:
         return forms[1]
 
+
 def int2word(n):
     if n == 0:
         return ZERO[0]
@@ -209,6 +212,7 @@ def int2word(n):
 
     return ' '.join(words)
 
+
 def n2w(n):
     n = str(n).replace(',', '.')
     if '.' in n:
@@ -217,7 +221,8 @@ def n2w(n):
     else:
         return int2word(int(n))
 
-def to_currency(n, currency='EUR', cents = True):
+
+def to_currency(n, currency='EUR', cents=True):
     if type(n) == int:
         if n < 0:
             minus = True
@@ -248,7 +253,8 @@ def to_currency(n, currency='EUR', cents = True):
         cents_str = "%02d" % right
 
     return u'%s%s %s, %s %s' % (minus_str, int2word(left), pluralize(left, cr1),
-                              cents_str, pluralize(right, cr2))
+                                cents_str, pluralize(right, cr2))
+
 
 class Num2Word_LT(object):
     def to_cardinal(self, number):
@@ -257,6 +263,8 @@ class Num2Word_LT(object):
     def to_ordinal(self, number):
         raise NotImplementedError()
 
+
 if __name__ == '__main__':
     import doctest
+
     doctest.testmod()

num2words/lang_NL.py

@@ -21,19 +21,22 @@ from .lang_EU import Num2Word_EU
 
 class Num2Word_NL(Num2Word_EU):
     def set_high_numwords(self, high):
-        max = 3 + 6*len(high)
+        max = 3 + 6 * len(high)
 
         for word, n in zip(high, range(max, 3, -6)):
-            self.cards[10**n] = word + "iljard"
-            self.cards[10**(n-3)] = word + "iljoen"
+            self.cards[10 ** n] = word + "iljard"
+            self.cards[10 ** (n - 3)] = word + "iljoen"
 
     def setup(self):
         self.negword = "min "
         self.pointword = "komma"
-        self.errmsg_floatord = "Het zwevende puntnummer %s kan niet omgezet worden naar een ordernummer." # "Cannot treat float %s as ordinal."
-        self.errmsg_nonnum = "Alleen nummers (type (%s)) kunnen naar woorden omgezet worden." # "type(((type(%s)) ) not in [long, int, float]"
-        self.errmsg_negord = "Het negatieve getal %s kan niet omgezet worden naar een ordernummer." # "Cannot treat negative num %s as ordinal."
-        self.errmsg_toobig = "Het getal %s moet minder zijn dan %s." # "abs(%s) must be less than %s."
+        # "Cannot treat float %s as ordinal."
+        self.errmsg_floatord = "Het zwevende puntnummer %s kan niet omgezet worden naar een ordernummer."
+        # "type(((type(%s)) ) not in [long, int, float]"
+        self.errmsg_nonnum = "Alleen nummers (type (%s)) kunnen naar woorden omgezet worden."
+        # "Cannot treat negative num %s as ordinal."
+        self.errmsg_negord = "Het negatieve getal %s kan niet omgezet worden naar een ordernummer."
+        self.errmsg_toobig = "Het getal %s moet minder zijn dan %s."  # "abs(%s) must be less than %s."
         self.exclude_title = []
 
         lows = ["non", "okt", "sept", "sext", "quint", "quadr", "tr", "b", "m"]
@@ -42,10 +45,7 @@ class Num2Word_NL(Num2Word_EU):
         tens = ["dez", "vigint", "trigint", "quadragint", "quinquagint",
                 "sexagint", "septuagint", "oktogint", "nonagint"]
 
-
-
-
-        self.high_numwords = ["zend"]+self.gen_high_numwords(units, tens, lows)
+        self.high_numwords = ["zend"] + self.gen_high_numwords(units, tens, lows)
         self.mid_numwords = [(1000, "duizend"), (100, "honderd"),
                              (90, "negentig"), (80, "tachtig"), (70, "zeventig"),
                              (60, "zestig"), (50, "vijftig"), (40, "veertig"),
@@ -57,7 +57,7 @@ class Num2Word_NL(Num2Word_EU):
                              "nul"]
 
         self.ords = {"één": "eerst",
-                    "twee": "tweed",
+                     "twee": "tweed",
                      "drie": "derd",
                      "vier": "vierd",
                      "vijf": "vijfd",
@@ -65,9 +65,9 @@ class Num2Word_NL(Num2Word_EU):
                      "zeven": "zevend",
                      "acht": "achtst",
                      "negen": "negend",
-                     "tien":"tiend",
-                     "elf":"elfd",
-                     "twaalf":"twaalfd",
+                     "tien": "tiend",
+                     "elf": "elfd",
+                     "twaalf": "twaalfd",
 
                      "ig": "igst",
                      "erd": "erdst",
@@ -79,12 +79,12 @@ class Num2Word_NL(Num2Word_EU):
         ctext, cnum, ntext, nnum = curr + next
 
         if cnum == 1:
-            if nnum < 10**6:
+            if nnum < 10 ** 6:
                 return next
             ctext = "een"
 
         if nnum > cnum:
-            if nnum >= 10**6:
+            if nnum >= 10 ** 6:
                 ctext += " "
             val = cnum * nnum
         else:
@@ -93,11 +93,11 @@ class Num2Word_NL(Num2Word_EU):
                     ntext = "een"
 
                 if ntext.endswith("e"):
-                        ntext += "ën" # "n"
+                    ntext += "ën"  # "n"
                 else:
-                        ntext += "en"
-                ntext, ctext = ctext, ntext # + "en"
-            elif cnum >= 10**6:
+                    ntext += "en"
+                ntext, ctext = ctext, ntext  # + "en"
+            elif cnum >= 10 ** 6:
                 ctext += " "
             val = cnum + nnum
 
@@ -120,15 +120,16 @@ class Num2Word_NL(Num2Word_EU):
     def to_currency(self, val, longval=True, old=False):
         if old:
             return self.to_splitnum(val, hightxt="euro/s", lowtxt="cent/s",
-                                    jointxt="en",longval=longval)
+                                    jointxt="en", longval=longval)
         return super(Num2Word_NL, self).to_currency(val, jointxt="en",
                                                     longval=longval)
 
     def to_year(self, val, longval=True):
-        if not (val//100)%10:
+        if not (val // 100) % 10:
             return self.to_cardinal(val)
         return self.to_splitnum(val, hightxt="honderd", longval=longval)
 
+
 n2w = Num2Word_NL()
 to_card = n2w.to_cardinal
 to_ord = n2w.to_ordinal
@@ -136,10 +137,10 @@ to_ordnum = n2w.to_ordinal_num
 
 
 def main():
-    for val in [1, 7, 8, 12, 17, 62,81, 91, 99, 100, 101, 102, 155,
-             180, 300, 308, 832, 1000, 1001, 1061,1062, 1100, 1500, 1701, 3000,
-             8280, 8291, 150000, 500000, 3000000, 1000000, 2000001, 1000000000, 2000000000,
-             -21212121211221211111, -2.121212, -1.0000100]:
+    for val in [1, 7, 8, 12, 17, 62, 81, 91, 99, 100, 101, 102, 155,
+                180, 300, 308, 832, 1000, 1001, 1061, 1062, 1100, 1500, 1701, 3000,
+                8280, 8291, 150000, 500000, 3000000, 1000000, 2000001, 1000000000, 2000000000,
+                -21212121211221211111, -2.121212, -1.0000100]:
         n2w.test(val)
 
     n2w.test(3000000)
@@ -150,6 +151,6 @@ def main():
     print(n2w.to_year(1820))
     print(n2w.to_year(2001))
 
+
 if __name__ == "__main__":
     main()
-

num2words/lang_NO.py

@@ -17,12 +17,13 @@
 from __future__ import division, unicode_literals, print_function
 from . import lang_EU
 
+
 class Num2Word_NO(lang_EU.Num2Word_EU):
     def set_high_numwords(self, high):
-        max = 3 + 6*len(high)
+        max = 3 + 6 * len(high)
         for word, n in zip(high, range(max, 3, -6)):
-            self.cards[10**n] = word + "illard"
-            self.cards[10**(n-3)] = word + "illion"
+            self.cards[10 ** n] = word + "illard"
+            self.cards[10 ** (n - 3)] = word + "illion"
 
     def setup(self):
         self.negword = "minus "
@@ -39,34 +40,32 @@ class Num2Word_NO(lang_EU.Num2Word_EU):
                              "tolv", "elleve", "ti", "ni", "\xe5tte",
                              "syv", "seks", "fem", "fire", "tre", "to",
                              "en", "null"]
-        self.ords = { "en"    : "f\xf8rste",
-                      "to"    : "andre",
-                      "tre"  : "tredje",
-                      "fire" : "fjerde",
-                      "fem"   : "femte",
-                      "seks" : "sjette",
-                      "syv" : "syvende",
-                      "\xe5tte" : "\xe5ttende",
-                      "ni" : "niende",
-                      "ti" : "tiende",
-                      "elleve" : "ellevte",
-                      "tolv" : "tolvte",
-                      "tjue" : "tjuende" }
-
+        self.ords = {"en": "f\xf8rste",
+                     "to": "andre",
+                     "tre": "tredje",
+                     "fire": "fjerde",
+                     "fem": "femte",
+                     "seks": "sjette",
+                     "syv": "syvende",
+                     "\xe5tte": "\xe5ttende",
+                     "ni": "niende",
+                     "ti": "tiende",
+                     "elleve": "ellevte",
+                     "tolv": "tolvte",
+                     "tjue": "tjuende"}
 
     def merge(self, lpair, rpair):
         ltext, lnum = lpair
         rtext, rnum = rpair
         if lnum == 1 and rnum < 100:
             return (rtext, rnum)
-        elif 100 > lnum > rnum :
-            return ("%s-%s"%(ltext, rtext), lnum + rnum)
+        elif 100 > lnum > rnum:
+            return ("%s-%s" % (ltext, rtext), lnum + rnum)
         elif lnum >= 100 > rnum:
-            return ("%s og %s"%(ltext, rtext), lnum + rnum)
+            return ("%s og %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)
@@ -84,21 +83,19 @@ class Num2Word_NO(lang_EU.Num2Word_EU):
         outwords[-1] = "".join(lastwords)
         return " ".join(outwords)
 
-
     def to_ordinal_num(self, value):
         self.verify_ordinal(value)
-        return "%s%s"%(value, self.to_ordinal(value)[-2:])
-
+        return "%s%s" % (value, self.to_ordinal(value)[-2:])
 
     def to_year(self, val, longval=True):
-        if not (val//100)%10:
+        if not (val // 100) % 10:
             return self.to_cardinal(val)
         return self.to_splitnum(val, hightxt="hundre", jointxt="og",
                                 longval=longval)
 
     def to_currency(self, val, longval=True):
         return self.to_splitnum(val, hightxt="krone/r", lowtxt="\xf8re/r",
-                                jointxt="og", longval=longval, cents = True)
+                                jointxt="og", longval=longval, cents=True)
 
 
 n2w = Num2Word_NO()
@@ -107,14 +104,16 @@ to_ord = n2w.to_ordinal
 to_ordnum = n2w.to_ordinal_num
 to_year = n2w.to_year
 
+
 def main():
-    for val in [ 1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155,
-             180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000,
-             8280, 8291, 150000, 500000, 1000000, 2000000, 2000001,
-             -21212121211221211111, -2.121212, -1.0000100]:
+    for val in [1, 11, 12, 21, 31, 33, 71, 80, 81, 91, 99, 100, 101, 102, 155,
+                180, 300, 308, 832, 1000, 1001, 1061, 1100, 1500, 1701, 3000,
+                8280, 8291, 150000, 500000, 1000000, 2000000, 2000001,
+                -21212121211221211111, -2.121212, -1.0000100]:
         n2w.test(val)
-    n2w.test(1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
-    for val in [1,120,1000,1120,1800, 1976,2000,2010,2099,2171]:
+    n2w.test(
+        1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730)
+    for val in [1, 120, 1000, 1120, 1800, 1976, 2000, 2010, 2099, 2171]:
         print(val, "er", n2w.to_currency(val))
         print(val, "er", n2w.to_year(val))
 

num2words/lang_PL.py

@@ -155,16 +155,16 @@ HUNDREDS = {
 }
 
 THOUSANDS = {
-    1: (u'tysiąc', u'tysiące', u'tysięcy'), # 10^3
-    2: (u'milion', u'miliony', u'milionów'), # 10^6
-    3: (u'miliard', u'miliardy', u'miliardów'), # 10^9
-    4: (u'bilion', u'biliony', u'bilionów'), # 10^12
-    5: (u'biliard', u'biliardy', u'biliardów'), # 10^15
-    6: (u'trylion', u'tryliony', u'trylionów'), # 10^18
-    7: (u'tryliard', u'tryliardy', u'tryliardów'), # 10^21
-    8: (u'kwadrylion', u'kwadryliony', u'kwadrylionów'), # 10^24
-    9: (u'kwaryliard', u'kwadryliardy', u'kwadryliardów'), # 10^27
-    10: (u'kwintylion', u'kwintyliony', u'kwintylionów'), # 10^30
+    1: (u'tysiąc', u'tysiące', u'tysięcy'),  # 10^3
+    2: (u'milion', u'miliony', u'milionów'),  # 10^6
+    3: (u'miliard', u'miliardy', u'miliardów'),  # 10^9
+    4: (u'bilion', u'biliony', u'bilionów'),  # 10^12
+    5: (u'biliard', u'biliardy', u'biliardów'),  # 10^15
+    6: (u'trylion', u'tryliony', u'trylionów'),  # 10^18
+    7: (u'tryliard', u'tryliardy', u'tryliardów'),  # 10^21
+    8: (u'kwadrylion', u'kwadryliony', u'kwadrylionów'),  # 10^24
+    9: (u'kwaryliard', u'kwadryliardy', u'kwadryliardów'),  # 10^27
+    10: (u'kwintylion', u'kwintyliony', u'kwintylionów'),  # 10^30
 }
 
 CURRENCIES = {
@@ -235,7 +235,7 @@ def n2w(n):
         return int2word(int(n))
 
 
-def to_currency(n, currency = 'EUR', cents = True, seperator = ','):
+def to_currency(n, currency='EUR', cents=True, seperator=','):
     if type(n) == int:
         if n < 0:
             minus = True
@@ -287,4 +287,5 @@ class Num2Word_PL(object):
 
 if __name__ == '__main__':
     import doctest
+
     doctest.testmod()

num2words/lang_RU.py

@@ -166,16 +166,16 @@ HUNDREDS = {
 }
 
 THOUSANDS = {
-    1: (u'тысяча', u'тысячи', u'тысяч'), # 10^3
-    2: (u'миллион', u'миллиона', u'миллионов'), # 10^6
-    3: (u'миллиард', u'миллиарда', u'миллиардов'), # 10^9
-    4: (u'триллион', u'триллиона', u'триллионов'), # 10^12
-    5: (u'квадриллион', u'квадриллиона', u'квадриллионов'), # 10^15
-    6: (u'квинтиллион', u'квинтиллиона', u'квинтиллионов'), # 10^18
-    7: (u'секстиллион', u'секстиллиона', u'секстиллионов'), # 10^21
-    8: (u'септиллион', u'септиллиона', u'септиллионов'), # 10^24
-    9: (u'октиллион', u'октиллиона', u'октиллионов'), # 10^27
-    10: (u'нониллион', u'нониллиона', u'нониллионов'), # 10^30
+    1: (u'тысяча', u'тысячи', u'тысяч'),  # 10^3
+    2: (u'миллион', u'миллиона', u'миллионов'),  # 10^6
+    3: (u'миллиард', u'миллиарда', u'миллиардов'),  # 10^9
+    4: (u'триллион', u'триллиона', u'триллионов'),  # 10^12
+    5: (u'квадриллион', u'квадриллиона', u'квадриллионов'),  # 10^15
+    6: (u'квинтиллион', u'квинтиллиона', u'квинтиллионов'),  # 10^18
+    7: (u'секстиллион', u'секстиллиона', u'секстиллионов'),  # 10^21
+    8: (u'септиллион', u'септиллиона', u'септиллионов'),  # 10^24
+    9: (u'октиллион', u'октиллиона', u'октиллионов'),  # 10^27
+    10: (u'нониллион', u'нониллиона', u'нониллионов'),  # 10^30
 }
 
 CURRENCIES = {
@@ -195,7 +195,7 @@ def splitby3(n):
         if start > 0:
             yield int(n[:start])
         for i in range(start, length, 3):
-            yield int(n[i:i+3])
+            yield int(n[i:i + 3])
     else:
         yield int(n)
 
@@ -309,4 +309,5 @@ class Num2Word_RU(object):
 
 if __name__ == '__main__':
     import doctest
+
     doctest.testmod()

num2words/lang_TR.py

@@ -541,7 +541,8 @@ class Num2Word_TR(object):
         if not int(val) == 0:
             self.integers_to_read = [str(int(val)), float_digits[len(float_digits) - self.precision:]]
         else:
-            self.integers_to_read = ["0", "0" * (self.precision - len(float_digits)) + float_digits[len(float_digits) - self.precision:]]
+            self.integers_to_read = ["0", "0" * (self.precision - len(float_digits))
+                                     + float_digits[len(float_digits) - self.precision:]]
         if len(self.integers_to_read[0]) % 3 > 0:
             self.total_triplets_to_read = (len(self.integers_to_read[0]) // 3) + 1
         elif len(self.integers_to_read[0]) % 3 == 0:

num2words/lang_UK.py

@@ -166,16 +166,16 @@ HUNDREDS = {
 }
 
 THOUSANDS = {
-    1: (u'тисяча', u'тисячi', u'тисяч'), # 10^3
-    2: (u'мiльйон', u'мiльйони', u'мiльйонiв'), # 10^6
-    3: (u'мiльярд', u'мiльярди', u'мiльярдiв'), # 10^9
-    4: (u'трильйон', u'трильйони', u'трильйонiв'), # 10^12
-    5: (u'квадрильйон', u'квадрильйони', u'квадрильйонiв'), # 10^15
-    6: (u'квiнтильйон', u'квiнтильйони', u'квiнтильйонiв'), # 10^18
-    7: (u'секстильйон', u'секстильйони', u'секстильйонiв'), # 10^21
-    8: (u'септильйон', u'септильйони', u'септильйонiв'), # 10^24
-    9: (u'октильйон', u'октильйони', u'октильйонiв'), # 10^27
-    10: (u'нонiльйон', u'нонiльйони', u'нонiльйонiв'), # 10^30
+    1: (u'тисяча', u'тисячi', u'тисяч'),  # 10^3
+    2: (u'мiльйон', u'мiльйони', u'мiльйонiв'),  # 10^6
+    3: (u'мiльярд', u'мiльярди', u'мiльярдiв'),  # 10^9
+    4: (u'трильйон', u'трильйони', u'трильйонiв'),  # 10^12
+    5: (u'квадрильйон', u'квадрильйони', u'квадрильйонiв'),  # 10^15
+    6: (u'квiнтильйон', u'квiнтильйони', u'квiнтильйонiв'),  # 10^18
+    7: (u'секстильйон', u'секстильйони', u'секстильйонiв'),  # 10^21
+    8: (u'септильйон', u'септильйони', u'септильйонiв'),  # 10^24
+    9: (u'октильйон', u'октильйони', u'октильйонiв'),  # 10^27
+    10: (u'нонiльйон', u'нонiльйони', u'нонiльйонiв'),  # 10^30
 }
 
 CURRENCIES = {
@@ -195,7 +195,7 @@ def splitby3(n):
         if start > 0:
             yield int(n[:start])
         for i in range(start, length, 3):
-            yield int(n[i:i+3])
+            yield int(n[i:i + 3])
     else:
         yield int(n)
 
@@ -247,8 +247,7 @@ def int2word(n, feminine=True):
             ones = ONES_FEMININE if i == 1 or feminine and i == 0 else ONES
             words.append(ones[n1][0])
 
-
-        if i > 0 and ((n1+n2+n3) > 0):
+        if i > 0 and ((n1 + n2 + n3) > 0):
             words.append(pluralize(x, THOUSANDS[i]))
 
     return ' '.join(words)
@@ -314,4 +313,5 @@ class Num2Word_UK(object):
 
 if __name__ == '__main__':
     import doctest
+
     doctest.testmod()

num2words/orderedmapping.py

@@ -30,6 +30,6 @@ class OrderedMapping(dict):
             yield item
 
     def __repr__(self):
-        out = ["%s: %s"%(repr(item), repr(self[item])) for item in self]
+        out = ["%s: %s" % (repr(item), repr(self[item])) for item in self]
         out = ", ".join(out)
-        return "{%s}"%out
+        return "{%s}" % out