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:
Daniel dos Santos
2022-08-12 16:28:40 -03:00
committed by GitHub
parent 531afc86bb 13c5b1c8d1
commit 882c08b639
8 changed files with 563 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
README.rst
View File

@@ -76,6 +76,7 @@ Besides the numerical argument, there are two main optional arguments.
**lang:** The language in which to convert the number. Supported values are:
* ``en`` (English, default)
* ``am`` (Amharic)
* ``ar`` (Arabic)
* ``cz`` (Czech)
* ``de`` (German)
@@ -112,6 +113,7 @@ Besides the numerical argument, there are two main optional arguments.
* ``ro`` (Romanian)
* ``ru`` (Russian)
* ``te`` (Telugu)
* ``tg`` (Tajik)
* ``tr`` (Turkish)
* ``th`` (Thai)
* ``vi`` (Vietnamese)
@@ -149,4 +151,4 @@ added Lithuanian support, but didn't take over maintenance of the project.
I am thus basing myself on Marius Grigaitis' improvements and re-publishing
``pynum2word`` as ``num2words``.
Virgil Dupras, Savoir-faire Linux
Virgil Dupras, Savoir-faire Linux

16
num2words/__init__.py
View File

@@ -17,15 +17,16 @@
from __future__ import unicode_literals
from . import (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_TH,
lang_TR, lang_UK, lang_VI)
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)
CONVERTER_CLASSES = {
'am': lang_AM.Num2Word_AM(),
'ar': lang_AR.Num2Word_AR(),
'cz': lang_CZ.Num2Word_CZ(),
'en': lang_EN.Num2Word_EN(),
@@ -61,6 +62,7 @@ CONVERTER_CLASSES = {
'he': lang_HE.Num2Word_HE(),
'it': lang_IT.Num2Word_IT(),
'vi': lang_VI.Num2Word_VI(),
'tg': lang_TG.Num2Word_TG(),
'th': lang_TH.Num2Word_TH(),
'tr': lang_TR.Num2Word_TR(),
'nl': lang_NL.Num2Word_NL(),

129
num2words/lang_AM.py Normal file
View File

@@ -0,0 +1,129 @@
# -*- 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 division, print_function, unicode_literals
from . import lang_EU
class Num2Word_AM(lang_EU.Num2Word_EU):
CURRENCY_FORMS = {'ETB': (('ብር', 'ብር'), ('ሳንቲም', 'ሳንቲም'))}
GIGA_SUFFIX = 'ቢሊዮን'
MEGA_SUFFIX = 'ሚሊዮን'
def set_high_numwords(self, high):
cap = 3 * (len(high) + 1)
for word, n in zip(high, range(cap, 5, -3)):
if n == 9:
self.cards[10 ** n] = word + self.GIGA_SUFFIX
else:
self.cards[10 ** n] = word + self.MEGA_SUFFIX
def setup(self):
super(Num2Word_AM, self).setup()
self.negword = 'አሉታዊ '
self.pointword = 'ነጥብ'
self.exclude_title = ['እና', 'ነጥብ', 'አሉታዊ']
self.mid_numwords = [(1000, 'ሺህ'), (100, 'መቶ'), (90, 'ዘጠና'),
(80, 'ሰማኒያ'), (70, 'ሰባ'), (60, 'ስድሳ'),
(50, 'አምሳ'), (40, 'አርባ'), (30, 'ሠላሳ')]
self.low_numwords = ['ሃያ', 'አሥራ ዘጠኝ', 'አሥራ ስምንት', 'አሥራ ሰባት',
'አስራ ስድስት', 'አሥራ አምስት', 'አሥራ አራት', 'አሥራ ሦስት',
'አሥራ ሁለት', 'አሥራ አንድ', 'አሥር', 'ዘጠኝ', 'ስምንት',
'ሰባት', 'ስድስት', 'አምስት', 'አራት', 'ሦስት', 'ሁለት',
'አንድ', 'ዜሮ']
self.ords = {'አንድ': 'አንደኛ',
'ሁለት': 'ሁለተኛ',
'ሦስት': 'ሦስተኛ',
'አራት': 'አራተኛ',
'አምስት': 'አምስተኛ',
'ስድስት': 'ስድስተኛ',
'ሰባት': 'ሰባተኛ',
'ስምንት': 'ስምንተኛ',
'ዘጠኝ': 'ዘጠነኛ',
'አሥር': 'አሥረኛ',
'አሥራ አንድ': 'አሥራ አንደኛ',
'አሥራ ሁለት': 'አሥራ ሁለተኛ',
'አሥራ ሦስት': 'አሥራ ሦስተኛ',
'አሥራ አራት': 'አሥራ አራተኛ',
'አሥራ አምስት': 'አሥራ አምስተኛ',
'አሥራ ስድስት': 'አሥራ ስድስተኛ',
'አሥራ ሰባት': 'አሥራ ሰባተኛ',
'አሥራ ስምንት': 'አሥራ ስምንተኛ',
'አሥራ ዘጠኝ': 'አሥራ ዘጠነኛ'}
def to_cardinal(self, value):
try:
assert int(value) == value
except (ValueError, TypeError, AssertionError):
return self.to_cardinal_float(value)
out = ''
if value >= self.MAXVAL:
raise OverflowError(self.errmsg_toobig % (value, self.MAXVAL))
if value == 100:
return self.title(out + 'መቶ')
else:
val = self.splitnum(value)
words, num = self.clean(val)
return self.title(out + words)
def merge(self, lpair, rpair):
ltext, lnum = lpair
rtext, rnum = rpair
if lnum == 1 and rnum < 100:
return rtext, rnum
elif 100 > lnum > rnum:
return '%s %s' % (ltext, rtext), lnum + rnum
elif lnum >= 100 > rnum:
return '%s %s' % (ltext, rtext), lnum + rnum
elif rnum > lnum:
return '%s %s' % (ltext, rtext), lnum * rnum
def to_ordinal(self, value):
self.verify_ordinal(value)
outwords = self.to_cardinal(value).split(' ')
lastwords = outwords[-1].split('-')
lastword = lastwords[-1].lower()
try:
lastword = self.ords[lastword]
except KeyError:
lastword += 'ኛ'
lastwords[-1] = self.title(lastword)
outwords[-1] = ' '.join(lastwords)
return ' '.join(outwords)
def to_ordinal_num(self, value):
self.verify_ordinal(value)
return '%s%s' % (value, self.to_ordinal(value)[-1:])
def to_currency(self, val, currency='ብር', cents=True, separator=' ከ',
adjective=True):
result = super(Num2Word_AM, self).to_currency(
val, currency=currency, cents=cents, separator=separator,
adjective=adjective)
return result
def to_year(self, val, longval=True):
if not (val // 100) % 10:
return self.to_cardinal(val)
return self.to_splitnum(val, hightxt='መቶ', longval=longval)

27
num2words/lang_HE.py
View File

@@ -81,11 +81,7 @@ AND = u'ו'
def pluralize(n, forms):
# gettext implementation:
# (n%10==1 && n%100!=11 ? 0 : n != 0 ? 1 : 2)
form = 0 if (n % 10 == 1 and n % 100 != 11) else 1 if n != 0 else 2
form = 1 if n == 0 else 0 if n == 1 else 1
return forms[form]
@@ -140,17 +136,30 @@ def n2w(n):
return int2word(int(n))
def to_currency(n, currency='EUR', cents=True, separator=','):
raise NotImplementedError()
class Num2Word_HE(Num2Word_Base):
CURRENCY_FORMS = {
'NIS': (('שקל', 'שקלים'), ('אגורה', 'אגורות')),
'EUR': (('אירו', 'אירו'), ('סנט', 'סנט')),
'USD': (('דולר', 'דולרים'), ('סנט', 'סנט')),
}
def to_cardinal(self, number):
return n2w(number)
def to_ordinal(self, number):
raise NotImplementedError()
def pluralize(self, n, forms):
return pluralize(n, forms)
def to_currency(self, val, currency='NIS', cents=True, separator=' ו',
adjective=False):
result = super(Num2Word_HE, self).to_currency(
val, currency=currency, cents=cents, separator=separator,
adjective=adjective)
# In Hebrew the separator is along with the following word
return result.replace(" ו ", " ו")
if __name__ == '__main__':
yo = Num2Word_HE()

149
num2words/lang_TG.py Normal file
View File

@@ -0,0 +1,149 @@
# -*- 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 division, print_function, unicode_literals
from . import lang_EU
GENERIC_DOLLARS = ("доллар", "доллар")
GENERIC_CENTS = ("сент", "сент")
class Num2Word_TG(lang_EU.Num2Word_EU):
CURRENCY_FORMS = {
# repalced by EUR
"EUR": (("евро", "евро"), GENERIC_CENTS),
# replaced by EUR
"USD": (GENERIC_DOLLARS, GENERIC_CENTS),
"RUB": (("рубл", "рубл"), ("копейк", "копейк")),
"TJS": (("сомонӣ", "сомонӣ"), ("дирам", "дирам")),
}
GIGA_SUFFIX = "иллиард"
MEGA_SUFFIX = "иллион"
def set_high_numwords(self, high):
cap = 3 * (len(high) + 1)
for word, n in zip(high, range(cap, 5, -3)):
if n == 9:
self.cards[10 ** n] = word + self.GIGA_SUFFIX
else:
self.cards[10 ** n] = word + self.MEGA_SUFFIX
def setup(self):
super(Num2Word_TG, self).setup()
lows = ["квинт", "квадр", "тр", "м", "м"]
self.high_numwords = self.gen_high_numwords([], [], lows)
self.negword = "минус "
self.pointword = "нуқта"
self.exclude_title = ["ва", "минус", "нуқта"]
self.mid_numwords = [
(1000, "ҳазор"),
(100, "сад"),
(90, "навад"),
(80, "ҳаштод"),
(70, "ҳафтод"),
(60, "шаст"),
(50, "панҷоҳ"),
(40, "чил"),
(30, "си"),
]
self.low_numwords = [
"бист",
"нуздаҳ",
"ҳаждаҳ",
"ҳабдаҳ",
"шонздаҳ",
"понздаҳ",
"чордаҳ",
"сенздаҳ",
"дувоздаҳ",
"ёздаҳ",
"даҳ",
"нӯҳ",
"ҳашт",
"ҳафт",
"шаш",
"панҷ",
"чор",
"се",
"ду",
"як",
"сифр",
]
def to_cardinal(self, value):
try:
assert int(value) == value
except (ValueError, TypeError, AssertionError):
return self.to_cardinal_float(value)
out = ""
if value < 0:
value = abs(value)
out = self.negword
if value >= self.MAXVAL:
raise OverflowError(self.errmsg_toobig % (value, self.MAXVAL))
if value == 100:
return self.title(out + "сад")
else:
val = self.splitnum(value)
words, num = self.clean(val)
return self.title(out + words)
def merge(self, lpair, rpair):
ltext, lnum = lpair
rtext, rnum = rpair
if lnum == 1 and rnum < 100:
return (rtext, rnum)
elif 100 > lnum > rnum:
if ltext == "си":
return ("%sю %s" % (ltext, rtext), lnum + rnum)
elif ltext == "панҷоҳ":
return ("панҷову %s" % (rtext), lnum + rnum)
else:
return ("%sу %s" % (ltext, rtext), lnum + rnum)
elif lnum >= 100 > rnum:
return ("%sу %s" % (ltext, rtext), lnum + rnum)
elif rnum > lnum:
if ltext == "яксад" and rtext not in self.low_numwords:
return ("сад %s" % (rtext), lnum * rnum)
if rtext == "сад":
return ("%s%s" % (ltext, rtext), lnum * rnum)
else:
return ("%s %s" % (ltext, rtext), lnum * rnum)
return ("%sу %s" % (ltext, rtext), lnum + rnum)
def to_ordinal(self, value):
self.verify_ordinal(value)
cardinal = self.to_cardinal(value)
outwords = cardinal.split(" ")
lastword = outwords[-1]
if lastword in ["ду", "се", "си"]:
return "%sюм" % (cardinal)
else:
return "%sум" % (cardinal)
def to_ordinal_num(self, value):
self.verify_ordinal(value)
return "%s%s" % (value, self.to_ordinal(value)[-2:])

94
tests/test_am.py Normal file
View File

@@ -0,0 +1,94 @@
# -*- 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 unittest import TestCase
from num2words import num2words
class Num2WordsAMTest(TestCase):
def test_cardinal(self):
self.assertEqual(num2words(100, lang='am'), 'መቶ')
self.assertEqual(num2words(100000, lang='am'), 'አንድ መቶ ሺህ')
self.assertEqual(num2words(101, lang='am'), 'አንድ መቶ አንድ')
def test_and_join_199(self):
self.assertEqual(num2words(199, lang='am'), 'አንድ መቶ ዘጠና ዘጠኝ')
def test_to_ordinal(self):
self.assertEqual(
num2words(1, lang='am', to='ordinal'),
'አንደኛ'
)
self.assertEqual(
num2words(13, lang='am', to='ordinal'),
'አሥራ ሦስተኛ'
)
self.assertEqual(
num2words(22, lang='am', to='ordinal'),
'ሃያ ሁለተኛ'
)
self.assertEqual(
num2words(10000, lang='am', to='ordinal'),
'አሥር ሺህኛ'
)
def test_to_ordinal_num(self):
self.assertEqual(num2words(10, lang='am', to='ordinal_num'), '10ኛ')
self.assertEqual(num2words(21, lang='am', to='ordinal_num'), '21ኛ')
self.assertEqual(num2words(102, lang='am', to='ordinal_num'), '102ኛ')
def test_cardinal_for_float_number(self):
self.assertEqual(num2words(12.5, lang='am'), 'አሥራ ሁለት ነጥብ አምስት')
self.assertEqual(num2words(12.51, lang='am'), 'አሥራ ሁለት ነጥብ አምስት አንድ')
self.assertEqual(num2words(12.53, lang='am'), 'አሥራ ሁለት ነጥብ አምስት ሦስት')
def test_to_overflow(self):
with self.assertRaises(OverflowError):
num2words('1000000000000000000000000000000000000000000000000000000'
'0000000000000000000000000000000000000000000000000000000'
'0000000000000000000000000000000000000000000000000000000'
'0000000000000000000000000000000000000000000000000000000'
'0000000000000000000000000000000000000000000000000000000'
'00000000000000000000000000000000', lang='am')
def test_to_currency(self):
self.assertEqual(
num2words('38.4', lang='am', to='currency', cents=False,
currency='ETB'), 'ሠላሳ ስምንት ብር ከ 40 ሳንቲም'
)
self.assertEqual(
num2words('0', lang='am', to='currency', separator=' እና',
cents=True, currency='ETB'), 'ዜሮ ብር እና ዜሮ ሳንቲም'
)
self.assertEqual(
num2words('1.50', lang='am', to='currency', cents=True,
currency='ETB'), 'አንድ ብር ከ አምሳ ሳንቲም'
)
def test_to_year(self):
self.assertEqual(num2words(1990, lang='am', to='year'),
'አሥራ ዘጠኝ መቶ ዘጠና')
self.assertEqual(num2words(5555, lang='am', to='year'),
'አምሳ አምስት መቶ አምሳ አምስት')
self.assertEqual(num2words(2017, lang='am', to='year'),
'ሁለት ሺህ አሥራ ሰባት')
self.assertEqual(num2words(1066, lang='am', to='year'),
'አንድ ሺህ ስድሳ ስድስት')
self.assertEqual(num2words(1865, lang='am', to='year'),
'አሥራ ስምንት መቶ ስድሳ አምስት')

43
tests/test_he.py
View File

@@ -20,6 +20,7 @@ from __future__ import unicode_literals
from unittest import TestCase
from num2words import num2words
from num2words.lang_HE import Num2Word_HE
class Num2WordsHETest(TestCase):
@@ -71,3 +72,45 @@ class Num2WordsHETest(TestCase):
self.assertEqual(
num2words(6870, lang="he"), u'ששת אלפים שמונה מאות ושבעים'
)
def test_pluralize(self):
n = Num2Word_HE()
cr1, cr2 = n.CURRENCY_FORMS['NIS']
self.assertEqual(n.pluralize(1, cr1), 'שקל')
self.assertEqual(n.pluralize(2, cr1), 'שקלים')
self.assertEqual(n.pluralize(1, cr2), 'אגורה')
self.assertEqual(n.pluralize(2, cr2), 'אגורות')
cr1, cr2 = n.CURRENCY_FORMS['USD']
self.assertEqual(n.pluralize(1, cr1), 'דולר')
self.assertEqual(n.pluralize(2, cr1), 'דולרים')
self.assertEqual(n.pluralize(1, cr2), 'סנט')
self.assertEqual(n.pluralize(2, cr2), 'סנט')
def test_to_currency(self):
n = Num2Word_HE()
self.assertEqual(
n.to_currency(20.0, currency='NIS'), 'עשרים שקלים ואפס אגורות'
)
self.assertEqual(
n.to_currency(100.0, currency='NIS'), 'מאה שקלים ואפס אגורות'
)
self.assertEqual(
n.to_currency(100.50, currency='NIS'), 'מאה שקלים וחמישים אגורות'
)
def test_to_cardinal(self):
n = Num2Word_HE()
self.assertEqual(n.to_cardinal(1500), u'אלף וחמש מאות')
class Num2WordsHETestNotImplementedMethofs(TestCase):
n = Num2Word_HE()
def test_to_ordinal(self):
with self.assertRaises(NotImplementedError):
self.n.to_ordinal('1')
def test_large_number(self):
with self.assertRaises(NotImplementedError):
num2words(2000000, lang="he")

118
tests/test_tg.py Normal file
View File

@@ -0,0 +1,118 @@
# -*- 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 Num2WordsTGTest(TestCase):
def test_cardinal(self):
with self.assertRaises(OverflowError):
num2words(1000000000000000000000000, lang="tg")
self.assertEqual(num2words(100, lang="tg"), "сад")
self.assertEqual(num2words(100000, lang="tg"), "сад ҳазор")
self.assertEqual(num2words(101, lang="tg"), "яксаду як")
self.assertEqual(num2words(110, lang="tg"), "яксаду даҳ")
self.assertEqual(num2words(115, lang="tg"), "яксаду понздаҳ")
self.assertEqual(num2words(123, lang="tg"), "яксаду бисту се")
self.assertEqual(num2words(1000, lang="tg"), "як ҳазор")
self.assertEqual(num2words(1001, lang="tg"), "як ҳазору як")
self.assertEqual(num2words(2012, lang="tg"), "ду ҳазору дувоздаҳ")
self.assertEqual(
num2words(12519.85, lang="tg"),
"дувоздаҳ ҳазору панҷсаду нуздаҳ нуқта ҳашт панҷ",
)
self.assertEqual(
num2words(1234567890, lang="tg"),
"як миллиарду дусаду сию чор миллиону панҷсаду шасту ҳафт ҳазору "
"ҳаштсаду навад",
)
self.assertEqual(num2words(1000000, lang="tg"), "як миллион")
self.assertEqual(num2words(1000000000, lang="tg"), "як миллиард")
self.assertEqual(num2words(1000000000000, lang="tg"), "як триллион")
self.assertEqual(num2words(5, lang="tg"), "панҷ")
self.assertEqual(num2words(-1, lang="tg"), "минус як")
self.assertEqual(num2words(-15, lang="tg"), "минус понздаҳ")
self.assertEqual(num2words(-100, lang="tg"), "минус сад")
def test_to_ordinal(self):
self.assertEqual(num2words(1, lang="tg", to="ordinal"), "якум")
self.assertEqual(num2words(2, lang="tg", to="ordinal"), "дуюм")
self.assertEqual(num2words(3, lang="tg", to="ordinal"), "сеюм")
self.assertEqual(num2words(30, lang="tg", to="ordinal"), "сиюм")
self.assertEqual(num2words(13, lang="tg", to="ordinal"), "сенздаҳум")
self.assertEqual(num2words(20, lang="tg", to="ordinal"), "бистум")
self.assertEqual(num2words(23, lang="tg", to="ordinal"), "бисту сеюм")
self.assertEqual(num2words(100, lang="tg", to="ordinal"), "садум")
self.assertEqual(
num2words(136, lang="tg", to="ordinal"), "яксаду сию шашум"
)
self.assertEqual(num2words(500, lang="tg", to="ordinal"), "панҷсадум")
self.assertEqual(
num2words(1000, lang="tg", to="ordinal"), "як ҳазорум"
)
self.assertEqual(
num2words(1001, lang="tg", to="ordinal"), "як ҳазору якум"
)
self.assertEqual(
num2words(2000, lang="tg", to="ordinal"), "ду ҳазорум"
)
self.assertEqual(
num2words(1000000, lang="tg", to="ordinal"), "як миллионум"
)
self.assertEqual(
num2words(1000000000, lang="tg", to="ordinal"), "як миллиардум"
)
def test_to_currency(self):
self.assertEqual(
num2words(1.0, lang="tg", to="currency", currency="EUR"),
"як евро, сифр сент",
)
self.assertEqual(
num2words(1.0, lang="tg", to="currency", currency="TJS"),
"як сомонӣ, сифр дирам",
)
self.assertEqual(
num2words(1234.56, lang="tg", to="currency", currency="TJS"),
"як ҳазору дусаду сию чор сомонӣ, панҷову шаш дирам",
)
self.assertEqual(
num2words(1234.56, lang="tg", to="currency", currency="RUB"),
"як ҳазору дусаду сию чор рубл, панҷову шаш копейк",
)
self.assertEqual(
num2words(
12519.85, lang="tg", to="currency", currency="TJS", cents=False
),
"дувоздаҳ ҳазору панҷсаду нуздаҳ сомонӣ, 85 дирам",
)
self.assertEqual(
num2words("1230.56", lang="tg", to="currency", currency="USD"),
"як ҳазору дусаду си доллар, панҷову шаш сент",
)
def test_to_ordinal_num(self):
self.assertEqual(
num2words("100", lang="tg", to="ordinal_num"),
"100ум",
)