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 base

Browse Source
This commit is contained in:
Ernesto Rodriguez Ortiz
2019-12-31 09:59:08 -05:00
committed by GitHub
parent a1d29fc2bc ff6ff0e6a6
commit af7882a7bd
9 changed files with 362 additions and 233 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
num2words/lang_ES.py
View File

@@ -15,7 +15,9 @@
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA
from __future__ import print_function, unicode_literals
from __future__ import division, print_function, unicode_literals
import math
from .lang_EU import Num2Word_EU
@@ -120,7 +122,6 @@ class Num2Word_ES(Num2Word_EU):
def to_ordinal(self, value):
self.verify_ordinal(value)
try:
if value == 0:
text = ""
elif value <= 10:
@@ -143,25 +144,26 @@ class Num2Word_ES(Num2Word_EU):
self.to_ordinal(value - cen))
)
elif value < 1e18:
# Round down to the nearest 1e(3n)
# 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 ""
)
dec = 1000 ** int(math.log(int(value), 1000))
# Split the parts before and after the word for 'dec'
# eg (12, 345) = divmod(12_345, 1_000)
high_part, low_part = divmod(value, dec)
cardinal = self.to_cardinal(high_part) if high_part != 1 else ""
text = (
"%s%s%s %s" % (cardinal, self.ords[dec], self.gender_stem,
self.to_ordinal(value - part))
self.to_ordinal(low_part))
)
else:
text = self.to_cardinal(value)
except KeyError:
text = self.to_cardinal(value)
return text.strip()
def to_ordinal_num(self, value):

37
num2words/lang_HE.py
View File

@@ -18,32 +18,33 @@
from __future__ import print_function, unicode_literals
from .base import Num2Word_Base
from .utils import get_digits, splitbyx
ZERO = (u'אפס',)
ONES = {
1: (u'אחד',),
2: (u'שנים',),
1: (u'אחת',),
2: (u'שתים',),
3: (u'שלש',),
4: (u'ארבע',),
5: (u'חמש',),
6: (u'שש',),
7: (u'שבע',),
8: (u'שמנה',),
8: (u'שמונה',),
9: (u'תשע',),
}
TENS = {
0: (u'עשר',),
1: (u'אחד עשרה',),
2: (u'שנים עשרה',),
1: (u'אחת עשרה',),
2: (u'שתים עשרה',),
3: (u'שלש עשרה',),
4: (u'ארבע עשרה',),
5: (u'חמש עשרה',),
6: (u'שש עשרה',),
7: (u'שבע עשרה',),
8: (u'שמנה עשרה',),
8: (u'שמונה עשרה',),
9: (u'תשע עשרה',),
}
@@ -54,7 +55,7 @@ TWENTIES = {
5: (u'חמישים',),
6: (u'ששים',),
7: (u'שבעים',),
8: (u'שמנים',),
8: (u'שמונים',),
9: (u'תשעים',),
}
@@ -67,6 +68,13 @@ HUNDRED = {
THOUSANDS = {
1: (u'אלף',),
2: (u'אלפיים',),
3: (u'שלשת אלפים',),
4: (u'ארבעת אלפים',),
5: (u'חמשת אלפים',),
6: (u'ששת אלפים',),
7: (u'שבעת אלפים',),
8: (u'שמונת אלפים',),
9: (u'תשעת אלפים',),
}
AND = u'ו'
@@ -100,12 +108,15 @@ def int2word(n):
n1, n2, n3 = get_digits(x)
if i > 0:
words.append(THOUSANDS[n1][0])
continue
if n3 > 0:
if n3 <= 2:
words.append(HUNDRED[n3][0])
else:
words.append(ONES[n3][0])
words.append(HUNDRED[3][0])
words.append(ONES[n3][0] + ' ' + HUNDRED[3][0])
if n2 > 1:
words.append(TWENTIES[n2][0])
@@ -116,14 +127,12 @@ def int2word(n):
words.append(ONES[n1][0])
if i > 0:
if i <= 2:
words.append(THOUSANDS[i][0])
else:
words.append(ONES[i][0])
words.append(THOUSANDS[1][0])
# source: https://hebrew-academy.org.il/2017/01/30/ו-החיבור-במספרים/
if len(words) > 1:
words[-1] = AND + words[-1]
return ' '.join(words)
@@ -135,7 +144,7 @@ def to_currency(n, currency='EUR', cents=True, separator=','):
raise NotImplementedError()
class Num2Word_HE(object):
class Num2Word_HE(Num2Word_Base):
def to_cardinal(self, number):
return n2w(number)

20
num2words/lang_TR.py
View File

@@ -24,17 +24,17 @@ class Num2Word_TR(object):
self.precision = 2
self.negword = u"eksi"
self.pointword = u"virgül"
self.CURRENCY_UNIT = (u"lira",)
self.CURRENCY_SUBUNIT = (u"kuruş",)
self.CURRENCY_UNIT = u"lira"
self.CURRENCY_SUBUNIT = u"kuruş"
self.errmsg_nonnum = u"Sadece sayılar yazıya çevrilebilir."
self.errmsg_floatord = u"Tam sayı olmayan {} sıralamada kullanılamaz."
self.errmsg_negord = u"Pozitif olmayan {} sıralamada kullanılamaz."
self.errmsg_toobig = u"abs({}) sayı yazıya çevirmek için çok büyük. " \
u"Yazıya çevrilebilecek en büyük rakam {}."
self.exclude_title = []
self.DECIMAL_SIGN = (",",)
self.ORDINAL_SIGN = (".",)
self.ZERO = (u"sıfır",)
self.DECIMAL_SIGN = ","
self.ORDINAL_SIGN = "."
self.ZERO = u"sıfır"
self.CARDINAL_ONES = {
"1": u"bir",
"2": u"iki",
@@ -444,7 +444,7 @@ class Num2Word_TR(object):
wrd += self.CARDINAL_ONES.get(self.integers_to_read[1][1], "")
if self.integers_to_read[0] == "0":
wrd = self.ZERO[0] + wrd
wrd = self.ZERO + wrd
else:
wrd = self.to_cardinal(int(self.integers_to_read[0])) + wrd
return wrd
@@ -830,9 +830,11 @@ class Num2Word_TR(object):
found = 1
def to_currency(self, value):
if int(value) == 0:
return u"bedelsiz"
valueparts = self.to_cardinal(value).split(self.pointword)
if len(valueparts) == 1:
return valueparts[0] + self.CURRENCY_UNIT[0]
return valueparts[0] + self.CURRENCY_UNIT
if len(valueparts) == 2:
return self.CURRENCY_UNIT[0].join(valueparts) + \
self.CURRENCY_SUBUNIT[0]
return self.CURRENCY_UNIT.join(valueparts) + \
self.CURRENCY_SUBUNIT

2
tests/test_cli.py
View File

@@ -102,7 +102,7 @@ class CliTestCase(unittest.TestCase):
)
def test_cli_with_lang_to(self):
"""You should be able to specify a language
"""You should be able to specify a language and currency
"""
output = self.cli.run_cmd(150.55, '--lang', 'es', '--to', 'currency')
self.assertEqual(output.return_code, 0)

37
tests/test_dk.py Normal file
View File

@@ -0,0 +1,37 @@
# coding: 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
from unittest import TestCase
from num2words import num2words
class Num2WordsDKTest(TestCase):
def test_ordinal(self):
self.assertEqual(num2words(1, to="ordinal", lang="dk"), "første")
self.assertEqual(num2words(5, to="ordinal", lang="dk"), "femte")
def test_cardinal(self):
self.assertEqual(num2words(0, to="cardinal", lang="dk"), "nul")
self.assertEqual(num2words(1, to="cardinal", lang="dk"), "et")
self.assertEqual(num2words(2, to="cardinal", lang="dk"), "to")
self.assertEqual(num2words(5, to="cardinal", lang="dk"), "fem")
self.assertEqual(num2words(8, to="cardinal", lang="dk"), "otte")
self.assertEqual(num2words(18, to="cardinal", lang="dk"), "atten")
self.assertEqual(num2words(45, to="cardinal", lang="dk"), "femogfyrre")

8
tests/test_en.py
View File

@@ -26,10 +26,18 @@ class Num2WordsENTest(TestCase):
self.assertEqual(num2words(199), "one hundred and ninety-nine")
def test_ordinal(self):
self.assertEqual(
num2words(0, lang='en', to='ordinal'),
'zeroth'
)
self.assertEqual(
num2words(1, lang='en', to='ordinal'),
'first'
)
self.assertEqual(
num2words(13, lang='en', to='ordinal'),
'thirteenth'
)
self.assertEqual(
num2words(22, lang='en', to='ordinal'),
'twenty-second'

1
tests/test_es.py
View File

@@ -95,6 +95,7 @@ TEST_CASES_ORDINAL = (
(28, 'vigésimo octavo'),
(100, 'centésimo'),
(1000, 'milésimo'),
(12345, 'docemilésimo tricentésimo quadragésimo quinto'),
(1000000, 'millonésimo'),
(1000000000000000, 'cuadrillonésimo'),
(1000000000000000000, 'un trillón') # over 1e18 is not supported

73
tests/test_he.py Normal file
View File

@@ -0,0 +1,73 @@
# -*- coding: 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
from unittest import TestCase
from num2words import num2words
class Num2WordsHETest(TestCase):
maxDiff = None
def test_0(self):
self.assertEqual(num2words(0, lang="he"), u'אפס')
def test_1_to_10(self):
self.assertEqual(num2words(1, lang="he"), u'אחת')
self.assertEqual(num2words(2, lang="he"), u'שתים')
self.assertEqual(num2words(7, lang="he"), u'שבע')
self.assertEqual(num2words(10, lang="he"), u'עשר')
def test_11_to_19(self):
self.assertEqual(num2words(11, lang="he"), u'אחת עשרה')
self.assertEqual(num2words(13, lang="he"), u'שלש עשרה')
self.assertEqual(num2words(15, lang="he"), u'חמש עשרה')
self.assertEqual(num2words(16, lang="he"), u'שש עשרה')
self.assertEqual(num2words(19, lang="he"), u'תשע עשרה')
def test_20_to_99(self):
self.assertEqual(num2words(20, lang="he"), u'עשרים')
self.assertEqual(num2words(23, lang="he"), u'עשרים ושלש')
self.assertEqual(num2words(28, lang="he"), u'עשרים ושמונה')
self.assertEqual(num2words(31, lang="he"), u'שלשים ואחת')
self.assertEqual(num2words(40, lang="he"), u'ארבעים')
self.assertEqual(num2words(66, lang="he"), u'ששים ושש')
self.assertEqual(num2words(92, lang="he"), u'תשעים ושתים')
def test_100_to_999(self):
self.assertEqual(num2words(100, lang="he"), u'מאה')
self.assertEqual(num2words(111, lang="he"), u'מאה ואחת עשרה')
self.assertEqual(num2words(150, lang="he"), u'מאה וחמישים')
self.assertEqual(num2words(196, lang="he"), u'מאה תשעים ושש')
self.assertEqual(num2words(200, lang="he"), u'מאתיים')
self.assertEqual(num2words(210, lang="he"), u'מאתיים ועשר')
self.assertEqual(num2words(701, lang="he"), u'שבע מאות ואחת')
def test_1000_to_9999(self):
self.assertEqual(num2words(1000, lang="he"), u'אלף')
self.assertEqual(num2words(1001, lang="he"), u'אלף ואחת')
self.assertEqual(num2words(1500, lang="he"), u'אלף וחמש מאות')
self.assertEqual(
num2words(7378, lang="he"), u'שבעת אלפים שלש מאות שבעים ושמונה'
)
self.assertEqual(num2words(2000, lang="he"), u'אלפיים')
self.assertEqual(num2words(2100, lang="he"), u'אלפיים ומאה')
self.assertEqual(
num2words(6870, lang="he"), u'ששת אלפים שמונה מאות ושבעים'
)

329
tests/test_tr.py
View File

@@ -24,171 +24,168 @@ from num2words import num2words
class Num2WordsTRTest(TestCase):
def test_tr(self):
# ref https://github.com/savoirfairelinux/num2words/issues/8
testlang = "tr"
testcases = [
{"test": 0, "to": "currency", "expected": u"bedelsiz"},
{"test": 1.1, "to": "currency", "expected": u"birliraonkuruş"},
{"test": 2000, "to": "currency", "expected": u"ikibinlira"},
{"test": 110000, "to": "currency", "expected": u"yüzonbinlira"},
{"test": 1002000, "to": "currency",
"expected": u"birmilyonikibinlira"},
{"test": 1002001, "to": "currency",
"expected": u"birmilyonikibinbirlira"},
{"test": 1100000, "to": "currency",
"expected": u"birmilyonyüzbinlira"},
{"test": 1, "to": "ordinal", "expected": u"birinci"},
{"test": 2, "to": "ordinal", "expected": u"ikinci"},
{"test": 9, "to": "ordinal", "expected": u"dokuzuncu"},
{"test": 10, "to": "ordinal", "expected": u"onuncu"},
{"test": 11, "to": "ordinal", "expected": u"onbirinci"},
{"test": 44, "to": "ordinal", "expected": u"kırkdördüncü"},
{"test": 100, "to": "ordinal", "expected": u"yüzüncü"},
{"test": 101, "to": "ordinal", "expected": u"yüzbirinci"},
{"test": 103, "to": "ordinal", "expected": u"yüzüçüncü"},
{"test": 110, "to": "ordinal", "expected": u"yüzonuncu"},
{"test": 111, "to": "ordinal", "expected": u"yüzonbirinci"},
{"test": 1000, "to": "ordinal", "expected": u"bininci"},
{"test": 1001, "to": "ordinal", "expected": u"binbirinci"},
{"test": 1010, "to": "ordinal", "expected": u"binonuncu"},
{"test": 1011, "to": "ordinal", "expected": u"binonbirinci"},
{"test": 1100, "to": "ordinal", "expected": u"binyüzüncü"},
{"test": 1110, "to": "ordinal", "expected": u"binyüzonuncu"},
{"test": 2341, "to": "ordinal",
"expected": u"ikibinüçyüzkırkbirinci"},
{"test": 10000, "to": "ordinal", "expected": u"onbininci"},
{"test": 10010, "to": "ordinal", "expected": u"onbinonuncu"},
{"test": 10100, "to": "ordinal", "expected": u"onbinyüzüncü"},
{"test": 10110, "to": "ordinal", "expected": u"onbinyüzonuncu"},
{"test": 11000, "to": "ordinal", "expected": u"onbirbininci"},
{"test": 35000, "to": "ordinal", "expected": u"otuzbeşbininci"},
{"test": 116331, "to": "ordinal",
"expected": u"yüzonaltıbinüçyüzotuzbirinci"},
{"test": 116330, "to": "ordinal",
"expected": u"yüzonaltıbinüçyüzotuzuncu"},
{"test": 100000, "to": "ordinal", "expected": u"yüzbininci"},
{"test": 501000, "to": "ordinal",
"expected": u"beşyüzbirbininci"},
{"test": 1000111, "to": "ordinal",
"expected": u"birmilyonyüzonbirinci"},
{"test": 111000111, "to": "ordinal",
"expected": u"yüzonbirmilyonyüzonbirinci"},
{"test": 111001111, "to": "ordinal",
"expected": u"yüzonbirmilyonbinyüzonbirinci"},
{"test": 111111111, "to": "ordinal",
"expected": u"yüzonbirmilyonyüzonbirbinyüzonbirinci"},
{"test": 100001000, "to": "ordinal",
"expected": u"yüzmilyonbininci"},
{"test": 100001001, "to": "ordinal",
"expected": u"yüzmilyonbinbirinci"},
{"test": 100010000, "to": "ordinal",
"expected": u"yüzmilyononbininci"},
{"test": 100010001, "to": "ordinal",
"expected": u"yüzmilyononbinbirinci"},
{"test": 100011000, "to": "ordinal",
"expected": u"yüzmilyononbirbininci"},
{"test": 100011001, "to": "ordinal",
"expected": u"yüzmilyononbirbinbirinci"},
{"test": 101011001, "to": "ordinal",
"expected": u"yüzbirmilyononbirbinbirinci"},
{"test": 101011010, "to": "ordinal",
"expected": u"yüzbirmilyononbirbinonuncu"},
{"test": 1101011010, "to": "ordinal",
"expected": u"birmilyaryüzbirmilyononbirbinonuncu"},
{"test": 101101011010, "to": "ordinal",
"expected": u"yüzbirmilyaryüzbirmilyononbirbinonuncu"},
{"test": 1000000000001, "to": "ordinal",
"expected": u"birtrilyonbirinci"},
{"test": 1.2, "to": "ordinal", "expected": u""},
{"test": 1.3, "to": "ordinal", "expected": u""},
{"test": 3000, "to": "ordinal", "expected": u"üçbininci"},
{"test": 120000, "to": "ordinal", "expected": u"yüzyirmibininci"},
{"test": 1002002, "to": "ordinal",
"expected": u"birmilyonikibinikinci"},
{"test": 1003000, "to": "ordinal",
"expected": u"birmilyonüçbininci"},
{"test": 1200000, "to": "ordinal",
"expected": u"birmilyonikiyüzbininci"},
{"test": 1, "to": "cardinal", "expected": u"bir"},
{"test": 2, "to": "cardinal", "expected": u"iki"},
{"test": 9, "to": "cardinal", "expected": u"dokuz"},
{"test": 10, "to": "cardinal", "expected": u"on"},
{"test": 11, "to": "cardinal", "expected": u"onbir"},
{"test": 44, "to": "cardinal", "expected": u"kırkdört"},
{"test": 100, "to": "cardinal", "expected": u"yüz"},
{"test": 101, "to": "cardinal", "expected": u"yüzbir"},
{"test": 103, "to": "cardinal", "expected": u"yüzüç"},
{"test": 110, "to": "cardinal", "expected": u"yüzon"},
{"test": 111, "to": "cardinal", "expected": u"yüzonbir"},
{"test": 1000, "to": "cardinal", "expected": u"bin"},
{"test": 1001, "to": "cardinal", "expected": u"binbir"},
{"test": 1010, "to": "cardinal", "expected": u"binon"},
{"test": 1011, "to": "cardinal", "expected": u"binonbir"},
{"test": 1100, "to": "cardinal", "expected": u"binyüz"},
{"test": 1110, "to": "cardinal", "expected": u"binyüzon"},
{"test": 2341, "to": "cardinal",
"expected": u"ikibinüçyüzkırkbir"},
{"test": 10000, "to": "cardinal", "expected": u"onbin"},
{"test": 10010, "to": "cardinal", "expected": u"onbinon"},
{"test": 10100, "to": "cardinal", "expected": u"onbinyüz"},
{"test": 10110, "to": "cardinal", "expected": u"onbinyüzon"},
{"test": 11000, "to": "cardinal", "expected": u"onbirbin"},
{"test": 35000, "to": "cardinal", "expected": u"otuzbeşbin"},
{"test": 116331, "to": "cardinal",
"expected": u"yüzonaltıbinüçyüzotuzbir"},
{"test": 116330, "to": "cardinal",
"expected": u"yüzonaltıbinüçyüzotuz"},
{"test": 500000, "to": "cardinal", "expected": u"beşyüzbin"},
{"test": 501000, "to": "cardinal", "expected": u"beşyüzbirbin"},
{"test": 1000111, "to": "cardinal",
"expected": u"birmilyonyüzonbir"},
{"test": 111000111, "to": "cardinal",
"expected": u"yüzonbirmilyonyüzonbir"},
{"test": 111001111, "to": "cardinal",
"expected": u"yüzonbirmilyonbinyüzonbir"},
{"test": 111111111, "to": "cardinal",
"expected": u"yüzonbirmilyonyüzonbirbinyüzonbir"},
{"test": 100001000, "to": "cardinal",
"expected": u"yüzmilyonbin"},
{"test": 100001001, "to": "cardinal",
"expected": u"yüzmilyonbinbir"},
{"test": 100010000, "to": "cardinal",
"expected": u"yüzmilyononbin"},
{"test": 100010001, "to": "cardinal",
"expected": u"yüzmilyononbinbir"},
{"test": 100011000, "to": "cardinal",
"expected": u"yüzmilyononbirbin"},
{"test": 100011001, "to": "cardinal",
"expected": u"yüzmilyononbirbinbir"},
{"test": 101011001, "to": "cardinal",
"expected": u"yüzbirmilyononbirbinbir"},
{"test": 101011010, "to": "cardinal",
"expected": u"yüzbirmilyononbirbinon"},
{"test": 1101011010, "to": "cardinal",
"expected": u"birmilyaryüzbirmilyononbirbinon"},
{"test": 101101011010, "to": "cardinal",
"expected": u"yüzbirmilyaryüzbirmilyononbirbinon"},
{"test": 1000000000001, "to": "cardinal",
"expected": u"birtrilyonbir"},
{"test": 0.01, "to": "cardinal", "expected": u"sıfırvirgülbir"},
{"test": 0.21, "to": "cardinal",
"expected": u"sıfırvirgülyirmibir"},
{"test": 0.1, "to": "cardinal", "expected": u"sıfırvirgülon"},
{"test": 1.01, "to": "cardinal", "expected": u"birvirgülbir"},
{"test": 1.1, "to": "cardinal", "expected": u"birvirgülon"},
{"test": 1.21, "to": "cardinal",
"expected": u"birvirgülyirmibir"},
{"test": 101101011010.02, "to": "cardinal",
"expected": u"yüzbirmilyaryüzbirmilyononbirbinonvirgüliki"},
{"test": 101101011010.2, "to": "cardinal",
"expected": u"yüzbirmilyaryüzbirmilyononbirbinonvirgülyirmi"}
]
self.assertEqual(num2words(1, True, "tr"), u"birinci")
self.assertEqual(num2words(2, True, "tr"), u"ikinci")
self.assertEqual(num2words(9, True, "tr"), u"dokuzuncu")
self.assertEqual(num2words(10, True, "tr"), u"onuncu")
self.assertEqual(num2words(11, True, "tr"), u"onbirinci")
self.assertEqual(num2words(44, True, "tr"), u"kırkdördüncü")
self.assertEqual(num2words(100, True, "tr"), u"yüzüncü")
self.assertEqual(num2words(101, True, "tr"), u"yüzbirinci")
self.assertEqual(num2words(103, True, "tr"), u"yüzüçüncü")
self.assertEqual(num2words(110, True, "tr"), u"yüzonuncu")
self.assertEqual(num2words(111, True, "tr"), u"yüzonbirinci")
self.assertEqual(num2words(1000, True, "tr"), u"bininci")
self.assertEqual(num2words(1001, True, "tr"), u"binbirinci")
self.assertEqual(num2words(1010, True, "tr"), u"binonuncu")
self.assertEqual(num2words(1011, True, "tr"), u"binonbirinci")
self.assertEqual(num2words(1100, True, "tr"), u"binyüzüncü")
self.assertEqual(num2words(1110, True, "tr"), u"binyüzonuncu")
for casedata in testcases:
self.assertEqual(
num2words(2341, True, "tr"), u"ikibinüçyüzkırkbirinci"
)
self.assertEqual(num2words(10000, True, "tr"), u"onbininci")
self.assertEqual(num2words(10010, True, "tr"), u"onbinonuncu")
self.assertEqual(num2words(10100, True, "tr"), u"onbinyüzüncü")
self.assertEqual(num2words(10110, True, "tr"), u"onbinyüzonuncu")
self.assertEqual(num2words(11000, True, "tr"), u"onbirbininci")
self.assertEqual(num2words(35000, True, "tr"), u"otuzbeşbininci")
self.assertEqual(
num2words(116331, True, "tr"), u"yüzonaltıbinüçyüzotuzbirinci"
)
self.assertEqual(
num2words(116330, True, "tr"), u"yüzonaltıbinüçyüzotuzuncu"
)
self.assertEqual(num2words(100000, True, "tr"), u"yüzbininci")
self.assertEqual(num2words(501000, True, "tr"), u"beşyüzbirbininci")
self.assertEqual(
num2words(1000111, True, "tr"), u"birmilyonyüzonbirinci"
)
self.assertEqual(
num2words(111000111, True, "tr"), u"yüzonbirmilyonyüzonbirinci"
)
self.assertEqual(
num2words(111001111, True, "tr"), u"yüzonbirmilyonbinyüzonbirinci"
)
self.assertEqual(
num2words(111111111, True, "tr"),
u"yüzonbirmilyonyüzonbirbinyüzonbirinci"
)
self.assertEqual(num2words(100001000, True, "tr"), u"yüzmilyonbininci")
self.assertEqual(
num2words(100001001, True, "tr"), u"yüzmilyonbinbirinci"
)
self.assertEqual(
num2words(100010000, True, "tr"), u"yüzmilyononbininci"
)
self.assertEqual(
num2words(100010001, True, "tr"), u"yüzmilyononbinbirinci"
)
self.assertEqual(
num2words(100011000, True, "tr"), u"yüzmilyononbirbininci"
)
self.assertEqual(
num2words(100011001, True, "tr"), u"yüzmilyononbirbinbirinci"
)
self.assertEqual(
num2words(101011001, True, "tr"), u"yüzbirmilyononbirbinbirinci"
)
self.assertEqual(
num2words(101011010, True, "tr"), u"yüzbirmilyononbirbinonuncu"
)
self.assertEqual(
num2words(1101011010, True, "tr"),
u"birmilyaryüzbirmilyononbirbinonuncu"
)
self.assertEqual(
num2words(101101011010, True, "tr"),
u"yüzbirmilyaryüzbirmilyononbirbinonuncu"
)
self.assertEqual(
num2words(1000000000001, True, "tr"), u"birtrilyonbirinci"
)
self.assertEqual(num2words(1, False, "tr"), u"bir")
self.assertEqual(num2words(2, False, "tr"), u"iki")
self.assertEqual(num2words(9, False, "tr"), u"dokuz")
self.assertEqual(num2words(10, False, "tr"), u"on")
self.assertEqual(num2words(11, False, "tr"), u"onbir")
self.assertEqual(num2words(44, False, "tr"), u"kırkdört")
self.assertEqual(num2words(100, False, "tr"), u"yüz")
self.assertEqual(num2words(101, False, "tr"), u"yüzbir")
self.assertEqual(num2words(103, False, "tr"), u"yüzüç")
self.assertEqual(num2words(110, False, "tr"), u"yüzon")
self.assertEqual(num2words(111, False, "tr"), u"yüzonbir")
self.assertEqual(num2words(1000, False, "tr"), u"bin")
self.assertEqual(num2words(1001, False, "tr"), u"binbir")
self.assertEqual(num2words(1010, False, "tr"), u"binon")
self.assertEqual(num2words(1011, False, "tr"), u"binonbir")
self.assertEqual(num2words(1100, False, "tr"), u"binyüz")
self.assertEqual(num2words(1110, False, "tr"), u"binyüzon")
self.assertEqual(num2words(2341, False, "tr"), u"ikibinüçyüzkırkbir")
self.assertEqual(num2words(10000, False, "tr"), u"onbin")
self.assertEqual(num2words(10010, False, "tr"), u"onbinon")
self.assertEqual(num2words(10100, False, "tr"), u"onbinyüz")
self.assertEqual(num2words(10110, False, "tr"), u"onbinyüzon")
self.assertEqual(num2words(11000, False, "tr"), u"onbirbin")
self.assertEqual(num2words(35000, False, "tr"), u"otuzbeşbin")
self.assertEqual(
num2words(116331, False, "tr"), u"yüzonaltıbinüçyüzotuzbir"
)
self.assertEqual(
num2words(116330, False, "tr"), u"yüzonaltıbinüçyüzotuz"
)
self.assertEqual(num2words(500000, False, "tr"), u"beşyüzbin")
self.assertEqual(num2words(501000, False, "tr"), u"beşyüzbirbin")
self.assertEqual(num2words(1000111, False, "tr"), u"birmilyonyüzonbir")
self.assertEqual(
num2words(111000111, False, "tr"), u"yüzonbirmilyonyüzonbir"
)
self.assertEqual(
num2words(111001111, False, "tr"), u"yüzonbirmilyonbinyüzonbir"
)
self.assertEqual(
num2words(111111111, False, "tr"),
u"yüzonbirmilyonyüzonbirbinyüzonbir"
)
self.assertEqual(num2words(100001000, False, "tr"), u"yüzmilyonbin")
self.assertEqual(num2words(100001001, False, "tr"), u"yüzmilyonbinbir")
self.assertEqual(num2words(100010000, False, "tr"), u"yüzmilyononbin")
self.assertEqual(
num2words(100010001, False, "tr"), u"yüzmilyononbinbir"
)
self.assertEqual(
num2words(100011000, False, "tr"), u"yüzmilyononbirbin"
)
self.assertEqual(
num2words(100011001, False, "tr"), u"yüzmilyononbirbinbir"
)
self.assertEqual(
num2words(101011001, False, "tr"), u"yüzbirmilyononbirbinbir"
)
self.assertEqual(
num2words(101011010, False, "tr"), u"yüzbirmilyononbirbinon"
)
self.assertEqual(
num2words(1101011010, False, "tr"),
u"birmilyaryüzbirmilyononbirbinon"
)
self.assertEqual(
num2words(101101011010, False, "tr"),
u"yüzbirmilyaryüzbirmilyononbirbinon"
)
self.assertEqual(
num2words(1000000000001, False, "tr"), u"birtrilyonbir"
)
self.assertEqual(num2words(0.01, False, "tr"), u"sıfırvirgülbir")
self.assertEqual(num2words(0.1, False, "tr"), u"sıfırvirgülon")
self.assertEqual(num2words(0.21, False, "tr"), u"sıfırvirgülyirmibir")
self.assertEqual(num2words(1.01, False, "tr"), u"birvirgülbir")
self.assertEqual(num2words(1.1, False, "tr"), u"birvirgülon")
self.assertEqual(num2words(1.21, False, "tr"), u"birvirgülyirmibir")
self.assertEqual(
num2words(101101011010.02, False, "tr"),
u"yüzbirmilyaryüzbirmilyononbirbinonvirgüliki"
)
self.assertEqual(
num2words(101101011010.2, False, "tr"),
u"yüzbirmilyaryüzbirmilyononbirbinonvirgülyirmi"
)
num2words(casedata["test"],
lang=testlang,
to=casedata["to"]),
casedata["expected"])