From f030d7ec69c163b8f634406c3ab0250b45bcd49c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Bregar?= Date: Sat, 20 Jun 2015 20:18:26 +0200 Subject: [PATCH 1/6] =?UTF-8?q?Sloven=C5=A1=C4=8Dina?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- num2words/lang_SL.py | 146 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 146 insertions(+) create mode 100644 num2words/lang_SL.py diff --git a/num2words/lang_SL.py b/num2words/lang_SL.py new file mode 100644 index 0000000..7e6982e --- /dev/null +++ b/num2words/lang_SL.py @@ -0,0 +1,146 @@ +# -*- coding: utf-8 -*- +# Copyright (c) 2003, Taro Ogawa. All Rights Reserved. +# Copyright (c) 2013, Savoir-faire Linux inc. All Rights Reserved. +# Copyright (c) 2015, Blaz Bregar. All Rights Reserved. + +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, +# MA 02110-1301 USA + +# -*- coding: utf-8 -*- + +from __future__ import unicode_literals +from .lang_EU import Num2Word_EU + +class Num2Word_SL(Num2Word_EU): + def set_high_numwords(self, 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 + "iljon" + + + def setup(self): + self.negword = "minus " + self.pointword = "celih" + self.errmsg_nonnum = "Only numbers may be converted to words." + self.errmsg_toobig = "Number is too large to convert to words." + self.exclude_title = [] + + lows = ["non", "okt", "sept", "sext", "quint", "quadr", "tr", "b", "m"] + units = ["", "un", "duo", "tre", "quattuor", "quin", "sex", "sept", + "okto", "novem"] + tens = ["dez", "vigint", "trigint", "quadragint", "quinquagint", + "sexagint", "septuagint", "oktogint", "nonagint"] + self.high_numwords = ["zent"]+self.gen_high_numwords(units, tens, lows) + self.mid_numwords = [(1000, "tisoč "), (900, "devetsto"), (800, "osemsto"), + (700, "sedemsto"), (600, "šesto"), (500, "petsto"), (400, "štiristo"), (300, "tristo"), + (200, "dvesto"), (100, "sto"), + (90, "devetdeset"), (80, "osemdeset"), (70, "sedemdeset"), + (60, "šestdeset"), (50, "petdeset"), (40, "štirideset"), + (30, "trideset")] + self.low_numwords = ["dvajset", "devetnajst", "osemnajst", "sedemnajst", + "šestnajst", "petnajst", "štirinajst", "trinajst", + "dvanajst", "enajst", "deset", "devet", "osem", "sedem", + "šest", "pet", "štiri", "tri", "dva", "ena", + "nič"] + self.ords = { "ena" : "prvi", + "dve" : "drugi", + "acht" : "ach", + "sieben" : "sieb", + "ig" : "igs" } + self.ordflag = False + + + def merge(self, curr, next): + ctext, cnum, ntext, nnum = curr + next + + if cnum == 1: + if nnum < 10**6 or self.ordflag: + return next + ctext = "" + + if nnum > cnum: + if nnum >= 10**6: + if cnum > 1: + if ntext.endswith("d") or self.ordflag: + ntext += "" + else: + ntext += "ov" + ctext += " " + val = cnum * nnum + else: + if nnum < 10 < cnum < 100: + if nnum == 1: + ntext = "ena" + ntext, ctext = ctext, ntext + "in" + 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 + outword = self.to_cardinal(value) + self.ordflag = False + for key in self.ords: + if outword.endswith(key): + outword = outword[:len(outword) - len(key)] + self.ords[key] + break + return outword + "te" + + + # Is this correct?? + def to_ordinal_num(self, value): + self.verify_ordinal(value) + return str(value) + "te" + + + def to_currency(self, val, longval=True, old=False): + if old: + return self.to_splitnum(val, hightxt="evro/a/v", lowtxt="stotin/a/i/ov", + jointxt="in",longval=longval) + return super(Num2Word_SL, self).to_currency(val, jointxt="in", + longval=longval) + + def to_year(self, val, longval=True): + if not (val//100)%10: + return self.to_cardinal(val) + return self.to_splitnum(val, hightxt="hundert", longval=longval) + + + +n2w = Num2Word_SL() +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]: + n2w.test(val) + + n2w.test(1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730) + print n2w.to_currency(112121) + print n2w.to_year(2000) + +if __name__ == "__main__": + main() + From b796aab4eb7691da8524c0bc814195436c0f7368 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Bregar?= Date: Sat, 20 Jun 2015 20:21:37 +0200 Subject: [PATCH 2/6] =?UTF-8?q?Added=20Sloven=C5=A1=C4=8Dina=20(sl=5FSI)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- num2words/__init__.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/num2words/__init__.py b/num2words/__init__.py index 7719937..c57a2a9 100644 --- a/num2words/__init__.py +++ b/num2words/__init__.py @@ -24,6 +24,7 @@ from . import lang_DE from . import lang_ES from . import lang_LT from . import lang_LV +from . import lang_SL CONVERTER_CLASSES = { 'en': lang_EN.Num2Word_EN(), @@ -34,6 +35,7 @@ CONVERTER_CLASSES = { 'es': lang_ES.Num2Word_ES(), 'lt': lang_LT.Num2Word_LT(), 'lv': lang_LV.Num2Word_LV(), + 'sl': lang_SL.Num2Word_SL(), } def num2words(number, ordinal=False, lang='en'): From 49a39fc253a9529b547461e456c2cc3b0c2719f0 Mon Sep 17 00:00:00 2001 From: Ernesto Rodriguez Ortiz Date: Fri, 29 Sep 2017 15:29:25 -0400 Subject: [PATCH 3/6] Allow call to other convertes as to_currency, to_year There are at least to issues related with questions about how to use other convertes. This changes should allow the use of this converters --- num2words/__init__.py | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/num2words/__init__.py b/num2words/__init__.py index 69ad8db..a53456a 100644 --- a/num2words/__init__.py +++ b/num2words/__init__.py @@ -63,7 +63,10 @@ CONVERTER_CLASSES = { 'vi_VN': lang_VN.Num2Word_VN() } -def num2words(number, ordinal=False, lang='en'): +CONVERTES_TYPES = ['cardinal', 'ordinal', 'year', 'currency'] + + +def num2words(number, ordinal=False, lang='en', to='cardinal'): # We try the full language first if lang not in CONVERTER_CLASSES: # ... and then try only the first 2 letters @@ -71,7 +74,11 @@ def num2words(number, ordinal=False, lang='en'): if lang not in CONVERTER_CLASSES: raise NotImplementedError() converter = CONVERTER_CLASSES[lang] + # backwards compatible if ordinal: return converter.to_ordinal(number) - else: - return converter.to_cardinal(number) + + if to not in CONVERTES_TYPES: + raise NotImplementedError() + + return getattr(converter, 'to_{}'.format(to))(number) From 2f3acee36fefef2661d501bf7ac6aa1fd32769a5 Mon Sep 17 00:00:00 2001 From: Marc Ducobu Date: Thu, 19 Oct 2017 11:57:37 +0200 Subject: [PATCH 4/6] lang_DK do not depends on num2words --- num2words/lang_DK.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/num2words/lang_DK.py b/num2words/lang_DK.py index 64cf793..807b0f4 100644 --- a/num2words/lang_DK.py +++ b/num2words/lang_DK.py @@ -15,7 +15,7 @@ # MA 02110-1301 USA from __future__ import division, unicode_literals, print_function -from num2words import lang_EU +from . import lang_EU class Num2Word_DK(lang_EU.Num2Word_EU): def set_high_numwords(self, high): From 5d7697a85e92393cafb278e9dc1c21b8cceb4d49 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Bregar?= Date: Sun, 22 Oct 2017 15:50:55 +0200 Subject: [PATCH 5/6] resolved merge --- num2words/__init__.py | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/num2words/__init__.py b/num2words/__init__.py index c57a2a9..004986b 100644 --- a/num2words/__init__.py +++ b/num2words/__init__.py @@ -16,26 +16,60 @@ from __future__ import unicode_literals +from . import lang_AR from . import lang_EN from . import lang_EN_GB from . import lang_EN_IN from . import lang_FR +from . import lang_FR_CH +from . import lang_FR_DZ from . import lang_DE from . import lang_ES from . import lang_LT from . import lang_LV +from . import lang_PL +from . import lang_RU +from . import lang_ID +from . import lang_NO +from . import lang_DK +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_VN +from . import lang_TR +from . import lang_NL +from . import lang_UK from . import lang_SL CONVERTER_CLASSES = { + 'ar': lang_AR.Num2Word_AR(), 'en': lang_EN.Num2Word_EN(), 'en_GB': lang_EN_GB.Num2Word_EN_GB(), 'en_IN': lang_EN_IN.Num2Word_EN_IN(), 'fr': lang_FR.Num2Word_FR(), + 'fr_CH': lang_FR_CH.Num2Word_FR_CH(), + 'fr_DZ': lang_FR_DZ.Num2Word_FR_DZ(), 'de': lang_DE.Num2Word_DE(), 'es': lang_ES.Num2Word_ES(), + 'es_CO': lang_ES_CO.Num2Word_ES_CO(), + 'es_VE': lang_ES_VE.Num2Word_ES_VE(), + 'id': lang_ID.Num2Word_ID(), 'lt': lang_LT.Num2Word_LT(), 'lv': lang_LV.Num2Word_LV(), + 'pl': lang_PL.Num2Word_PL(), + 'ru': lang_RU.Num2Word_RU(), 'sl': lang_SL.Num2Word_SL(), + 'no': lang_NO.Num2Word_NO(), + 'dk': lang_DK.Num2Word_DK(), + 'pt_BR': lang_PT_BR.Num2Word_PT_BR(), + 'he': lang_HE.Num2Word_HE(), + 'it': lang_IT.Num2Word_IT(), + 'vi_VN': lang_VN.Num2Word_VN(), + 'tr': lang_TR.Num2Word_TR(), + 'nl': lang_NL.Num2Word_NL(), + 'uk': lang_UK.Num2Word_UK() } def num2words(number, ordinal=False, lang='en'): From 2ee0e49a8b4ba33f99967b6a70759bfdd0c93aed Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Bregar?= Date: Sun, 22 Oct 2017 18:06:49 +0200 Subject: [PATCH 6/6] Added Slovene --- README.rst | 3 +- num2words/lang_SL.py | 71 ++++++++++++++++++++++++++++---------------- tests/test_sl.py | 55 ++++++++++++++++++++++++++++++++++ 3 files changed, 102 insertions(+), 27 deletions(-) create mode 100644 tests/test_sl.py diff --git a/README.rst b/README.rst index 9cf9cc5..a65d706 100644 --- a/README.rst +++ b/README.rst @@ -4,7 +4,7 @@ num2words - Convert numbers to words in multiple languages .. image:: https://travis-ci.org/savoirfairelinux/num2words.svg?branch=master :target: https://travis-ci.org/savoirfairelinux/num2words -``num2words`` is a library that converts numbers like ``42`` to words like ``forty-two``. +``num2words`` is a library that converts numbers like ``42`` to words like ``forty-two``. It supports multiple languages (see the list below for full list of languages) and can even generate ordinal numbers like ``forty-second`` (although this last feature is a bit buggy for some languages at the moment). @@ -67,6 +67,7 @@ cardinal one. * ``no`` (Norwegian) * ``pl`` (Polish) * ``pt_BR`` (Brazilian Portuguese) +* ``sl`` (Slovene) * ``ru`` (Russian) * ``tr`` (Turkish) * ``vn`` (Vietnamese) diff --git a/num2words/lang_SL.py b/num2words/lang_SL.py index 7e6982e..4de0a90 100644 --- a/num2words/lang_SL.py +++ b/num2words/lang_SL.py @@ -37,14 +37,8 @@ class Num2Word_SL(Num2Word_EU): self.errmsg_toobig = "Number is too large to convert to words." self.exclude_title = [] - lows = ["non", "okt", "sept", "sext", "quint", "quadr", "tr", "b", "m"] - units = ["", "un", "duo", "tre", "quattuor", "quin", "sex", "sept", - "okto", "novem"] - tens = ["dez", "vigint", "trigint", "quadragint", "quinquagint", - "sexagint", "septuagint", "oktogint", "nonagint"] - self.high_numwords = ["zent"]+self.gen_high_numwords(units, tens, lows) - self.mid_numwords = [(1000, "tisoč "), (900, "devetsto"), (800, "osemsto"), - (700, "sedemsto"), (600, "šesto"), (500, "petsto"), (400, "štiristo"), (300, "tristo"), + self.mid_numwords = [(1000, "tisoč"), (900, "devetsto"), (800, "osemsto"), + (700, "sedemsto"), (600, "šesto"), (500, "petsto"), (400, "štiristo"), (300, "tristo"), (200, "dvesto"), (100, "sto"), (90, "devetdeset"), (80, "osemdeset"), (70, "sedemdeset"), (60, "šestdeset"), (50, "petdeset"), (40, "štirideset"), @@ -52,19 +46,27 @@ class Num2Word_SL(Num2Word_EU): self.low_numwords = ["dvajset", "devetnajst", "osemnajst", "sedemnajst", "šestnajst", "petnajst", "štirinajst", "trinajst", "dvanajst", "enajst", "deset", "devet", "osem", "sedem", - "šest", "pet", "štiri", "tri", "dva", "ena", + "šest", "pet", "štiri", "tri", "dve", "ena", "nič"] - self.ords = { "ena" : "prvi", - "dve" : "drugi", - "acht" : "ach", - "sieben" : "sieb", - "ig" : "igs" } + self.ords = { "ena" : "prv", + "dve" : "drug", + "tri" : "tretj", + "štiri" : "četrt", + "sedem" : "sedm", + "osem" : "osm", + "sto" : "stot", + "tisoč" : "tisoč", + "miljon" : "miljont" + } self.ordflag = False def merge(self, curr, next): ctext, cnum, ntext, nnum = curr + next + if ctext == "dve" and not self.ordflag: + ctext = "dva" + if cnum == 1: if nnum < 10**6 or self.ordflag: return next @@ -72,25 +74,43 @@ class Num2Word_SL(Num2Word_EU): if nnum > cnum: if nnum >= 10**6: - if cnum > 1: - if ntext.endswith("d") or self.ordflag: + if self.ordflag: + ntext += "t" + + elif cnum == 2: + if ntext.endswith("d"): + ntext += "i" + else: + ntext += "a" + + elif 2 < cnum < 5: + if ntext.endswith("d"): + ntext += "e" + elif not ntext.endswith("d"): + ntext += "i" + + else: + if ntext.endswith("d"): ntext += "" + elif ntext.endswith("d"): + ntext += "e" else: ntext += "ov" + + if nnum >= 10**2 and self.ordflag == False: ctext += " " + val = cnum * nnum else: if nnum < 10 < cnum < 100: - if nnum == 1: - ntext = "ena" ntext, ctext = ctext, ntext + "in" - elif cnum >= 10**6: + elif cnum >= 10**2 and self.ordflag == False: ctext += " " val = cnum + nnum word = ctext + ntext return (word, val) - + def to_ordinal(self, value): self.verify_ordinal(value) @@ -101,13 +121,13 @@ class Num2Word_SL(Num2Word_EU): if outword.endswith(key): outword = outword[:len(outword) - len(key)] + self.ords[key] break - return outword + "te" + return outword + "i" # Is this correct?? def to_ordinal_num(self, value): self.verify_ordinal(value) - return str(value) + "te" + return str(value) + "." def to_currency(self, val, longval=True, old=False): @@ -123,7 +143,7 @@ class Num2Word_SL(Num2Word_EU): return self.to_splitnum(val, hightxt="hundert", longval=longval) - + n2w = Num2Word_SL() to_card = n2w.to_cardinal to_ord = n2w.to_ordinal @@ -138,9 +158,8 @@ def main(): n2w.test(val) n2w.test(1325325436067876801768700107601001012212132143210473207540327057320957032975032975093275093275093270957329057320975093272950730) - print n2w.to_currency(112121) - print n2w.to_year(2000) + print(n2w.to_currency(112121)) + print(n2w.to_year(2000)) if __name__ == "__main__": main() - diff --git a/tests/test_sl.py b/tests/test_sl.py new file mode 100644 index 0000000..b41332f --- /dev/null +++ b/tests/test_sl.py @@ -0,0 +1,55 @@ +# -*- encoding: utf-8 -*- +# Copyright (c) 2015, Savoir-faire Linux inc. All Rights Reserved. + +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, +# MA 02110-1301 USA + +from __future__ import unicode_literals + +from 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") + self.assertEqual(num2words(4, ordinal=True, lang='sl'), "četrti") + self.assertEqual(num2words(7, ordinal=True, lang='sl'), "sedmi") + self.assertEqual(num2words(8, ordinal=True, lang='sl'), "osmi") + self.assertEqual(num2words(12, ordinal=True, lang='sl'), "dvanajsti") + 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") + + 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") + + 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(4000000000, lang='sl'), "štiri miljarde") + + def test_cardinal_for_decimal_number(self): + self.assertEqual(num2words(3.486, lang='sl'), "tri celih štiri osem") + + def test_ordinal_for_negative_numbers(self): + self.assertRaises(TypeError, num2words, -12, ordinal=True, lang='sl') + + def test_ordinal_for_floating_numbers(self): + self.assertRaises(TypeError, num2words, 2.453, ordinal=True, lang='sl')