diff --git a/num2words/__init__.py b/num2words/__init__.py index 69ad8db..58eabfb 100644 --- a/num2words/__init__.py +++ b/num2words/__init__.py @@ -37,6 +37,7 @@ from . import lang_IT from . import lang_ES_VE from . import lang_ES_CO from . import lang_VN +from . import lang_TR CONVERTER_CLASSES = { @@ -60,7 +61,8 @@ CONVERTER_CLASSES = { 'pt_BR': lang_PT_BR.Num2Word_PT_BR(), 'he': lang_HE.Num2Word_HE(), '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'): diff --git a/num2words/lang_TR.py b/num2words/lang_TR.py new file mode 100644 index 0000000..dc3c26a --- /dev/null +++ b/num2words/lang_TR.py @@ -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] diff --git a/tests/test_tr.py b/tests/test_tr.py new file mode 100644 index 0000000..3e9753d --- /dev/null +++ b/tests/test_tr.py @@ -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")