bblaz/num2words
1
0
Fork 0
mirror of https://github.com/bblaz/num2words.git synced 2025-12-06 06:42:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into master

Browse Source
This commit is contained in:
Marlon Rodriguez Garcia
2022-08-18 10:07:36 -04:00
committed by GitHub
parent 882c08b639 18b00075fc
commit 605d82ec34
11 changed files with 488 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
num2words/__init__.py
View File

@@ -18,12 +18,13 @@
from __future__ import unicode_literals
from . import (lang_AM, lang_AR, lang_CZ, lang_DE, lang_DK, lang_EN,
lang_EN_IN, lang_ES, lang_ES_CO, lang_ES_NI, lang_ES_VE,
lang_FA, lang_FI, lang_FR, lang_FR_BE, lang_FR_CH, lang_FR_DZ,
lang_HE, lang_HU, lang_ID, lang_IT, lang_JA, lang_KN, lang_KO,
lang_KZ, lang_LT, lang_LV, lang_NL, lang_NO, lang_PL, lang_PT,
lang_PT_BR, lang_RO, lang_RU, lang_SL, lang_SR, lang_SV,
lang_TE, lang_TG, lang_TH, lang_TR, lang_UK, lang_VI)
lang_EN_IN, lang_EO, lang_ES, lang_ES_CO, lang_ES_NI,
lang_ES_VE, lang_FA, lang_FI, lang_FR, lang_FR_BE, lang_FR_CH,
lang_FR_DZ, lang_HE, lang_HU, lang_ID, lang_IT, lang_JA,
lang_KN, lang_KO, lang_KZ, lang_LT, lang_LV, lang_NL, lang_NO,
lang_PL, lang_PT, lang_PT_BR, lang_RO, lang_RU, lang_SL,
lang_SR, lang_SV, lang_TE, lang_TG, lang_TH, lang_TR, lang_UK,
lang_VI)
CONVERTER_CLASSES = {
'am': lang_AM.Num2Word_AM(),
@@ -38,6 +39,7 @@ CONVERTER_CLASSES = {
'fr_DZ': lang_FR_DZ.Num2Word_FR_DZ(),
'de': lang_DE.Num2Word_DE(),
'fi': lang_FI.Num2Word_FI(),
'eo': lang_EO.Num2Word_EO(),
'es': lang_ES.Num2Word_ES(),
'es_CO': lang_ES_CO.Num2Word_ES_CO(),
'es_NI': lang_ES_NI.Num2Word_ES_NI(),

130
num2words/lang_EO.py Normal file
View File

@@ -0,0 +1,130 @@
# -*- coding: utf-8 -*-
# Copyright (c) 2021, 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 print_function, unicode_literals
from .base import Num2Word_Base
class Num2Word_EO(Num2Word_Base):
CURRENCY_FORMS = {
"EUR": (("eŭro", "eŭroj"), ("centimo", "centimoj")),
"USD": (("dolaro", "dolaroj"), ("cendo", "cendoj")),
"FRF": (("franko", "frankoj"), ("centimo", "centimoj")),
"GBP": (("pundo", "pundoj"), ("penco", "pencoj")),
"CNY": (("juano", "juanoj"), ("feno", "fenoj")),
}
GIGA_SUFFIX = "iliardo"
MEGA_SUFFIX = "iliono"
def set_high_numwords(self, high):
cap = 3 + 6 * len(high)
for word, n in zip(high, range(cap, 3, -6)):
if self.GIGA_SUFFIX:
self.cards[10 ** n] = word + self.GIGA_SUFFIX
if self.MEGA_SUFFIX:
self.cards[10 ** (n - 3)] = word + self.MEGA_SUFFIX
def gen_high_numwords(self, units, tens, lows):
out = [u + t for t in tens for u in units]
out.reverse()
return out + lows
def setup(self):
lows = ["naŭ", "ok", "sep", "ses", "kvin", "kvar", "tr", "b", "m"]
units = ["", "un", "duo", "tre", "kvatuor",
"kvin", "seks", "septen", "okto", "novem"]
tens = ["dek", "vigint", "trigint", "kvadragint", "kvinkvagint",
"seksagint", "septuagint", "oktogint", "nonagint"]
self.high_numwords = ["cent"] + self.gen_high_numwords(units, tens,
lows)
self.negword = "minus "
self.pointword = "komo"
self.errmsg_nonnum = u"Sole nombroj povas esti konvertita en vortojn."
self.errmsg_toobig = (
u"Tro granda nombro por esti konvertita en vortojn."
)
self.exclude_title = ["kaj", "komo", "minus"]
self.mid_numwords = [(1000, "mil"), (100, "cent"), (90, "naŭdek"),
(80, "okdek"), (70, "sepdek"), (60, "sesdek"),
(50, "kvindek"), (40, "kvardek"), (30, "tridek")]
self.low_numwords = ["dudek", "dek naŭ", "dek ok", "dek sep",
"dek ses", "dek kvin", "dek kvar", "dek tri",
"dek du", "dek unu", "dek", "naŭ", "ok", "sep",
"ses", "kvin", "kvar", "tri", "du", "unu", "nul"]
self.ords = {
"unu": "unua",
"du": "dua",
"tri": "tria",
"kvar": "kvara",
"kvin": "kvina",
"ses": "sesa",
"sep": "sepa",
"ok": "oka",
"naŭ": "naŭa",
"dek": "deka"
}
def merge(self, curr, next):
ctext, cnum, ntext, nnum = curr + next
if cnum == 1 and nnum < 1000000:
return next
if nnum >= 10**6 and cnum > 1:
return ("%s %sj" % (ctext, ntext), cnum + nnum)
if nnum == 100:
return ("%s%s" % (ctext, ntext), cnum + nnum)
return ("%s %s" % (ctext, ntext), cnum + nnum)
def to_ordinal(self, value):
self.verify_ordinal(value)
word = self.to_cardinal(value)
for src, repl in self.ords.items():
if word.endswith(src):
word = word[:-len(src)] + repl
return word
if word.endswith("o"):
word = word[:-1] + "a"
elif word.endswith("oj"):
word = word[:-2] + "a"
else:
word = word + "a"
return word
def to_ordinal_num(self, value):
self.verify_ordinal(value)
out = str(value)
out += "a"
return out
def to_currency(self, val, currency="EUR", cents=True, separator=" kaj",
adjective=False):
result = super(Num2Word_EO, self).to_currency(
val, currency=currency, cents=cents, separator=separator,
adjective=adjective)
return result
def pluralize(self, n, forms):
form = 0 if n <= 1 else 1
return forms[form]

6
num2words/lang_EU.py
View File

@@ -43,7 +43,8 @@ class Num2Word_EU(Num2Word_Base):
'MXN': (('peso', 'pesos'), GENERIC_CENTS),
'RON': (('leu', 'lei', 'de lei'), ('ban', 'bani', 'de bani')),
'INR': (('rupee', 'rupees'), ('paisa', 'paise')),
'HUF': (('forint', 'forint'), ('fillér', 'fillér'))
'HUF': (('forint', 'forint'), ('fillér', 'fillér')),
'UZS': (('sum', 'sums'), ('tiyin', 'tiyins'))
}
CURRENCY_ADJECTIVES = {
@@ -56,7 +57,8 @@ class Num2Word_EU(Num2Word_Base):
'MXN': 'Mexican',
'RON': 'Romanian',
'INR': 'Indian',
'HUF': 'Hungarian'
'HUF': 'Hungarian',
'UZS': 'Uzbekistan'
}
GIGA_SUFFIX = "illiard"

119
num2words/lang_IT.py
View File

@@ -16,6 +16,8 @@
from __future__ import unicode_literals
from .lang_EU import Num2Word_EU
# Globals
# -------
@@ -43,57 +45,27 @@ EXPONENT_PREFIXES = [
]
# Utils
# =====
def phonetic_contraction(string):
return (string
.replace("oo", "o") # ex. "centootto"
.replace("ao", "o") # ex. "settantaotto"
.replace("io", "o") # ex. "ventiotto"
.replace("au", "u") # ex. "trentauno"
.replace("iu", "u") # ex. "ventiunesimo"
)
def exponent_length_to_string(exponent_length):
# We always assume `exponent` to be a multiple of 3. If it's not true, then
# Num2Word_IT.big_number_to_cardinal did something wrong.
prefix = EXPONENT_PREFIXES[exponent_length // 6]
if exponent_length % 6 == 0:
return prefix + "ilione"
else:
return prefix + "iliardo"
def accentuate(string):
# This is inefficient: it may do several rewritings when deleting
# half-sentence accents. However, it is the easiest method and speed is
# not crucial (duh), so...
return " ".join(
# Deletes half-sentence accents and accentuates the last "tre"
[w.replace("tré", "tre")[:-3] + "tré"
# We shouldn't accentuate a single "tre": is has to be a composite
# word. ~~~~~~~~~~
if w[-3:] == "tre" and len(w) > 3
# Deletes half-sentence accents anyway
# ~~~~~~~~~~~~~~~~~~~~~~
else w.replace("tré", "tre")
for w in string.split()
])
def omitt_if_zero(number_to_string):
return "" if number_to_string == ZERO else number_to_string
GENERIC_DOLLARS = ('dollaro', 'dollari')
GENERIC_CENTS = ('centesimo', 'centesimi')
CURRENCIES_UNA = ('GBP')
# Main class
# ==========
class Num2Word_IT:
class Num2Word_IT(Num2Word_EU):
CURRENCY_FORMS = {
'EUR': (('euro', 'euro'), GENERIC_CENTS),
'USD': (GENERIC_DOLLARS, GENERIC_CENTS),
'GBP': (('sterlina', 'sterline'), ('penny', 'penny')),
'CNY': (('yuan', 'yuan'), ('fen', 'fen')),
}
MINUS_PREFIX_WORD = "meno "
FLOAT_INFIX_WORD = " virgola "
def setup(self):
Num2Word_EU.setup(self)
def __init__(self):
pass
@@ -206,3 +178,64 @@ class Num2Word_IT:
if string[-3:] == "mil":
string += "l"
return string + "esimo"
def to_currency(self, val, currency='EUR', cents=True, separator=' e',
adjective=False):
result = super(Num2Word_IT, self).to_currency(
val, currency=currency, cents=cents, separator=separator,
adjective=adjective)
# Handle exception. In italian language is "un euro",
# "un dollaro" etc. (not "uno euro", "uno dollaro").
# There is an exception, some currencies need "una":
# e.g. "una sterlina"
if currency in CURRENCIES_UNA:
list_result = result.split(" ")
if list_result[0] == "uno":
list_result[0] = list_result[0].replace("uno", "una")
result = " ".join(list_result)
result = result.replace("uno", "un")
return result
# Utils
# =====
def phonetic_contraction(string):
return (string
.replace("oo", "o") # ex. "centootto"
.replace("ao", "o") # ex. "settantaotto"
.replace("io", "o") # ex. "ventiotto"
.replace("au", "u") # ex. "trentauno"
.replace("iu", "u") # ex. "ventiunesimo"
)
def exponent_length_to_string(exponent_length):
# We always assume `exponent` to be a multiple of 3. If it's not true, then
# Num2Word_IT.big_number_to_cardinal did something wrong.
prefix = EXPONENT_PREFIXES[exponent_length // 6]
if exponent_length % 6 == 0:
return prefix + "ilione"
else:
return prefix + "iliardo"
def accentuate(string):
# This is inefficient: it may do several rewritings when deleting
# half-sentence accents. However, it is the easiest method and speed is
# not crucial (duh), so...
return " ".join(
# Deletes half-sentence accents and accentuates the last "tre"
[w.replace("tré", "tre")[:-3] + "tré"
# We shouldn't accentuate a single "tre": is has to be a composite
# word. ~~~~~~~~~~
if w[-3:] == "tre" and len(w) > 3
# Deletes half-sentence accents anyway
# ~~~~~~~~~~~~~~~~~~~~~~
else w.replace("tré", "tre")
for w in string.split()
])
def omitt_if_zero(number_to_string):
return "" if number_to_string == ZERO else number_to_string

2
num2words/lang_PL.py
View File

@@ -80,7 +80,7 @@ TWENTIES = {
6: ('sześćdziesiąt',),
7: ('siedemdziesiąt',),
8: ('osiemdziesiąt',),
9: ('dziewięćdzisiąt',),
9: ('dziewięćdziesiąt',),
}
TWENTIES_ORDINALS = {

3
num2words/lang_RU.py
View File

@@ -113,6 +113,9 @@ class Num2Word_RU(Num2Word_Base):
'KZT': (
('тенге', 'тенге', 'тенге'), ('тиын', 'тиына', 'тиынов')
),
'UZS': (
('сум', 'сума', 'сумов'), ('тийин', 'тийина', 'тийинов')
),
}
def setup(self):

6
tests/test_en.py
View File

@@ -131,6 +131,12 @@ class Num2WordsENTest(TestCase):
"four pesos and one cent"
)
self.assertEqual(
num2words('2000.00', lang='en', to='currency', separator=' and',
cents=True, currency='UZS'),
"two thousand sums and zero tiyins"
)
def test_to_year(self):
# issue 141
# "e2 e2"

190
tests/test_eo.py Normal file
View File

@@ -0,0 +1,190 @@
# -*- coding: utf-8 -*-
# Copyright (c) 2021, 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
TEST_CASES_CARDINAL = (
(1, "unu"),
(2, "du"),
(3, "tri"),
(5.5, "kvin komo kvin"),
(11, "dek unu"),
(12, "dek du"),
(16, "dek ses"),
(17.42, "dek sep komo kvar du"),
(19, "dek naŭ"),
(20, "dudek"),
(21, "dudek unu"),
(26, "dudek ses"),
(27.312, "dudek sep komo tri unu du"),
(28, "dudek ok"),
(30, "tridek"),
(31, "tridek unu"),
(40, "kvardek"),
(44, "kvardek kvar"),
(50, "kvindek"),
(53.486, "kvindek tri komo kvar ok ses"),
(55, "kvindek kvin"),
(60, "sesdek"),
(67, "sesdek sep"),
(70, "sepdek"),
(79, "sepdek naŭ"),
(89, "okdek naŭ"),
(95, "naŭdek kvin"),
(100, "cent"),
(101, "cent unu"),
(199, "cent naŭdek naŭ"),
(203, "ducent tri"),
(287, "ducent okdek sep"),
(300.42, "tricent komo kvar du"),
(356, "tricent kvindek ses"),
(400, "kvarcent"),
(434, "kvarcent tridek kvar"),
(578, "kvincent sepdek ok"),
(689, "sescent okdek naŭ"),
(729, "sepcent dudek naŭ"),
(894, "okcent naŭdek kvar"),
(999, "naŭcent naŭdek naŭ"),
(1000, "mil"),
(1001, "mil unu"),
(1097, "mil naŭdek sep"),
(1104, "mil cent kvar"),
(1243, "mil ducent kvardek tri"),
(2385, "du mil tricent okdek kvin"),
(3766, "tri mil sepcent sesdek ses"),
(4196, "kvar mil cent naŭdek ses"),
(4196.42, "kvar mil cent naŭdek ses komo kvar du"),
(5846, "kvin mil okcent kvardek ses"),
(6459, "ses mil kvarcent kvindek naŭ"),
(7232, "sep mil ducent tridek du"),
(8569, "ok mil kvincent sesdek naŭ"),
(9539, "naŭ mil kvincent tridek naŭ"),
(1000000, "unu miliono"),
(1000001, "unu miliono unu"),
(4000000, "kvar milionoj"),
(4000004, "kvar milionoj kvar"),
(4300000, "kvar milionoj tricent mil"),
(80000000, "okdek milionoj"),
(300000000, "tricent milionoj"),
(10000000000000, "dek bilionoj"),
(10000000000010, "dek bilionoj dek"),
(100000000000000, "cent bilionoj"),
(1000000000000000000, "unu triliono"),
(1000000000000000000000, "unu triliardo"),
(10000000000000000000000000, "dek kvarilionoj")
)
TEST_CASES_ORDINAL = (
(1, "unua"),
(8, "oka"),
(12, "dek dua"),
(14, "dek kvara"),
(28, "dudek oka"),
(100, "centa"),
(1000, "mila"),
(1000000, "unu miliona"),
(1000000000000000, "unu biliarda"),
(1000000000000000000, "unu triliona")
)
TEST_CASES_ORDINAL_NUM = (
(1, "1a"),
(8, "8a"),
(11, "11a"),
(12, "12a"),
(14, "14a"),
(21, "21a"),
(28, "28a"),
(100, "100a"),
(101, "101a"),
(1000, "1000a"),
(1000000, "1000000a")
)
TEST_CASES_TO_CURRENCY_EUR = (
(1.00, "unu eŭro kaj nul centimo"),
(2.01, "du eŭroj kaj unu centimo"),
(8.10, "ok eŭroj kaj dek centimoj"),
(12.26, "dek du eŭroj kaj dudek ses centimoj"),
(21.29, "dudek unu eŭroj kaj dudek naŭ centimoj"),
(81.25, "okdek unu eŭroj kaj dudek kvin centimoj"),
(100.00, "cent eŭroj kaj nul centimo"),
)
TEST_CASES_TO_CURRENCY_FRF = (
(1.00, "unu franko kaj nul centimo"),
(2.01, "du frankoj kaj unu centimo"),
(8.10, "ok frankoj kaj dek centimoj"),
(12.27, "dek du frankoj kaj dudek sep centimoj"),
(21.29, "dudek unu frankoj kaj dudek naŭ centimoj"),
(81.25, "okdek unu frankoj kaj dudek kvin centimoj"),
(100.00, "cent frankoj kaj nul centimo"),
)
TEST_CASES_TO_CURRENCY_USD = (
(1.00, "unu dolaro kaj nul cendo"),
(2.01, "du dolaroj kaj unu cendo"),
(8.10, "ok dolaroj kaj dek cendoj"),
(12.26, "dek du dolaroj kaj dudek ses cendoj"),
(21.29, "dudek unu dolaroj kaj dudek naŭ cendoj"),
(81.25, "okdek unu dolaroj kaj dudek kvin cendoj"),
(100.00, "cent dolaroj kaj nul cendo"),
)
class Num2WordsEOTest(TestCase):
def test_number(self):
for test in TEST_CASES_CARDINAL:
self.assertEqual(num2words(test[0], lang="eo"), test[1])
def test_ordinal(self):
for test in TEST_CASES_ORDINAL:
self.assertEqual(
num2words(test[0], lang="eo", ordinal=True),
test[1]
)
def test_ordinal_num(self):
for test in TEST_CASES_ORDINAL_NUM:
self.assertEqual(
num2words(test[0], lang="eo", to="ordinal_num"),
test[1]
)
def test_currency_eur(self):
for test in TEST_CASES_TO_CURRENCY_EUR:
self.assertEqual(
num2words(test[0], lang="eo", to="currency", currency="EUR"),
test[1]
)
def test_currency_frf(self):
for test in TEST_CASES_TO_CURRENCY_FRF:
self.assertEqual(
num2words(test[0], lang="eo", to="currency", currency="FRF"),
test[1]
)
def test_currency_usd(self):
for test in TEST_CASES_TO_CURRENCY_USD:
self.assertEqual(
num2words(test[0], lang="eo", to="currency", currency="USD"),
test[1]
)

51
tests/test_it.py
View File

@@ -21,6 +21,36 @@ from unittest import TestCase
from num2words import num2words
TEST_CASES_TO_CURRENCY_EUR = (
(1.00, 'un euro e zero centesimi'),
(2.01, 'due euro e un centesimo'),
(8.10, 'otto euro e dieci centesimi'),
(12.26, 'dodici euro e ventisei centesimi'),
(21.29, 'ventun euro e ventinove centesimi'),
(81.25, 'ottantun euro e venticinque centesimi'),
(100.00, 'cento euro e zero centesimi'),
)
TEST_CASES_TO_CURRENCY_USD = (
(1.00, 'un dollaro e zero centesimi'),
(2.01, 'due dollari e un centesimo'),
(8.10, 'otto dollari e dieci centesimi'),
(12.26, 'dodici dollari e ventisei centesimi'),
(21.29, 'ventun dollari e ventinove centesimi'),
(81.25, 'ottantun dollari e venticinque centesimi'),
(100.00, 'cento dollari e zero centesimi'),
)
TEST_CASES_TO_CURRENCY_GBP = (
(1.00, 'una sterlina e zero penny'),
(2.01, 'due sterline e un penny'),
(8.10, 'otto sterline e dieci penny'),
(12.26, 'dodici sterline e ventisei penny'),
(21.29, 'ventun sterline e ventinove penny'),
(81.25, 'ottantun sterline e venticinque penny'),
(100.00, 'cento sterline e zero penny'),
)
class Num2WordsITTest(TestCase):
maxDiff = None
@@ -240,3 +270,24 @@ class Num2WordsITTest(TestCase):
self.assertAlmostEqual(
num2words(1.1, lang="it"), "uno virgola uno"
)
def test_currency_eur(self):
for test in TEST_CASES_TO_CURRENCY_EUR:
self.assertEqual(
num2words(test[0], lang='it', to='currency', currency='EUR'),
test[1]
)
def test_currency_usd(self):
for test in TEST_CASES_TO_CURRENCY_USD:
self.assertEqual(
num2words(test[0], lang='it', to='currency', currency='USD'),
test[1]
)
def test_currency_gbp(self):
for test in TEST_CASES_TO_CURRENCY_GBP:
self.assertEqual(
num2words(test[0], lang='it', to='currency', currency='GBP'),
test[1]
)

19
tests/test_pl.py
View File

@@ -24,11 +24,13 @@ from num2words import num2words
class Num2WordsPLTest(TestCase):
def test_cardinal(self):
self.assertEqual(num2words(90, lang='pl'), "dziewięćdziesiąt")
self.assertEqual(num2words(100, lang='pl'), "sto")
self.assertEqual(num2words(101, lang='pl'), "sto jeden")
self.assertEqual(num2words(110, lang='pl'), "sto dziesięć")
self.assertEqual(num2words(115, lang='pl'), "sto piętnaście")
self.assertEqual(num2words(123, lang='pl'), "sto dwadzieścia trzy")
self.assertEqual(num2words(400, lang='pl'), "czterysta")
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")
@@ -52,7 +54,7 @@ class Num2WordsPLTest(TestCase):
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"
"sześćdziesiąt siedem tysięcy osiemset dziewięćdziesiąt"
)
self.assertEqual(
num2words(10000000001000000100000, lang='pl'),
@@ -62,20 +64,20 @@ class Num2WordsPLTest(TestCase):
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 "
"dziewięćdziesią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 "
"dziewięć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 "
"siedemset dziewiętnaście kwintylionów dziewięćdziesiąt cztery "
"kwadryliardy dwieście trzydzieści cztery kwadryliony sześćset "
"dziewięćdzisiąt trzy tryliardy sześćset sześćdziesiąt trzy "
"dziewięćdziesią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"
"tysięcy dwieście dziewięćdziesiąt jeden"
)
self.assertEqual(
num2words(
@@ -94,6 +96,9 @@ class Num2WordsPLTest(TestCase):
self.assertEqual(num2words(100, lang='pl', to='ordinal'), "setny")
self.assertEqual(
num2words(101, lang='pl', to='ordinal'), "sto pierwszy")
self.assertEqual(num2words(120, lang='pl', to='ordinal'),
"sto dwudziesty")
self.assertEqual(num2words(20, lang='pl', to='ordinal'), "dwudziesty")
self.assertEqual(num2words(121, lang='pl', to='ordinal'),
"sto dwudziesty pierwszy")
self.assertEqual(
@@ -118,6 +123,10 @@ class Num2WordsPLTest(TestCase):
self.assertEqual(num2words(1000000, lang='pl',
to='ordinal'), "milionowy")
def test_to_ordinal_error(self):
with self.assertRaises(NotImplementedError):
num2words(1.5, lang='pl', to='ordinal')
def test_currency(self):
self.assertEqual(
num2words(1.0, lang='pl', to='currency', currency='EUR'),

5
tests/test_ru.py
View File

@@ -272,3 +272,8 @@ class Num2WordsRUTest(TestCase):
'одна тысяча двести тридцать четыре доллара, пятьдесят шесть '
'центов'
)
self.assertEqual(
num2words(10122, lang='ru', to='currency', currency='UZS',
separator=' и'),
'сто один сум и двадцать два тийина'
)