def test_cardinal_for_negative_number(self): self.assertEqual( num2words(-923, lang='id'), "min sembilan ratus dua puluh tiga" ) self.assertEqual( num2words(-0.234, lang='id'), "min nol koma dua tiga empat" )
def test_cardinal_for_decimal_number(self): self.assertEqual( num2words(12.234, lang='id'), "dua belas koma dua tiga empat" ) self.assertEqual( num2words(9.076, lang='id'), "sembilan koma nol tujuh enam" )
def _ordinal2word(wordsList, indice): """Convert an ordinal number to a written word. i.e. 1er --> premier param strNumber: an utf-8 ordinal number return a 'written' ordinal number """ strNumber = NumberFormula._normalizeNumber(wordsList[indice]) if strNumber.encode('utf-8') == u"1st".encode('utf-8'): return u"first" strNewNumber = re.sub(u"[ndstrh]", "", strNumber) # print strNewNumber # if NumberFormula._isCardinalNumber(strNewNumber): if strNewNumber.isdigit(): strNewNumber = num2words(int(strNewNumber), ordinal=True) # print(strNewNumber) elif NumberFormula._isRomanNumber(strNewNumber): #Roman to cardinal strNewNumber = strNewNumber.encode('utf-8') # print strNewNumber cardinalNumber = fromRoman(strNewNumber) #Digits to ordinal strNewNumber = num2words(cardinalNumber, ordinal=True) else: print("newnumberis not digit!!!") strNewNumber = strNumber return strNewNumber
def test_hundred_thousands(self): self.assertEqual('cem mil', num2words(100000, ordinal=False, lang='pt_BR')) self.assertEqual('oitocentos mil', num2words(800000, ordinal=False, lang='pt_BR')) self.assertEqual('oitocentos mil e seis', num2words(800006, ordinal=False, lang='pt_BR'))
def test_1000_to_9999(self): self.assertEqual(num2words(1000, lang='th'), "หนึ่งพัน") self.assertEqual( num2words(2175, lang='th'), "สองพันหนึ่งร้อยเจ็ดสิบห้า" ) self.assertEqual(num2words(4582, lang='th'), "สี่พันห้าร้อยแปดสิบสอง") self.assertEqual(num2words(9346, lang='th'), "เก้าพันสามร้อยสี่สิบหก")
def _ordinal2word(wordsList, indice): """Convert an ordinal number to a written word. i.e. 1er --> premier param strNumber: an utf-8 ordinal number return a 'written' ordinal number """ strNumber = NumberFormula._normalizeNumber(wordsList[indice]) if strNumber.encode('utf-8') == u"1ère".encode('utf-8'): return u"première" strNewNumber = re.sub(u"[erèm]", "", strNumber) if NumberFormula._isCardinalNumber(strNewNumber): strNewNumber = num2words(int(strNewNumber), ordinal=True, lang='fr') elif NumberFormula._isRomanNumber(strNewNumber): #Roman to cardinal strNewNumber = strNewNumber.encode('utf-8') cardinalNumber = fromRoman(strNewNumber) #Digits to ordinal strNewNumber = num2words(cardinalNumber, ordinal=True, lang='fr') else: strNewNumber = strNumber strNewNumber = re.sub(r'vingtsi','vingti',strNewNumber) strNewNumber = re.sub(r'centsi','centi',strNewNumber) strNewNumber = re.sub(r'millionsi','millioni',strNewNumber) strNewNumber = re.sub(r'milliardsi','milliardi',strNewNumber) return strNewNumber
def test_decimal_number(self): self.assertEqual( num2words(1000.11, lang="vi"), "một nghìn phẩy mười một" ) self.assertEqual( num2words(1000.21, lang="vi"), "một nghìn phẩy hai mươi mốt" )
def test_negative(self): self.assertEqual(num2words(-10, lang='th'), "ติดลบสิบ") self.assertEqual(num2words(-10.50, lang='th'), "ติดลบสิบจุดห้า") self.assertEqual( num2words(-100.00, lang='th', to='currency'), "ติดลบหนึ่งร้อยบาทถ้วน" )
def test_100_to_999(self): self.assertEqual(num2words(100, lang="vi"), "một trăm") self.assertEqual(num2words(150, lang="vi"), "một trăm năm mươi") self.assertEqual( num2words(196, lang="vi"), "một trăm chín mươi sáu" ) self.assertEqual(num2words(200, lang="vi"), "hai trăm") self.assertEqual(num2words(210, lang="vi"), "hai trăm mười")
def test_overflow(self): with self.assertRaises(OverflowError): num2words("100000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000")
def test_negative(self): number = 648972145 pos_crd = num2words(+number, lang="it") neg_crd = num2words(-number, lang="it") pos_ord = num2words(+number, lang="it", ordinal=True) neg_ord = num2words(-number, lang="it", ordinal=True) self.assertEqual("meno " + pos_crd, neg_crd) self.assertEqual("meno " + pos_ord, neg_ord)
def digitsToWords(item): if isinstance(item, (int, long)): return num2words(item) if isinstance(item, (str, unicode)) and item.isdigit(): return num2words(int(item)) return item
def test_numbers(self): self.assertEqual(num2words(42, lang="kn"), u"ನಲವತ್ತ್ ಎರಡು") self.assertEqual(num2words(893, lang="kn"), u"ಎಂಟು ನೂರ ತೊಂಬತ್ತ ಮೂರು") self.assertEqual( num2words(1729, lang="kn"), u"ಒಂದು ಸಾವಿರ ಏಳು ನೂರ ಇಪ್ಪತ್ತ್ಒಂಬತ್ತು" ) self.assertEqual(num2words(123, lang="kn"), u"ಒಂದು ನೂರ ಇಪ್ಪತ್ತ್ ಮೂರು") self.assertEqual(num2words(32211, lang="kn"), u"ಮೂವತ್ತ್ಎರಡು ಸಾವಿರ ಎರಡು ನೂರ ಹನ್ನೊಂದು")
def get_all_subjects(group_id): lessons = [] group = Group.get_by_id(group_id) days = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'] for day in days: for item in getattr(group,day): for i in range(1,7): if getattr(item,'lesson_'+ num2words(i))!=None or getattr(item,'lesson_'+ num2words(i)) > 0: lessons.append(Lessons.query.get(getattr(item,'lesson_'+ num2words(i)))) return lessons
def supports_num2words(language): global _NUM2WORDS_SUPPORT if language not in _NUM2WORDS_SUPPORT: try: num2words(0, lang=language) _NUM2WORDS_SUPPORT[language] = True except NotImplementedError: _NUM2WORDS_SUPPORT[language] = False return _NUM2WORDS_SUPPORT[language]
def test_currency(self): self.assertEqual( num2words(1234.12, lang='fr_DZ', to='currency'), "mille deux cent trente-quatre dinards et douze centimes" ) self.assertEqual( num2words(45689.89, lang='fr_DZ', to='currency'), "quarante-cinq mille six cent quatre-vingt-neuf dinards et " "quatre-vingt-neuf centimes" )
def test_10000_to_99999(self): self.assertEqual( num2words(11111, lang='th'), "หนึ่งหมื่นหนึ่งพันหนึ่งร้อยสิบเอ็ด" ) self.assertEqual( num2words(22222, lang='th'), "สองหมื่นสองพันสองร้อยยี่สิบสอง" ) self.assertEqual( num2words(84573, lang='th'), "แปดหมื่นสี่พันห้าร้อยเจ็ดสิบสาม" )
def test_currency(self): self.assertEqual( num2words(10.0, lang='cz', to='currency', currency='EUR'), "deset euro, nula centů") self.assertEqual( num2words(1.0, lang='cz', to='currency', currency='CZK'), "jedna koruna, nula haléřů") self.assertEqual( num2words(1234.56, lang='cz', to='currency', currency='EUR'), "tisíc dvěstě třicet čtyři euro, padesát šest centů") self.assertEqual( num2words(1234.56, lang='cz', to='currency', currency='CZK'), "tisíc dvěstě třicet čtyři koruny, padesát šest haléřů") self.assertEqual( num2words(101.11, lang='cz', to='currency', currency='EUR', separator=' a'), "sto jedna euro a jedenáct centů") self.assertEqual( num2words(101.21, lang='cz', to='currency', currency='CZK', separator=' a'), "sto jedna korun a dvacet jedna haléřů" ) self.assertEqual( num2words(-12519.85, lang='cz', to='currency', cents=False), "mínus dvanáct tisíc pětset devatenáct euro, 85 centů" ) self.assertEqual( num2words(123.50, lang='cz', to='currency', currency='CZK', separator=' a'), "sto dvacet tři koruny a padesát haléřů" ) self.assertEqual( num2words(19.50, lang='cz', to='currency', cents=False), "devatenáct euro, 50 centů" )
def speak_time_signal(): # get time now = datetime.datetime.now() hour = num2words.num2words(now.hour) minute = num2words.num2words(now.minute) # compose the sentence sentence = 'The time is {hour} {minute}.'.format(hour=hour, minute=minute) filename = 'time_signal.mp3' # speak raspi s = SpeakRaspi(filename=filename) s.speak(sentence=sentence)
def in_words(integer, in_million=True): """ Returns string in words for the given integer. """ locale = 'en_IN' if not in_million else frappe.local.lang integer = int(integer) try: ret = num2words(integer, lang=locale) except NotImplementedError: ret = num2words(integer, lang='en') return ret.replace('-', ' ')
def loan_ammount_asking(loanammount): if loanammount.isdigit(): loanammount = int(loanammount) if loanammount >= 100000 and loanammount <= 5000000: loan_ammount_json_obj = json.dumps( {'message_human': loanammount, 'loan_ammount_in_words': num2words(int(loanammount)), 'message_bot': ['Ok we are considering the ' + str( loanammount) + " as borrower's loan ammount."], 'suggestion_message': ["Bye"], 'current_form_action': "/loan_chat?msg=", 'next_form_action': "/end_chat?msg=", 'previous_form_action': "/mobilenumber_asking?msg", 'next_field_type': "button", 'previous_field_type': "number", "placeholder_text": ["Bye"]}, sort_keys=True, indent=4, separators=(',', ': ')) elif loanammount < 100000: loan_ammount_json_obj = json.dumps( {'message_human': loanammount, 'loan_ammount_in_words': num2words(int(loanammount)), 'message_bot': ['Sorry but we are doing loans in range of 100000 to 5000000.', 'We can consider 1000000 ammount of loan for you at first glance.', ], 'suggestion_message': ["Bye"], 'current_form_action': "/loan_chat?msg=", 'next_form_action': "/end_chat?msg=", 'previous_form_action': "/mobilenumber_asking?msg", 'next_field_type': "button", 'previous_field_type': "number", "placeholder_text": ["Bye"]}, sort_keys=True, indent=4, separators=(',', ': ')) elif loanammount > 5000000: loan_ammount_json_obj = json.dumps({'message_human': loanammount, 'message_bot': [ 'Sorry but we are doing loans in range of 100000 to 5000000.', 'We can consider 50000000 ammount of loan for you at first glance.', ], 'suggestion_message': ["Bye"], 'current_form_action': "/loan_chat?msg=", 'next_form_action': "/end_chat?msg=", 'previous_form_action': "/mobilenumber_asking?msg", 'next_field_type': "button", 'previous_field_type': "number", "placeholder_text": ["Bye"]}, sort_keys=True, indent=4, separators=(',', ': ')) elif not (loanammount.isdigit()): loan_ammount_json_obj = json.dumps({'message_human': loanammount, 'message_bot': [ "Please enter the loan ammount in digits between the range of 1000000 and 5000000."], 'suggestion_message': [""], 'current_form_action': "/loan_chat?msg=", 'next_form_action': "", 'previous_form_action': "/mobilenumber_asking?msg", 'next_field_type': "", 'previous_field_type': "number", "placeholder_text": "Please enter the loan ammount in digits between the range of 1000000 and 5000000."}, sort_keys=True, indent=4, separators=(',', ': ')) return loan_ammount_json_obj
def test_cardinal_integer_negative(self): self.assertEqual(num2words(-1, lang='pt_BR'), 'menos um') self.assertEqual( num2words(-256, lang='pt_BR'), 'menos duzentos e cinquenta e seis' ) self.assertEqual(num2words(-1000, lang='pt_BR'), 'menos mil') self.assertEqual(num2words(-1000000, lang='pt_BR'), 'menos um milhão') self.assertEqual( num2words(-1234567, lang='pt_BR'), 'menos um milhão, duzentos e trinta e quatro mil, quinhentos e ' 'sessenta e sete' )
def test_ordinal_at_crucial_number(self): self.assertEqual(num2words(100, ordinal=True, lang='sl'), "stoti") self.assertEqual(num2words(1000, ordinal=True, lang='sl'), "tisoči") self.assertEqual( num2words(4000, ordinal=True, lang='sl'), "štiritisoči" ) self.assertEqual( num2words(2000000, ordinal=True, lang='sl'), "dvamilijonti" ) self.assertEqual( num2words(5000000000, ordinal=True, lang='sl'), "petmilijardti" )
def test_100000_to_999999(self): self.assertEqual( num2words(153247, lang='th'), "หนึ่งแสนห้าหมื่นสามพันสองร้อยสี่สิบเจ็ด" ) self.assertEqual( num2words(562442, lang='th'), "ห้าแสนหกหมื่นสองพันสี่ร้อยสี่สิบสอง" ) self.assertEqual( num2words(999999, lang='th'), "เก้าแสนเก้าหมื่นเก้าพันเก้าร้อยเก้าสิบเก้า" )
def transcribe_number (n, lang, flx): if flx == 'nominative': return num2words(n, ordinal=False, lang=lang) elif flx == 'ordinal': return num2words(n, ordinal=True, lang=lang) elif flx == 'ordgen': res = num2words(n, ordinal=True, lang=lang) if lang == 'de': res += u'n' return res else: raise Exception('transcribe_number: flx "%s" not recognized.' % flx)
def test_currency(self): self.assertEqual( num2words(100, lang='th', to='currency', currency='THB'), "หนึ่งร้อยบาทถ้วน" ) self.assertEqual( num2words(100, lang='th', to='currency', currency='USD'), "หนึ่งร้อยดอลลาร์" ) self.assertEqual( num2words(100, lang='th', to='currency', currency='EUR'), "หนึ่งร้อยยูโร" )
def test_cardinal_for_float_number(self): self.assertEqual( num2words(12.40, lang='uk'), "дванадцять кома чотири" ) self.assertEqual( num2words(17.31, lang='uk'), "сiмнадцять кома тридцять одна" ) self.assertEqual( num2words(14.13, lang='uk'), "чотирнадцять кома тринадцять" ) self.assertEqual( num2words(12.31, lang='uk'), "дванадцять кома тридцять одна" )
def num_to_word(num): if num <=9: return num2words(num) #return (num) else: values = [] for i in [int(x) for x in str(num)]: temp = num2words(i) values.append(str(temp)) #d = divmod(num,10) #values.append(d) return values
def test_1000_to_9999(self): self.assertEqual(num2words(1000, lang="vi_VN"), "một nghìn") self.assertEqual(num2words(1500, lang="vi_VN"), "một nghìn năm trăm") self.assertEqual(num2words(7378, lang="vi_VN"), "bảy nghìn ba trăm bảy mươi tám") self.assertEqual(num2words(2000, lang="vi_VN"), "hai nghìn") self.assertEqual(num2words(2100, lang="vi_VN"), "hai nghìn một trăm") self.assertEqual(num2words(6870, lang="vi_VN"), "sáu nghìn tám trăm bảy mươi") self.assertEqual(num2words(10000, lang="vi_VN"), "mười nghìn") self.assertEqual(num2words(100000, lang="vi_VN"), "một trăm nghìn") self.assertEqual(num2words(523456, lang="vi_VN"), "năm trăm hai mươi ba nghìn bốn trăm năm mươi sáu")
def test_ordinal_special_joins(self): # ref https://github.com/savoirfairelinux/num2words/issues/18 self.assertEqual( num2words(5, ordinal=True, lang='fr'), "cinquième" ) self.assertEqual( num2words(35, ordinal=True, lang='fr'), "trente-cinquième" ) self.assertEqual( num2words(9, ordinal=True, lang='fr'), "neuvième" ) self.assertEqual( num2words(49, ordinal=True, lang='fr'), "quarante-neuvième" )
def numToFRWord(match): num = int(match.group(0)) return num2words(num, lang='fr')
def convert_number_to_string(num): word = num2words(num) word = word.replace("-", "") return word.capitalize()
def alphabetic_value(number_entity, language): value = number_entity[ENTITY][VALUE] if value != int(value): # num2words does not handle floats correctly return None return num2words(int(value), lang=language)
#To convert number to words #Firstly install num2words module ie pip install num2words #then import the module like below from num2words import num2words my_no = "123456" no_words = num2words(my_no) print(f'123456 in words is {no_words}')
def test_ordinal_more_than_twenty(self): self.assertEqual( num2words(81, ordinal=True, lang='nl'), "eenentachtigste" )
def test_ordinal_less_than_twenty(self): self.assertEqual(num2words(7, ordinal=True, lang='nl'), "zevende") self.assertEqual(num2words(8, ordinal=True, lang='nl'), "achtste") self.assertEqual(num2words(12, ordinal=True, lang='nl'), "twaalfde") self.assertEqual(num2words(17, ordinal=True, lang='nl'), "zeventiende")
def evaluate(question,ans,MODE): actualAnswer = ans question = preprocess_sentence(question) inputs = [inpQsTrain.word_index[i] for i in question.split(' ') if i!=''] inputs = tf.keras.preprocessing.sequence.pad_sequences([inputs], maxlen=maxLengInpTrain, padding='post') inputsTensor = tf.convert_to_tensor(inputs) result = '' predictSet = [] hidden = [tf.zeros((1, units))] encoderOutput, encoderHidden = encoder(inputsTensor, hidden) decoderHidden = encoderHidden if MODE == "AutoEncoder": tokenzr = inpQsTrain decoderInput = tf.expand_dims([tokenzr.word_index['<start>']], 0) for t in range(maxLengthTargTrain): predictions, decoderHidden,_ = decoder(decoderInput, decoderHidden, encoderOutput) predicted_id = tf.argmax(predictions[0]).numpy() predictSet.append(predicted_id) if tokenzr.index_word[predicted_id] != '<end>': result += tokenzr.index_word[predicted_id] + ' ' else: break decoderInput = tf.expand_dims([predicted_id], 0) predictSet = tf.keras.preprocessing.sequence.pad_sequences([predictSet], maxlen=maxLengInpTrain, padding='post') predictSetTensor = tf.convert_to_tensor(predictSet) correct_prediction = tf.equal( tf.round( predictSetTensor ), tf.round( inputsTensor ) ) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)).numpy() return question, result, accuracy, None if MODE == "QuestionAnswering": tokenzr = targAsTrain decoderInput = tf.expand_dims([tokenzr.word_index['<start>']], 0) for t in range(maxLengthTargTrain): predictions, decoderHidden,_ = decoder(decoderInput, decoderHidden, encoderOutput) predicted_id = tf.argmax(predictions[0]).numpy() predictSet.append(predicted_id) #print(predicted_id) if predicted_id!=0 and tokenzr.index_word[predicted_id] != '<end>': result += tokenzr.index_word[predicted_id] + ' ' else: break decoderInput = tf.expand_dims([predicted_id], 0) predictSet = tf.keras.preprocessing.sequence.pad_sequences([predictSet], maxlen=maxLengthTargTrain, padding='post') predictSetTensor = tf.convert_to_tensor(predictSet) #print(actualAnswer) actualAnswer = re.split("_|,",actualAnswer)[0] result = result.split(",")[0].replace(" ","") actualAnswerWups = wn.synsets(actualAnswer) resultWups = wn.synsets(result) if len(actualAnswerWups) >0 and len(resultWups) >0: WUPS = actualAnswerWups[0].wup_similarity(resultWups[0]) else: WUPS = 0 if ans.isdigit(): ans=num2words(ans).replace("point zero","").replace(" ","") ans = re.split("_|,",ans) actualAnswer = [targAsTrain.word_index.get(key.replace(" ","")) for key in ans] actualAnswer = [x for x in actualAnswer if x is not None] actualAnswer = tf.keras.preprocessing.sequence.pad_sequences([actualAnswer], maxlen=maxLengthTargTrain, padding='post') actualAnswerTensor = tf.convert_to_tensor(actualAnswer) correct_prediction = tf.equal( tf.round( predictSetTensor ), tf.round( actualAnswerTensor ) ) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)).numpy() return question, result, accuracy , WUPS return question, result , accuracy, None
def test_ordinal_special_joins(self): self.assertEqual( num2words(5, ordinal=True, lang='fr_CH'), "cinquième" ) self.assertEqual( num2words(6, ordinal=True, lang='fr_CH'), "sixième" ) self.assertEqual( num2words(35, ordinal=True, lang='fr_CH'), "trente-cinquième" ) self.assertEqual(num2words(9, ordinal=True, lang='fr_CH'), "neuvième") self.assertEqual( num2words(49, ordinal=True, lang='fr_CH'), "quarante-neuvième" ) self.assertEqual(num2words(71, lang='fr_CH'), "septante et un") self.assertEqual(num2words(81, lang='fr_CH'), "huitante et un") self.assertEqual(num2words(80, lang='fr_CH'), "huitante") self.assertEqual(num2words(880, lang='fr_CH'), "huit cents huitante") self.assertEqual( num2words(91, ordinal=True, lang='fr_CH'), "nonante et unième" ) self.assertEqual(num2words(53, lang='fr_CH'), "cinquante-trois")
import time from num2words import num2words from datetime import datetime while True: current = "{:%X}".format(datetime.now()) current = current.split(':') hour = num2words(int(current[0])) minute = num2words(int(current[1])) if int(current[0]) < 12: thing = "AM" else: thing = "PM" if int(current[1]) < 10: oh = "oh " else: oh = "" print("It is " + hour + " " + oh + minute + " " + thing) time.sleep(60)
def district_name(district_fips): district_num = int(district_fips) if district_num: return num2words.num2words(district_num, to='ordinal_num') return 'At-Large'
#return [d[0] for d in differences if d[1]!=1] #filter out orthogonal seraches wordre = "[A-Za-z0-9'-]+" def searchify(search_string): ''' inputs: string output: dictionary {word: count} removes plurals ''' word_dict = {} l = re.findall() l[i] = num2word if l[i] can be int: # turn numbers into words l[i] = num2words(l[i]) l[i] = l[i].lower() # make all letters lowercase if l[i][0] == "'": # remove single quotes l[i] = l[i][1:] elif l[i][-1] == "'": l[i] = l[i][:-1] if l[i] not in word_dict: word_dict[l[i]] = 1 else: word_dict[l[i]] += 1
def replace_numbers(text: str) -> str: """Replaces numbers with their text version""" text = re.sub(r"(\d+)(st|nd|rd|th)?", lambda x: num2words(int(x.group(1)), x.group(2) is not None), text) return text
def convert_lyrics(text, lang, atsign, db_filename): lines = [] start = "@" if atsign else "" moby = setup_db(lang, db_filename) # Preprocessing for line in text.split("\n"): if line.strip() == "": lines.append(line) continue tok = [] # Number translation for w in line.split(): if w.isalpha(): tok.append(w) continue if lang not in num_langs: tok.append(w) continue try: x = int(w) if x in range(1000, 9999 + 1): n = num2words(x, lang=lang, to="year") else: n = num2words(x, lang=lang) tok.append(n.replace("-", " ")) except ValueError: try: f = float(w) n = num2words(f, lang=lang) tok.append(n.replace("-", " ")) except ValueError: tok.append(w) line = " ".join(tok) for c in BAD_CHARS: line = line.replace(c, "") line = line.replace("-", "=") line = line.replace("&", "and") line = line[0:len(line) - 1].replace("?", "") + line[len(line) - 1] line = line[0:len(line) - 1].replace("!", "") + line[len(line) - 1] lines.append(line.strip()) formatted = "" for line in lines: if line.strip() == "": formatted += "\n" continue tok = [] for w in line.split(): if all([not c.isalnum() for c in w]): continue if not w[-1].isalnum(): w_format = w[:len(w) - 1] endchar = w[-1] else: w_format = w endchar = "" hyphenated = hyphenate(moby, db_filename, w_format, lang) tok.append(hyphenated + endchar) formatted += start + " ".join(tok) + "\n" return formatted
def test_cardinal_at_some_numbers(self): self.assertEqual(num2words(82, lang='nl'), u'twee\xebntachtig') self.assertEqual(num2words(1013, lang='nl'), "duizenddertien") self.assertEqual(num2words(2000000, lang='nl'), "twee miljoen") self.assertEqual(num2words(4000000000, lang='nl'), "vier miljard")
def checkpass(self): '''Identify Password''' upper, color_up = StringVar(), StringVar() lower, color_down = StringVar(), StringVar() digit, color_digit = StringVar(), StringVar() symbol, color_sym = StringVar(), StringVar() comb_num = StringVar() year, month, week, day, hour, minute, second = StringVar(), \ StringVar(), StringVar(), StringVar(), StringVar(), StringVar(), \ StringVar() quark_l = tkFont.Font(family= "Quark", size= 13, weight="bold") passtext = self.text.get() force = self.passforce.get() textlist = self.countstring(passtext) probanum = self.probaCrackPass(textlist, force, passtext) upper.set(str(textlist[0]) + ' Upper Case ') color_up.set(textlist[4][0]) lower.set(str(textlist[1]) + ' Lower case ') color_down.set(textlist[4][1]) digit.set(str(textlist[2]) + ' Digit ') color_digit.set(textlist[4][2]) symbol.set(str(textlist[3]) + ' Symbol ') color_sym.set(textlist[4][3]) comb_num.set("Your password has " + str(probanum[0]) + " combination " + \ "it cracked!") year.set(probanum[1][0]) month.set(probanum[1][1]) week.set(probanum[1][2]) day.set(probanum[1][3]) hour.set(probanum[1][4]) minute.set(probanum[1][5]) second.set(probanum[1][6]) self.labelresult = Label(self.master, text='Your password contains :', \ font=quark_l) self.labelresult.grid(row=4, column=0) self.labelupper = Label(self.master, text=upper.get(), \ font=quark_l, fg=color_up.get()) self.labelupper.grid(row=5, column=0) self.labellower = Label(self.master, text=lower.get(), \ font=quark_l, fg=color_down.get()) self.labellower.grid(row=6, column=0) self.labelnumber = Label(self.master, text=digit.get(), \ font=quark_l, fg=color_digit.get()) self.labelnumber.grid(row=7, column=0) self.labelsymbol = Label(self.master, text=symbol.get(), \ font=quark_l, fg=color_sym.get()) self.labelsymbol.grid(row=8, column=0) self.labeltextproba = Label(self.master, text=comb_num.get(), font=quark_l) self.labeltextproba.grid(row=4, column=1) self.labelcrack = Label(self.master, text= \ 'Your password has will cracked in', font=quark_l) self.labelcrack.grid(row=5, column=1) self.labelyear = Label(self.master, text=year.get()+ " --> " + \ num2words(int(year.get())) + " Years", font=quark_l) self.labelyear.grid(row=6, column=1) self.labelmonth = Label(self.master, text=month.get() + " --> " + \ num2words(int(month.get())) + " Months", font=quark_l) self.labelmonth.grid(row=7, column=1) self.labelweek = Label(self.master, text=week.get() + " --> " + \ num2words(int(week.get())) + " Weeks", font=quark_l) self.labelweek.grid(row=8, column=1) self.labelday = Label(self.master, text=day.get() + " --> " + \ num2words(int(day.get())) + " Days", font=quark_l) self.labelday.grid(row=9, column=1) self.labelhour = Label(self.master, text=hour.get() + " --> " + \ num2words(int(hour.get())) + " Hours", font=quark_l) self.labelhour.grid(row=10, column=1) self.labelminute = Label(self.master, text=minute.get() + " --> " + \ num2words(int(minute.get())) + " Minutes", font=quark_l) self.labelminute.grid(row=11, column=1) self.labelsecond = Label(self.master, text=second.get() + " --> " + \ num2words(int(second.get())) + " Seconds", font=quark_l) self.labelsecond.grid(row=12, column=1)
def test_ordinal(self): self.assertEqual(num2words(1, lang='pt', ordinal=True), 'primeiro') self.assertEqual(num2words(2, lang='pt', ordinal=True), 'segundo') self.assertEqual(num2words(3, lang='pt', ordinal=True), 'terceiro') self.assertEqual(num2words(4, lang='pt', ordinal=True), 'quarto') self.assertEqual(num2words(5, lang='pt', ordinal=True), 'quinto') self.assertEqual(num2words(6, lang='pt', ordinal=True), 'sexto') self.assertEqual(num2words(7, lang='pt', ordinal=True), 'sétimo') self.assertEqual(num2words(8, lang='pt', ordinal=True), 'oitavo') self.assertEqual(num2words(9, lang='pt', ordinal=True), 'nono') self.assertEqual(num2words(10, lang='pt', ordinal=True), 'décimo') self.assertEqual( num2words(11, lang='pt', ordinal=True), 'décimo primeiro' ) self.assertEqual( num2words(12, lang='pt', ordinal=True), 'décimo segundo' ) self.assertEqual( num2words(13, lang='pt', ordinal=True), 'décimo terceiro' ) self.assertEqual( num2words(14, lang='pt', ordinal=True), 'décimo quarto' ) self.assertEqual( num2words(15, lang='pt', ordinal=True), 'décimo quinto' ) self.assertEqual( num2words(16, lang='pt', ordinal=True), 'décimo sexto' ) self.assertEqual( num2words(17, lang='pt', ordinal=True), 'décimo sétimo' ) self.assertEqual( num2words(18, lang='pt', ordinal=True), 'décimo oitavo' ) self.assertEqual( num2words(19, lang='pt', ordinal=True), 'décimo nono' ) self.assertEqual( num2words(20, lang='pt', ordinal=True), 'vigésimo' ) self.assertEqual( num2words(21, lang='pt', ordinal=True), 'vigésimo primeiro' ) self.assertEqual( num2words(22, lang='pt', ordinal=True), 'vigésimo segundo' ) self.assertEqual( num2words(35, lang='pt', ordinal=True), 'trigésimo quinto' ) self.assertEqual( num2words(99, lang='pt', ordinal=True), 'nonagésimo nono' ) self.assertEqual( num2words(100, lang='pt', ordinal=True), 'centésimo' ) self.assertEqual( num2words(101, lang='pt', ordinal=True), 'centésimo primeiro' ) self.assertEqual( num2words(128, lang='pt', ordinal=True), 'centésimo vigésimo oitavo' ) self.assertEqual( num2words(713, lang='pt', ordinal=True), 'septigentésimo décimo terceiro' ) self.assertEqual( num2words(1000, lang='pt', ordinal=True), 'milésimo' ) self.assertEqual( num2words(1001, lang='pt', ordinal=True), 'milésimo primeiro' ) self.assertEqual( num2words(1111, lang='pt', ordinal=True), 'milésimo centésimo décimo primeiro' ) self.assertEqual( num2words(2114, lang='pt', ordinal=True), 'segundo milésimo centésimo décimo quarto' ) self.assertEqual( num2words(73421, lang='pt', ordinal=True), 'septuagésimo terceiro milésimo quadrigentésimo vigésimo primeiro' ) self.assertEqual( num2words(100000, lang='pt', ordinal=True), 'centésimo milésimo' ) self.assertEqual( num2words(250050, lang='pt', ordinal=True), 'ducentésimo quinquagésimo milésimo quinquagésimo' ) self.assertEqual( num2words(6000000, lang='pt', ordinal=True), 'sexto milionésimo' ) self.assertEqual( num2words(19000000000, lang='pt', ordinal=True), 'décimo nono milésimo milionésimo' ) self.assertEqual( num2words(145000000002, lang='pt', ordinal=True), 'centésimo quadragésimo quinto milésimo milionésimo segundo' )
def test_cardinal_for_decimal_number(self): self.assertEqual( num2words(3.486, lang='nl'), "drie komma vier acht zes" )
def _get_amount_in_words(self): for r in self: r.amount_in_words = num2words(r.amount)
def test_cardinal_integer(self): self.assertEqual(num2words(1, lang='pt'), 'um') self.assertEqual(num2words(2, lang='pt'), 'dois') self.assertEqual(num2words(3, lang='pt'), 'três') self.assertEqual(num2words(4, lang='pt'), 'quatro') self.assertEqual(num2words(5, lang='pt'), 'cinco') self.assertEqual(num2words(6, lang='pt'), 'seis') self.assertEqual(num2words(7, lang='pt'), 'sete') self.assertEqual(num2words(8, lang='pt'), 'oito') self.assertEqual(num2words(9, lang='pt'), 'nove') self.assertEqual(num2words(10, lang='pt'), 'dez') self.assertEqual(num2words(11, lang='pt'), 'onze') self.assertEqual(num2words(12, lang='pt'), 'doze') self.assertEqual(num2words(13, lang='pt'), 'treze') self.assertEqual(num2words(14, lang='pt'), 'catorze') self.assertEqual(num2words(15, lang='pt'), 'quinze') self.assertEqual(num2words(16, lang='pt'), 'dezasseis') self.assertEqual(num2words(17, lang='pt'), 'dezassete') self.assertEqual(num2words(18, lang='pt'), 'dezoito') self.assertEqual(num2words(19, lang='pt'), 'dezanove') self.assertEqual(num2words(20, lang='pt'), 'vinte') self.assertEqual(num2words(21, lang='pt'), 'vinte e um') self.assertEqual(num2words(22, lang='pt'), 'vinte e dois') self.assertEqual(num2words(35, lang='pt'), 'trinta e cinco') self.assertEqual(num2words(99, lang='pt'), 'noventa e nove') self.assertEqual(num2words(100, lang='pt'), 'cem') self.assertEqual(num2words(101, lang='pt'), 'cento e um') self.assertEqual(num2words(128, lang='pt'), 'cento e vinte e oito') self.assertEqual(num2words(713, lang='pt'), 'setecentos e treze') self.assertEqual(num2words(1000, lang='pt'), 'mil') self.assertEqual(num2words(1001, lang='pt'), 'mil e um') self.assertEqual(num2words(1111, lang='pt'), 'mil cento e onze') self.assertEqual( num2words(2114, lang='pt'), 'dois mil cento e catorze' ) self.assertEqual( num2words(2200, lang='pt'), 'dois mil e duzentos' ) self.assertEqual( num2words(2230, lang='pt'), 'dois mil duzentos e trinta' ) self.assertEqual( num2words(73400, lang='pt'), 'setenta e três mil e quatrocentos' ) self.assertEqual( num2words(73421, lang='pt'), 'setenta e três mil quatrocentos e vinte e um' ) self.assertEqual(num2words(100000, lang='pt'), 'cem mil') self.assertEqual( num2words(250050, lang='pt'), 'duzentos e cinquenta mil e cinquenta' ) self.assertEqual( num2words(6000000, lang='pt'), 'seis milhões' ) self.assertEqual( num2words(100000000, lang='pt'), 'cem milhões' ) self.assertEqual( num2words(19000000000, lang='pt'), 'dezanove mil milhões' ) self.assertEqual( num2words(145000000002, lang='pt'), 'cento e quarenta e cinco mil milhões e dois' ) self.assertEqual( num2words(4635102, lang='pt'), 'quatro milhões seiscentos e trinta e cinco mil cento e dois' ) self.assertEqual( num2words(145254635102, lang='pt'), 'cento e quarenta e cinco mil duzentos e cinquenta e quatro ' 'milhões seiscentos e trinta e cinco mil cento e dois' ) self.assertEqual( num2words(1000000000000, lang='pt'), 'um bilião' ) self.assertEqual( num2words(2000000000000, lang='pt'), 'dois biliões' ) self.assertEqual( num2words(1000000000000000, lang='pt'), 'mil biliões' ) self.assertEqual( num2words(2000000000000000, lang='pt'), 'dois mil biliões' ) self.assertEqual( num2words(1000000000000000000, lang='pt'), 'um trilião' ) self.assertEqual( num2words(2000000000000000000, lang='pt'), 'dois triliões' )
pass # lowercase text word = word.lower() # process dollars if word == "$": add_dollar = True cleaned_text.append("dollars") continue if word[0] == "$" and len(word) > 1: assert 1 == 0, word # preserve numbers if len(set(word) - NUMBERS) == 0 and word != ",": word = word.replace(",", "") if not add_dollar: cleaned_text.append( num2words.num2words(int(word), to="year").replace( " oh-", " o ").replace("-", " ").replace(",", "")) if add_dollar: cleaned_text[-1] = (num2words.num2words( int(word), to="cardinal").replace("-", " ").replace(",", "")) cleaned_text.append("dollars") add_dollar = False continue add_dollar = False if (len(word) > 2 and len(set(word[:-2]) - NUMBERS) == 0 and (word[-2:] == "th" or word[-2:] == "st" or word[-2:] == "nd" or word[-2:] == "rd")): cleaned_text.append( num2words.num2words(int(word[:-2].replace(",", "")), to="ordinal").replace("-", " ").replace(
def test_100_to_999(self): self.assertEqual(num2words(100, lang="rm"), "tschient") self.assertEqual(num2words(101, lang="rm"), "tschientedin") self.assertEqual(num2words(102, lang="rm"), "tschientedus") self.assertEqual(num2words(103, lang="rm"), "tschientetrais") self.assertEqual(num2words(104, lang="rm"), "tschientequatter") self.assertEqual(num2words(105, lang="rm"), "tschientetschintg") self.assertEqual(num2words(106, lang="rm"), "tschientesis") self.assertEqual(num2words(107, lang="rm"), "tschienteset") self.assertEqual(num2words(108, lang="rm"), "tschientedotg") self.assertEqual(num2words(109, lang="rm"), "tschientenov") self.assertEqual(num2words(110, lang="rm"), "tschientediesch") self.assertEqual(num2words(111, lang="rm"), "tschientedindesch") self.assertEqual(num2words(112, lang="rm"), "tschientedudesch") self.assertEqual(num2words(113, lang="rm"), "tschientetredesch") self.assertEqual(num2words(114, lang="rm"), "tschientquattordesch") self.assertEqual(num2words(115, lang="rm"), "tschientequindesch") self.assertEqual(num2words(116, lang="rm"), "tschientesedesch") self.assertEqual(num2words(117, lang="rm"), "tschientdeschset") self.assertEqual(num2words(118, lang="rm"), "tschientdeschdotg") self.assertEqual(num2words(119, lang="rm"), "tschientdeschnov") self.assertEqual(num2words(120, lang="rm"), "tschienteventg") self.assertEqual(num2words(121, lang="rm"), "tschientventgin") self.assertEqual(num2words(122, lang="rm"), "tschientventgadus") self.assertEqual(num2words(123, lang="rm"), "tschientventgatrais") self.assertEqual(num2words(124, lang="rm"), "tschientventgaquatter") self.assertEqual(num2words(125, lang="rm"), "tschientventgatschintg") self.assertEqual(num2words(126, lang="rm"), "tschientventgasis") self.assertEqual(num2words(127, lang="rm"), "tschientventgaset") self.assertEqual(num2words(128, lang="rm"), "tschientventgotg") self.assertEqual(num2words(129, lang="rm"), "tschientventganov") self.assertEqual(num2words(130, lang="rm"), "tschientetrenta") self.assertEqual(num2words(131, lang="rm"), "tschienttrentin") self.assertEqual(num2words(150, lang="rm"), "tschienttschuncanta") self.assertEqual(num2words(196, lang="rm"), "tschientnovantasis") self.assertEqual(num2words(200, lang="rm"), "duatschient") self.assertEqual(num2words(208, lang="rm"), "duatschientedotg") self.assertEqual(num2words(210, lang="rm"), "duatschientediesch") self.assertEqual(num2words(271, lang="rm"), "duatschientsettantin") self.assertEqual(num2words(300, lang="rm"), "traitschient") self.assertEqual(num2words(308, lang="rm"), "traitschientedotg") self.assertEqual(num2words(311, lang="rm"), "traitschientedindesch") self.assertEqual(num2words(375, lang="rm"), "traitschientsettantatschintg") self.assertEqual(num2words(400, lang="rm"), "quattertschient") self.assertEqual(num2words(409, lang="rm"), "quattertschientenov") self.assertEqual(num2words(410, lang="rm"), "quattertschientediesch") self.assertEqual(num2words(472, lang="rm"), "quattertschientsettantadus") self.assertEqual(num2words(701, lang="rm"), "settschientedin")
def get_env_num_str(self, number): num_str = num2words.num2words(number) return num_str[0].upper() + num_str[1:]
def test_20_to_99(self): self.assertEqual(num2words(20, lang="rm"), "ventg") self.assertEqual(num2words(21, lang="rm"), "ventgin") self.assertEqual(num2words(22, lang="rm"), "ventgadus") self.assertEqual(num2words(23, lang="rm"), "ventgatrais") self.assertEqual(num2words(28, lang="rm"), "ventgotg") self.assertEqual(num2words(30, lang="rm"), "trenta") self.assertEqual(num2words(31, lang="rm"), "trentin") self.assertEqual(num2words(34, lang="rm"), "trentaquatter") self.assertEqual(num2words(38, lang="rm"), "trentotg") self.assertEqual(num2words(40, lang="rm"), "quaranta") self.assertEqual(num2words(50, lang="rm"), "tschuncanta") self.assertEqual(num2words(59, lang="rm"), "tschuncantanov") self.assertEqual(num2words(66, lang="rm"), "sessantasis") self.assertEqual(num2words(77, lang="rm"), "settantaset") self.assertEqual(num2words(81, lang="rm"), "otgantin") self.assertEqual(num2words(92, lang="rm"), "novantadus")
def test_currency(self): for test in TEST_NIO: self.assertEqual(num2words(test[0], lang='es_NI', to='currency'), test[1])
node.right = Node(temp2) if (node.right != -1): dq.append(node.right) return root def inorder(root): if (root is not None): inorder(root.left) print("ordered ", root.data) inorder(root.right) result = [] nodes = [] n = int(input("enter the number of element")) for i in range(n): temp = int(input()) nodes.append(temp) #print(nodes) root = formbinarytree(nodes, 0) boundary(root) sum = 0 for i in range(len(result)): sum = sum + result[i] # print("boundary ",result[i]) print(num2words(sum)) inorder(root)
def build_daily_message(possible, confirmed, DEBUG=True): logger.debug("Confirmed count - %s | Possible Count - %s" % (len(confirmed), len(possible))) header = "Daily Digest %s:" % datetime.strftime(datetime.now(), "%m/%d") messages = "MESSAGES SENT TO TWITTER: \n" if len(confirmed) == 0 and len(possible) == 0: logger.info("No launches - sending message. ") launch = Launch.objects.filter( net__gte=datetime.now()).order_by('net').first() message = "%s There are currently no launches scheduled within the next 48 hours. Next up is %s on %s" % ( header, launch.name, custom_strftime("%B {S} at %I:%M %p %Z", launch.net)) messages = messages + message + "\n" send_twitter_update(message, DEBUG) if len(confirmed) == 1 and len(possible) == 0: launch = confirmed[0] current_time = datetime.utcnow() launch_time = datetime.utcfromtimestamp(int(launch.netstamp)) logger.info("One launch - sending message. ") message = "%s %s launching from %s in %s hours. \n %s" % ( header, launch.name, launch.pad.location.name, '{0:g}'.format( float( round( abs(launch_time - current_time).total_seconds() / 3600.0))), 'https://spacelaunchnow.me/launch/%s' % launch.slug) messages = messages + message + "\n" send_twitter_update(message, DEBUG) if len(confirmed) == 0 and len(possible) == 1: launch = possible[0] logger.info("One launch - sending message. ") date = datetime.utcfromtimestamp( launch.netstamp).replace(tzinfo=pytz.UTC) message = "%s %s might be launching from %s on %s." % ( header, launch.name, launch.pad.location.name, date.strftime("%A at %H:%S %Z")) messages = messages + message + "\n" send_twitter_update(message, DEBUG) if len(confirmed) == 1 and len(possible) == 1: possible_launch = possible[0] confirmed_launch = confirmed[0] logger.info("One launch possible - sending message. ") date = datetime.utcfromtimestamp( possible_launch.netstamp).replace(tzinfo=pytz.UTC) message = "%s %s might be launching from %s on %s." % ( header, possible_launch.name, possible_launch.pad.location.name, date.strftime("%A at %H:%S %Z")) messages = messages + message + "\n" response_id = send_twitter_update(message, DEBUG) current_time = datetime.utcnow() launch_time = datetime.utcfromtimestamp(int(confirmed_launch.netstamp)) logger.info("One launch confirmed - sending message. ") message = "%s %s launching from %s in %s hours. \n %s" % ( header, confirmed_launch.name, confirmed_launch.pad.location.name, '{0:g}'.format( float( round( abs(launch_time - current_time).total_seconds() / 3600.0))), 'https://spacelaunchnow.me/launch/%s' % launch.slug) messages = messages + message + "\n" send_twitter_update(message, DEBUG, response_id) if len(confirmed) > 1 and len(possible) == 0: logger.info("More then one launch - sending summary first. ") message = "%s There are %i confirmed launches within the next 48 hours...(1/%i)" % ( header, len(confirmed), len(confirmed) + 1) messages = messages + message + "\n" response_id = send_twitter_update(message, DEBUG) for index, launch in enumerate(confirmed, start=1): current_time = datetime.utcnow() launch_time = datetime.utcfromtimestamp(int(launch.netstamp)) message = "%s launching from %s in %s hours. (%i/%i) \n %s" % ( launch.name, launch.pad.location.name, '{0:g}'.format( float( round( abs(launch_time - current_time).total_seconds() / 3600.0))), index + 1, len(confirmed) + 1, 'https://spacelaunchnow.me/launch/%s' % launch.slug) messages = messages + message + "\n" response_id = send_twitter_update(message, DEBUG, response_id) if len(confirmed) == 0 and len(possible) > 1: logger.info("More then one launch - sending summary first. ") message = "%s There are %s possible launches within the next 48 hours...(1/%i)" % ( header, num2words(len(possible)), len(possible) + 1) messages = messages + message + "\n" response_id = send_twitter_update(message, DEBUG) for index, launch in enumerate(possible, start=1): date = datetime.utcfromtimestamp( launch.netstamp).replace(tzinfo=pytz.UTC) message = "%s might be launching from %s on %s. (%i/%i)" % ( launch.name, launch.pad.location.name, date.strftime("%A at %H:%S %Z"), index + 1, len(possible) + 1) messages = messages + message + "\n" response_id = send_twitter_update(message, DEBUG, response_id) if len(confirmed) > 1 and len(possible) > 1: total = confirmed + possible logger.info("More then one launch - sending summary first. ") message = "%s There are %i possible and %i confirmed launches within the next 48 hours." % ( header, num2words(len(possible)), num2words(len(confirmed))) messages = messages + message + "\n" response_id = send_twitter_update(message, DEBUG) # Possible launches for index, launch in enumerate(possible, start=1): message = "%s might be launching from %s on %s. (%i/%i)" % ( launch.name, launch.pad.location.name, datetime.fromtimestamp( launch.launch.netstamp).strftime("%A at %H:%S %Z"), index, len(total)) messages = messages + message + "\n" response_id = send_twitter_update(message, DEBUG, response_id) # Confirmed launches for index, launch in enumerate(confirmed, start=1): current_time = datetime.utcnow() launch_time = datetime.utcfromtimestamp(int(launch.netstamp)) message = "%s launching from %s in %s hours. (%i/%i) \n %s" % ( launch.name, launch.pad.location.name, '{0:g}'.format( float( round( abs(launch_time - current_time).total_seconds() / 3600.0))), possible + index, len(total), 'https://spacelaunchnow.me/launch/%s' % launch.slug) messages = messages + message + "\n" send_twitter_update(message, DEBUG, response_id) create_daily_digest_record( len(confirmed) + len(possible), messages, confirmed + possible)
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ''' #Program to Count Numbers # This is an example program to show how to generate speech with the Raspberry Pi. # You can see the full written tutorial here: http://www.dexterindustries.com/howto/make-your-raspberry-pi-speak/ #This program makes the Pi count numbers down from the number entered by the user till zero. from num2words import num2words from subprocess import call cmd_beg = 'espeak -ven+f4 ' cmd_end = ' 2>/dev/null' # To dump the std errors to /dev/null x = int(input("Enter a number: ")) count = num2words(x) + ' Count Down Starts' print(count) #Replacing ' ' with '_' to identify words in the text entered count = count.replace(' ', '_') #Calls the Espeak TTS Engine to read aloud a Text call([cmd_beg + count + cmd_end], shell=True) #To do a Count Down for i in range(x, -1, -1): # To count numbers down from the entered number till zero cmd = num2words(i) #To convert the Numbers to Text print(i) #Calls the Espeak TTS Engine to read aloud the Numbers call([cmd_beg + cmd + cmd_end], shell=True)
from num2words import num2words from transliterate import translit from gtts import gTTS speech = '''Ladies and gentlemen, I'm 78 years old and I finally got 15 minutes of fame once in a lifetime and I guess that this is mine. People have also told me to make these next few minutes escruciatingly embarrassing and to take vengeance of my enemies. Neither will happen. More than 3 years ago I moved to Novo-Novsk, but worked on new Magnetic Storage for last 40. When I was 8...''' speech_translit = translit(speech, 'ru') ttseng = gTTS(speech, lang='en') ttseng.save = ('speech.mp3') print(speech_translit) print('78', translit(num2words(78), 'ru'), sep=' - ') print('15', translit(num2words(15), 'ru'), sep=' - ') print('3', translit(num2words(3), 'ru'), sep=' - ') print('40', translit(num2words(40), 'ru'), sep=' - ') print('8', translit(num2words(8), 'ru'), sep=' - ')
def transformation_text(text): # ESTER Problem "Mohamed v" ===> "Mohammed cinq" text = re.sub("mohammed vi", "mohamed six", text) text = re.sub("mohammed v", "mohamed cinq", text) # map all "mohamed" to "mohammed" text = re.sub("mohamed", "mohammed", text) # character normalization: text = re.sub("&", "et", text) text = re.sub("æ", "ae", text) text = re.sub("œ", "oe", text) # ESTER 2 Problem "19ème" ====> "dix-neuvième" text = re.sub("19ème", "dix-neuvième", text) text = re.sub("Canal \+", "canal plus", text) #if "###" in text or len(re.findall(r"\[.+\]", text)) > 0 or \ # len(re.findall(r"\p{L}+-[^\p{L}]|\p{L}+-$",text)) > 0 \ # or len(re.findall("[^\p{L}]-\p{L}+|^-\p{L}+", text)) > 0: # bool=False #else: # ^^ remove text = re.sub(r"\^+", "", text) text = re.sub(r"\_+", "", text) # 4x4 # Remove noise sound (BIP) over Name of places and person #text = re.sub(r"¤[^ ]+|[^ ]+¤|¤", "", text.strip()) if len(re.findall(r"\dx\d", text)) > 0: text = re.sub(r"x", " ", text) if len(re.findall("\d+h\d+", text)) > 0: heures = re.findall("\d+h\d+", text) for h in heures: split_h = h.split('h') text_rep = split_h[0] + ' heure ' + split_h[1] text = text.replace(h, text_rep) text = re.sub(r',|¸', ' ', text) # remove silence character : OK #text=re.sub(r"(/.+/","remplacer par la 1er",text) # Liaison non standard remarquable text = re.sub(r'=', '', text) # Comment Transcriber text = re.sub(r'\{.+\}', '', text) text = re.sub(r'\(.+\}', '', text) #print "detecter (///|/|<|>)" # Remove undecidable variant heared like on (n') en: text = re.sub(r"\(.+\)|\(\)", "", text) #text = re.sub(r"(\+|[*]+|///|/|<|>)", "", text.strip()) #text=re.sub(r"-|_|\."," ",text.strip()) text = re.sub(r'(O.K.)', 'ok', text) text = re.sub(r'(O.K)', 'ok', text) # Replace . with '' text = re.sub(r'\.|,|;', '', text) #text=re.sub(r"{[^{]+}"," ",text.strip()) # Remove ? ! < > : OK #<[^\p{L}]|[^\p{L}]>|#+|<\p{L}+[ ]|<\p{L}+$ text = re.sub(r":|\?|/|\!|#+|²", "", text) text = re.sub(r"%", "pour cent", text) # replace silence character with <sil> : OK #text=re.sub(r"(\+)", "<sil>", text) #text=re.sub(r"(\+)", "!SIL", text) #text=re.sub(r"(///)", "!SIL", text) #text=re.sub(r"(///)", "<long-sil>", text) #if len(re.findall(r"/.+/", text)) > 0: #print "AVANT***********"+text # for unchoosen_text in re.findall(r"/.+/", text): # choose first undecideble word # unchoosen_word=unchoosen_text.split(',') # for choosen_word in unchoosen_word: # isn't incomprehensible word # if len(re.findall(r"\*+|\d+", choosen_word))==0: # choosen_word = choosen_word.replace('/', '') # text = text.replace(unchoosen_text, choosen_word) #print "Apres************"+text # Remove noise sound (BIP) over Name of places and person #text=re.sub(r"(¤.+¤)",'<NOISE>',text) # replace unkown syllable text = re.sub(r"\*+", "", text) # cut of recording : OK #text=re.sub(r"\$+","",text) # remove " character: OK text = re.sub(r"\"+", "", text) # t 'avais text = re.sub(r"[ ]\'", "\'", text) text = re.sub(r"\'", "\' ", text) # for example : A43 #num_list = re.findall("\w+?-?\d+", text) num_list = re.findall("[a-zA-Z]+\'*[a-zA-Z]*[-]?\d+" "", text) if len(num_list) > 0: for s in num_list: split_between_char_int = re.findall( r'([a-zA-Z]+\'*[a-zA-Z]*)-?(\d+)', s) num_in_word = num2words(int(split_between_char_int[0][1]), lang='fr') #num_in_word=normalize('NFKD', num_in_word).encode('ascii', 'ignore') #text = re.sub(r"(^|[ ])"+str(s)+"([ ]|$)"," " + str(split_between_char_int[0][0]) +" "+ str(num_in_word) + " ",text) text = re.sub( r"(^|[ ])" + str(s), " " + str(split_between_char_int[0][0]) + " " + str(num_in_word) + " ", text) #num_list = re.findall("\d+\w+", text) num_list = re.findall("\d+[a-zA-Z]+\'*[a-zA-Z]*", text) if len(num_list) > 0: for s in num_list: split_between_char_int = re.findall( r'(\d+)([a-zA-Z]+\'*[a-zA-Z]*)', s) #re.findall(r'\d+\w+',s) num_in_word = num2words(int(split_between_char_int[0][0]), lang='fr') #num_in_word=normalize('NFKD', num_in_word).encode('ascii', 'ignore') #text = re.sub(r"(^|[ ])"+str(s)+"([ ]|$)"," " + str(split_between_char_int[0][0]) +" "+ str(num_in_word) + " ",text) text = re.sub( r"(^|[ ])" + str(s), " " + str(num_in_word) + " " + str(split_between_char_int[0][1]) + " ", text) # convert number if exist : OK num_list = re.findall("\d+", text) if len(num_list) > 0: #print text #print "********************************* NUM2WORD" for num in num_list: num_in_word = num2words(int(num), lang='fr') #num_in_word=normalize('NFKD', num_in_word).encode('ascii', 'ignore') text = re.sub(r"(^|[ ])" + str(num) + "([ ]|$)", " " + str(num_in_word) + " ", text) #print text # replace n succesive spaces with one space. : OK text = re.sub(r"\s{2,}", " ", text) text = re.sub(r" $", "", text) text = re.sub("^ ", '', text) # change bounding | to < and > : OK #balise=set(re.findall(r"\|\w+_?\w+\|",text)) #if len(balise)>0: #print(balise) # for b in balise: # new_balise='<'+b[1:len(b)-1]+'>' # text=text.replace(b,new_balise) #print(text) # c'est l'essaim .... text = text.lower() text = re.sub("[ ]-|-$", "", text) return text
def test_writ_numbers_ord(self): for num in self.test_nums: writ_num = num2words(num, ordinal=True, lang='de') self.assertOneOK(num, writ_num)