Multitude of corrections of Slovene language (#246)

* Multitude of corrections of Slovene language

* Indentation correction for flake8

* Added tests from https://github.com/gregopet/num2words by @gregopet and merged them with existing.

* Flake8ing tests.

* Sorted imports

* Some more sorting...

* Last time for sorting?

num2words/__init__.py

@@ -17,40 +17,12 @@
 
 from __future__ import unicode_literals
 
-from . import lang_AR
+from . import (lang_AR, lang_CZ, lang_DE, lang_DK, lang_EN, lang_EN_IN,
-from . import lang_CZ
+               lang_ES, lang_ES_CO, lang_ES_VE, lang_FI, lang_FR, lang_FR_BE,
-from . import lang_EN
+               lang_FR_CH, lang_FR_DZ, lang_HE, lang_ID, lang_IT, lang_JA,
-from . import lang_EN_IN
+               lang_KO, lang_LT, lang_LV, lang_NL, lang_NO, lang_PL, lang_PT,
-from . import lang_FR
+               lang_PT_BR, lang_RO, lang_RU, lang_SL, lang_SR, lang_TH,
-from . import lang_FR_CH
+               lang_TR, lang_UK, lang_VI)
-from . import lang_FR_BE
-from . import lang_FR_DZ
-from . import lang_DE
-from . import lang_ES
-from . import lang_FI
-from . import lang_LT
-from . import lang_LV
-from . import lang_PL
-from . import lang_RO
-from . import lang_RU
-from . import lang_ID
-from . import lang_JA
-from . import lang_NO
-from . import lang_DK
-from . import lang_PT
-from . import lang_PT_BR
-from . import lang_HE
-from . import lang_IT
-from . import lang_ES_VE
-from . import lang_ES_CO
-from . import lang_VI
-from . import lang_TR
-from . import lang_NL
-from . import lang_UK
-from . import lang_SL
-from . import lang_SR
-from . import lang_TH
-from . import lang_KO
 
 CONVERTER_CLASSES = {
     'ar': lang_AR.Num2Word_AR(),

num2words/lang_SL.py

@@ -22,8 +22,8 @@ from .lang_EU import Num2Word_EU
 
 
 class Num2Word_SL(Num2Word_EU):
-    GIGA_SUFFIX = "iljard"
+    GIGA_SUFFIX = "ilijard"
-    MEGA_SUFFIX = "iljon"
+    MEGA_SUFFIX = "ilijon"
 
     def setup(self):
         super(Num2Word_SL, self).setup()
@@ -36,7 +36,7 @@ class Num2Word_SL(Num2Word_EU):
 
         self.mid_numwords = [(1000, "tisoč"), (900, "devetsto"),
                              (800, "osemsto"), (700, "sedemsto"),
-                             (600, "šesto"), (500, "petsto"),
+                             (600, "šeststo"), (500, "petsto"),
                              (400, "štiristo"), (300, "tristo"),
                              (200, "dvesto"), (100, "sto"),
                              (90, "devetdeset"), (80, "osemdeset"),
@@ -57,16 +57,31 @@ class Num2Word_SL(Num2Word_EU):
                      "osem": "osm",
                      "sto": "stot",
                      "tisoč": "tisoč",
-                     "miljon": "miljont"
+                     "milijon": "milijont"
                      }
         self.ordflag = False
 
     def merge(self, curr, next):
         ctext, cnum, ntext, nnum = curr + next
 
-        if ctext == "dve" and not self.ordflag:
+        if ctext.endswith("dve") and self.ordflag and nnum <= 1000000:
+            ctext = ctext[:len(ctext)-1] + "a"
+
+        if ctext == "dve" and not self.ordflag and nnum < 1000000000:
             ctext = "dva"
 
+        if (ctext.endswith("tri") or ctext.endswith("štiri")) and\
+           nnum == 1000000 and not self.ordflag:
+            if ctext.endswith("štiri"):
+                ctext = ctext[:-1]
+            ctext = ctext + "je"
+
+        if cnum >= 20 and cnum < 100 and nnum == 2:
+            ntext = "dva"
+
+        if ctext.endswith("ena") and nnum >= 1000:
+            ctext = ctext[0:-1]
+
         if cnum == 1:
             if nnum < 10**6 or self.ordflag:
                 return next
@@ -89,15 +104,28 @@ class Num2Word_SL(Num2Word_EU):
                     elif not ntext.endswith("d"):
                         ntext += "i"
 
+                elif ctext.endswith("en"):
+                    if ntext.endswith("d") or ntext.endswith("n"):
+                        ntext += ""
+
+                elif ctext.endswith("dve") and ntext.endswith("n"):
+                    ctext = ctext[:-1] + "a"
+                    ntext += "a"
+
+                elif ctext.endswith("je") and ntext.endswith("n"):
+                    ntext += "i"
+
                 else:
                     if ntext.endswith("d"):
+                        ntext += "a"
+                    elif ntext.endswith("n"):
                         ntext += ""
                     elif ntext.endswith("d"):
                         ntext += "e"
                     else:
                         ntext += "ov"
 
-            if nnum >= 10**2 and self.ordflag is False:
+            if nnum >= 10**2 and self.ordflag is False and ctext:
                 ctext += " "
 
             val = cnum * nnum

tests/test_cli.py

@@ -22,6 +22,7 @@ import os
 import unittest
 
 import delegator
+
 import num2words
 
 

tests/test_sl.py

@@ -22,7 +22,7 @@ from unittest import TestCase
 from num2words import num2words
 
 
-class Num2WordsDETest(TestCase):
+class Num2WordsSLTest(TestCase):
     def test_ordinal_less_than_twenty(self):
         self.assertEqual(num2words(2, ordinal=True, lang='sl'), "drugi")
         self.assertEqual(num2words(4, ordinal=True, lang='sl'), "četrti")
@@ -43,17 +43,160 @@ class Num2WordsDETest(TestCase):
             num2words(4000, ordinal=True, lang='sl'), "štiritisoči"
         )
         self.assertEqual(
-            num2words(2000000, ordinal=True, lang='sl'), "dvemiljonti"
+            num2words(2000000, ordinal=True, lang='sl'), "dvamilijonti"
         )
         self.assertEqual(
-            num2words(5000000000, ordinal=True, lang='sl'), "petmiljardti"
+            num2words(5000000000, ordinal=True, lang='sl'), "petmilijardti"
         )
 
+    def test_ordinal_numbers_from_repository_of_test_cases(self):
+        # Tests were compiled from cases in
+        # https://github.com/gregopet/zapis-slovenskih-stevil
+        # The male gender is used by the project so those test cases were
+        # copied
+        self.assertEqual(num2words(1, ordinal=True, lang='sl'), "prvi")
+        self.assertEqual(num2words(2, ordinal=True, lang='sl'), "drugi")
+        self.assertEqual(num2words(3, ordinal=True, lang='sl'), "tretji")
+        self.assertEqual(num2words(4, ordinal=True, lang='sl'), "četrti")
+        self.assertEqual(num2words(5, ordinal=True, lang='sl'), "peti")
+        self.assertEqual(num2words(6, ordinal=True, lang='sl'), "šesti")
+        self.assertEqual(num2words(7, ordinal=True, lang='sl'), "sedmi")
+        self.assertEqual(num2words(8, ordinal=True, lang='sl'), "osmi")
+        self.assertEqual(num2words(9, ordinal=True, lang='sl'), "deveti")
+        self.assertEqual(num2words(10, ordinal=True, lang='sl'), "deseti")
+        self.assertEqual(num2words(100, ordinal=True, lang='sl'), "stoti")
+        self.assertEqual(num2words(101, ordinal=True, lang='sl'), "stoprvi")
+        self.assertEqual(num2words(102, ordinal=True, lang='sl'), "stodrugi")
+        self.assertEqual(num2words(103, ordinal=True, lang='sl'), "stotretji")
+        self.assertEqual(num2words(104, ordinal=True, lang='sl'), "stočetrti")
+        self.assertEqual(num2words(105, ordinal=True, lang='sl'), "stopeti")
+        self.assertEqual(num2words(106, ordinal=True, lang='sl'), "stošesti")
+        self.assertEqual(num2words(200, ordinal=True, lang='sl'), "dvestoti")
+        self.assertEqual(num2words(1000, ordinal=True, lang='sl'), "tisoči")
+        self.assertEqual(num2words(1001, ordinal=True, lang='sl'), "tisočprvi")
+        self.assertEqual(num2words(1002, ordinal=True, lang='sl'),
+                         "tisočdrugi")
+        self.assertEqual(num2words(1003, ordinal=True, lang='sl'),
+                         "tisočtretji")
+        self.assertEqual(num2words(1004, ordinal=True, lang='sl'),
+                         "tisoččetrti")
+        self.assertEqual(num2words(1005, ordinal=True, lang='sl'),
+                         "tisočpeti")
+        self.assertEqual(num2words(1006, ordinal=True, lang='sl'),
+                         "tisočšesti")
+        self.assertEqual(num2words(2000, ordinal=True, lang='sl'),
+                         "dvatisoči")
+        self.assertEqual(num2words(20000, ordinal=True, lang='sl'),
+                         "dvajsettisoči")
+        self.assertEqual(num2words(200000, ordinal=True, lang='sl'),
+                         "dvestotisoči")
+        self.assertEqual(num2words(1000000, ordinal=True, lang='sl'),
+                         "milijonti")
+        self.assertEqual(num2words(2000000, ordinal=True, lang='sl'),
+                         "dvamilijonti")
+        self.assertEqual(num2words(3000000, ordinal=True, lang='sl'),
+                         "trimilijonti")
+        self.assertEqual(num2words(101000000, ordinal=True, lang='sl'),
+                         "stoenmilijonti")
+        self.assertEqual(num2words(202000000, ordinal=True, lang='sl'),
+                         "dvestodvamilijonti")
+        self.assertEqual(num2words(1121, ordinal=True, lang='sl'),
+                         "tisočstoenaindvajseti")
+        self.assertEqual(num2words(2405, ordinal=True, lang='sl'),
+                         "dvatisočštiristopeti")
+
     def test_cardinal_at_some_numbers(self):
         self.assertEqual(num2words(2, lang='sl'), "dve")
         self.assertEqual(num2words(4000, lang='sl'), "štiri tisoč")
-        self.assertEqual(num2words(2000000, lang='sl'), "dva miljona")
+        self.assertEqual(num2words(2000000, lang='sl'), "dva milijona")
-        self.assertEqual(num2words(4000000000, lang='sl'), "štiri miljarde")
+        self.assertEqual(num2words(4000000000, lang='sl'), "štiri milijarde")
+
+    def test_cardinal_numbers_from_repository_of_test_cases(self):
+        # Tests were compiled from cases in
+        # https://github.com/gregopet/zapis-slovenskih-stevil
+        self.assertEqual(num2words(0, lang='sl'), "nič")
+        self.assertEqual(num2words(1, lang='sl'), "ena")
+        self.assertEqual(num2words(2, lang='sl'), "dve")
+        self.assertEqual(num2words(3, lang='sl'), "tri")
+        self.assertEqual(num2words(4, lang='sl'), "štiri")
+        self.assertEqual(num2words(5, lang='sl'), "pet")
+        self.assertEqual(num2words(6, lang='sl'), "šest")
+        self.assertEqual(num2words(7, lang='sl'), "sedem")
+        self.assertEqual(num2words(8, lang='sl'), "osem")
+        self.assertEqual(num2words(9, lang='sl'), "devet")
+        self.assertEqual(num2words(10, lang='sl'), "deset")
+        self.assertEqual(num2words(11, lang='sl'), "enajst")
+        self.assertEqual(num2words(12, lang='sl'), "dvanajst")
+        self.assertEqual(num2words(13, lang='sl'), "trinajst")
+        self.assertEqual(num2words(14, lang='sl'), "štirinajst")
+        self.assertEqual(num2words(15, lang='sl'), "petnajst")
+        self.assertEqual(num2words(16, lang='sl'), "šestnajst")
+        self.assertEqual(num2words(17, lang='sl'), "sedemnajst")
+        self.assertEqual(num2words(18, lang='sl'), "osemnajst")
+        self.assertEqual(num2words(19, lang='sl'), "devetnajst")
+        self.assertEqual(num2words(20, lang='sl'), "dvajset")
+        self.assertEqual(num2words(21, lang='sl'), "enaindvajset")
+        self.assertEqual(num2words(22, lang='sl'), "dvaindvajset")
+        self.assertEqual(num2words(23, lang='sl'), "triindvajset")
+        self.assertEqual(num2words(24, lang='sl'), "štiriindvajset")
+        self.assertEqual(num2words(25, lang='sl'), "petindvajset")
+        self.assertEqual(num2words(26, lang='sl'), "šestindvajset")
+        self.assertEqual(num2words(27, lang='sl'), "sedemindvajset")
+        self.assertEqual(num2words(28, lang='sl'), "osemindvajset")
+        self.assertEqual(num2words(29, lang='sl'), "devetindvajset")
+        self.assertEqual(num2words(30, lang='sl'), "trideset")
+        self.assertEqual(num2words(40, lang='sl'), "štirideset")
+        self.assertEqual(num2words(50, lang='sl'), "petdeset")
+        self.assertEqual(num2words(60, lang='sl'), "šestdeset")
+        self.assertEqual(num2words(70, lang='sl'), "sedemdeset")
+        self.assertEqual(num2words(80, lang='sl'), "osemdeset")
+        self.assertEqual(num2words(90, lang='sl'), "devetdeset")
+        self.assertEqual(num2words(100, lang='sl'), "sto")
+        self.assertEqual(num2words(101, lang='sl'), "sto ena")
+        self.assertEqual(num2words(102, lang='sl'), "sto dve")
+        self.assertEqual(num2words(103, lang='sl'), "sto tri")
+        self.assertEqual(num2words(104, lang='sl'), "sto štiri")
+        self.assertEqual(num2words(105, lang='sl'), "sto pet")
+        self.assertEqual(num2words(106, lang='sl'), "sto šest")
+        self.assertEqual(num2words(200, lang='sl'), "dvesto")
+        self.assertEqual(num2words(300, lang='sl'), "tristo")
+        self.assertEqual(num2words(400, lang='sl'), "štiristo")
+        self.assertEqual(num2words(500, lang='sl'), "petsto")
+        self.assertEqual(num2words(600, lang='sl'), "šeststo")
+        self.assertEqual(num2words(700, lang='sl'), "sedemsto")
+        self.assertEqual(num2words(800, lang='sl'), "osemsto")
+        self.assertEqual(num2words(900, lang='sl'), "devetsto")
+        self.assertEqual(num2words(1000, lang='sl'), "tisoč")
+        self.assertEqual(num2words(1001, lang='sl'), "tisoč ena")
+        self.assertEqual(num2words(1002, lang='sl'), "tisoč dve")
+        self.assertEqual(num2words(1003, lang='sl'), "tisoč tri")
+        self.assertEqual(num2words(1004, lang='sl'), "tisoč štiri")
+        self.assertEqual(num2words(1005, lang='sl'), "tisoč pet")
+        self.assertEqual(num2words(1006, lang='sl'), "tisoč šest")
+        self.assertEqual(num2words(2000, lang='sl'), "dva tisoč")
+        self.assertEqual(num2words(20000, lang='sl'), "dvajset tisoč")
+        self.assertEqual(num2words(100000, lang='sl'), "sto tisoč")
+        self.assertEqual(num2words(101000, lang='sl'), "sto en tisoč")
+        self.assertEqual(num2words(200000, lang='sl'), "dvesto tisoč")
+        self.assertEqual(num2words(1000000, lang='sl'), "milijon")
+        self.assertEqual(num2words(2000000, lang='sl'), "dva milijona")
+        self.assertEqual(num2words(3000000, lang='sl'), "trije milijoni")
+        self.assertEqual(num2words(101000000, lang='sl'), "sto en milijon")
+        self.assertEqual(num2words(202000000, lang='sl'),
+                         "dvesto dva milijona")
+        self.assertEqual(num2words(303000000, lang='sl'),
+                         "tristo trije milijoni")
+        self.assertEqual(num2words(304000000, lang='sl'),
+                         "tristo štirje milijoni")
+        self.assertEqual(num2words(1000000000, lang='sl'), "milijarda")
+        self.assertEqual(num2words(2000000000, lang='sl'), "dve milijardi")
+        self.assertEqual(num2words(1121, lang='sl'), "tisoč sto enaindvajset")
+        self.assertEqual(num2words(2401, lang='sl'), "dva tisoč štiristo ena")
+        self.assertEqual(num2words(201001004, lang='sl'),
+                         "dvesto en milijon tisoč štiri")
+        self.assertEqual(
+            num2words(1803603801, lang='sl'),
+            "milijarda osemsto trije milijoni šeststo tri tisoč osemsto ena")
 
     def test_cardinal_for_decimal_number(self):
         self.assertEqual(num2words(3.48, lang='sl'), "tri celih štiri osem")