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

Merge pull request #84 from Framras/master

Browse Source 
Add Turkish language support.
This commit is contained in:
Ernesto Rodriguez Ortiz
2017-09-05 08:44:23 -04:00
committed by GitHub
parent 39356b495d 935d95a87f
commit e6b2dbc4b9
3 changed files with 689 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
num2words/__init__.py
View File

@@ -37,6 +37,7 @@ from . import lang_IT
from . import lang_ES_VE from . import lang_ES_VE
from . import lang_ES_CO from . import lang_ES_CO
from . import lang_VN from . import lang_VN
from . import lang_TR
CONVERTER_CLASSES = { CONVERTER_CLASSES = {
@@ -60,7 +61,8 @@ CONVERTER_CLASSES = {
'pt_BR': lang_PT_BR.Num2Word_PT_BR(), 'pt_BR': lang_PT_BR.Num2Word_PT_BR(),
'he': lang_HE.Num2Word_HE(), 'he': lang_HE.Num2Word_HE(),
'it': lang_IT.Num2Word_IT(), 'it': lang_IT.Num2Word_IT(),
'vi_VN': lang_VN.Num2Word_VN() 'vi_VN': lang_VN.Num2Word_VN(),
'tr': lang_TR.Num2Word_TR()
} }
def num2words(number, ordinal=False, lang='en'): def num2words(number, ordinal=False, lang='en'):

565
num2words/lang_TR.py Normal file
View File

@@ -0,0 +1,565 @@
# -*- encoding: utf-8 -*-
# Copyright (c) 2003, Taro Ogawa. All Rights Reserved.
# Copyright (c) 2013, Savoir-faire Linux inc. All Rights Reserved.
# Copyright (c) 2017, Tufan Kaynak, Framras. 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
class Num2Word_TR(object):
def __init__(self):
self.precision = 2
self.negword = u"eksi"
self.pointword = u"virgül"
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. Yazıya çevrilebilecek en büyük rakam {}."
self.exclude_title = []
self.DECIMAL_SIGN = (",",)
self.ORDINAL_SIGN = (".",)
self.ZERO = (u"sıfır",)
self.CARDINAL_ONES = {
"1": u"bir",
"2": u"iki",
"3": u"üç",
"4": u"dört",
"5": u"beş",
"6": u"altı",
"7": u"yedi",
"8": u"sekiz",
"9": u"dokuz"
}
self.ORDINAL_ONES = {
"1": u"birinci",
"2": u"ikinci",
"3": u"üçüncü",
"4": u"dördüncü",
"5": u"beşinci",
"6": u"altıncı",
"7": u"yedinci",
"8": u"sekizinci",
"9": u"dokuzuncu"
}
self.CARDINAL_TENS = {
"1": u"on",
"2": u"yirmi",
"3": u"otuz",
"4": u"kırk",
"5": u"elli",
"6": u"altmış",
"7": u"yetmiş",
"8": u"seksen",
"9": u"doksan"
}
self.ORDINAL_TENS = {
"1": u"onuncu",
"2": u"yirminci",
"3": u"otuzuncu",
"4": u"kırkıncı",
"5": u"ellinci",
"6": u"altmışıncı",
"7": u"yetmişinci",
"8": u"sekseninci",
"9": u"doksanıncı"
}
self.HUNDREDS = {
"2": u"iki",
"3": u"üç",
"4": u"dört",
"5": u"beş",
"6": u"altı",
"7": u"yedi",
"8": u"sekiz",
"9": u"dokuz"
}
self.CARDINAL_HUNDRED = (u"yüz",)
self.ORDINAL_HUNDRED = (u"yüzüncü",)
self.CARDINAL_TRIPLETS = {
1: u"bin",
2: u"milyon",
3: u"milyar",
4: u"trilyon",
5: u"katrilyon",
6: u"kentilyon"
}
self.ORDINAL_TRIPLETS = {
1: u"bininci",
2: u"milyonuncu",
3: u"milyarıncı",
4: u"trilyonuncu",
5: u"katrilyonuncu",
6: u"kentilyon"
}
self.MAXVAL = (10 ** ((len(self.CARDINAL_TRIPLETS) + 1) * 3)) - 1
self.integers_to_read = []
self.total_triplets_to_read = 0
self.total_digits_outside_triplets = 0
self.order_of_last_zero_digit = 0
def to_cardinal(self, value):
wrd = ""
is_cardinal = self.verify_cardinal(value)
if is_cardinal:
if not int(value) == value:
return self.to_cardinal_float(value)
self.to_splitnum(value)
if self.order_of_last_zero_digit >= len(self.integers_to_read[0]):
# number like 00 and all 0s and even more, raise error
return wrd
if self.total_triplets_to_read == 1:
if self.total_digits_outside_triplets == 2:
if self.order_of_last_zero_digit == 1:
# number like x0, read cardinal x0 and return
wrd += self.CARDINAL_TENS.get(self.integers_to_read[0][0], "")
return wrd
if self.order_of_last_zero_digit == 0:
# number like xy, read cardinal xy and return
wrd += self.CARDINAL_TENS.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_ONES.get(self.integers_to_read[0][1], "")
return wrd
if self.total_digits_outside_triplets == 1:
if self.order_of_last_zero_digit == 0:
# number like x, read cardinal x and return
wrd += self.CARDINAL_ONES.get(self.integers_to_read[0][0], "")
return wrd
if self.total_digits_outside_triplets == 0:
if self.order_of_last_zero_digit == 2:
# number like x00, read cardinal x00 and return
wrd += self.HUNDREDS.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_HUNDRED[0]
return wrd
if self.order_of_last_zero_digit == 1:
# number like xy0, read cardinal xy0 and return
wrd += self.HUNDREDS.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_HUNDRED[0]
wrd += self.CARDINAL_TENS.get(self.integers_to_read[0][1], "")
return wrd
if self.order_of_last_zero_digit == 0:
# number like xyz, read cardinal xyz and return
wrd += self.HUNDREDS.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_HUNDRED[0]
wrd += self.CARDINAL_TENS.get(self.integers_to_read[0][1], "")
wrd += self.CARDINAL_ONES.get(self.integers_to_read[0][2], "")
return wrd
if self.total_triplets_to_read >= 2:
if self.total_digits_outside_triplets == 2:
if self.order_of_last_zero_digit == len(self.integers_to_read[0]) - 1:
# number like x0 and all 0s, read cardinal x0 0..0 and return
wrd += self.CARDINAL_TENS.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_TRIPLETS[self.total_triplets_to_read - 1]
return wrd
if self.order_of_last_zero_digit == len(self.integers_to_read[0]) - 2:
# number like xy and all 0s, read cardinal xy 0..0 and return
wrd += self.CARDINAL_TENS.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_ONES.get(self.integers_to_read[0][1], "")
wrd += self.CARDINAL_TRIPLETS[self.total_triplets_to_read - 1]
return wrd
if self.order_of_last_zero_digit < len(self.integers_to_read[0]) - 2:
# number like xy and others, read cardinal xy n..n and return
wrd += self.CARDINAL_TENS.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_ONES.get(self.integers_to_read[0][1], "")
wrd += self.CARDINAL_TRIPLETS[self.total_triplets_to_read - 1]
if self.total_digits_outside_triplets == 1:
if self.order_of_last_zero_digit == len(self.integers_to_read[0]) - 1:
# number like x and all 0s, read cardinal x 0..0 and return
if not (self.total_triplets_to_read == 2 and self.integers_to_read[0][0] == "1"):
wrd += self.CARDINAL_ONES.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_TRIPLETS[self.total_triplets_to_read - 1]
return wrd
if self.order_of_last_zero_digit < len(self.integers_to_read[0]) - 1:
# number like x and others, read cardinal x n..n and return
if not (self.total_triplets_to_read == 2 and self.integers_to_read[0][0] == "1"):
wrd += self.CARDINAL_ONES.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_TRIPLETS[self.total_triplets_to_read - 1]
if self.total_digits_outside_triplets == 0:
if self.order_of_last_zero_digit == len(self.integers_to_read[0]) - 1:
# number like x00 and all 0s, read cardinal x00 0..0 and return
wrd += self.HUNDREDS.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_HUNDRED[0]
wrd += self.CARDINAL_TRIPLETS[self.total_triplets_to_read - 1]
return wrd
if self.order_of_last_zero_digit == len(self.integers_to_read[0]) - 2:
# number like xy0 and all 0s, read cardinal xy0 0..0 and return
wrd += self.HUNDREDS.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_HUNDRED[0]
wrd += self.CARDINAL_TENS.get(self.integers_to_read[0][1], "")
wrd += self.CARDINAL_TRIPLETS[self.total_triplets_to_read - 1]
return wrd
if self.order_of_last_zero_digit == len(self.integers_to_read[0]) - 3:
# number like xyz and all 0s, read cardinal xyz 0..0 and return
wrd += self.HUNDREDS.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_HUNDRED[0]
wrd += self.CARDINAL_TENS.get(self.integers_to_read[0][1], "")
wrd += self.CARDINAL_ONES.get(self.integers_to_read[0][2], "")
wrd += self.CARDINAL_TRIPLETS[self.total_triplets_to_read - 1]
return wrd
if self.order_of_last_zero_digit < len(self.integers_to_read[0]) - 3:
# number like xyz and all others, read cardinal xyz n..n
wrd += self.HUNDREDS.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_HUNDRED[0]
wrd += self.CARDINAL_TENS.get(self.integers_to_read[0][1], "")
if not (self.total_triplets_to_read == 2 and self.integers_to_read[0][2] == "1"):
wrd += self.CARDINAL_ONES.get(self.integers_to_read[0][2], "")
wrd += self.CARDINAL_TRIPLETS[self.total_triplets_to_read - 1]
for i in list(range(self.total_triplets_to_read - 1, 0, -1)):
reading_triplet_order = self.total_triplets_to_read - i
if self.total_digits_outside_triplets == 0:
last_read_digit_order = reading_triplet_order * 3
else:
last_read_digit_order = (reading_triplet_order - 1) * 3 + self.total_digits_outside_triplets
if not self.integers_to_read[0][last_read_digit_order: last_read_digit_order + 3] == "000":
if not self.integers_to_read[0][last_read_digit_order] == "0":
wrd += self.HUNDREDS.get(self.integers_to_read[0][last_read_digit_order], "")
if self.order_of_last_zero_digit == len(self.integers_to_read[0]) - (
last_read_digit_order) - 1:
if i == 1:
wrd += self.CARDINAL_HUNDRED[0]
return wrd
elif i > 1:
wrd += self.CARDINAL_HUNDRED[0]
wrd += self.CARDINAL_TRIPLETS[i - 1]
return wrd
else:
wrd += self.CARDINAL_HUNDRED[0]
if not self.integers_to_read[0][last_read_digit_order + 1] == "0":
if self.order_of_last_zero_digit == len(self.integers_to_read[0]) - (
last_read_digit_order) - 2:
if i == 1:
wrd += self.CARDINAL_TENS.get(
self.integers_to_read[0][last_read_digit_order + 1], "")
return wrd
elif i > 1:
wrd += self.CARDINAL_TENS.get(
self.integers_to_read[0][last_read_digit_order + 1], "")
wrd += self.CARDINAL_TRIPLETS[i - 1]
return wrd
else:
wrd += self.CARDINAL_TENS.get(self.integers_to_read[0][last_read_digit_order + 1],
"")
if not self.integers_to_read[0][last_read_digit_order + 2] == "0":
if self.order_of_last_zero_digit == len(self.integers_to_read[0]) - (
last_read_digit_order) - 3:
if i == 1:
wrd += self.CARDINAL_ONES.get(
self.integers_to_read[0][last_read_digit_order + 2], "")
return wrd
if i == 2:
if not self.integers_to_read[0][
last_read_digit_order: last_read_digit_order + 2] == "00":
wrd += self.CARDINAL_ONES.get(
self.integers_to_read[0][last_read_digit_order + 2], "")
elif not self.integers_to_read[0][last_read_digit_order + 2] == "1":
wrd += self.CARDINAL_ONES.get(
self.integers_to_read[0][last_read_digit_order + 2], "")
wrd += self.CARDINAL_TRIPLETS[i - 1]
return wrd
if i > 2:
wrd += self.CARDINAL_ONES.get(
self.integers_to_read[0][last_read_digit_order + 2], "")
wrd += self.CARDINAL_TRIPLETS[i - 1]
return wrd
else:
if not self.integers_to_read[0][
last_read_digit_order: last_read_digit_order + 2] == "00":
wrd += self.CARDINAL_ONES.get(
self.integers_to_read[0][last_read_digit_order + 2], "")
else:
if i == 2:
if not self.integers_to_read[0][
last_read_digit_order: last_read_digit_order + 2] == "00":
wrd += self.CARDINAL_ONES.get(
self.integers_to_read[0][last_read_digit_order + 2], "")
elif not self.integers_to_read[0][last_read_digit_order + 2] == "1":
wrd += self.CARDINAL_ONES.get(
self.integers_to_read[0][last_read_digit_order + 2], "")
wrd += self.CARDINAL_TRIPLETS[i - 1]
return wrd
def to_cardinal_float(self, value):
self.to_splitnum(value)
wrd = ""
wrd += self.pointword
if len(self.integers_to_read[1]) >= 1:
wrd += self.CARDINAL_TENS.get(self.integers_to_read[1][0], "")
if len(self.integers_to_read[1]) == 2:
wrd += self.CARDINAL_ONES.get(self.integers_to_read[1][1], "")
if self.integers_to_read[0] == "0":
wrd = self.ZERO[0] + wrd
else:
wrd = self.to_cardinal(int(self.integers_to_read[0])) + wrd
return wrd
def verify_cardinal(self, value):
iscardinal = True
try:
if not float(value) == value:
iscardinal = False
except (ValueError, TypeError):
raise TypeError(self.errmsg_nonnum)
if abs(value) >= self.MAXVAL:
raise OverflowError(self.errmsg_toobig.format(value, self.MAXVAL))
return iscardinal
def verify_ordinal(self, value):
isordinal = True
try:
if not int(value) == value:
isordinal = False
if not abs(value) == value:
raise TypeError(self.errmsg_negord.format(value))
except (ValueError, TypeError):
raise TypeError(self.errmsg_nonnum)
if abs(value) >= self.MAXVAL:
raise OverflowError(self.errmsg_toobig.format(value, self.MAXVAL))
return isordinal
def to_ordinal(self, value):
wrd = ""
isordinal = self.verify_ordinal(value)
if isordinal:
self.to_splitnum(value)
if self.order_of_last_zero_digit >= len(self.integers_to_read[0]):
# number like 00 and all 0s and even more, raise error
return wrd
if self.total_triplets_to_read == 1:
if self.total_digits_outside_triplets == 2:
if self.order_of_last_zero_digit == 1:
# number like x0, read ordinal x0 and return
wrd += self.ORDINAL_TENS.get(self.integers_to_read[0][0], "")
return wrd
if self.order_of_last_zero_digit == 0:
# number like xy, read ordinal xy and return
wrd += self.CARDINAL_TENS.get(self.integers_to_read[0][0], "")
wrd += self.ORDINAL_ONES.get(self.integers_to_read[0][1], "")
return wrd
if self.total_digits_outside_triplets == 1:
if self.order_of_last_zero_digit == 0:
# number like x, read ordinal x and return
wrd += self.ORDINAL_ONES.get(self.integers_to_read[0][0], "")
return wrd
if self.total_digits_outside_triplets == 0:
if self.order_of_last_zero_digit == 2:
# number like x00, read ordinal x00 and return
wrd += self.HUNDREDS.get(self.integers_to_read[0][0], "")
wrd += self.ORDINAL_HUNDRED[0]
return wrd
if self.order_of_last_zero_digit == 1:
# number like xy0, read ordinal xy0 and return
wrd += self.HUNDREDS.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_HUNDRED[0]
wrd += self.ORDINAL_TENS.get(self.integers_to_read[0][1], "")
return wrd
if self.order_of_last_zero_digit == 0:
# number like xyz, read ordinal xyz and return
wrd += self.HUNDREDS.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_HUNDRED[0]
wrd += self.CARDINAL_TENS.get(self.integers_to_read[0][1], "")
if not self.integers_to_read[0][2] == "0":
wrd += self.ORDINAL_ONES.get(self.integers_to_read[0][2], "")
return wrd
if self.total_triplets_to_read >= 2:
if self.total_digits_outside_triplets == 2:
if self.order_of_last_zero_digit == len(self.integers_to_read[0]) - 1:
# number like x0 and all 0s, read ordinal x0 0..0 and return
wrd += self.CARDINAL_TENS.get(self.integers_to_read[0][0], "")
wrd += self.ORDINAL_TRIPLETS[self.total_triplets_to_read - 1]
return wrd
if self.order_of_last_zero_digit == len(self.integers_to_read[0]) - 2:
# number like xy and all 0s, read ordinal xy 0..0 and return
wrd += self.CARDINAL_TENS.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_ONES.get(self.integers_to_read[0][1], "")
wrd += self.ORDINAL_TRIPLETS[self.total_triplets_to_read - 1]
return wrd
if self.order_of_last_zero_digit < len(self.integers_to_read[0]) - 2:
# number like xy and others, read cardinal xy n..n and return
wrd += self.CARDINAL_TENS.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_ONES.get(self.integers_to_read[0][1], "")
wrd += self.CARDINAL_TRIPLETS[self.total_triplets_to_read - 1]
if self.total_digits_outside_triplets == 1:
if self.order_of_last_zero_digit == len(self.integers_to_read[0]) - 1:
# number like x and all 0s, read ordinal x 0..0 and return
if not (self.total_triplets_to_read == 2 and self.integers_to_read[0][0] == "1"):
wrd += self.CARDINAL_ONES.get(self.integers_to_read[0][0], "")
wrd += self.ORDINAL_TRIPLETS[self.total_triplets_to_read - 1]
return wrd
if self.order_of_last_zero_digit < len(self.integers_to_read[0]) - 1:
# number like x and others, read cardinal x n..n and return
if not (self.total_triplets_to_read == 2 and self.integers_to_read[0][0] == "1"):
wrd += self.CARDINAL_ONES.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_TRIPLETS[self.total_triplets_to_read - 1]
if self.total_digits_outside_triplets == 0:
if self.order_of_last_zero_digit == len(self.integers_to_read[0]) - 1:
# number like x00 and all 0s, read ordinal x00 0..0 and return
wrd += self.HUNDREDS.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_HUNDRED[0]
wrd += self.ORDINAL_TRIPLETS[self.total_triplets_to_read - 1]
return wrd
if self.order_of_last_zero_digit == len(self.integers_to_read[0]) - 2:
# number like xy0 and all 0s, read ordinal xy0 0..0 and return
wrd += self.HUNDREDS.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_HUNDRED[0]
wrd += self.CARDINAL_TENS.get(self.integers_to_read[0][1], "")
wrd += self.ORDINAL_TRIPLETS[self.total_triplets_to_read - 1]
return wrd
if self.order_of_last_zero_digit == len(self.integers_to_read[0]) - 3:
# number like xyz and all 0s, read ordinal xyz 0..0 and return
wrd += self.HUNDREDS.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_HUNDRED[0]
wrd += self.CARDINAL_TENS.get(self.integers_to_read[0][1], "")
wrd += self.CARDINAL_ONES.get(self.integers_to_read[0][2], "")
wrd += self.ORDINAL_TRIPLETS[self.total_triplets_to_read - 1]
return wrd
if self.order_of_last_zero_digit < len(self.integers_to_read[0]) - 3:
# number like xyz and all others, read cardinal xyz n..n
wrd += self.HUNDREDS.get(self.integers_to_read[0][0], "")
wrd += self.CARDINAL_HUNDRED[0]
wrd += self.CARDINAL_TENS.get(self.integers_to_read[0][1], "")
if not (self.total_triplets_to_read == 2 and self.integers_to_read[0][2] == "1"):
wrd += self.CARDINAL_ONES.get(self.integers_to_read[0][2], "")
wrd += self.CARDINAL_TRIPLETS[self.total_triplets_to_read - 1]
for i in list(range(self.total_triplets_to_read - 1, 0, -1)):
reading_triplet_order = self.total_triplets_to_read - i
if self.total_digits_outside_triplets == 0:
last_read_digit_order = reading_triplet_order * 3
else:
last_read_digit_order = (reading_triplet_order - 1) * 3 + self.total_digits_outside_triplets
if not self.integers_to_read[0][last_read_digit_order: last_read_digit_order + 3] == "000":
if not self.integers_to_read[0][last_read_digit_order] == "0":
if not self.integers_to_read[0][last_read_digit_order] == "1":
wrd += self.CARDINAL_ONES.get(self.integers_to_read[0][last_read_digit_order], "")
if self.order_of_last_zero_digit == len(self.integers_to_read[0]) - (
last_read_digit_order) - 1:
if i == 1:
wrd += self.ORDINAL_HUNDRED[0]
return wrd
elif i > 1:
wrd += self.CARDINAL_HUNDRED[0]
wrd += self.ORDINAL_TRIPLETS[i - 1]
return wrd
else:
wrd += self.CARDINAL_HUNDRED[0]
if not self.integers_to_read[0][last_read_digit_order + 1] == "0":
if self.order_of_last_zero_digit == len(self.integers_to_read[0]) - (
last_read_digit_order) - 2:
if i == 1:
wrd += self.ORDINAL_TENS.get(
self.integers_to_read[0][last_read_digit_order + 1], "")
return wrd
elif i > 1:
wrd += self.CARDINAL_TENS.get(
self.integers_to_read[0][last_read_digit_order + 1], "")
wrd += self.ORDINAL_TRIPLETS[i - 1]
return wrd
else:
wrd += self.CARDINAL_TENS.get(self.integers_to_read[0][last_read_digit_order + 1],
"")
if not self.integers_to_read[0][last_read_digit_order + 2] == "0":
if self.order_of_last_zero_digit == len(self.integers_to_read[0]) - (
last_read_digit_order) - 3:
if i == 1:
wrd += self.ORDINAL_ONES.get(
self.integers_to_read[0][last_read_digit_order + 2], "")
return wrd
if i == 2:
if not self.integers_to_read[0][
last_read_digit_order: last_read_digit_order + 2] == "00":
wrd += self.CARDINAL_ONES.get(
self.integers_to_read[0][last_read_digit_order + 2], "")
elif not self.integers_to_read[0][last_read_digit_order + 2] == "1":
wrd += self.CARDINAL_ONES.get(
self.integers_to_read[0][last_read_digit_order + 2], "")
wrd += self.ORDINAL_TRIPLETS[i - 1]
return wrd
if i > 2:
wrd += self.CARDINAL_ONES.get(
self.integers_to_read[0][last_read_digit_order + 2], "")
wrd += self.ORDINAL_TRIPLETS[i - 1]
return wrd
else:
if not self.integers_to_read[0][
last_read_digit_order: last_read_digit_order + 2] == "00":
wrd += self.CARDINAL_ONES.get(
self.integers_to_read[0][last_read_digit_order + 2], "")
else:
if not self.integers_to_read[0][
last_read_digit_order: last_read_digit_order + 2] == "00":
wrd += self.CARDINAL_ONES.get(
self.integers_to_read[0][last_read_digit_order + 2], "")
elif not self.integers_to_read[0][last_read_digit_order + 2] == "1":
wrd += self.CARDINAL_ONES.get(
self.integers_to_read[0][last_read_digit_order + 2], "")
wrd += self.CARDINAL_TRIPLETS[i - 1]
return wrd
def to_splitnum(self, val):
float_digits = str(int(val * 10 ** self.precision))
if not int(val) == 0:
self.integers_to_read = [str(int(val)), float_digits[len(float_digits) - self.precision:]]
else:
self.integers_to_read = ["0", "0" * (self.precision - len(float_digits)) + float_digits[len(float_digits) - self.precision:]]
if len(self.integers_to_read[0]) % 3 > 0:
self.total_triplets_to_read = (len(self.integers_to_read[0]) // 3) + 1
elif len(self.integers_to_read[0]) % 3 == 0:
self.total_triplets_to_read = len(self.integers_to_read[0]) // 3
self.total_digits_outside_triplets = len(self.integers_to_read[0]) % 3
okunacak = list(self.integers_to_read[0][::-1])
self.order_of_last_zero_digit = 0
found = 0
for i in range(len(okunacak) - 1):
if int(okunacak[i]) == 0 and found == 0:
self.order_of_last_zero_digit = i + 1
else:
found = 1
def to_currency(self, value, **kwargs):
valueparts = self.to_cardinal(value).split(self.pointword)
if len(valueparts) == 1:
return valueparts[0] + self.CURRENCY_UNIT[0]
if len(valueparts) == 2:
return self.CURRENCY_UNIT[0].join(valueparts) + self.CURRENCY_SUBUNIT[0]

121
tests/test_tr.py Normal file
View File

@@ -0,0 +1,121 @@
# -*- encoding: utf-8 -*-
# Copyright (c) 2013, Savoir-faire Linux inc. All Rights Reserved.
# Copyright (c) 2017, Tufan Kaynak, Framras. 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 Num2WordsTRTest(TestCase):
def test_tr(self):
# ref https://github.com/savoirfairelinux/num2words/issues/8
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")
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")