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)
