From 905faa20fcb8aba57d1aac6eed987653acf8b9af Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Moreno?= Date: Thu, 16 Mar 2017 16:31:43 -0500 Subject: [PATCH 1/8] [IMP]Adds new files for ES_CO and ES_VE. --- num2words/lang_ES_CO.py | 183 ++++++++++++++++++++++++++++++++++++++++ num2words/lang_ES_VE.py | 183 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 366 insertions(+) create mode 100644 num2words/lang_ES_CO.py create mode 100644 num2words/lang_ES_VE.py diff --git a/num2words/lang_ES_CO.py b/num2words/lang_ES_CO.py new file mode 100644 index 0000000..9302c7d --- /dev/null +++ b/num2words/lang_ES_CO.py @@ -0,0 +1,183 @@ +# encoding: UTF-8 + +# Copyright (c) 2003, Taro Ogawa. All Rights Reserved. +# Copyright (c) 2013, 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, print_function +from .lang_EU import Num2Word_EU + + +class Num2Word_ES(Num2Word_EU): + # //CHECK: Is this sufficient?? + def set_high_numwords(self, high): + max = 3 + 6*len(high) + + for word, n in zip(high, range(max, 3, -6)): + self.cards[10**(n-3)] = word + "illón" + + def setup(self): + lows = ["cuatr", "tr", "b", "m"] + self.high_numwords = self.gen_high_numwords([], [], lows) + self.negword = "menos " + self.pointword = "punto" + self.errmsg_nonnum = "Solo números pueden ser convertidos a letras." + self.errmsg_toobig = "Numero muy grande para ser convertido a letras." + self.gender_stem = "o" + self.exclude_title = ["y", "menos", "punto"] + self.mid_numwords = [(1000, "mil"), (100, "cien"), + (90, "noventa"), (80, "ochenta"), + (70, "setenta"), (60, "sesenta"), + (50, "cincuenta"), (40, "cuarenta"), + (30, "treinta")] + self.low_numwords = ["veintinueve", "veintiocho", "veintisiete", + "veintiséis", "veinticinco", "veinticuatro", + "veintitrés", "veintidós", "veintiuno", + "veinte", "diecinueve", "dieciocho", "diecisiete", + "dieciseis", "quince", "catorce", "trece", "doce", + "once", "diez", "nueve", "ocho", "siete", "seis", + "cinco", "cuatro", "tres", "dos", "uno", "cero"] + self.ords = { + 1: "primer", + 2: "segund", + 3: "tercer", + 4: "cuart", + 5: "quint", + 6: "sext", + 7: "séptim", + 8: "octav", + 9: "noven", + 10: "décim", + 20: "vigésim", + 30: "trigésim", + 40: "quadragésim", + 50: "quincuagésim", + 60: "sexagésim", + 70: "septuagésim", + 80: "octogésim", + 90: "nonagésim", + 100: "centésim", + 200: "ducentésim", + 300: "tricentésim", + 400: "cuadrigentésim", + 500: "quingentésim", + 600: "sexcentésim", + 700: "septigentésim", + 800: "octigentésim", + 900: "noningentésim", + 1e3: "milésim", + 1e6: "millonésim", + 1e9: "billonésim", + 1e12: "trillonésim", + 1e15: "cuadrillonésim" + } + + def merge(self, curr, next): + ctext, cnum, ntext, nnum = curr + next + + if cnum == 1: + if nnum < 1000000: + return next + ctext = "un" + elif cnum == 100 and not nnum == 1000: + ctext += "t" + self.gender_stem + + if nnum < cnum: + if cnum < 100: + return ("%s y %s" % (ctext, ntext), cnum + nnum) + return ("%s %s" % (ctext, ntext), cnum + nnum) + elif (not nnum % 1000000) and cnum > 1: + ntext = ntext[:-3] + "lones" + + if nnum == 100: + if cnum == 5: + ctext = "quinien" + ntext = "" + elif cnum == 7: + ctext = "sete" + elif cnum == 9: + ctext = "nove" + ntext += "t" + self.gender_stem + "s" + else: + ntext = " " + ntext + + return (ctext + ntext, cnum * nnum) + + def to_ordinal(self, value): + self.verify_ordinal(value) + text = "" + try: + if value == 0: + text = "" + elif value <= 10: + text = "%s%s" % (self.ords[value], self.gender_stem) + elif value <= 12: + text = "%s%s%s" % (self.ords[10], self.gender_stem, self.to_ordinal(value - 10)) + elif value <= 100: + dec = (value / 10) * 10 + text = "%s%s %s" % (self.ords[dec], self.gender_stem, self.to_ordinal(value - dec)) + elif value <= 1e3: + cen = (value / 100) * 100 + text = "%s%s %s" % (self.ords[cen], self.gender_stem, self.to_ordinal(value - cen)) + elif value < 1e18: + # dec contains the following: + # [ 1e3, 1e6): 1e3 + # [ 1e6, 1e9): 1e6 + # [ 1e9, 1e12): 1e9 + # [1e12, 1e15): 1e12 + # [1e15, 1e18): 1e15 + dec = 10 ** ((((len(str(int(value))) - 1) / 3 - 1) + 1) * 3) + part = int(float(value / dec) * dec) + cardinal = self.to_cardinal(part / dec) if part / dec != 1 else "" + text = "%s%s%s %s" % (cardinal, self.ords[dec], self.gender_stem, self.to_ordinal(value - part)) + else: + text = self.to_cardinal(value) + except KeyError: + text = self.to_cardinal(value) + return text.strip() + + def to_ordinal_num(self, value): + self.verify_ordinal(value) + return "%s%s" % (value, "º" if self.gender_stem == 'o' else "ª") + + def to_currency(self, val, longval=True, old=False): + if old: + return self.to_splitnum(val, hightxt="peso/s", lowtxt="peso/s", + divisor=1000, jointxt="y", longval=longval) + return super(Num2Word_ES, self).to_currency(val, jointxt="y", + longval=longval) + + +n2w = Num2Word_ES() +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(1222)) + print(n2w.to_currency(1222, old=True)) + print(n2w.to_year(1222)) + + +if __name__ == "__main__": + main() diff --git a/num2words/lang_ES_VE.py b/num2words/lang_ES_VE.py new file mode 100644 index 0000000..d174d07 --- /dev/null +++ b/num2words/lang_ES_VE.py @@ -0,0 +1,183 @@ +# encoding: UTF-8 + +# Copyright (c) 2003, Taro Ogawa. All Rights Reserved. +# Copyright (c) 2013, 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, print_function +from .lang_EU import Num2Word_EU + + +class Num2Word_ES(Num2Word_EU): + # //CHECK: Is this sufficient?? + def set_high_numwords(self, high): + max = 3 + 6*len(high) + + for word, n in zip(high, range(max, 3, -6)): + self.cards[10**(n-3)] = word + "illón" + + def setup(self): + lows = ["cuatr", "tr", "b", "m"] + self.high_numwords = self.gen_high_numwords([], [], lows) + self.negword = "menos " + self.pointword = "punto" + self.errmsg_nonnum = "Solo números pueden ser convertidos a letras." + self.errmsg_toobig = "Numero muy grande para ser convertido a letras." + self.gender_stem = "o" + self.exclude_title = ["y", "menos", "punto"] + self.mid_numwords = [(1000, "mil"), (100, "cien"), + (90, "noventa"), (80, "ochenta"), + (70, "setenta"), (60, "sesenta"), + (50, "cincuenta"), (40, "cuarenta"), + (30, "treinta")] + self.low_numwords = ["veintinueve", "veintiocho", "veintisiete", + "veintiséis", "veinticinco", "veinticuatro", + "veintitrés", "veintidós", "veintiuno", + "veinte", "diecinueve", "dieciocho", "diecisiete", + "dieciseis", "quince", "catorce", "trece", "doce", + "once", "diez", "nueve", "ocho", "siete", "seis", + "cinco", "cuatro", "tres", "dos", "uno", "cero"] + self.ords = { + 1: "primer", + 2: "segund", + 3: "tercer", + 4: "cuart", + 5: "quint", + 6: "sext", + 7: "séptim", + 8: "octav", + 9: "noven", + 10: "décim", + 20: "vigésim", + 30: "trigésim", + 40: "quadragésim", + 50: "quincuagésim", + 60: "sexagésim", + 70: "septuagésim", + 80: "octogésim", + 90: "nonagésim", + 100: "centésim", + 200: "ducentésim", + 300: "tricentésim", + 400: "cuadrigentésim", + 500: "quingentésim", + 600: "sexcentésim", + 700: "septigentésim", + 800: "octigentésim", + 900: "noningentésim", + 1e3: "milésim", + 1e6: "millonésim", + 1e9: "billonésim", + 1e12: "trillonésim", + 1e15: "cuadrillonésim" + } + + def merge(self, curr, next): + ctext, cnum, ntext, nnum = curr + next + + if cnum == 1: + if nnum < 1000000: + return next + ctext = "un" + elif cnum == 100 and not nnum == 1000: + ctext += "t" + self.gender_stem + + if nnum < cnum: + if cnum < 100: + return ("%s y %s" % (ctext, ntext), cnum + nnum) + return ("%s %s" % (ctext, ntext), cnum + nnum) + elif (not nnum % 1000000) and cnum > 1: + ntext = ntext[:-3] + "lones" + + if nnum == 100: + if cnum == 5: + ctext = "quinien" + ntext = "" + elif cnum == 7: + ctext = "sete" + elif cnum == 9: + ctext = "nove" + ntext += "t" + self.gender_stem + "s" + else: + ntext = " " + ntext + + return (ctext + ntext, cnum * nnum) + + def to_ordinal(self, value): + self.verify_ordinal(value) + text = "" + try: + if value == 0: + text = "" + elif value <= 10: + text = "%s%s" % (self.ords[value], self.gender_stem) + elif value <= 12: + text = "%s%s%s" % (self.ords[10], self.gender_stem, self.to_ordinal(value - 10)) + elif value <= 100: + dec = (value / 10) * 10 + text = "%s%s %s" % (self.ords[dec], self.gender_stem, self.to_ordinal(value - dec)) + elif value <= 1e3: + cen = (value / 100) * 100 + text = "%s%s %s" % (self.ords[cen], self.gender_stem, self.to_ordinal(value - cen)) + elif value < 1e18: + # dec contains the following: + # [ 1e3, 1e6): 1e3 + # [ 1e6, 1e9): 1e6 + # [ 1e9, 1e12): 1e9 + # [1e12, 1e15): 1e12 + # [1e15, 1e18): 1e15 + dec = 10 ** ((((len(str(int(value))) - 1) / 3 - 1) + 1) * 3) + part = int(float(value / dec) * dec) + cardinal = self.to_cardinal(part / dec) if part / dec != 1 else "" + text = "%s%s%s %s" % (cardinal, self.ords[dec], self.gender_stem, self.to_ordinal(value - part)) + else: + text = self.to_cardinal(value) + except KeyError: + text = self.to_cardinal(value) + return text.strip() + + def to_ordinal_num(self, value): + self.verify_ordinal(value) + return "%s%s" % (value, "º" if self.gender_stem == 'o' else "ª") + + def to_currency(self, val, longval=True, old=False): + if old: + return self.to_splitnum(val, hightxt="bolívar/es Fuerte/s", lowtxt="bolívar/es fuerte/s", + divisor=1000, jointxt="y", longval=longval) + return super(Num2Word_ES, self).to_currency(val, jointxt="y", + longval=longval) + + +n2w = Num2Word_ES() +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(1222)) + print(n2w.to_currency(1222, old=True)) + print(n2w.to_year(1222)) + + +if __name__ == "__main__": + main() From b0bca269244d5e5e17a9a8fede49e881bc0db8d9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Moreno?= Date: Thu, 16 Mar 2017 16:33:33 -0500 Subject: [PATCH 2/8] [IMP]Adds new files for ES_CO and ES_VE. --- num2words/lang_ES_CO.py | 2 +- num2words/lang_ES_VE.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/num2words/lang_ES_CO.py b/num2words/lang_ES_CO.py index 9302c7d..b719e05 100644 --- a/num2words/lang_ES_CO.py +++ b/num2words/lang_ES_CO.py @@ -20,7 +20,7 @@ from __future__ import unicode_literals, print_function from .lang_EU import Num2Word_EU -class Num2Word_ES(Num2Word_EU): +class Num2Word_ES_CO(Num2Word_EU): # //CHECK: Is this sufficient?? def set_high_numwords(self, high): max = 3 + 6*len(high) diff --git a/num2words/lang_ES_VE.py b/num2words/lang_ES_VE.py index d174d07..1e7e3b0 100644 --- a/num2words/lang_ES_VE.py +++ b/num2words/lang_ES_VE.py @@ -20,7 +20,7 @@ from __future__ import unicode_literals, print_function from .lang_EU import Num2Word_EU -class Num2Word_ES(Num2Word_EU): +class Num2Word_ES_VE(Num2Word_EU): # //CHECK: Is this sufficient?? def set_high_numwords(self, high): max = 3 + 6*len(high) From aff876c4a6667eb47ea4edb7d1696269fede3fac Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Moreno?= Date: Mon, 27 Mar 2017 10:23:34 -0500 Subject: [PATCH 3/8] [IMP]Reworked the files ES_CO and ES_VE. --- num2words/lang_ES_CO.py | 136 +--------------------------------------- num2words/lang_ES_VE.py | 136 +--------------------------------------- 2 files changed, 6 insertions(+), 266 deletions(-) diff --git a/num2words/lang_ES_CO.py b/num2words/lang_ES_CO.py index b719e05..d72fe40 100644 --- a/num2words/lang_ES_CO.py +++ b/num2words/lang_ES_CO.py @@ -17,140 +17,10 @@ # MA 02110-1301 USA from __future__ import unicode_literals, print_function -from .lang_EU import Num2Word_EU +from .lang_ES import Num2Word_ES -class Num2Word_ES_CO(Num2Word_EU): - # //CHECK: Is this sufficient?? - 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-3)] = word + "illón" - - def setup(self): - lows = ["cuatr", "tr", "b", "m"] - self.high_numwords = self.gen_high_numwords([], [], lows) - self.negword = "menos " - self.pointword = "punto" - self.errmsg_nonnum = "Solo números pueden ser convertidos a letras." - self.errmsg_toobig = "Numero muy grande para ser convertido a letras." - self.gender_stem = "o" - self.exclude_title = ["y", "menos", "punto"] - self.mid_numwords = [(1000, "mil"), (100, "cien"), - (90, "noventa"), (80, "ochenta"), - (70, "setenta"), (60, "sesenta"), - (50, "cincuenta"), (40, "cuarenta"), - (30, "treinta")] - self.low_numwords = ["veintinueve", "veintiocho", "veintisiete", - "veintiséis", "veinticinco", "veinticuatro", - "veintitrés", "veintidós", "veintiuno", - "veinte", "diecinueve", "dieciocho", "diecisiete", - "dieciseis", "quince", "catorce", "trece", "doce", - "once", "diez", "nueve", "ocho", "siete", "seis", - "cinco", "cuatro", "tres", "dos", "uno", "cero"] - self.ords = { - 1: "primer", - 2: "segund", - 3: "tercer", - 4: "cuart", - 5: "quint", - 6: "sext", - 7: "séptim", - 8: "octav", - 9: "noven", - 10: "décim", - 20: "vigésim", - 30: "trigésim", - 40: "quadragésim", - 50: "quincuagésim", - 60: "sexagésim", - 70: "septuagésim", - 80: "octogésim", - 90: "nonagésim", - 100: "centésim", - 200: "ducentésim", - 300: "tricentésim", - 400: "cuadrigentésim", - 500: "quingentésim", - 600: "sexcentésim", - 700: "septigentésim", - 800: "octigentésim", - 900: "noningentésim", - 1e3: "milésim", - 1e6: "millonésim", - 1e9: "billonésim", - 1e12: "trillonésim", - 1e15: "cuadrillonésim" - } - - def merge(self, curr, next): - ctext, cnum, ntext, nnum = curr + next - - if cnum == 1: - if nnum < 1000000: - return next - ctext = "un" - elif cnum == 100 and not nnum == 1000: - ctext += "t" + self.gender_stem - - if nnum < cnum: - if cnum < 100: - return ("%s y %s" % (ctext, ntext), cnum + nnum) - return ("%s %s" % (ctext, ntext), cnum + nnum) - elif (not nnum % 1000000) and cnum > 1: - ntext = ntext[:-3] + "lones" - - if nnum == 100: - if cnum == 5: - ctext = "quinien" - ntext = "" - elif cnum == 7: - ctext = "sete" - elif cnum == 9: - ctext = "nove" - ntext += "t" + self.gender_stem + "s" - else: - ntext = " " + ntext - - return (ctext + ntext, cnum * nnum) - - def to_ordinal(self, value): - self.verify_ordinal(value) - text = "" - try: - if value == 0: - text = "" - elif value <= 10: - text = "%s%s" % (self.ords[value], self.gender_stem) - elif value <= 12: - text = "%s%s%s" % (self.ords[10], self.gender_stem, self.to_ordinal(value - 10)) - elif value <= 100: - dec = (value / 10) * 10 - text = "%s%s %s" % (self.ords[dec], self.gender_stem, self.to_ordinal(value - dec)) - elif value <= 1e3: - cen = (value / 100) * 100 - text = "%s%s %s" % (self.ords[cen], self.gender_stem, self.to_ordinal(value - cen)) - elif value < 1e18: - # dec contains the following: - # [ 1e3, 1e6): 1e3 - # [ 1e6, 1e9): 1e6 - # [ 1e9, 1e12): 1e9 - # [1e12, 1e15): 1e12 - # [1e15, 1e18): 1e15 - dec = 10 ** ((((len(str(int(value))) - 1) / 3 - 1) + 1) * 3) - part = int(float(value / dec) * dec) - cardinal = self.to_cardinal(part / dec) if part / dec != 1 else "" - text = "%s%s%s %s" % (cardinal, self.ords[dec], self.gender_stem, self.to_ordinal(value - part)) - else: - text = self.to_cardinal(value) - except KeyError: - text = self.to_cardinal(value) - return text.strip() - - def to_ordinal_num(self, value): - self.verify_ordinal(value) - return "%s%s" % (value, "º" if self.gender_stem == 'o' else "ª") +class Num2Word_ES_CO(Num2Word_ES): def to_currency(self, val, longval=True, old=False): if old: @@ -160,7 +30,7 @@ class Num2Word_ES_CO(Num2Word_EU): longval=longval) -n2w = Num2Word_ES() +n2w = Num2Word_ES_CO() to_card = n2w.to_cardinal to_ord = n2w.to_ordinal to_ordnum = n2w.to_ordinal_num diff --git a/num2words/lang_ES_VE.py b/num2words/lang_ES_VE.py index 1e7e3b0..2ad8150 100644 --- a/num2words/lang_ES_VE.py +++ b/num2words/lang_ES_VE.py @@ -17,140 +17,10 @@ # MA 02110-1301 USA from __future__ import unicode_literals, print_function -from .lang_EU import Num2Word_EU +from .lang_ES import Num2Word_ES -class Num2Word_ES_VE(Num2Word_EU): - # //CHECK: Is this sufficient?? - 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-3)] = word + "illón" - - def setup(self): - lows = ["cuatr", "tr", "b", "m"] - self.high_numwords = self.gen_high_numwords([], [], lows) - self.negword = "menos " - self.pointword = "punto" - self.errmsg_nonnum = "Solo números pueden ser convertidos a letras." - self.errmsg_toobig = "Numero muy grande para ser convertido a letras." - self.gender_stem = "o" - self.exclude_title = ["y", "menos", "punto"] - self.mid_numwords = [(1000, "mil"), (100, "cien"), - (90, "noventa"), (80, "ochenta"), - (70, "setenta"), (60, "sesenta"), - (50, "cincuenta"), (40, "cuarenta"), - (30, "treinta")] - self.low_numwords = ["veintinueve", "veintiocho", "veintisiete", - "veintiséis", "veinticinco", "veinticuatro", - "veintitrés", "veintidós", "veintiuno", - "veinte", "diecinueve", "dieciocho", "diecisiete", - "dieciseis", "quince", "catorce", "trece", "doce", - "once", "diez", "nueve", "ocho", "siete", "seis", - "cinco", "cuatro", "tres", "dos", "uno", "cero"] - self.ords = { - 1: "primer", - 2: "segund", - 3: "tercer", - 4: "cuart", - 5: "quint", - 6: "sext", - 7: "séptim", - 8: "octav", - 9: "noven", - 10: "décim", - 20: "vigésim", - 30: "trigésim", - 40: "quadragésim", - 50: "quincuagésim", - 60: "sexagésim", - 70: "septuagésim", - 80: "octogésim", - 90: "nonagésim", - 100: "centésim", - 200: "ducentésim", - 300: "tricentésim", - 400: "cuadrigentésim", - 500: "quingentésim", - 600: "sexcentésim", - 700: "septigentésim", - 800: "octigentésim", - 900: "noningentésim", - 1e3: "milésim", - 1e6: "millonésim", - 1e9: "billonésim", - 1e12: "trillonésim", - 1e15: "cuadrillonésim" - } - - def merge(self, curr, next): - ctext, cnum, ntext, nnum = curr + next - - if cnum == 1: - if nnum < 1000000: - return next - ctext = "un" - elif cnum == 100 and not nnum == 1000: - ctext += "t" + self.gender_stem - - if nnum < cnum: - if cnum < 100: - return ("%s y %s" % (ctext, ntext), cnum + nnum) - return ("%s %s" % (ctext, ntext), cnum + nnum) - elif (not nnum % 1000000) and cnum > 1: - ntext = ntext[:-3] + "lones" - - if nnum == 100: - if cnum == 5: - ctext = "quinien" - ntext = "" - elif cnum == 7: - ctext = "sete" - elif cnum == 9: - ctext = "nove" - ntext += "t" + self.gender_stem + "s" - else: - ntext = " " + ntext - - return (ctext + ntext, cnum * nnum) - - def to_ordinal(self, value): - self.verify_ordinal(value) - text = "" - try: - if value == 0: - text = "" - elif value <= 10: - text = "%s%s" % (self.ords[value], self.gender_stem) - elif value <= 12: - text = "%s%s%s" % (self.ords[10], self.gender_stem, self.to_ordinal(value - 10)) - elif value <= 100: - dec = (value / 10) * 10 - text = "%s%s %s" % (self.ords[dec], self.gender_stem, self.to_ordinal(value - dec)) - elif value <= 1e3: - cen = (value / 100) * 100 - text = "%s%s %s" % (self.ords[cen], self.gender_stem, self.to_ordinal(value - cen)) - elif value < 1e18: - # dec contains the following: - # [ 1e3, 1e6): 1e3 - # [ 1e6, 1e9): 1e6 - # [ 1e9, 1e12): 1e9 - # [1e12, 1e15): 1e12 - # [1e15, 1e18): 1e15 - dec = 10 ** ((((len(str(int(value))) - 1) / 3 - 1) + 1) * 3) - part = int(float(value / dec) * dec) - cardinal = self.to_cardinal(part / dec) if part / dec != 1 else "" - text = "%s%s%s %s" % (cardinal, self.ords[dec], self.gender_stem, self.to_ordinal(value - part)) - else: - text = self.to_cardinal(value) - except KeyError: - text = self.to_cardinal(value) - return text.strip() - - def to_ordinal_num(self, value): - self.verify_ordinal(value) - return "%s%s" % (value, "º" if self.gender_stem == 'o' else "ª") +class Num2Word_ES_VE(Num2Word_ES): def to_currency(self, val, longval=True, old=False): if old: @@ -160,7 +30,7 @@ class Num2Word_ES_VE(Num2Word_EU): longval=longval) -n2w = Num2Word_ES() +n2w = Num2Word_ES_VE() to_card = n2w.to_cardinal to_ord = n2w.to_ordinal to_ordnum = n2w.to_ordinal_num From 02b73fd444fda15b38528e3f4cf590d23da20954 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Moreno?= Date: Mon, 27 Mar 2017 10:30:13 -0500 Subject: [PATCH 4/8] [IMP]Deleted unnecessary super return. --- num2words/lang_ES_CO.py | 3 --- num2words/lang_ES_VE.py | 4 ---- 2 files changed, 7 deletions(-) diff --git a/num2words/lang_ES_CO.py b/num2words/lang_ES_CO.py index d72fe40..0f306b6 100644 --- a/num2words/lang_ES_CO.py +++ b/num2words/lang_ES_CO.py @@ -23,11 +23,8 @@ from .lang_ES import Num2Word_ES class Num2Word_ES_CO(Num2Word_ES): def to_currency(self, val, longval=True, old=False): - if old: return self.to_splitnum(val, hightxt="peso/s", lowtxt="peso/s", divisor=1000, jointxt="y", longval=longval) - return super(Num2Word_ES, self).to_currency(val, jointxt="y", - longval=longval) n2w = Num2Word_ES_CO() diff --git a/num2words/lang_ES_VE.py b/num2words/lang_ES_VE.py index 2ad8150..974daf3 100644 --- a/num2words/lang_ES_VE.py +++ b/num2words/lang_ES_VE.py @@ -23,12 +23,8 @@ from .lang_ES import Num2Word_ES class Num2Word_ES_VE(Num2Word_ES): def to_currency(self, val, longval=True, old=False): - if old: return self.to_splitnum(val, hightxt="bolívar/es Fuerte/s", lowtxt="bolívar/es fuerte/s", divisor=1000, jointxt="y", longval=longval) - return super(Num2Word_ES, self).to_currency(val, jointxt="y", - longval=longval) - n2w = Num2Word_ES_VE() to_card = n2w.to_cardinal From 91f3dc6854d5a35273ee46c423dd5d781ac84e5d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Moreno?= Date: Thu, 30 Mar 2017 14:59:48 -0500 Subject: [PATCH 5/8] [IMP]Adds new languages in init file. --- num2words/__init__.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/num2words/__init__.py b/num2words/__init__.py index 57c4d57..3884ebb 100644 --- a/num2words/__init__.py +++ b/num2words/__init__.py @@ -33,6 +33,8 @@ 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 CONVERTER_CLASSES = { 'en': lang_EN.Num2Word_EN(), @@ -42,6 +44,8 @@ CONVERTER_CLASSES = { 'fr_CH': lang_FR_CH.Num2Word_FR_CH(), '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(), From 19d0a903ab58a3ebe91954c778e38a186512d77f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Moreno?= Date: Fri, 31 Mar 2017 10:15:53 -0500 Subject: [PATCH 6/8] [IMP] Adds test files for es, es_co and es_ve. --- tests/test_es.py | 30 ++++++++++++++++++++++++++++++ tests/test_es_co.py | 30 ++++++++++++++++++++++++++++++ tests/test_es_ve.py | 30 ++++++++++++++++++++++++++++++ 3 files changed, 90 insertions(+) create mode 100644 tests/test_es.py create mode 100644 tests/test_es_co.py create mode 100644 tests/test_es_ve.py diff --git a/tests/test_es.py b/tests/test_es.py new file mode 100644 index 0000000..3de6e1f --- /dev/null +++ b/tests/test_es.py @@ -0,0 +1,30 @@ +# Copyright (c) 2013, 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 unittest import TestCase + +from num2words import num2words + +class Num2WordsENTest(TestCase): + def test_and_join_199(self): + # ref https://github.com/savoirfairelinux/num2words/issues/8 + self.assertEqual(num2words(199), "ciento noventa y nueve") + + def test_cardinal_for_float_number(self): + # issue 24 + self.assertEqual(num2words(12.50), "doce punto cincuenta") + self.assertEqual(num2words(12.51), "doce punto cincuenta y uno") + self.assertEqual(num2words(12.53), "doce punto cincuenta y tres") + self.assertEqual(num2words(12.59), "doce punto cincuenta y nueve") \ No newline at end of file diff --git a/tests/test_es_co.py b/tests/test_es_co.py new file mode 100644 index 0000000..3de6e1f --- /dev/null +++ b/tests/test_es_co.py @@ -0,0 +1,30 @@ +# Copyright (c) 2013, 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 unittest import TestCase + +from num2words import num2words + +class Num2WordsENTest(TestCase): + def test_and_join_199(self): + # ref https://github.com/savoirfairelinux/num2words/issues/8 + self.assertEqual(num2words(199), "ciento noventa y nueve") + + def test_cardinal_for_float_number(self): + # issue 24 + self.assertEqual(num2words(12.50), "doce punto cincuenta") + self.assertEqual(num2words(12.51), "doce punto cincuenta y uno") + self.assertEqual(num2words(12.53), "doce punto cincuenta y tres") + self.assertEqual(num2words(12.59), "doce punto cincuenta y nueve") \ No newline at end of file diff --git a/tests/test_es_ve.py b/tests/test_es_ve.py new file mode 100644 index 0000000..3de6e1f --- /dev/null +++ b/tests/test_es_ve.py @@ -0,0 +1,30 @@ +# Copyright (c) 2013, 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 unittest import TestCase + +from num2words import num2words + +class Num2WordsENTest(TestCase): + def test_and_join_199(self): + # ref https://github.com/savoirfairelinux/num2words/issues/8 + self.assertEqual(num2words(199), "ciento noventa y nueve") + + def test_cardinal_for_float_number(self): + # issue 24 + self.assertEqual(num2words(12.50), "doce punto cincuenta") + self.assertEqual(num2words(12.51), "doce punto cincuenta y uno") + self.assertEqual(num2words(12.53), "doce punto cincuenta y tres") + self.assertEqual(num2words(12.59), "doce punto cincuenta y nueve") \ No newline at end of file From afcaff81000078d0419332bee9d244321ecb21d0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Moreno?= Date: Fri, 31 Mar 2017 10:38:39 -0500 Subject: [PATCH 7/8] [IMP] Adds a better test cases. --- tests/test_es.py | 97 +++++++++++++++++++++++++++++++++++++++----- tests/test_es_co.py | 98 ++++++++++++++++++++++++++++++++++++++++----- tests/test_es_ve.py | 98 ++++++++++++++++++++++++++++++++++++++++----- 3 files changed, 263 insertions(+), 30 deletions(-) diff --git a/tests/test_es.py b/tests/test_es.py index 3de6e1f..59e9457 100644 --- a/tests/test_es.py +++ b/tests/test_es.py @@ -12,19 +12,96 @@ # 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 Num2WordsENTest(TestCase): - def test_and_join_199(self): - # ref https://github.com/savoirfairelinux/num2words/issues/8 - self.assertEqual(num2words(199), "ciento noventa y nueve") - def test_cardinal_for_float_number(self): - # issue 24 - self.assertEqual(num2words(12.50), "doce punto cincuenta") - self.assertEqual(num2words(12.51), "doce punto cincuenta y uno") - self.assertEqual(num2words(12.53), "doce punto cincuenta y tres") - self.assertEqual(num2words(12.59), "doce punto cincuenta y nueve") \ No newline at end of file +class Num2WordsESTest(TestCase): + + def test_number(self): + + test_cases = ( + (1,'uno'), + (2,'dos'), + (3,'tres'), + (11,'once'), + (12,'doce'), + (16,'dieciseis'), + (19,'diecinueve'), + (20,'veinte'), + (21,'veintiuno'), + (26,'veintiseis'), + (28,'vientiocho'), + (30,'treinta'), + (31,'treinta y uno'), + (40,'treinta y dos'), + (43,'treinta y tres'), + (50,'cincuenta'), + (55,'cincuenta y cinco'), + (60,'secenta'), + (67,'secenta y siete'), + (70,'setenta'), + (79,'setenta y nueve'), + (100,'cien'), + (101,'ciento uno'), + (199,'ciento noventa y nueve'), + (203,'docientos tres'), + (287,'docientos ochenta y siete'), + (300,'trecientos'), + (356,'trecientos cincuenta y seis'), + (410,'cuatrocientos'), + (434,'cuatrocientos treinta y cuatro'), + (578,'quinientos setenta y ocho'), + (689,'seiciento ochenta y nueve'), + (729,'setencientos veintinueve'), + (894,'ochocientos noventa y cuatro'), + (999,'novecientos noventa y nueve'), + (1000,'mil'), + (1001,'mil uno'), + (1097,'mil noventa y siete'), + (1104,'mil ciento cuatro'), + (1243,'mil docientos cuarenta y tres'), + (2385,'dos mil trecientos ochenta y cinco'), + (3766,'tresmil setencientos sesenta y seis'), + (4196,'cuatromil ciento noventa y seis'), + (5846,'cinco mil ochocientos cuarenta y seis'), + (6459,'seis mil cuatrocientos cincuenta y nueve'), + (7232,'siete mil docientos treinta y dos'), + (8569,'ocho mil quinientos sesenta y nueve'), + (9539,'nueve mil quinientos treinta y nueve'), + (1000000,'un millon'), + (1000001,'un millon uno'), + # (1000000100,'un miliardocento'), # DOES NOT WORK TODO: FIX + ) + + for test in test_cases: + self.assertEqual(num2words(test[0], lang='es'), test[1]) + + def test_ordinal(self): + + test_cases = ( + (1,'primero'), + (8,'octavo'), + (12,'decimo segundo'), + (14,'decimo cuarto'), + (28,'vigesimo octavo'), + (100,'centesimo'), + ) + + for test in test_cases: + self.assertEqual(num2words(test[0], lang='es', ordinal=True), test[1]) + + def test_currency(self): + test_case = ( + (1, 'una peseta'), + (5, 'cinco pesetas'), + (18, 'dieciocho pesetas'), + (100, 'cien pesetas'), + (1000, 'mil pesetas'), + ) + + for test in test_case: + self.assertAlmostEqual(num2words.to_currency(test, lang='es')) diff --git a/tests/test_es_co.py b/tests/test_es_co.py index 3de6e1f..0ebcd68 100644 --- a/tests/test_es_co.py +++ b/tests/test_es_co.py @@ -13,18 +13,96 @@ # 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 Num2WordsENTest(TestCase): - def test_and_join_199(self): - # ref https://github.com/savoirfairelinux/num2words/issues/8 - self.assertEqual(num2words(199), "ciento noventa y nueve") - def test_cardinal_for_float_number(self): - # issue 24 - self.assertEqual(num2words(12.50), "doce punto cincuenta") - self.assertEqual(num2words(12.51), "doce punto cincuenta y uno") - self.assertEqual(num2words(12.53), "doce punto cincuenta y tres") - self.assertEqual(num2words(12.59), "doce punto cincuenta y nueve") \ No newline at end of file +class Num2WordsESCOTest(TestCase): + + def test_number(self): + + test_cases = ( + (1,'uno'), + (2,'dos'), + (3,'tres'), + (11,'once'), + (12,'doce'), + (16,'dieciseis'), + (19,'diecinueve'), + (20,'veinte'), + (21,'veintiuno'), + (26,'veintiseis'), + (28,'vientiocho'), + (30,'treinta'), + (31,'treinta y uno'), + (40,'treinta y dos'), + (43,'treinta y tres'), + (50,'cincuenta'), + (55,'cincuenta y cinco'), + (60,'secenta'), + (67,'secenta y siete'), + (70,'setenta'), + (79,'setenta y nueve'), + (100,'cien'), + (101,'ciento uno'), + (199,'ciento noventa y nueve'), + (203,'docientos tres'), + (287,'docientos ochenta y siete'), + (300,'trecientos'), + (356,'trecientos cincuenta y seis'), + (410,'cuatrocientos'), + (434,'cuatrocientos treinta y cuatro'), + (578,'quinientos setenta y ocho'), + (689,'seiciento ochenta y nueve'), + (729,'setencientos veintinueve'), + (894,'ochocientos noventa y cuatro'), + (999,'novecientos noventa y nueve'), + (1000,'mil'), + (1001,'mil uno'), + (1097,'mil noventa y siete'), + (1104,'mil ciento cuatro'), + (1243,'mil docientos cuarenta y tres'), + (2385,'dos mil trecientos ochenta y cinco'), + (3766,'tresmil setencientos sesenta y seis'), + (4196,'cuatromil ciento noventa y seis'), + (5846,'cinco mil ochocientos cuarenta y seis'), + (6459,'seis mil cuatrocientos cincuenta y nueve'), + (7232,'siete mil docientos treinta y dos'), + (8569,'ocho mil quinientos sesenta y nueve'), + (9539,'nueve mil quinientos treinta y nueve'), + (1000000,'un millon'), + (1000001,'un millon uno'), + # (1000000100,'un miliardocento'), # DOES NOT WORK TODO: FIX + ) + + for test in test_cases: + self.assertEqual(num2words(test[0], lang='es_CO'), test[1]) + + def test_ordinal(self): + + test_cases = ( + (1,'primero'), + (8,'octavo'), + (12,'decimo segundo'), + (14,'decimo cuarto'), + (28,'vigesimo octavo'), + (100,'centesimo'), + ) + + for test in test_cases: + self.assertEqual(num2words(test[0], lang='es_CO', ordinal=True), test[1]) + + def test_currency(self): + test_case = ( + (1, 'un peso'), + (5, 'cinco pesos'), + (18, 'dieciocho pesos'), + (100, 'cien pesos'), + (1000, 'mil pesos'), + ) + + for test in test_case: + self.assertAlmostEqual(num2words.to_currency(test, lang='es_CO')) diff --git a/tests/test_es_ve.py b/tests/test_es_ve.py index 3de6e1f..b5d8bdd 100644 --- a/tests/test_es_ve.py +++ b/tests/test_es_ve.py @@ -13,18 +13,96 @@ # 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 Num2WordsENTest(TestCase): - def test_and_join_199(self): - # ref https://github.com/savoirfairelinux/num2words/issues/8 - self.assertEqual(num2words(199), "ciento noventa y nueve") - def test_cardinal_for_float_number(self): - # issue 24 - self.assertEqual(num2words(12.50), "doce punto cincuenta") - self.assertEqual(num2words(12.51), "doce punto cincuenta y uno") - self.assertEqual(num2words(12.53), "doce punto cincuenta y tres") - self.assertEqual(num2words(12.59), "doce punto cincuenta y nueve") \ No newline at end of file +class Num2WordsESVETest(TestCase): + + def test_number(self): + + test_cases = ( + (1,'uno'), + (2,'dos'), + (3,'tres'), + (11,'once'), + (12,'doce'), + (16,'dieciseis'), + (19,'diecinueve'), + (20,'veinte'), + (21,'veintiuno'), + (26,'veintiseis'), + (28,'vientiocho'), + (30,'treinta'), + (31,'treinta y uno'), + (40,'treinta y dos'), + (43,'treinta y tres'), + (50,'cincuenta'), + (55,'cincuenta y cinco'), + (60,'secenta'), + (67,'secenta y siete'), + (70,'setenta'), + (79,'setenta y nueve'), + (100,'cien'), + (101,'ciento uno'), + (199,'ciento noventa y nueve'), + (203,'docientos tres'), + (287,'docientos ochenta y siete'), + (300,'trecientos'), + (356,'trecientos cincuenta y seis'), + (410,'cuatrocientos'), + (434,'cuatrocientos treinta y cuatro'), + (578,'quinientos setenta y ocho'), + (689,'seiciento ochenta y nueve'), + (729,'setencientos veintinueve'), + (894,'ochocientos noventa y cuatro'), + (999,'novecientos noventa y nueve'), + (1000,'mil'), + (1001,'mil uno'), + (1097,'mil noventa y siete'), + (1104,'mil ciento cuatro'), + (1243,'mil docientos cuarenta y tres'), + (2385,'dos mil trecientos ochenta y cinco'), + (3766,'tresmil setencientos sesenta y seis'), + (4196,'cuatromil ciento noventa y seis'), + (5846,'cinco mil ochocientos cuarenta y seis'), + (6459,'seis mil cuatrocientos cincuenta y nueve'), + (7232,'siete mil docientos treinta y dos'), + (8569,'ocho mil quinientos sesenta y nueve'), + (9539,'nueve mil quinientos treinta y nueve'), + (1000000,'un millon'), + (1000001,'un millon uno'), + # (1000000100,'un miliardocento'), # DOES NOT WORK TODO: FIX + ) + + for test in test_cases: + self.assertEqual(num2words(test[0], lang='es_VE'), test[1]) + + def test_ordinal(self): + + test_cases = ( + (1,'primero'), + (8,'octavo'), + (12,'decimo segundo'), + (14,'decimo cuarto'), + (28,'vigesimo octavo'), + (100,'centesimo'), + ) + + for test in test_cases: + self.assertEqual(num2words(test[0], lang='es_VE', ordinal=True), test[1]) + + def test_currency(self): + test_case = ( + (1, 'un bolivar fuerte'), + (5, 'cinco bolivares fuertes'), + (18, 'dieciocho bolivares fuertes'), + (100, 'cien bolivares fuertes'), + (1000, 'mil bolivares fuertes'), + ) + + for test in test_case: + self.assertAlmostEqual(num2words.to_currency(test, lang='es_VE')) From fb2911deeafe30e94f922389906899f29f825e88 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Moreno?= Date: Fri, 31 Mar 2017 10:53:55 -0500 Subject: [PATCH 8/8] [FIX]Fixed typo errors and PEP8 errors. [DEL]Deleted test_case currency. --- num2words/lang_ES.py | 9 ++-- tests/test_es.py | 126 ++++++++++++++++++++----------------------- tests/test_es_co.py | 126 ++++++++++++++++++++----------------------- tests/test_es_ve.py | 125 ++++++++++++++++++++---------------------- 4 files changed, 174 insertions(+), 212 deletions(-) diff --git a/num2words/lang_ES.py b/num2words/lang_ES.py index c010d52..e28e896 100644 --- a/num2words/lang_ES.py +++ b/num2words/lang_ES.py @@ -1,4 +1,4 @@ -#encoding: UTF-8 +# encoding: UTF-8 # Copyright (c) 2003, Taro Ogawa. All Rights Reserved. # Copyright (c) 2013, Savoir-faire Linux inc. All Rights Reserved. @@ -19,16 +19,16 @@ from __future__ import unicode_literals, print_function from .lang_EU import Num2Word_EU + class Num2Word_ES(Num2Word_EU): - #//CHECK: Is this sufficient?? + # //CHECK: Is this sufficient?? 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-3)] = word + "illón" - def setup(self): lows = ["cuatr", "tr", "b", "m"] self.high_numwords = self.gen_high_numwords([], [], lows) @@ -81,7 +81,6 @@ class Num2Word_ES(Num2Word_EU): 1e12 : "trillonésim", 1e15 : "cuadrillonésim" } - def merge(self, curr, next): ctext, cnum, ntext, nnum = curr + next @@ -113,7 +112,6 @@ class Num2Word_ES(Num2Word_EU): return (ctext + ntext, cnum * nnum) - def to_ordinal(self, value): self.verify_ordinal(value) text = "" @@ -151,7 +149,6 @@ class Num2Word_ES(Num2Word_EU): self.verify_ordinal(value) return "%s%s" % (value, "º" if self.gender_stem == 'o' else "ª") - def to_currency(self, val, longval=True, old=False): if old: return self.to_splitnum(val, hightxt="peso/s", lowtxt="peseta/s", diff --git a/tests/test_es.py b/tests/test_es.py index 59e9457..0a2e59b 100644 --- a/tests/test_es.py +++ b/tests/test_es.py @@ -1,3 +1,4 @@ +# encoding: UTF-8 # Copyright (c) 2013, Savoir-faire Linux inc. All Rights Reserved. # This library is free software; you can redistribute it and/or @@ -24,57 +25,56 @@ class Num2WordsESTest(TestCase): def test_number(self): test_cases = ( - (1,'uno'), - (2,'dos'), - (3,'tres'), - (11,'once'), - (12,'doce'), - (16,'dieciseis'), - (19,'diecinueve'), - (20,'veinte'), - (21,'veintiuno'), - (26,'veintiseis'), - (28,'vientiocho'), - (30,'treinta'), - (31,'treinta y uno'), - (40,'treinta y dos'), - (43,'treinta y tres'), - (50,'cincuenta'), - (55,'cincuenta y cinco'), - (60,'secenta'), - (67,'secenta y siete'), - (70,'setenta'), - (79,'setenta y nueve'), - (100,'cien'), - (101,'ciento uno'), - (199,'ciento noventa y nueve'), - (203,'docientos tres'), - (287,'docientos ochenta y siete'), - (300,'trecientos'), - (356,'trecientos cincuenta y seis'), - (410,'cuatrocientos'), - (434,'cuatrocientos treinta y cuatro'), - (578,'quinientos setenta y ocho'), - (689,'seiciento ochenta y nueve'), - (729,'setencientos veintinueve'), - (894,'ochocientos noventa y cuatro'), - (999,'novecientos noventa y nueve'), - (1000,'mil'), - (1001,'mil uno'), - (1097,'mil noventa y siete'), - (1104,'mil ciento cuatro'), - (1243,'mil docientos cuarenta y tres'), - (2385,'dos mil trecientos ochenta y cinco'), - (3766,'tresmil setencientos sesenta y seis'), - (4196,'cuatromil ciento noventa y seis'), - (5846,'cinco mil ochocientos cuarenta y seis'), - (6459,'seis mil cuatrocientos cincuenta y nueve'), - (7232,'siete mil docientos treinta y dos'), - (8569,'ocho mil quinientos sesenta y nueve'), - (9539,'nueve mil quinientos treinta y nueve'), - (1000000,'un millon'), - (1000001,'un millon uno'), - # (1000000100,'un miliardocento'), # DOES NOT WORK TODO: FIX + (1, 'uno'), + (2, 'dos'), + (3, 'tres'), + (11, 'once'), + (12, 'doce'), + (16, 'dieciseis'), + (19, 'diecinueve'), + (20, 'veinte'), + (21, 'veintiuno'), + (26, 'veintiséis'), + (28, 'vientiocho'), + (30, 'treinta'), + (31, 'treinta y uno'), + (40, 'treinta y dos'), + (43, 'treinta y tres'), + (50, 'cincuenta'), + (55, 'cincuenta y cinco'), + (60, 'secenta'), + (67, 'secenta y siete'), + (70, 'setenta'), + (79, 'setenta y nueve'), + (100, 'cien'), + (101, 'ciento uno'), + (199, 'ciento noventa y nueve'), + (203, 'docientos tres'), + (287, 'docientos ochenta y siete'), + (300, 'trecientos'), + (356, 'trecientos cincuenta y seis'), + (410, 'cuatrocientos'), + (434, 'cuatrocientos treinta y cuatro'), + (578, 'quinientos setenta y ocho'), + (689, 'seiciento ochenta y nueve'), + (729, 'setencientos veintinueve'), + (894, 'ochocientos noventa y cuatro'), + (999, 'novecientos noventa y nueve'), + (1000, 'mil'), + (1001, 'mil uno'), + (1097, 'mil noventa y siete'), + (1104, 'mil ciento cuatro'), + (1243, 'mil docientos cuarenta y tres'), + (2385, 'dos mil trecientos ochenta y cinco'), + (3766, 'tresmil setencientos sesenta y seis'), + (4196, 'cuatromil ciento noventa y seis'), + (5846, 'cinco mil ochocientos cuarenta y seis'), + (6459, 'seis mil cuatrocientos cincuenta y nueve'), + (7232, 'siete mil docientos treinta y dos'), + (8569, 'ocho mil quinientos sesenta y nueve'), + (9539, 'nueve mil quinientos treinta y nueve'), + (1000000, 'un millón'), + (1000001, 'un millón uno'), ) for test in test_cases: @@ -83,25 +83,13 @@ class Num2WordsESTest(TestCase): def test_ordinal(self): test_cases = ( - (1,'primero'), - (8,'octavo'), - (12,'decimo segundo'), - (14,'decimo cuarto'), - (28,'vigesimo octavo'), - (100,'centesimo'), + (1, 'primero'), + (8, 'octavo'), + (12, 'décimosegundo'), + (14, 'décimo cuarto'), + (28, 'vigésimo octavo'), + (100, 'centésimo'), ) for test in test_cases: self.assertEqual(num2words(test[0], lang='es', ordinal=True), test[1]) - - def test_currency(self): - test_case = ( - (1, 'una peseta'), - (5, 'cinco pesetas'), - (18, 'dieciocho pesetas'), - (100, 'cien pesetas'), - (1000, 'mil pesetas'), - ) - - for test in test_case: - self.assertAlmostEqual(num2words.to_currency(test, lang='es')) diff --git a/tests/test_es_co.py b/tests/test_es_co.py index 0ebcd68..85c6349 100644 --- a/tests/test_es_co.py +++ b/tests/test_es_co.py @@ -1,3 +1,4 @@ +# encoding: UTF-8 # Copyright (c) 2013, Savoir-faire Linux inc. All Rights Reserved. # This library is free software; you can redistribute it and/or @@ -25,57 +26,56 @@ class Num2WordsESCOTest(TestCase): def test_number(self): test_cases = ( - (1,'uno'), - (2,'dos'), - (3,'tres'), - (11,'once'), - (12,'doce'), - (16,'dieciseis'), - (19,'diecinueve'), - (20,'veinte'), - (21,'veintiuno'), - (26,'veintiseis'), - (28,'vientiocho'), - (30,'treinta'), - (31,'treinta y uno'), - (40,'treinta y dos'), - (43,'treinta y tres'), - (50,'cincuenta'), - (55,'cincuenta y cinco'), - (60,'secenta'), - (67,'secenta y siete'), - (70,'setenta'), - (79,'setenta y nueve'), - (100,'cien'), - (101,'ciento uno'), - (199,'ciento noventa y nueve'), - (203,'docientos tres'), - (287,'docientos ochenta y siete'), - (300,'trecientos'), - (356,'trecientos cincuenta y seis'), - (410,'cuatrocientos'), - (434,'cuatrocientos treinta y cuatro'), - (578,'quinientos setenta y ocho'), - (689,'seiciento ochenta y nueve'), - (729,'setencientos veintinueve'), - (894,'ochocientos noventa y cuatro'), - (999,'novecientos noventa y nueve'), - (1000,'mil'), - (1001,'mil uno'), - (1097,'mil noventa y siete'), - (1104,'mil ciento cuatro'), - (1243,'mil docientos cuarenta y tres'), - (2385,'dos mil trecientos ochenta y cinco'), - (3766,'tresmil setencientos sesenta y seis'), - (4196,'cuatromil ciento noventa y seis'), - (5846,'cinco mil ochocientos cuarenta y seis'), - (6459,'seis mil cuatrocientos cincuenta y nueve'), - (7232,'siete mil docientos treinta y dos'), - (8569,'ocho mil quinientos sesenta y nueve'), - (9539,'nueve mil quinientos treinta y nueve'), - (1000000,'un millon'), - (1000001,'un millon uno'), - # (1000000100,'un miliardocento'), # DOES NOT WORK TODO: FIX + (1, 'uno'), + (2, 'dos'), + (3, 'tres'), + (11, 'once'), + (12, 'doce'), + (16, 'dieciseis'), + (19, 'diecinueve'), + (20, 'veinte'), + (21, 'veintiuno'), + (26, 'veintiséis'), + (28, 'vientiocho'), + (30, 'treinta'), + (31, 'treinta y uno'), + (40, 'treinta y dos'), + (43, 'treinta y tres'), + (50, 'cincuenta'), + (55, 'cincuenta y cinco'), + (60, 'secenta'), + (67, 'secenta y siete'), + (70, 'setenta'), + (79, 'setenta y nueve'), + (100, 'cien'), + (101, 'ciento uno'), + (199, 'ciento noventa y nueve'), + (203, 'docientos tres'), + (287, 'docientos ochenta y siete'), + (300, 'trecientos'), + (356, 'trecientos cincuenta y seis'), + (410, 'cuatrocientos'), + (434, 'cuatrocientos treinta y cuatro'), + (578, 'quinientos setenta y ocho'), + (689, 'seiciento ochenta y nueve'), + (729, 'setencientos veintinueve'), + (894, 'ochocientos noventa y cuatro'), + (999, 'novecientos noventa y nueve'), + (1000, 'mil'), + (1001, 'mil uno'), + (1097, 'mil noventa y siete'), + (1104, 'mil ciento cuatro'), + (1243, 'mil docientos cuarenta y tres'), + (2385, 'dos mil trecientos ochenta y cinco'), + (3766, 'tresmil setencientos sesenta y seis'), + (4196, 'cuatromil ciento noventa y seis'), + (5846, 'cinco mil ochocientos cuarenta y seis'), + (6459, 'seis mil cuatrocientos cincuenta y nueve'), + (7232, 'siete mil docientos treinta y dos'), + (8569, 'ocho mil quinientos sesenta y nueve'), + (9539, 'nueve mil quinientos treinta y nueve'), + (1000000, 'un millón'), + (1000001, 'un millón uno'), ) for test in test_cases: @@ -84,25 +84,13 @@ class Num2WordsESCOTest(TestCase): def test_ordinal(self): test_cases = ( - (1,'primero'), - (8,'octavo'), - (12,'decimo segundo'), - (14,'decimo cuarto'), - (28,'vigesimo octavo'), - (100,'centesimo'), + (1, 'primero'), + (8, 'octavo'), + (12, 'décimo segundo'), + (14, 'décimo cuarto'), + (28, 'vigésimo octavo'), + (100, 'centésimo'), ) for test in test_cases: self.assertEqual(num2words(test[0], lang='es_CO', ordinal=True), test[1]) - - def test_currency(self): - test_case = ( - (1, 'un peso'), - (5, 'cinco pesos'), - (18, 'dieciocho pesos'), - (100, 'cien pesos'), - (1000, 'mil pesos'), - ) - - for test in test_case: - self.assertAlmostEqual(num2words.to_currency(test, lang='es_CO')) diff --git a/tests/test_es_ve.py b/tests/test_es_ve.py index b5d8bdd..1a4db01 100644 --- a/tests/test_es_ve.py +++ b/tests/test_es_ve.py @@ -1,3 +1,4 @@ +# encoding: UTF-8 # Copyright (c) 2013, Savoir-faire Linux inc. All Rights Reserved. # This library is free software; you can redistribute it and/or @@ -25,57 +26,56 @@ class Num2WordsESVETest(TestCase): def test_number(self): test_cases = ( - (1,'uno'), - (2,'dos'), - (3,'tres'), - (11,'once'), - (12,'doce'), - (16,'dieciseis'), - (19,'diecinueve'), - (20,'veinte'), - (21,'veintiuno'), - (26,'veintiseis'), - (28,'vientiocho'), - (30,'treinta'), - (31,'treinta y uno'), - (40,'treinta y dos'), - (43,'treinta y tres'), - (50,'cincuenta'), - (55,'cincuenta y cinco'), - (60,'secenta'), - (67,'secenta y siete'), - (70,'setenta'), - (79,'setenta y nueve'), - (100,'cien'), - (101,'ciento uno'), - (199,'ciento noventa y nueve'), - (203,'docientos tres'), - (287,'docientos ochenta y siete'), - (300,'trecientos'), - (356,'trecientos cincuenta y seis'), - (410,'cuatrocientos'), - (434,'cuatrocientos treinta y cuatro'), - (578,'quinientos setenta y ocho'), - (689,'seiciento ochenta y nueve'), - (729,'setencientos veintinueve'), - (894,'ochocientos noventa y cuatro'), - (999,'novecientos noventa y nueve'), - (1000,'mil'), - (1001,'mil uno'), - (1097,'mil noventa y siete'), - (1104,'mil ciento cuatro'), - (1243,'mil docientos cuarenta y tres'), - (2385,'dos mil trecientos ochenta y cinco'), - (3766,'tresmil setencientos sesenta y seis'), - (4196,'cuatromil ciento noventa y seis'), - (5846,'cinco mil ochocientos cuarenta y seis'), - (6459,'seis mil cuatrocientos cincuenta y nueve'), - (7232,'siete mil docientos treinta y dos'), - (8569,'ocho mil quinientos sesenta y nueve'), - (9539,'nueve mil quinientos treinta y nueve'), - (1000000,'un millon'), - (1000001,'un millon uno'), - # (1000000100,'un miliardocento'), # DOES NOT WORK TODO: FIX + (1, 'uno'), + (2, 'dos'), + (3, 'tres'), + (11, 'once'), + (12, 'doce'), + (16, 'dieciseis'), + (19, 'diecinueve'), + (20, 'veinte'), + (21, 'veintiuno'), + (26, 'veintiséis'), + (28, 'vientiocho'), + (30, 'treinta'), + (31, 'treinta y uno'), + (40, 'treinta y dos'), + (43, 'treinta y tres'), + (50, 'cincuenta'), + (55, 'cincuenta y cinco'), + (60, 'secenta'), + (67, 'secenta y siete'), + (70, 'setenta'), + (79, 'setenta y nueve'), + (100, 'cien'), + (101, 'ciento uno'), + (199, 'ciento noventa y nueve'), + (203, 'docientos tres'), + (287, 'docientos ochenta y siete'), + (300, 'trecientos'), + (356, 'trecientos cincuenta y seis'), + (410, 'cuatrocientos'), + (434, 'cuatrocientos treinta y cuatro'), + (578, 'quinientos setenta y ocho'), + (689, 'seiciento ochenta y nueve'), + (729, 'setencientos veintinueve'), + (894, 'ochocientos noventa y cuatro'), + (999, 'novecientos noventa y nueve'), + (1000, 'mil'), + (1001, 'mil uno'), + (1097, 'mil noventa y siete'), + (1104, 'mil ciento cuatro'), + (1243, 'mil docientos cuarenta y tres'), + (2385, 'dos mil trecientos ochenta y cinco'), + (3766, 'tresmil setencientos sesenta y seis'), + (4196, 'cuatromil ciento noventa y seis'), + (5846, 'cinco mil ochocientos cuarenta y seis'), + (6459, 'seis mil cuatrocientos cincuenta y nueve'), + (7232, 'siete mil docientos treinta y dos'), + (8569, 'ocho mil quinientos sesenta y nueve'), + (9539, 'nueve mil quinientos treinta y nueve'), + (1000000, 'un millón'), + (1000001, 'un millón uno'), ) for test in test_cases: @@ -84,25 +84,14 @@ class Num2WordsESVETest(TestCase): def test_ordinal(self): test_cases = ( - (1,'primero'), - (8,'octavo'), - (12,'decimo segundo'), - (14,'decimo cuarto'), - (28,'vigesimo octavo'), - (100,'centesimo'), + (1, 'primero'), + (8, 'octavo'), + (12, 'décimo segundo'), + (14, 'décimo cuarto'), + (28, 'vigésimo octavo'), + (100, 'centésimo'), ) for test in test_cases: self.assertEqual(num2words(test[0], lang='es_VE', ordinal=True), test[1]) - def test_currency(self): - test_case = ( - (1, 'un bolivar fuerte'), - (5, 'cinco bolivares fuertes'), - (18, 'dieciocho bolivares fuertes'), - (100, 'cien bolivares fuertes'), - (1000, 'mil bolivares fuertes'), - ) - - for test in test_case: - self.assertAlmostEqual(num2words.to_currency(test, lang='es_VE'))