Activate flake8, isort and coveralls in the configuration of tox (#105)

* Activate flake8, isort and coveralls in the configuration of tox * Update code to respect PEP8 * Fix bug in the lang_IT for python 3 * Update the README to include the new converters.
2025-12-06 06:42:25 +00:00 · 2017-10-30 14:06:46 -04:00
parent c6015db8b4
commit 3da0c54f3b
52 changed files with 1393 additions and 572 deletions
--- a/tests/test_ar.py
+++ b/tests/test_ar.py
@@ -48,6 +48,7 @@ TEST_CASES_ORDINAL = (
    (100, 'مئة'),
 )

+
 class Num2WordsARTest(TestCase):

    def test_number(self):
--- a/tests/test_de.py
+++ b/tests/test_de.py
@@ -20,6 +20,7 @@ from unittest import TestCase

 from num2words import num2words

+
 class Num2WordsDETest(TestCase):
    def test_ordinal_less_than_twenty(self):
        self.assertEqual(num2words(7, ordinal=True, lang='de'), "siebte")
@@ -28,14 +29,27 @@ class Num2WordsDETest(TestCase):
        self.assertEqual(num2words(17, ordinal=True, lang='de'), "siebzehnte")

    def test_ordinal_more_than_twenty(self):
-        self.assertEqual(num2words(81, ordinal=True, lang='de'), "einundachtzigste")
+        self.assertEqual(
+            num2words(81, ordinal=True, lang='de'), "einundachtzigste"
+        )

    def test_ordinal_at_crucial_number(self):
-        self.assertEqual(num2words(100, ordinal=True, lang='de'), "hundertste")
-        self.assertEqual(num2words(1000, ordinal=True, lang='de'), "tausendste")
-        self.assertEqual(num2words(4000, ordinal=True, lang='de'), "viertausendste")
-        self.assertEqual(num2words(2000000, ordinal=True, lang='de'), "zwei millionenste")
-        self.assertEqual(num2words(5000000000, ordinal=True, lang='de'), "fünf milliardenste")
+        self.assertEqual(
+            num2words(100, ordinal=True, lang='de'), "hundertste"
+        )
+        self.assertEqual(
+            num2words(1000, ordinal=True, lang='de'), "tausendste"
+        )
+        self.assertEqual(
+            num2words(4000, ordinal=True, lang='de'), "viertausendste"
+        )
+        self.assertEqual(
+            num2words(2000000, ordinal=True, lang='de'), "zwei millionenste"
+        )
+        self.assertEqual(
+            num2words(5000000000, ordinal=True, lang='de'),
+            "fünf milliardenste"
+        )

    def test_cardinal_at_some_numbers(self):
        self.assertEqual(num2words(2000000, lang='de'), "zwei millionen")
@@ -48,4 +62,4 @@ class Num2WordsDETest(TestCase):
        self.assertRaises(TypeError, num2words, -12, ordinal=True, lang='de')

    def test_ordinal_for_floating_numbers(self):
-        self.assertRaises(TypeError, num2words, 2.453, ordinal=True, lang='de')
+        self.assertRaises(TypeError, num2words, 2.453, ordinal=True, lang='de')
--- a/tests/test_en.py
+++ b/tests/test_en.py
@@ -17,6 +17,7 @@ from unittest import TestCase

 from num2words import num2words

+
 class Num2WordsENTest(TestCase):
    def test_and_join_199(self):
        # ref https://github.com/savoirfairelinux/num2words/issues/8
@@ -27,4 +28,4 @@ class Num2WordsENTest(TestCase):
        self.assertEqual(num2words(12.50), "twelve point five zero")
        self.assertEqual(num2words(12.51), "twelve point five one")
        self.assertEqual(num2words(12.53), "twelve point five three")
-        self.assertEqual(num2words(12.59), "twelve point five nine")
+        self.assertEqual(num2words(12.59), "twelve point five nine")
--- a/tests/test_es.py
+++ b/tests/test_es.py
@@ -81,6 +81,7 @@ TEST_CASES_ORDINAL = (
    (100, 'centésimo'),
 )

+
 class Num2WordsESTest(TestCase):

    def test_number(self):
--- a/tests/test_es_co.py
+++ b/tests/test_es_co.py
@@ -17,6 +17,7 @@
 from __future__ import unicode_literals

 from num2words import num2words
+
 from . import test_es


--- a/tests/test_es_ve.py
+++ b/tests/test_es_ve.py
@@ -17,6 +17,7 @@
 from __future__ import unicode_literals

 from num2words import num2words
+
 from . import test_es


--- a/tests/test_fr.py
+++ b/tests/test_fr.py
@@ -20,11 +20,19 @@ from unittest import TestCase

 from num2words import num2words

+
 class Num2WordsENTest(TestCase):
    def test_ordinal_special_joins(self):
        # ref https://github.com/savoirfairelinux/num2words/issues/18
-        self.assertEqual(num2words(5, ordinal=True, lang='fr'), "cinquième")
-        self.assertEqual(num2words(35, ordinal=True, lang='fr'), "trente-cinquième")
-        self.assertEqual(num2words(9, ordinal=True, lang='fr'), "neuvième")
-        self.assertEqual(num2words(49, ordinal=True, lang='fr'), "quarante-neuvième")
-
+        self.assertEqual(
+            num2words(5, ordinal=True, lang='fr'), "cinquième"
+        )
+        self.assertEqual(
+            num2words(35, ordinal=True, lang='fr'), "trente-cinquième"
+        )
+        self.assertEqual(
+            num2words(9, ordinal=True, lang='fr'), "neuvième"
+        )
+        self.assertEqual(
+            num2words(49, ordinal=True, lang='fr'), "quarante-neuvième"
+        )
--- a/tests/test_fr_ch.py
+++ b/tests/test_fr_ch.py
@@ -20,17 +20,27 @@ from unittest import TestCase

 from num2words import num2words

+
 class Num2WordsENTest(TestCase):
    def test_ordinal_special_joins(self):
-        self.assertEqual(num2words(5, ordinal=True, lang='fr_CH'), "cinquième")
-        self.assertEqual(num2words(6, ordinal=True, lang='fr_CH'), "sixième")
-        self.assertEqual(num2words(35, ordinal=True, lang='fr_CH'), "trente-cinquième")
+        self.assertEqual(
+            num2words(5, ordinal=True, lang='fr_CH'), "cinquième"
+        )
+        self.assertEqual(
+            num2words(6, ordinal=True, lang='fr_CH'), "sixième"
+        )
+        self.assertEqual(
+            num2words(35, ordinal=True, lang='fr_CH'), "trente-cinquième"
+        )
        self.assertEqual(num2words(9, ordinal=True, lang='fr_CH'), "neuvième")
-        self.assertEqual(num2words(49, ordinal=True, lang='fr_CH'), "quarante-neuvième")
+        self.assertEqual(
+            num2words(49, ordinal=True, lang='fr_CH'), "quarante-neuvième"
+        )
        self.assertEqual(num2words(71, lang='fr_CH'), "septante et un")
        self.assertEqual(num2words(81, lang='fr_CH'), "huitante et un")
        self.assertEqual(num2words(80, lang='fr_CH'), "huitante")
        self.assertEqual(num2words(880, lang='fr_CH'), "huit cents huitante")
-        self.assertEqual(num2words(91, ordinal=True, lang='fr_CH'), "nonante et unième")
+        self.assertEqual(
+            num2words(91, ordinal=True, lang='fr_CH'), "nonante et unième"
+        )
        self.assertEqual(num2words(53, lang='fr_CH'), "cinquante-trois")
-
--- a/tests/test_fr_dz.py
+++ b/tests/test_fr_dz.py
@@ -18,10 +18,17 @@ from __future__ import unicode_literals

 from unittest import TestCase

-from num2words import num2words
 from num2words.lang_FR_DZ import to_currency

+
 class Num2WordsPLTest(TestCase):
    def test_currency(self):
-        self.assertEqual(to_currency(1234.12), "mille deux cent trente-quatre dinards virgule douze centimes")
-        self.assertEqual(to_currency(45689.89), "quarante-cinq mille six cent quatre-vingt-neuf dinards virgule quatre-vingt-neuf centimes")
+        self.assertEqual(
+            to_currency(1234.12),
+            "mille deux cent trente-quatre dinards virgule douze centimes"
+        )
+        self.assertEqual(
+            to_currency(45689.89),
+            "quarante-cinq mille six cent quatre-vingt-neuf dinards virgule "
+            "quatre-vingt-neuf centimes"
+        )
--- a/tests/test_id.py
+++ b/tests/test_id.py
@@ -17,31 +17,42 @@ from unittest import TestCase

 from num2words import num2words

+
 class Num2WordsIDTest(TestCase):
    def test_cardinal_for_natural_number(self):
        self.assertEqual(num2words(10, lang='id'), "sepuluh")
        self.assertEqual(num2words(11, lang='id'), "sebelas")
        self.assertEqual(num2words(108, lang='id'), "seratus delapan")
        self.assertEqual(num2words(1075, lang='id'), "seribu tujuh puluh lima")
-        self.assertEqual(num2words(1087231, lang='id'), "satu juta delapan puluh tujuh ribu dua ratus tiga puluh satu")
-        self.assertEqual(num2words(1000000408, lang='id'), "satu miliar empat ratus delapan")
+        self.assertEqual(
+            num2words(1087231, lang='id'),
+            "satu juta delapan puluh tujuh ribu dua ratus tiga puluh satu"
+        )
+        self.assertEqual(
+            num2words(1000000408, lang='id'),
+            "satu miliar empat ratus delapan"
+        )

    def test_cardinal_for_decimal_number(self):
-        self.assertEqual(num2words(12.234, lang='id'), "dua belas koma dua tiga empat")
-        self.assertEqual(num2words(9.076, lang='id'), "sembilan koma nol tujuh enam")
+        self.assertEqual(
+            num2words(12.234, lang='id'), "dua belas koma dua tiga empat"
+        )
+        self.assertEqual(
+            num2words(9.076, lang='id'), "sembilan koma nol tujuh enam"
+        )

    def test_cardinal_for_negative_number(self):
-        self.assertEqual(num2words(-923, lang='id'), "min sembilan ratus dua puluh tiga")
-        self.assertEqual(num2words(-0.234, lang='id'), "min nol koma dua tiga empat")
+        self.assertEqual(
+            num2words(-923, lang='id'), "min sembilan ratus dua puluh tiga"
+        )
+        self.assertEqual(
+            num2words(-0.234, lang='id'), "min nol koma dua tiga empat"
+        )

    def test_ordinal_for_natural_number(self):
        self.assertEqual(num2words(1, ordinal=True, lang='id'), "pertama")
        self.assertEqual(num2words(10, ordinal=True, lang='id'), "kesepuluh")

-    #def test_ordinal_numeric_for_natural_number(self):
-     #   self.assertEqual(num2words(1, ordinal=True, lang='id'), "ke-1")
-      #  self.assertEqual(num2words(10, ordinal=True, lang='id'), "ke-10")
-
    def test_ordinal_for_negative_number(self):
        self.assertRaises(TypeError, num2words, -12, ordinal=True, lang='id')

--- a/tests/test_it.py
+++ b/tests/test_it.py
@@ -15,9 +15,12 @@
 # MA 02110-1301 USA

 from __future__ import unicode_literals
+
 from unittest import TestCase
+
 from num2words import num2words

+
 class Num2WordsITTest(TestCase):

    maxDiff = None
@@ -32,14 +35,29 @@ class Num2WordsITTest(TestCase):
        self.assertEqual("meno " + pos_ord, neg_ord)

    def test_float_to_cardinal(self):
-        self.assertTrue("tre virgola uno quattro uno" in num2words(3.1415, lang="it"))
-        self.assertTrue("meno cinque virgola uno" in num2words(-5.15, lang="it"))
-        self.assertTrue("meno zero virgola uno" in num2words(-0.15, lang="it"))
+        self.assertEqual(
+            num2words(3.1415, lang="it"), "tre virgola uno quattro uno cinque"
+        )
+        self.assertEqual(
+            num2words(-5.15, lang="it"), "meno cinque virgola uno cinque"
+        )
+        self.assertEqual(
+            num2words(-0.15, lang="it"), "meno zero virgola uno cinque"
+        )

    def test_float_to_ordinal(self):
-        self.assertTrue("terzo virgola uno quattro uno" in num2words(3.1415, lang="it", ordinal=True))
-        self.assertTrue("meno quinto virgola uno" in num2words(-5.15, lang="it", ordinal=True))
-        self.assertTrue("meno zero virgola uno" in num2words(-0.15, lang="it", ordinal=True))
+        self.assertEqual(
+            num2words(3.1415, lang="it", ordinal=True),
+            "terzo virgola uno quattro uno cinque"
+        )
+        self.assertEqual(
+            num2words(-5.15, lang="it", ordinal=True),
+            "meno quinto virgola uno cinque"
+        )
+        self.assertEqual(
+            num2words(-0.15, lang="it", ordinal=True),
+            "meno zero virgola uno cinque"
+        )

    def test_0(self):
        self.assertEqual(num2words(0, lang="it"), "zero")
@@ -80,56 +98,130 @@ class Num2WordsITTest(TestCase):
        self.assertEqual(num2words(1000, lang="it"), "mille")
        self.assertEqual(num2words(1001, lang="it"), "milleuno")
        self.assertEqual(num2words(1500, lang="it"), "millecinquecento")
-        self.assertEqual(num2words(7378, lang="it"), "settemilatrecentosettantotto")
+        self.assertEqual(
+            num2words(7378, lang="it"), "settemilatrecentosettantotto"
+        )
        self.assertEqual(num2words(2000, lang="it"), "duemila")
        self.assertEqual(num2words(2100, lang="it"), "duemilacento")
-        self.assertEqual(num2words(6870, lang="it"), "seimilaottocentosettanta")
+        self.assertEqual(
+            num2words(6870, lang="it"), "seimilaottocentosettanta"
+        )
        self.assertEqual(num2words(10000, lang="it"), "diecimila")
-        self.assertEqual(num2words(98765, lang="it"), "novantottomilasettecentosessantacinque")
+        self.assertEqual(
+            num2words(98765, lang="it"),
+            "novantottomilasettecentosessantacinque"
+        )
        self.assertEqual(num2words(100000, lang="it"), "centomila")
-        self.assertEqual(num2words(523456, lang="it"), "cinquecentoventitremilaquattrocentocinquantasei")
+        self.assertEqual(
+            num2words(523456, lang="it"),
+            "cinquecentoventitremilaquattrocentocinquantasei"
+        )

    def test_big(self):
        self.assertEqual(num2words(1000000, lang="it"), "un milione")
        self.assertEqual(num2words(1000007, lang="it"), "un milione e sette")
-        self.assertEqual(num2words(1200000, lang="it"), "un milione e duecentomila")
+        self.assertEqual(
+            num2words(1200000, lang="it"), "un milione e duecentomila"
+        )
        self.assertEqual(num2words(3000000, lang="it"), "tre milioni")
        self.assertEqual(num2words(3000005, lang="it"), "tre milioni e cinque")
-        self.assertEqual(num2words(3800000, lang="it"), "tre milioni e ottocentomila")
+        self.assertEqual(
+            num2words(3800000, lang="it"), "tre milioni e ottocentomila"
+        )
        self.assertEqual(num2words(1000000000, lang="it"), "un miliardo")
-        self.assertEqual(num2words(1000000017, lang="it"), "un miliardo e diciassette")
+        self.assertEqual(
+            num2words(1000000017, lang="it"), "un miliardo e diciassette"
+        )
        self.assertEqual(num2words(2000000000, lang="it"), "due miliardi")
-        self.assertEqual(num2words(2000001000, lang="it"), "due miliardi e mille")
-        self.assertEqual(num2words(1234567890, lang="it"), "un miliardo, duecentotrentaquattro milioni e cinquecentosessantasettemilaottocentonovanta")
+        self.assertEqual(
+            num2words(2000001000, lang="it"), "due miliardi e mille"
+        )
+        self.assertEqual(
+            num2words(1234567890, lang="it"),
+            "un miliardo, duecentotrentaquattro milioni e "
+            "cinquecentosessantasettemilaottocentonovanta"
+        )
        self.assertEqual(num2words(1000000000000, lang="it"), "un bilione")
-        self.assertEqual(num2words(123456789012345678901234567890, lang="it"), "centoventitré quadriliardi, quattrocentocinquantasei quadrilioni, settecentottantanove triliardi, dodici trilioni, trecentoquarantacinque biliardi, seicentosettantotto bilioni, novecentouno miliardi, duecentotrentaquattro milioni e cinquecentosessantasettemilaottocentonovanta")
+        self.assertEqual(
+            num2words(123456789012345678901234567890, lang="it"),
+            "centoventitré quadriliardi, quattrocentocinquantasei "
+            "quadrilioni, settecentottantanove triliardi, dodici trilioni, "
+            "trecentoquarantacinque biliardi, seicentosettantotto bilioni, "
+            "novecentouno miliardi, duecentotrentaquattro milioni e "
+            "cinquecentosessantasettemilaottocentonovanta"
+        )

    def test_nth_1_to_99(self):
        self.assertEqual(num2words(1, lang="it", ordinal=True), "primo")
        self.assertEqual(num2words(8, lang="it", ordinal=True), "ottavo")
-        self.assertEqual(num2words(23, lang="it", ordinal=True), "ventitreesimo")
-        self.assertEqual(num2words(47, lang="it", ordinal=True), "quarantasettesimo")
-        self.assertEqual(num2words(99, lang="it", ordinal=True), "novantanovesimo")
+        self.assertEqual(
+            num2words(23, lang="it", ordinal=True), "ventitreesimo"
+        )
+        self.assertEqual(
+            num2words(47, lang="it", ordinal=True), "quarantasettesimo"
+        )
+        self.assertEqual(
+            num2words(99, lang="it", ordinal=True), "novantanovesimo"
+        )

    def test_nth_100_to_999(self):
        self.assertEqual(num2words(100, lang="it", ordinal=True), "centesimo")
-        self.assertEqual(num2words(112, lang="it", ordinal=True), "centododicesimo")
-        self.assertEqual(num2words(120, lang="it", ordinal=True), "centoventesimo")
-        self.assertEqual(num2words(316, lang="it", ordinal=True), "trecentosedicesimo")
-        self.assertEqual(num2words(700, lang="it", ordinal=True), "settecentesimo")
-        self.assertEqual(num2words(803, lang="it", ordinal=True), "ottocentotreesimo")
-        self.assertEqual(num2words(923, lang="it", ordinal=True), "novecentoventitreesimo")
+        self.assertEqual(
+            num2words(112, lang="it", ordinal=True), "centododicesimo"
+        )
+        self.assertEqual(
+            num2words(120, lang="it", ordinal=True), "centoventesimo"
+        )
+        self.assertEqual(
+            num2words(316, lang="it", ordinal=True), "trecentosedicesimo"
+        )
+        self.assertEqual(
+            num2words(700, lang="it", ordinal=True), "settecentesimo"
+        )
+        self.assertEqual(
+            num2words(803, lang="it", ordinal=True), "ottocentotreesimo"
+        )
+        self.assertEqual(
+            num2words(923, lang="it", ordinal=True), "novecentoventitreesimo"
+        )

    def test_nth_1000_to_999999(self):
        self.assertEqual(num2words(1000, lang="it", ordinal=True), "millesimo")
-        self.assertEqual(num2words(1001, lang="it", ordinal=True), "milleunesimo")
-        self.assertEqual(num2words(1003, lang="it", ordinal=True), "milletreesimo")
-        self.assertEqual(num2words(1200, lang="it", ordinal=True), "milleduecentesimo")
-        self.assertEqual(num2words(8640, lang="it", ordinal=True), "ottomilaseicentoquarantesimo")
-        self.assertEqual(num2words(14000, lang="it", ordinal=True), "quattordicimillesimo")
-        self.assertEqual(num2words(123456, lang="it", ordinal=True), "centoventitremilaquattrocentocinquantaseiesimo")
-        self.assertEqual(num2words(987654, lang="it", ordinal=True), "novecentottantasettemilaseicentocinquantaquattresimo")
+        self.assertEqual(
+            num2words(1001, lang="it", ordinal=True), "milleunesimo"
+        )
+        self.assertEqual(
+            num2words(1003, lang="it", ordinal=True), "milletreesimo"
+        )
+        self.assertEqual(
+            num2words(1200, lang="it", ordinal=True), "milleduecentesimo"
+        )
+        self.assertEqual(
+            num2words(8640, lang="it", ordinal=True),
+            "ottomilaseicentoquarantesimo"
+        )
+        self.assertEqual(
+            num2words(14000, lang="it", ordinal=True), "quattordicimillesimo"
+        )
+        self.assertEqual(
+            num2words(123456, lang="it", ordinal=True),
+            "centoventitremilaquattrocentocinquantaseiesimo"
+        )
+        self.assertEqual(
+            num2words(987654, lang="it", ordinal=True),
+            "novecentottantasettemilaseicentocinquantaquattresimo"
+        )

    def test_nth_big(self):
-        self.assertEqual(num2words(1000000001, lang="it", ordinal=True), "un miliardo e unesimo")
-        self.assertEqual(num2words(123456789012345678901234567890, lang="it", ordinal=True), "centoventitré quadriliardi, quattrocentocinquantasei quadrilioni, settecentottantanove triliardi, dodici trilioni, trecentoquarantacinque biliardi, seicentosettantotto bilioni, novecentouno miliardi, duecentotrentaquattro milioni e cinquecentosessantasettemilaottocentonovantesimo")
+        self.assertEqual(
+            num2words(1000000001, lang="it", ordinal=True),
+            "un miliardo e unesimo"
+        )
+        self.assertEqual(
+            num2words(123456789012345678901234567890, lang="it", ordinal=True),
+            "centoventitré quadriliardi, quattrocentocinquantasei "
+            "quadrilioni, settecentottantanove triliardi, dodici trilioni, "
+            "trecentoquarantacinque biliardi, seicentosettantotto bilioni, "
+            "novecentouno miliardi, duecentotrentaquattro milioni e "
+            "cinquecentosessantasettemilaottocentonovantesimo"
+        )
--- a/tests/test_nl.py
+++ b/tests/test_nl.py
@@ -20,6 +20,7 @@ from unittest import TestCase

 from num2words import num2words

+
 class Num2WordsNLTest(TestCase):
    def test_ordinal_less_than_twenty(self):
        self.assertEqual(num2words(7, ordinal=True, lang='nl'), "zevende")
@@ -28,17 +29,27 @@ class Num2WordsNLTest(TestCase):
        self.assertEqual(num2words(17, ordinal=True, lang='nl'), "zeventiende")

    def test_ordinal_more_than_twenty(self):
-        self.assertEqual(num2words(81, ordinal=True, lang='nl'), "eenentachtigste")
+        self.assertEqual(
+            num2words(81, ordinal=True, lang='nl'), "eenentachtigste"
+        )

    def test_ordinal_at_crucial_number(self):
        self.assertEqual(num2words(100, ordinal=True, lang='nl'), "honderdste")
-        self.assertEqual(num2words(1000, ordinal=True, lang='nl'), "duizendste")
-        self.assertEqual(num2words(4000, ordinal=True, lang='nl'), "vierduizendste")
-        self.assertEqual(num2words(2000000, ordinal=True, lang='nl'), "twee miljoenste")
-        self.assertEqual(num2words(5000000000, ordinal=True, lang='nl'), "vijf miljardste")
+        self.assertEqual(
+            num2words(1000, ordinal=True, lang='nl'), "duizendste"
+        )
+        self.assertEqual(
+            num2words(4000, ordinal=True, lang='nl'), "vierduizendste"
+        )
+        self.assertEqual(
+            num2words(2000000, ordinal=True, lang='nl'), "twee miljoenste"
+        )
+        self.assertEqual(
+            num2words(5000000000, ordinal=True, lang='nl'), "vijf miljardste"
+        )

    def test_cardinal_at_some_numbers(self):
-        self.assertEqual(num2words(82, lang='nl'), u'twee\xebntachtig')        
+        self.assertEqual(num2words(82, lang='nl'), u'twee\xebntachtig')
        self.assertEqual(num2words(1013, lang='nl'), "duizenddertien")
        self.assertEqual(num2words(2000000, lang='nl'), "twee miljoen")
        self.assertEqual(num2words(4000000000, lang='nl'), "vier miljard")
@@ -50,4 +61,4 @@ class Num2WordsNLTest(TestCase):
        self.assertRaises(TypeError, num2words, -12, ordinal=True, lang='nl')

    def test_ordinal_for_floating_numbers(self):
-        self.assertRaises(TypeError, num2words, 2.453, ordinal=True, lang='nl')
+        self.assertRaises(TypeError, num2words, 2.453, ordinal=True, lang='nl')
--- a/tests/test_pl.py
+++ b/tests/test_pl.py
@@ -21,6 +21,7 @@ from unittest import TestCase
 from num2words import num2words
 from num2words.lang_PL import to_currency

+
 class Num2WordsPLTest(TestCase):
    def test_cardinal(self):
        self.assertEqual(num2words(100, lang='pl'), "sto")
@@ -31,19 +32,70 @@ class Num2WordsPLTest(TestCase):
        self.assertEqual(num2words(1000, lang='pl'), "tysiąc")
        self.assertEqual(num2words(1001, lang='pl'), "tysiąc jeden")
        self.assertEqual(num2words(2012, lang='pl'), "dwa tysiące dwanaście")
-        self.assertEqual(num2words(12519.85, lang='pl'), "dwanaście tysięcy pięćset dziewiętnaście przecinek osiemdziesiąt pięć")
-        self.assertEqual(num2words(123.50, lang='pl'), "sto dwadzieścia trzy przecinek pięć")
-        self.assertEqual(num2words(1234567890, lang='pl'), "miliard dwieście trzydzieści cztery miliony pięćset sześćdziesiąt siedem tysięcy osiemset dziewięćdzisiąt")
-        self.assertEqual(num2words(215461407892039002157189883901676, lang='pl'), "dwieście piętnaście kwintylionów czterysta sześćdziesiąt jeden kwadryliardów czterysta siedem kwadrylionów osiemset dziewięćdzisiąt dwa tryliardy trzydzieści dziewięć trylionów dwa biliardy sto pięćdziesiąt siedem bilionów sto osiemdziesiąt dziewięć miliardów osiemset osiemdziesiąt trzy miliony dziewęćset jeden tysięcy sześćset siedemdziesiąt sześć")
-        self.assertEqual(num2words(719094234693663034822824384220291, lang='pl'), "siedemset dziewiętnaście kwintylionów dziewięćdzisiąt cztery kwadryliardy dwieście trzydzieści cztery kwadryliony sześćset dziewięćdzisiąt trzy tryliardy sześćset sześćdziesiąt trzy tryliony trzydzieści cztery biliardy osiemset dwadzieścia dwa biliony osiemset dwadzieścia cztery miliardy trzysta osiemdziesiąt cztery miliony dwieście dwadzieścia tysięcy dwieście dziewięćdzisiąt jeden")
+        self.assertEqual(
+            num2words(12519.85, lang='pl'),
+            "dwanaście tysięcy pięćset dziewiętnaście przecinek "
+            "osiemdziesiąt pięć"
+        )
+        self.assertEqual(
+            num2words(123.50, lang='pl'),
+            "sto dwadzieścia trzy przecinek pięć"
+        )
+        self.assertEqual(
+            num2words(1234567890, lang='pl'),
+            "miliard dwieście trzydzieści cztery miliony pięćset "
+            "sześćdziesiąt siedem tysięcy osiemset dziewięćdzisiąt"
+        )
+        self.assertEqual(
+            num2words(215461407892039002157189883901676, lang='pl'),
+            "dwieście piętnaście kwintylionów czterysta sześćdziesiąt jeden "
+            "kwadryliardów czterysta siedem kwadrylionów osiemset "
+            "dziewięćdzisiąt dwa tryliardy trzydzieści dziewięć trylionów "
+            "dwa biliardy sto pięćdziesiąt siedem bilionów sto osiemdziesiąt "
+            "dziewięć miliardów osiemset osiemdziesiąt trzy miliony "
+            "dziewęćset jeden tysięcy sześćset siedemdziesiąt sześć"
+        )
+        self.assertEqual(
+            num2words(719094234693663034822824384220291, lang='pl'),
+            "siedemset dziewiętnaście kwintylionów dziewięćdzisiąt cztery "
+            "kwadryliardy dwieście trzydzieści cztery kwadryliony sześćset "
+            "dziewięćdzisiąt trzy tryliardy sześćset sześćdziesiąt trzy "
+            "tryliony trzydzieści cztery biliardy osiemset dwadzieścia dwa "
+            "biliony osiemset dwadzieścia cztery miliardy trzysta "
+            "osiemdziesiąt cztery miliony dwieście dwadzieścia "
+            "tysięcy dwieście dziewięćdzisiąt jeden"
+        )

    def test_currency(self):
        self.assertEqual(to_currency(1.0, 'EUR'), "jeden euro, zero centów")
        self.assertEqual(to_currency(1.0, 'PLN'), "jeden złoty, zero groszy")
-        self.assertEqual(to_currency(1234.56, 'EUR'), "tysiąc dwieście trzydzieści cztery euro, pięćdziesiąt sześć centów")
-        self.assertEqual(to_currency(1234.56, 'PLN'), "tysiąc dwieście trzydzieści cztery złote, pięćdziesiąt sześć groszy")
-        self.assertEqual(to_currency(10111, 'EUR', seperator=' i'), "sto jeden euro i jedenaście centów")
-        self.assertEqual(to_currency(10121, 'PLN', seperator=' i'), "sto jeden złotych i dwadzieścia jeden groszy")
-        self.assertEqual(to_currency(-1251985, cents = False), "minus dwanaście tysięcy pięćset dziewiętnaście euro, 85 centów")
-        self.assertEqual(to_currency(123.50, 'PLN', seperator=' i'), "sto dwadzieścia trzy złote i pięćdziesiąt groszy")
-        self.assertEqual(to_currency(1950, cents = False), "dziewiętnaście euro, 50 centów")
+        self.assertEqual(
+            to_currency(1234.56, 'EUR'),
+            "tysiąc dwieście trzydzieści cztery euro, pięćdziesiąt sześć "
+            "centów"
+        )
+        self.assertEqual(
+            to_currency(1234.56, 'PLN'),
+            "tysiąc dwieście trzydzieści cztery złote, pięćdziesiąt sześć "
+            "groszy"
+        )
+        self.assertEqual(
+            to_currency(10111, 'EUR', seperator=' i'),
+            "sto jeden euro i jedenaście centów"
+        )
+        self.assertEqual(
+            to_currency(10121, 'PLN', seperator=' i'),
+            "sto jeden złotych i dwadzieścia jeden groszy"
+        )
+        self.assertEqual(
+            to_currency(-1251985, cents=False),
+            "minus dwanaście tysięcy pięćset dziewiętnaście euro, 85 centów"
+        )
+        self.assertEqual(
+            to_currency(123.50, 'PLN', seperator=' i'),
+            "sto dwadzieścia trzy złote i pięćdziesiąt groszy"
+        )
+        self.assertEqual(
+            to_currency(1950, cents=False),
+            "dziewiętnaście euro, 50 centów"
+        )
--- a/tests/test_pt_BR.py
+++ b/tests/test_pt_BR.py
@@ -63,36 +63,82 @@ class Num2WordsPTBRTest(TestCase):
        self.assertEqual(num2words(1000, lang='pt_BR'), 'mil')
        self.assertEqual(num2words(1001, lang='pt_BR'), 'mil e um')
        self.assertEqual(num2words(1111, lang='pt_BR'), 'mil, cento e onze')
-        self.assertEqual(num2words(2114, lang='pt_BR'), 'dois mil, cento e catorze')
-        self.assertEqual(num2words(73421, lang='pt_BR'), 'setenta e três mil, quatrocentos e vinte e um')
+        self.assertEqual(
+            num2words(2114, lang='pt_BR'), 'dois mil, cento e catorze'
+        )
+        self.assertEqual(
+            num2words(73421, lang='pt_BR'),
+            'setenta e três mil, quatrocentos e vinte e um'
+        )

        self.assertEqual(num2words(100000, lang='pt_BR'), 'cem mil')
-        self.assertEqual(num2words(250050, lang='pt_BR'), 'duzentos e cinquenta mil e cinquenta')
-        self.assertEqual(num2words(6000000, lang='pt_BR'), 'seis milhões')
-        self.assertEqual(num2words(19000000000, lang='pt_BR'), 'dezenove bilhões')
-        self.assertEqual(num2words(145000000002, lang='pt_BR'), 'cento e quarenta e cinco bilhões e dois')
+        self.assertEqual(
+            num2words(250050, lang='pt_BR'),
+            'duzentos e cinquenta mil e cinquenta'
+        )
+        self.assertEqual(
+            num2words(6000000, lang='pt_BR'), 'seis milhões'
+        )
+        self.assertEqual(
+            num2words(19000000000, lang='pt_BR'), 'dezenove bilhões'
+        )
+        self.assertEqual(
+            num2words(145000000002, lang='pt_BR'),
+            'cento e quarenta e cinco bilhões e dois'
+        )

    def test_cardinal_integer_negative(self):
        self.assertEqual(num2words(-1, lang='pt_BR'), 'menos um')
-        self.assertEqual(num2words(-256, lang='pt_BR'), 'menos duzentos e cinquenta e seis')
+        self.assertEqual(
+            num2words(-256, lang='pt_BR'), 'menos duzentos e cinquenta e seis'
+        )
        self.assertEqual(num2words(-1000, lang='pt_BR'), 'menos mil')
        self.assertEqual(num2words(-1000000, lang='pt_BR'), 'menos um milhão')
-        self.assertEqual(num2words(-1234567, lang='pt_BR'), 'menos um milhão, duzentos e trinta e quatro mil, quinhentos e sessenta e sete')
+        self.assertEqual(
+            num2words(-1234567, lang='pt_BR'),
+            'menos um milhão, duzentos e trinta e quatro mil, quinhentos e '
+            'sessenta e sete'
+        )

    def test_cardinal_float(self):
        self.assertEqual(num2words(Decimal('1.00'), lang='pt_BR'), 'um')
-        self.assertEqual(num2words(Decimal('1.01'), lang='pt_BR'), 'um vírgula zero um')
-        self.assertEqual(num2words(Decimal('1.035'), lang='pt_BR'), 'um vírgula zero três')
-        self.assertEqual(num2words(Decimal('1.35'), lang='pt_BR'), 'um vírgula três cinco')
-        self.assertEqual(num2words(Decimal('3.14159'), lang='pt_BR'), 'três vírgula um quatro')
-        self.assertEqual(num2words(Decimal('101.22'), lang='pt_BR'), 'cento e um vírgula dois dois')
-        self.assertEqual(num2words(Decimal('2345.75'), lang='pt_BR'), 'dois mil, trezentos e quarenta e cinco vírgula sete cinco')
+        self.assertEqual(num2words(
+            Decimal('1.01'), lang='pt_BR'), 'um vírgula zero um')
+        self.assertEqual(num2words(
+            Decimal('1.035'), lang='pt_BR'), 'um vírgula zero três'
+        )
+        self.assertEqual(num2words(
+            Decimal('1.35'), lang='pt_BR'), 'um vírgula três cinco'
+        )
+        self.assertEqual(
+            num2words(Decimal('3.14159'), lang='pt_BR'),
+            'três vírgula um quatro'
+        )
+        self.assertEqual(
+            num2words(Decimal('101.22'), lang='pt_BR'),
+            'cento e um vírgula dois dois'
+        )
+        self.assertEqual(
+            num2words(Decimal('2345.75'), lang='pt_BR'),
+            'dois mil, trezentos e quarenta e cinco vírgula sete cinco')

    def test_cardinal_float_negative(self):
-        self.assertEqual(num2words(Decimal('-2.34'), lang='pt_BR'), 'menos dois vírgula três quatro')
-        self.assertEqual(num2words(Decimal('-9.99'), lang='pt_BR'), 'menos nove vírgula nove nove')
-        self.assertEqual(num2words(Decimal('-7.01'), lang='pt_BR'), 'menos sete vírgula zero um')
-        self.assertEqual(num2words(Decimal('-222.22'), lang='pt_BR'), 'menos duzentos e vinte e dois vírgula dois dois')
+        self.assertEqual(
+            num2words(Decimal('-2.34'), lang='pt_BR'),
+            'menos dois vírgula três quatro'
+        )
+        self.assertEqual(
+            num2words(Decimal('-9.99'), lang='pt_BR'),
+            'menos nove vírgula nove nove'
+        )
+        self.assertEqual(
+            num2words(Decimal('-7.01'), lang='pt_BR'),
+            'menos sete vírgula zero um'
+        )
+        self.assertEqual(
+            num2words(Decimal('-222.22'), lang='pt_BR'),
+            'menos duzentos e vinte e dois vírgula dois dois'
+        )

    def test_ordinal(self):
        self.assertEqual(num2words(1, lang='pt_BR', ordinal=True), 'primeiro')
@@ -105,38 +151,103 @@ class Num2WordsPTBRTest(TestCase):
        self.assertEqual(num2words(8, lang='pt_BR', ordinal=True), 'oitavo')
        self.assertEqual(num2words(9, lang='pt_BR', ordinal=True), 'nono')
        self.assertEqual(num2words(10, lang='pt_BR', ordinal=True), 'décimo')
-        self.assertEqual(num2words(11, lang='pt_BR', ordinal=True), 'décimo primeiro')
-        self.assertEqual(num2words(12, lang='pt_BR', ordinal=True), 'décimo segundo')
-        self.assertEqual(num2words(13, lang='pt_BR', ordinal=True), 'décimo terceiro')
-        self.assertEqual(num2words(14, lang='pt_BR', ordinal=True), 'décimo quarto')
-        self.assertEqual(num2words(15, lang='pt_BR', ordinal=True), 'décimo quinto')
-        self.assertEqual(num2words(16, lang='pt_BR', ordinal=True), 'décimo sexto')
-        self.assertEqual(num2words(17, lang='pt_BR', ordinal=True), 'décimo sétimo')
-        self.assertEqual(num2words(18, lang='pt_BR', ordinal=True), 'décimo oitavo')
-        self.assertEqual(num2words(19, lang='pt_BR', ordinal=True), 'décimo nono')
-        self.assertEqual(num2words(20, lang='pt_BR', ordinal=True), 'vigésimo')
+        self.assertEqual(
+            num2words(11, lang='pt_BR', ordinal=True), 'décimo primeiro'
+        )
+        self.assertEqual(
+            num2words(12, lang='pt_BR', ordinal=True), 'décimo segundo'
+        )
+        self.assertEqual(
+            num2words(13, lang='pt_BR', ordinal=True), 'décimo terceiro'
+        )
+        self.assertEqual(
+            num2words(14, lang='pt_BR', ordinal=True), 'décimo quarto'
+        )
+        self.assertEqual(
+            num2words(15, lang='pt_BR', ordinal=True), 'décimo quinto'
+        )
+        self.assertEqual(
+            num2words(16, lang='pt_BR', ordinal=True), 'décimo sexto'
+        )
+        self.assertEqual(
+            num2words(17, lang='pt_BR', ordinal=True), 'décimo sétimo'
+        )
+        self.assertEqual(
+            num2words(18, lang='pt_BR', ordinal=True), 'décimo oitavo'
+        )
+        self.assertEqual(
+            num2words(19, lang='pt_BR', ordinal=True), 'décimo nono'
+        )
+        self.assertEqual(
+            num2words(20, lang='pt_BR', ordinal=True), 'vigésimo'
+        )

-        self.assertEqual(num2words(21, lang='pt_BR', ordinal=True), 'vigésimo primeiro')
-        self.assertEqual(num2words(22, lang='pt_BR', ordinal=True), 'vigésimo segundo')
-        self.assertEqual(num2words(35, lang='pt_BR', ordinal=True), 'trigésimo quinto')
-        self.assertEqual(num2words(99, lang='pt_BR', ordinal=True), 'nonagésimo nono')
+        self.assertEqual(
+            num2words(21, lang='pt_BR', ordinal=True), 'vigésimo primeiro'
+        )
+        self.assertEqual(
+            num2words(22, lang='pt_BR', ordinal=True), 'vigésimo segundo'
+        )
+        self.assertEqual(
+            num2words(35, lang='pt_BR', ordinal=True), 'trigésimo quinto'
+        )
+        self.assertEqual(
+            num2words(99, lang='pt_BR', ordinal=True), 'nonagésimo nono'
+        )

-        self.assertEqual(num2words(100, lang='pt_BR', ordinal=True), 'centésimo')
-        self.assertEqual(num2words(101, lang='pt_BR', ordinal=True), 'centésimo primeiro')
-        self.assertEqual(num2words(128, lang='pt_BR', ordinal=True), 'centésimo vigésimo oitavo')
-        self.assertEqual(num2words(713, lang='pt_BR', ordinal=True), 'septigentésimo décimo terceiro')
+        self.assertEqual(
+            num2words(100, lang='pt_BR', ordinal=True), 'centésimo'
+        )
+        self.assertEqual(
+            num2words(101, lang='pt_BR', ordinal=True), 'centésimo primeiro'
+        )
+        self.assertEqual(
+            num2words(128, lang='pt_BR', ordinal=True),
+            'centésimo vigésimo oitavo'
+        )
+        self.assertEqual(
+            num2words(713, lang='pt_BR', ordinal=True),
+            'septigentésimo décimo terceiro'
+        )

-        self.assertEqual(num2words(1000, lang='pt_BR', ordinal=True), 'milésimo')
-        self.assertEqual(num2words(1001, lang='pt_BR', ordinal=True), 'milésimo primeiro')
-        self.assertEqual(num2words(1111, lang='pt_BR', ordinal=True), 'milésimo centésimo décimo primeiro')
-        self.assertEqual(num2words(2114, lang='pt_BR', ordinal=True), 'segundo milésimo centésimo décimo quarto')
-        self.assertEqual(num2words(73421, lang='pt_BR', ordinal=True), 'septuagésimo terceiro milésimo quadrigentésimo vigésimo primeiro')
+        self.assertEqual(
+            num2words(1000, lang='pt_BR', ordinal=True), 'milésimo'
+        )
+        self.assertEqual(
+            num2words(1001, lang='pt_BR', ordinal=True), 'milésimo primeiro'
+        )
+        self.assertEqual(
+            num2words(1111, lang='pt_BR', ordinal=True),
+            'milésimo centésimo décimo primeiro'
+        )
+        self.assertEqual(
+            num2words(2114, lang='pt_BR', ordinal=True),
+            'segundo milésimo centésimo décimo quarto'
+        )
+        self.assertEqual(
+            num2words(73421, lang='pt_BR', ordinal=True),
+            'septuagésimo terceiro milésimo quadrigentésimo vigésimo primeiro'
+        )

-        self.assertEqual(num2words(100000, lang='pt_BR', ordinal=True), 'centésimo milésimo')
-        self.assertEqual(num2words(250050, lang='pt_BR', ordinal=True), 'ducentésimo quinquagésimo milésimo quinquagésimo')
-        self.assertEqual(num2words(6000000, lang='pt_BR', ordinal=True), 'sexto milionésimo')
-        self.assertEqual(num2words(19000000000, lang='pt_BR', ordinal=True), 'décimo nono bilionésimo')
-        self.assertEqual(num2words(145000000002, lang='pt_BR', ordinal=True), 'centésimo quadragésimo quinto bilionésimo segundo')
+        self.assertEqual(
+            num2words(100000, lang='pt_BR', ordinal=True),
+            'centésimo milésimo'
+        )
+        self.assertEqual(
+            num2words(250050, lang='pt_BR', ordinal=True),
+            'ducentésimo quinquagésimo milésimo quinquagésimo'
+        )
+        self.assertEqual(
+            num2words(6000000, lang='pt_BR', ordinal=True), 'sexto milionésimo'
+        )
+        self.assertEqual(
+            num2words(19000000000, lang='pt_BR', ordinal=True),
+            'décimo nono bilionésimo'
+        )
+        self.assertEqual(
+            num2words(145000000002, lang='pt_BR', ordinal=True),
+            'centésimo quadragésimo quinto bilionésimo segundo'
+        )

    def test_currency_integer(self):
        self.assertEqual(self.n2w.to_currency(1), 'um real')
@@ -167,53 +278,117 @@ class Num2WordsPTBRTest(TestCase):

        self.assertEqual(self.n2w.to_currency(100), 'cem reais')
        self.assertEqual(self.n2w.to_currency(101), 'cento e um reais')
-        self.assertEqual(self.n2w.to_currency(128), 'cento e vinte e oito reais')
+        self.assertEqual(
+            self.n2w.to_currency(128), 'cento e vinte e oito reais'
+        )
        self.assertEqual(self.n2w.to_currency(713), 'setecentos e treze reais')

        self.assertEqual(self.n2w.to_currency(1000), 'mil reais')
        self.assertEqual(self.n2w.to_currency(1001), 'mil e um reais')
        self.assertEqual(self.n2w.to_currency(1111), 'mil, cento e onze reais')
-        self.assertEqual(self.n2w.to_currency(2114), 'dois mil, cento e catorze reais')
-        self.assertEqual(self.n2w.to_currency(73421), 'setenta e três mil, quatrocentos e vinte e um reais')
+        self.assertEqual(
+            self.n2w.to_currency(2114), 'dois mil, cento e catorze reais'
+        )
+        self.assertEqual(
+            self.n2w.to_currency(73421),
+            'setenta e três mil, quatrocentos e vinte e um reais'
+        )

        self.assertEqual(self.n2w.to_currency(100000), 'cem mil reais')
-        self.assertEqual(self.n2w.to_currency(250050), 'duzentos e cinquenta mil e cinquenta reais')
-        self.assertEqual(self.n2w.to_currency(6000000), 'seis milhões de reais')
-        self.assertEqual(self.n2w.to_currency(19000000000), 'dezenove bilhões de reais')
-        self.assertEqual(self.n2w.to_currency(145000000002), 'cento e quarenta e cinco bilhões e dois reais')
+        self.assertEqual(
+            self.n2w.to_currency(250050),
+            'duzentos e cinquenta mil e cinquenta reais'
+        )
+        self.assertEqual(
+            self.n2w.to_currency(6000000), 'seis milhões de reais'
+        )
+        self.assertEqual(
+            self.n2w.to_currency(19000000000), 'dezenove bilhões de reais'
+        )
+        self.assertEqual(
+            self.n2w.to_currency(145000000002),
+            'cento e quarenta e cinco bilhões e dois reais'
+        )

    def test_currency_integer_negative(self):
        self.assertEqual(self.n2w.to_currency(-1), 'menos um real')
-        self.assertEqual(self.n2w.to_currency(-256), 'menos duzentos e cinquenta e seis reais')
+        self.assertEqual(
+            self.n2w.to_currency(-256),
+            'menos duzentos e cinquenta e seis reais'
+        )
        self.assertEqual(self.n2w.to_currency(-1000), 'menos mil reais')
-        self.assertEqual(self.n2w.to_currency(-1000000), 'menos um milhão de reais')
-        self.assertEqual(self.n2w.to_currency(-1234567), 'menos um milhão, duzentos e trinta e quatro mil, quinhentos e sessenta e sete reais')
+        self.assertEqual(
+            self.n2w.to_currency(-1000000), 'menos um milhão de reais'
+        )
+        self.assertEqual(
+            self.n2w.to_currency(-1234567),
+            'menos um milhão, duzentos e trinta e quatro mil, quinhentos e '
+            'sessenta e sete reais'
+        )

    def test_currency_float(self):
        self.assertEqual(self.n2w.to_currency(Decimal('1.00')), 'um real')
-        self.assertEqual(self.n2w.to_currency(Decimal('1.01')), 'um real e um centavo')
-        self.assertEqual(self.n2w.to_currency(Decimal('1.035')), 'um real e três centavos')
-        self.assertEqual(self.n2w.to_currency(Decimal('1.35')), 'um real e trinta e cinco centavos')
-        self.assertEqual(self.n2w.to_currency(Decimal('3.14159')), 'três reais e catorze centavos')
-        self.assertEqual(self.n2w.to_currency(Decimal('101.22')), 'cento e um reais e vinte e dois centavos')
-        self.assertEqual(self.n2w.to_currency(Decimal('2345.75')), 'dois mil, trezentos e quarenta e cinco reais e setenta e cinco centavos')
+        self.assertEqual(
+            self.n2w.to_currency(Decimal('1.01')), 'um real e um centavo'
+        )
+        self.assertEqual(
+            self.n2w.to_currency(Decimal('1.035')), 'um real e três centavos'
+        )
+        self.assertEqual(
+            self.n2w.to_currency(Decimal('1.35')),
+            'um real e trinta e cinco centavos'
+        )
+        self.assertEqual(
+            self.n2w.to_currency(Decimal('3.14159')),
+            'três reais e catorze centavos'
+        )
+        self.assertEqual(
+            self.n2w.to_currency(Decimal('101.22')),
+            'cento e um reais e vinte e dois centavos'
+        )
+        self.assertEqual(
+            self.n2w.to_currency(Decimal('2345.75')),
+            'dois mil, trezentos e quarenta e cinco reais e setenta e cinco '
+            'centavos'
+        )

    def test_currency_float_negative(self):
-        self.assertEqual(self.n2w.to_currency(Decimal('-2.34')), 'menos dois reais e trinta e quatro centavos')
-        self.assertEqual(self.n2w.to_currency(Decimal('-9.99')), 'menos nove reais e noventa e nove centavos')
-        self.assertEqual(self.n2w.to_currency(Decimal('-7.01')), 'menos sete reais e um centavo')
-        self.assertEqual(self.n2w.to_currency(Decimal('-222.22')), 'menos duzentos e vinte e dois reais e vinte e dois centavos')
+        self.assertEqual(
+            self.n2w.to_currency(Decimal('-2.34')),
+            'menos dois reais e trinta e quatro centavos'
+        )
+        self.assertEqual(
+            self.n2w.to_currency(Decimal('-9.99')),
+            'menos nove reais e noventa e nove centavos'
+        )
+        self.assertEqual(
+            self.n2w.to_currency(Decimal('-7.01')),
+            'menos sete reais e um centavo'
+        )
+        self.assertEqual(
+            self.n2w.to_currency(Decimal('-222.22')),
+            'menos duzentos e vinte e dois reais e vinte e dois centavos'
+        )

    def test_year(self):
        self.assertEqual(self.n2w.to_year(1001), 'mil e um')
-        self.assertEqual(self.n2w.to_year(1789), 'mil, setecentos e oitenta e nove')
-        self.assertEqual(self.n2w.to_year(1942), 'mil, novecentos e quarenta e dois')
-        self.assertEqual(self.n2w.to_year(1984), 'mil, novecentos e oitenta e quatro')
+        self.assertEqual(
+            self.n2w.to_year(1789), 'mil, setecentos e oitenta e nove'
+        )
+        self.assertEqual(
+            self.n2w.to_year(1942), 'mil, novecentos e quarenta e dois'
+        )
+        self.assertEqual(
+            self.n2w.to_year(1984), 'mil, novecentos e oitenta e quatro'
+        )
        self.assertEqual(self.n2w.to_year(2000), 'dois mil')
        self.assertEqual(self.n2w.to_year(2001), 'dois mil e um')
        self.assertEqual(self.n2w.to_year(2016), 'dois mil e dezesseis')

    def test_year_negative(self):
        self.assertEqual(self.n2w.to_year(-30), 'trinta antes de Cristo')
-        self.assertEqual(self.n2w.to_year(-744), 'setecentos e quarenta e quatro antes de Cristo')
+        self.assertEqual(
+            self.n2w.to_year(-744),
+            'setecentos e quarenta e quatro antes de Cristo'
+        )
        self.assertEqual(self.n2w.to_year(-10000), 'dez mil antes de Cristo')
--- a/tests/test_ru.py
+++ b/tests/test_ru.py
@@ -18,16 +18,27 @@ from unittest import TestCase

 from num2words import num2words

+
 class Num2WordsRUTest(TestCase):

    def test_cardinal(self):
        self.assertEqual(num2words(5, lang='ru'), u"пять")
        self.assertEqual(num2words(15, lang='ru'), u"пятнадцать")
        self.assertEqual(num2words(154, lang='ru'), u"сто пятьдесят четыре")
-        self.assertEqual(num2words(1135, lang='ru'), u"одна тысяча сто тридцать пять")
-        self.assertEqual(num2words(418531, lang='ru'), u"четыреста восемнадцать тысяч пятьсот тридцать один")
-        self.assertEqual(num2words(1000139, lang='ru'), u"один миллион сто тридцать девять")
+        self.assertEqual(
+            num2words(1135, lang='ru'), u"одна тысяча сто тридцать пять"
+        )
+        self.assertEqual(
+            num2words(418531, lang='ru'),
+            u"четыреста восемнадцать тысяч пятьсот тридцать один"
+        )
+        self.assertEqual(
+            num2words(1000139, lang='ru'), u"один миллион сто тридцать девять"
+        )

    def test_floating_point(self):
        self.assertEqual(num2words(5.2, lang='ru'), u"пять запятая два")
-        self.assertEqual(num2words(561.42, lang='ru'), u"пятьсот шестьдесят один запятая сорок два")
+        self.assertEqual(
+            num2words(561.42, lang='ru'),
+            u"пятьсот шестьдесят один запятая сорок два"
+        )
--- a/tests/test_sl.py
+++ b/tests/test_sl.py
@@ -20,6 +20,7 @@ from unittest import TestCase

 from num2words import num2words

+
 class Num2WordsDETest(TestCase):
    def test_ordinal_less_than_twenty(self):
        self.assertEqual(num2words(2, ordinal=True, lang='sl'), "drugi")
@@ -30,14 +31,22 @@ class Num2WordsDETest(TestCase):
        self.assertEqual(num2words(17, ordinal=True, lang='sl'), "sedemnajsti")

    def test_ordinal_more_than_twenty(self):
-        self.assertEqual(num2words(81, ordinal=True, lang='sl'), "enainosemdeseti")
+        self.assertEqual(
+            num2words(81, ordinal=True, lang='sl'), "enainosemdeseti"
+        )

    def test_ordinal_at_crucial_number(self):
        self.assertEqual(num2words(100, ordinal=True, lang='sl'), "stoti")
        self.assertEqual(num2words(1000, ordinal=True, lang='sl'), "tisoči")
-        self.assertEqual(num2words(4000, ordinal=True, lang='sl'), "štiritisoči")
-        self.assertEqual(num2words(2000000, ordinal=True, lang='sl'), "dvemiljonti")
-        self.assertEqual(num2words(5000000000, ordinal=True, lang='sl'), "petmiljardti")
+        self.assertEqual(
+            num2words(4000, ordinal=True, lang='sl'), "štiritisoči"
+        )
+        self.assertEqual(
+            num2words(2000000, ordinal=True, lang='sl'), "dvemiljonti"
+        )
+        self.assertEqual(
+            num2words(5000000000, ordinal=True, lang='sl'), "petmiljardti"
+        )

    def test_cardinal_at_some_numbers(self):
        self.assertEqual(num2words(2, lang='sl'), "dve")
--- a/tests/test_tr.py
+++ b/tests/test_tr.py
@@ -41,32 +41,69 @@ class Num2WordsTRTest(TestCase):
        self.assertEqual(num2words(1011, True, "tr"), u"binonbirinci")
        self.assertEqual(num2words(1100, True, "tr"), u"binyüzüncü")
        self.assertEqual(num2words(1110, True, "tr"), u"binyüzonuncu")
-        self.assertEqual(num2words(2341, True, "tr"), u"ikibinüçyüzkırkbirinci")
+        self.assertEqual(
+            num2words(2341, True, "tr"), u"ikibinüçyüzkırkbirinci"
+        )
        self.assertEqual(num2words(10000, True, "tr"), u"onbininci")
        self.assertEqual(num2words(10010, True, "tr"), u"onbinonuncu")
        self.assertEqual(num2words(10100, True, "tr"), u"onbinyüzüncü")
        self.assertEqual(num2words(10110, True, "tr"), u"onbinyüzonuncu")
        self.assertEqual(num2words(11000, True, "tr"), u"onbirbininci")
        self.assertEqual(num2words(35000, True, "tr"), u"otuzbeşbininci")
-        self.assertEqual(num2words(116331, True, "tr"), u"yüzonaltıbinüçyüzotuzbirinci")
-        self.assertEqual(num2words(116330, True, "tr"), u"yüzonaltıbinüçyüzotuzuncu")
+        self.assertEqual(
+            num2words(116331, True, "tr"), u"yüzonaltıbinüçyüzotuzbirinci"
+        )
+        self.assertEqual(
+            num2words(116330, True, "tr"), u"yüzonaltıbinüçyüzotuzuncu"
+        )
        self.assertEqual(num2words(100000, True, "tr"), u"yüzbininci")
        self.assertEqual(num2words(501000, True, "tr"), u"beşyüzbirbininci")
-        self.assertEqual(num2words(1000111, True, "tr"), u"birmilyonyüzonbirinci")
-        self.assertEqual(num2words(111000111, True, "tr"), u"yüzonbirmilyonyüzonbirinci")
-        self.assertEqual(num2words(111001111, True, "tr"), u"yüzonbirmilyonbinyüzonbirinci")
-        self.assertEqual(num2words(111111111, True, "tr"), u"yüzonbirmilyonyüzonbirbinyüzonbirinci")
+        self.assertEqual(
+            num2words(1000111, True, "tr"), u"birmilyonyüzonbirinci"
+        )
+        self.assertEqual(
+            num2words(111000111, True, "tr"), u"yüzonbirmilyonyüzonbirinci"
+        )
+        self.assertEqual(
+            num2words(111001111, True, "tr"), u"yüzonbirmilyonbinyüzonbirinci"
+        )
+        self.assertEqual(
+            num2words(111111111, True, "tr"),
+            u"yüzonbirmilyonyüzonbirbinyüzonbirinci"
+        )
        self.assertEqual(num2words(100001000, True, "tr"), u"yüzmilyonbininci")
-        self.assertEqual(num2words(100001001, True, "tr"), u"yüzmilyonbinbirinci")
-        self.assertEqual(num2words(100010000, True, "tr"), u"yüzmilyononbininci")
-        self.assertEqual(num2words(100010001, True, "tr"), u"yüzmilyononbinbirinci")
-        self.assertEqual(num2words(100011000, True, "tr"), u"yüzmilyononbirbininci")
-        self.assertEqual(num2words(100011001, True, "tr"), u"yüzmilyononbirbinbirinci")
-        self.assertEqual(num2words(101011001, True, "tr"), u"yüzbirmilyononbirbinbirinci")
-        self.assertEqual(num2words(101011010, True, "tr"), u"yüzbirmilyononbirbinonuncu")
-        self.assertEqual(num2words(1101011010, True, "tr"), u"birmilyaryüzbirmilyononbirbinonuncu")
-        self.assertEqual(num2words(101101011010, True, "tr"), u"yüzbirmilyaryüzbirmilyononbirbinonuncu")
-        self.assertEqual(num2words(1000000000001, True, "tr"), u"birtrilyonbirinci")
+        self.assertEqual(
+            num2words(100001001, True, "tr"), u"yüzmilyonbinbirinci"
+        )
+        self.assertEqual(
+            num2words(100010000, True, "tr"), u"yüzmilyononbininci"
+        )
+        self.assertEqual(
+            num2words(100010001, True, "tr"), u"yüzmilyononbinbirinci"
+        )
+        self.assertEqual(
+            num2words(100011000, True, "tr"), u"yüzmilyononbirbininci"
+        )
+        self.assertEqual(
+            num2words(100011001, True, "tr"), u"yüzmilyononbirbinbirinci"
+        )
+        self.assertEqual(
+            num2words(101011001, True, "tr"), u"yüzbirmilyononbirbinbirinci"
+        )
+        self.assertEqual(
+            num2words(101011010, True, "tr"), u"yüzbirmilyononbirbinonuncu"
+        )
+        self.assertEqual(
+            num2words(1101011010, True, "tr"),
+            u"birmilyaryüzbirmilyononbirbinonuncu"
+        )
+        self.assertEqual(
+            num2words(101101011010, True, "tr"),
+            u"yüzbirmilyaryüzbirmilyononbirbinonuncu"
+        )
+        self.assertEqual(
+            num2words(1000000000001, True, "tr"), u"birtrilyonbirinci"
+        )

        self.assertEqual(num2words(1, False, "tr"), u"bir")
        self.assertEqual(num2words(2, False, "tr"), u"iki")
@@ -92,30 +129,65 @@ class Num2WordsTRTest(TestCase):
        self.assertEqual(num2words(10110, False, "tr"), u"onbinyüzon")
        self.assertEqual(num2words(11000, False, "tr"), u"onbirbin")
        self.assertEqual(num2words(35000, False, "tr"), u"otuzbeşbin")
-        self.assertEqual(num2words(116331, False, "tr"), u"yüzonaltıbinüçyüzotuzbir")
-        self.assertEqual(num2words(116330, False, "tr"), u"yüzonaltıbinüçyüzotuz")
+        self.assertEqual(
+            num2words(116331, False, "tr"), u"yüzonaltıbinüçyüzotuzbir"
+        )
+        self.assertEqual(
+            num2words(116330, False, "tr"), u"yüzonaltıbinüçyüzotuz"
+        )
        self.assertEqual(num2words(500000, False, "tr"), u"beşyüzbin")
        self.assertEqual(num2words(501000, False, "tr"), u"beşyüzbirbin")
        self.assertEqual(num2words(1000111, False, "tr"), u"birmilyonyüzonbir")
-        self.assertEqual(num2words(111000111, False, "tr"), u"yüzonbirmilyonyüzonbir")
-        self.assertEqual(num2words(111001111, False, "tr"), u"yüzonbirmilyonbinyüzonbir")
-        self.assertEqual(num2words(111111111, False, "tr"), u"yüzonbirmilyonyüzonbirbinyüzonbir")
+        self.assertEqual(
+            num2words(111000111, False, "tr"), u"yüzonbirmilyonyüzonbir"
+        )
+        self.assertEqual(
+            num2words(111001111, False, "tr"), u"yüzonbirmilyonbinyüzonbir"
+        )
+        self.assertEqual(
+            num2words(111111111, False, "tr"),
+            u"yüzonbirmilyonyüzonbirbinyüzonbir"
+        )
        self.assertEqual(num2words(100001000, False, "tr"), u"yüzmilyonbin")
        self.assertEqual(num2words(100001001, False, "tr"), u"yüzmilyonbinbir")
        self.assertEqual(num2words(100010000, False, "tr"), u"yüzmilyononbin")
-        self.assertEqual(num2words(100010001, False, "tr"), u"yüzmilyononbinbir")
-        self.assertEqual(num2words(100011000, False, "tr"), u"yüzmilyononbirbin")
-        self.assertEqual(num2words(100011001, False, "tr"), u"yüzmilyononbirbinbir")
-        self.assertEqual(num2words(101011001, False, "tr"), u"yüzbirmilyononbirbinbir")
-        self.assertEqual(num2words(101011010, False, "tr"), u"yüzbirmilyononbirbinon")
-        self.assertEqual(num2words(1101011010, False, "tr"), u"birmilyaryüzbirmilyononbirbinon")
-        self.assertEqual(num2words(101101011010, False, "tr"), u"yüzbirmilyaryüzbirmilyononbirbinon")
-        self.assertEqual(num2words(1000000000001, False, "tr"), u"birtrilyonbir")
+        self.assertEqual(
+            num2words(100010001, False, "tr"), u"yüzmilyononbinbir"
+        )
+        self.assertEqual(
+            num2words(100011000, False, "tr"), u"yüzmilyononbirbin"
+        )
+        self.assertEqual(
+            num2words(100011001, False, "tr"), u"yüzmilyononbirbinbir"
+        )
+        self.assertEqual(
+            num2words(101011001, False, "tr"), u"yüzbirmilyononbirbinbir"
+        )
+        self.assertEqual(
+            num2words(101011010, False, "tr"), u"yüzbirmilyononbirbinon"
+        )
+        self.assertEqual(
+            num2words(1101011010, False, "tr"),
+            u"birmilyaryüzbirmilyononbirbinon"
+        )
+        self.assertEqual(
+            num2words(101101011010, False, "tr"),
+            u"yüzbirmilyaryüzbirmilyononbirbinon"
+        )
+        self.assertEqual(
+            num2words(1000000000001, False, "tr"), u"birtrilyonbir"
+        )
        self.assertEqual(num2words(0.01, False, "tr"), u"sıfırvirgülbir")
        self.assertEqual(num2words(0.1, False, "tr"), u"sıfırvirgülon")
        self.assertEqual(num2words(0.21, False, "tr"), u"sıfırvirgülyirmibir")
        self.assertEqual(num2words(1.01, False, "tr"), u"birvirgülbir")
        self.assertEqual(num2words(1.1, False, "tr"), u"birvirgülon")
        self.assertEqual(num2words(1.21, False, "tr"), u"birvirgülyirmibir")
-        self.assertEqual(num2words(101101011010.02, False, "tr"), u"yüzbirmilyaryüzbirmilyononbirbinonvirgüliki")
-        self.assertEqual(num2words(101101011010.2, False, "tr"), u"yüzbirmilyaryüzbirmilyononbirbinonvirgülyirmi")
+        self.assertEqual(
+            num2words(101101011010.02, False, "tr"),
+            u"yüzbirmilyaryüzbirmilyononbirbinonvirgüliki"
+        )
+        self.assertEqual(
+            num2words(101101011010.2, False, "tr"),
+            u"yüzbirmilyaryüzbirmilyononbirbinonvirgülyirmi"
+        )
--- a/tests/test_uk.py
+++ b/tests/test_uk.py
@@ -18,12 +18,21 @@ from unittest import TestCase

 from num2words import num2words

+
 class Num2WordsUKTest(TestCase):
    def test_and_join_199(self):
-        self.assertEqual(num2words(187,lang='uk'), u"сто вiсiмдесят сiм")
+        self.assertEqual(num2words(187, lang='uk'), u"сто вiсiмдесят сiм")

    def test_cardinal_for_float_number(self):
-        self.assertEqual(num2words(12.40,lang='uk'), u"дванадцять кома чотири")
-        self.assertEqual(num2words(17.31,lang='uk'), u"сiмнадцять кома тридцять одна")
-        self.assertEqual(num2words(14.13,lang='uk'), u"чотирнадцять кома тринадцять")
-        self.assertEqual(num2words(12.31,lang='uk'), u"дванадцять кома тридцять одна")
+        self.assertEqual(
+            num2words(12.40, lang='uk'), u"дванадцять кома чотири"
+        )
+        self.assertEqual(
+            num2words(17.31, lang='uk'), u"сiмнадцять кома тридцять одна"
+        )
+        self.assertEqual(
+            num2words(14.13, lang='uk'), u"чотирнадцять кома тринадцять"
+        )
+        self.assertEqual(
+            num2words(12.31, lang='uk'), u"дванадцять кома тридцять одна"
+        )
--- a/tests/test_vn.py
+++ b/tests/test_vn.py
@@ -15,11 +15,13 @@
 # MA 02110-1301 USA

 from __future__ import unicode_literals
+
 from unittest import TestCase
+
 from num2words import num2words

-class Num2WordsVNTest(TestCase):

+class Num2WordsVNTest(TestCase):

    def test_0(self):
        self.assertEqual(num2words(0, lang="vi_VN"), "không")
@@ -50,35 +52,57 @@ class Num2WordsVNTest(TestCase):
    def test_100_to_999(self):
        self.assertEqual(num2words(100, lang="vi_VN"), "một trăm")
        self.assertEqual(num2words(150, lang="vi_VN"), "một trăm năm mươi")
-        self.assertEqual(num2words(196, lang="vi_VN"), "một trăm chín mươi sáu")
+        self.assertEqual(
+            num2words(196, lang="vi_VN"), "một trăm chín mươi sáu"
+        )
        self.assertEqual(num2words(200, lang="vi_VN"), "hai trăm")
        self.assertEqual(num2words(210, lang="vi_VN"), "hai trăm mười")

    def test_1000_to_9999(self):
        self.assertEqual(num2words(1000, lang="vi_VN"), "một nghìn")
        self.assertEqual(num2words(1500, lang="vi_VN"), "một nghìn năm trăm")
-        self.assertEqual(num2words(7378, lang="vi_VN"), "bảy nghìn ba trăm bảy mươi tám")
+        self.assertEqual(
+            num2words(7378, lang="vi_VN"), "bảy nghìn ba trăm bảy mươi tám"
+        )
        self.assertEqual(num2words(2000, lang="vi_VN"), "hai nghìn")
        self.assertEqual(num2words(2100, lang="vi_VN"), "hai nghìn một trăm")
-        self.assertEqual(num2words(6870, lang="vi_VN"), "sáu nghìn tám trăm bảy mươi")
+        self.assertEqual(
+            num2words(6870, lang="vi_VN"), "sáu nghìn tám trăm bảy mươi"
+        )
        self.assertEqual(num2words(10000, lang="vi_VN"), "mười nghìn")
        self.assertEqual(num2words(100000, lang="vi_VN"), "một trăm nghìn")
-        self.assertEqual(num2words(523456, lang="vi_VN"), "năm trăm hai mươi ba nghìn bốn trăm năm mươi sáu")
+        self.assertEqual(
+            num2words(523456, lang="vi_VN"),
+            "năm trăm hai mươi ba nghìn bốn trăm năm mươi sáu"
+        )

    def test_big(self):
        self.assertEqual(num2words(1000000, lang="vi_VN"), "một triệu")
-        self.assertEqual(num2words(1200000, lang="vi_VN"), "một triệu hai trăm nghìn")
+        self.assertEqual(
+            num2words(1200000, lang="vi_VN"), "một triệu hai trăm nghìn"
+        )
        self.assertEqual(num2words(3000000, lang="vi_VN"), "ba triệu")
-        self.assertEqual(num2words(3800000, lang="vi_VN"), "ba triệu tám trăm nghìn")
+        self.assertEqual(
+            num2words(3800000, lang="vi_VN"), "ba triệu tám trăm nghìn"
+        )
        self.assertEqual(num2words(1000000000, lang="vi_VN"), "một tỷ")
        self.assertEqual(num2words(2000000000, lang="vi_VN"), "hai tỷ")
-        self.assertEqual(num2words(2000001000, lang="vi_VN"), "hai tỷ một nghìn")
-        self.assertEqual(num2words(1234567890, lang="vi_VN"), "một tỷ hai trăm ba mươi bốn triệu năm trăm sáu mươi bảy nghìn tám trăm chín mươi")
-
+        self.assertEqual(
+            num2words(2000001000, lang="vi_VN"), "hai tỷ một nghìn"
+        )
+        self.assertEqual(
+            num2words(1234567890, lang="vi_VN"),
+            "một tỷ hai trăm ba mươi bốn triệu năm trăm sáu mươi bảy nghìn "
+            "tám trăm chín mươi"
+        )

    def test_decimal_number(self):
-        self.assertEqual(num2words(1000.11, lang="vi_VN"), "một nghìn phẩy mười một")
-        self.assertEqual(num2words(1000.21, lang="vi_VN"), "một nghìn phẩy hai mươi mốt")
+        self.assertEqual(
+            num2words(1000.11, lang="vi_VN"), "một nghìn phẩy mười một"
+        )
+        self.assertEqual(
+            num2words(1000.21, lang="vi_VN"), "một nghìn phẩy hai mươi mốt"
+        )

    def test_special_number(self):
        """
@@ -95,12 +119,20 @@ class Num2WordsVNTest(TestCase):
        # >1000
        self.assertEqual(num2words(1001, lang="vi_VN"), "một nghìn lẻ một")
        self.assertEqual(num2words(1005, lang="vi_VN"), "một nghìn lẻ năm")
-        self.assertEqual(num2words(98765, lang="vi_VN"), "chín mươi tám nghìn bảy trăm sáu mươi lăm")
+        self.assertEqual(
+            num2words(98765, lang="vi_VN"),
+            "chín mươi tám nghìn bảy trăm sáu mươi lăm"
+        )

        # > 1000000
        self.assertEqual(num2words(3000005, lang="vi_VN"), "ba triệu lẻ năm")
        self.assertEqual(num2words(1000007, lang="vi_VN"), "một triệu lẻ bảy")

        # > 1000000000
-        self.assertEqual(num2words(1000000017, lang="vi_VN"), "một tỷ lẻ mười bảy")
-        self.assertEqual(num2words(1000101017, lang="vi_VN"), "một tỷ một trăm lẻ một nghìn lẻ mười bảy")
+        self.assertEqual(
+            num2words(1000000017, lang="vi_VN"), "một tỷ lẻ mười bảy"
+        )
+        self.assertEqual(
+            num2words(1000101017, lang="vi_VN"),
+            "một tỷ một trăm lẻ một nghìn lẻ mười bảy"
+        )