async def deleting_word(message):
session, isValid = await authorize(message.from_user.id, with_lang=True)
if not isValid:
return
logger.info(
str(session.get_user_id()) + " is deleting word " + message.text)
data = mysql_connect.fetchall(
"SELECT word, definition, hid FROM words "
"WHERE user=%s and language=%s and word=%s",
(session.get_user_id(), session.active_lang(), message.text))
session.status = ""
if data is None:
await bot.send_message(session.get_user_id(),
'The word does not exist in you dictionary')
return
session.hid_cash = list(x[2] for x in data)
k = to_one_row_keyboard(["Keep", "Delete"],
data=[0, 1],
action=["keep", "delete"])
w = data[0][0]
d = 'NA'
if len(data[0]) > 1:
d = data[0][1]
await bot.send_message(
session.get_user_id(),
"Do you want to delete word *{}* with definition\n{}".format(w, d),
reply_markup=k)
async def do_unscramble(session, keys, data, sentence, revealed, message):
logger.debug("{}: Keys = {}, revealed = {}", session.get_user_id(),
len(keys), revealed)
if len(keys) == 0 and len(revealed) > 0:
if revealed.strip() == session.unscramble_sentence[0].strip():
add_event(session.get_user_id(), session.active_lang(), session.get_current_hid(), 'SENTENCE', 10, 1)
await bot.send_message(session.get_user_id(), "Excellent!")
await next_unscramble(session)
else:
k = bot_utils.to_one_row_keyboard(['Restart', 'Next'],
[0, 1],
['restart_unscramble', 'next_unscramble'])
res = bot_utils.compare(revealed.strip(), session.unscramble_sentence[0].strip())
#TODO use Levenshtian distance
add_event(session.get_user_id(), session.active_lang(), session.get_current_hid(), 'SENTENCE', 10, 0)
await bot.send_message(session.get_user_id(), "A bit wrong.\nIt is:\n"
"{}\nyuor answer:\n{}"
.format(res[1], res[0]), parse_mode=types.ParseMode.HTML,
reply_markup=k)
await message.edit_text("*" + sentence[1] + "*" + "\n" + revealed)
return
actions = ['unscramble'] * len(data)
session.unscramble_keys = keys
session.unscramble_data = data
session.unscramble_revealed = revealed
session.unscramble_sentence = sentence
k = keys.copy()
k.append("RESTART")
a = actions.copy()
a.append("restart_unscramble")
d = data.copy()
d.append('-1')
k = bot_utils.to_vertical_keyboard(k, d, a)
await message.edit_text("*" + sentence[1] + "*" + "\n" + revealed, reply_markup=k)
async def wiktionary_search(message):
logger.debug(str(message.from_user.id) + " Adding word: " + message.text)
logger.info(str(message.from_user.id) + " Sending request to dictionaries")
session, isValid = await authorize(message.from_user.id)
if not isValid:
return
begin = time.time()
definitions = await get_definitions(session.active_lang(),
session.language_code, message.text,
message.from_user.id)
logger.info(
str(session.get_user_id()) + " Received response from dictionaries " +
str(time.time() - begin))
logger.debug(
str(session.get_user_id()) + " Received definitions: " +
str(definitions))
session.words_to_add = (message.text, definitions)
if len(definitions) == 0:
logger.info(str(session.get_user_id()) + " no definition found")
await message.reply(
"No definitions found. Make sure there is no typos in the word and the language you're "
"learning exists))")
kb = to_one_row_keyboard(
["Add definition", "Skip"],
data=[0, 1],
action=["add_user_definition", "add_user_definition"])
await bot.send_message(message.chat.id,
"Or you can add your own definition",
reply_markup=kb)
else:
session.definitions = definitions
await prepare_definition_selection(session, None)
async def addwords_message(message):
logger.info(str(message.from_user.id) + " started adding new words")
command = str(message.text)
session, isValid = await authorize(message.from_user.id, with_lang=True)
if not isValid:
return
lists_to_add = mysql_connect.lists_to_add(message.from_user.id,
session.active_lang())
if len(lists_to_add) > 0:
word_list = str(lists_to_add[0][0])
session.list_hid_word = (word_list, None, None)
k = to_one_row_keyboard(['Add words', 'Not now'], [0, 0],
["next_word_from_list", "skip_list"])
await bot.send_message(message.from_user.id,
"You have words to add from list *{}*".format(
word_list.title()),
reply_markup=k)
else:
session.status = "/addwords"
session.words_to_add = None
if command != "/addwords":
logger.warning(
str(message.from_user.id) + " put words after /addwords ")
logger.debug(str(message.from_user.id) + session.status)
await message.reply("Type in words in *" +
session.active_lang().title() + "*")
async def callback_mc_action(query: types.CallbackQuery, callback_data: dict):
logger.debug('Got this callback data: %r', callback_data)
await query.answer("Wrong.")
session, isValid = await authorize(query.from_user.id)
if not isValid:
return
answer = session.get_error_answer()
session.move_error_down()
k = to_one_row_keyboard(["OK"], data=[1], action=["reading_errors"])
await bot.send_message(chat_id=session.get_user_id(), text="It's " + answer, reply_markup=k)
async def voice_message(message: types.Message):
session, isValid = await authorize(message.from_user.id)
if not isValid:
return
logger.info(str(message.from_user.id) + ' voice message received')
if not session.subscribed:
await bot.send_message(message.from_user.id, "You need to buy subscription "
"to be able to use voice recognition."
"\n Use command /subscribe to buy subscription")
return
file = await bot.get_file(message.voice.file_id)
url = 'https://api.telegram.org/file/bot{}/'.format(TOKEN)
url = url + file["file_path"]
logger.debug("{} received voice at {}".format(message.from_user.id, url))
transcript = speech2text.transcribe(url, session.active_lang())
if session.get_current_word() is None:
await bot.send_message(message.from_user.id, "Start /learn or /test")
return
word = session.get_current_word()[0]
task_type = session.get_current_word()[2]
if transcript.lower() != word.lower():
word, transcript = compare(word.lower(), transcript.lower())
logger.debug(word, transcript)
#TODO use Levenshtain distance
# FIXME: here can be sentence or a summary, not only lexeme
if task_type in [2, 3]:
add_event(message.from_user.id,
session.active_lang(),
session.get_current_hid(),
'LEXEME', task_type, 0)
k = to_one_row_keyboard(['Next'], [0], ['voice_skip'])
await bot.send_message(message.from_user.id, "Correct : {}\n"
"You said: {}".format(word, transcript),
parse_mode=types.ParseMode.HTML,
reply_markup=k)
else:
await bot.send_message(message.from_user.id, "Correct : {}\n"
"You said: {}".format(word, transcript),
parse_mode=types.ParseMode.HTML)
else:
if task_type in [2, 3]:
level_up(session)
add_event(message.from_user.id, session.active_lang(), session.get_current_hid(), 'LEXEME', 2, 1)
await bot.send_message(message.from_user.id, "Excellent!")
await do_learning(session)
async def callback_show_action(query: types.CallbackQuery, callback_data: dict):
logger.info('Got this callback data: %r', callback_data)
await query.answer()
session, isValid = await authorize(query.from_user.id)
if not isValid:
return
session.add_error()
kb = to_one_row_keyboard(["Yes, I knew that!", "No, I forgot it"],
data=[0.5, 0],
action=["i_knew", "forgot"])
try:
await bot.send_message(query.from_user.id, session.get_current_definition(), reply_markup=kb)
except CantParseEntities as e:
logger.warning(e)
string = session.get_current_definition()
string = str(string).replace('*', '')
string = str(string).replace('_', '')
string = str(string).replace('`', '')
await bot.send_message(query.from_user.id, string, reply_markup=kb)
async def learn_words_from_list(query: types.CallbackQuery,
callback_data: dict):
logger.debug(
str(query.from_user.id) + " learn_all_words " + str(callback_data))
session, isValid = await authorize(query.from_user.id, with_lang=True)
if not isValid:
return
lists = mysql_connect.get_list_names(query.from_user.id,
session.active_lang())
list_name = lists[int(callback_data['data'])]
logger.info("{} learns {}", query.from_user.id, list_name)
text_hid = mysql_connect.fetchone(
'SELECT text_hid FROM user_texts WHERE user=%s AND list_name=%s',
(session.get_user_id(), list_name))
if text_hid is not None:
summary = mysql_connect.fetchone(
'SELECT summary FROM text_summary WHERE user=%s AND hid=%s',
(session.get_user_id(), text_hid[0]))
if summary is not None:
# (word, definition, mode, hid)]
session.words_to_learn = list()
session.words_to_learn.append(
(summary[0], list_name, 20, text_hid[0]))
k = to_one_row_keyboard(['Words', 'Summary'], [0, 1],
['text_words', 'text_summary'])
await bot.send_message(
session.get_user_id(),
'You created a summary for text _{}_.\n'
'Would you like to learn words or continue with your summary?'.
format(list_name),
reply_markup=k)
return
hids = mysql_connect.get_hids_for_list(query.from_user.id, list_name)
logger.info("{} has {} tasks from list {}", query.from_user.id, len(hids),
list_name)
hids_all = sr.get_items_to_learn(
(session.get_user_id(), session.active_lang()), upper_recall_limit=0.5)
logger.info("{} has {} tasks to learn", query.from_user.id, len(hids_all))
hids = list(set(hids) & set(hids_all))
logger.info("{} has {} tasks from list {} to learn", query.from_user.id,
len(hids), list_name)
# hids = list() #FIXME NOW delete after testing!!!
if len(hids) == 0:
sentence_hids = mysql_connect.get_sentence_hids(
query.from_user.id, list_name)
sentence_hids = ilt.get_objects(sentence_hids, '1 day',
session.get_user_id(),
session.active_lang(), "SENTENCE", 10)
logger.info("{} has {} sentences from list {} to learn",
query.from_user.id, len(sentence_hids), list_name)
await bot.send_message(
query.from_user.id,
"You have {} sentences from list {} to learn".format(
len(sentence_hids), list_name))
if len(sentence_hids) > 0:
session.current_level = 10 # Syntax learning
await learn_sentences(query.from_user.id, list_name, session,
sentence_hids)
else:
session.current_level = 20 # Text learning
await texts.text_summarization(query.from_user.id, list_name,
session)
else:
words = mysql_connect.fetch_by_hids(session.get_user_id(), hids)
logger.debug("{}, fetched {} tasks to do", session.get_user_id(),
len(words))
session.words_to_learn = words
session.current_word = 0
await start_learning(session)
async def do_learning1(session):
if not session.has_more_words_to_learn():
await reading.do_reading_errors1(session)
else:
session = await get_session(session.get_user_id())
if session is None:
return
word = session.get_current_word(
) # 0. word, 1. definition, 2. mode, 3. hid
if word is None:
await bot.send_message(session.get_user_id(), RESTART)
logger.error(str(session.get_user_id()) + " word is None")
return
if word[2] == 0:
# Do reading exercises
session.current_level = word[2]
logger.debug("{} started level {}", session.get_user_id(), word[2])
keyboard = to_one_row_keyboard(["I remember", "Show meaning"],
data=[0, 1],
action=["I_remember", "show"])
hint = get_hint(word[1])
word_context = await get_context(word, True)
await bot.send_message(session.get_user_id(),
word_context + "\n" + hint,
reply_markup=keyboard,
parse_mode=types.ParseMode.HTML)
elif word[2] == 2:
session.current_level = word[2]
logger.debug("{} started level {}", session.get_user_id(), word[2])
if session.subscribed:
logger.debug("{} is subscribed", session.get_user_id())
session.status = tasks[2]
word_context = await get_context(word, False)
word_context = re.sub(r'\b' + word[0] + r'\b',
' ... ',
word_context,
flags=re.I)
await bot.send_message(session.get_user_id(),
"<b>SAY</b> this word: <b>" + word[1] +
"</b>\n" + word_context,
parse_mode=types.ParseMode.HTML)
else:
level_up(session)
await do_learning(session)
elif word[2] == 3:
session.current_level = word[2]
logger.debug("{} started level {}", session.get_user_id(), word[2])
if session.subscribed:
logger.debug("{} is subscribed", session.get_user_id())
session.status = tasks[2]
await bot.send_message(
session.get_user_id(),
"*LISTEN* and *SAY* this word: *{}*\n{}".format(
word[0], word[1]))
voice = text2speech.get_voice(word[0], session.active_lang())
await bot.send_audio(chat_id=session.get_user_id(),
audio=voice,
performer=word[1],
caption=None,
title=word[0])
else:
level_up(session)
await do_learning(session)
elif word[2] == 1:
session.current_level = word[2]
logger.debug("{} started level {}", session.get_user_id(), word[2])
session.status = tasks[1]
word_context = await get_context(word, False)
word_context = re.sub(r'\b' + word[0] + r'\b',
' ... ',
word_context,
flags=re.I)
await bot.send_message(
session.get_user_id(),
"<b>WRITE</b> the correct word for the definition:\n"
"<b>" + word[1] + "</b>\n" + word_context,
parse_mode=types.ParseMode.HTML)
# SENTENCES
# Unscramble
elif word[2] == 10:
session.current_level = word[2]
logger.debug("{} started level {}", session.get_user_id(), word[2])
await syntaxis.unscramble(session, word)
async def learning(query: types.CallbackQuery, callback_data: dict):
await query.answer("Let's learn!")
logger.debug(query)
logger.debug(str(query.from_user.id)
+ "start_learning " + str(callback_data))
n = int(callback_data['data'])
session, isValid = await authorize(query.from_user.id, with_lang=True)
if not isValid:
return
upper_recall_limit = 0.5
if session.status == '/test':
upper_recall_limit = 1.0
if n == -1: # General vocabulary selected
hids = sr.get_items_to_learn(
(session.get_user_id(), session.active_lang()),
upper_recall_limit=upper_recall_limit)
if len(hids) == 0:
if session.status == '/test':
await bot.send_message(session.get_user_id(),
'You should add at least one word with /addwords command to start training')
else:
await bot.send_message(session.get_user_id(), 'You don\'t have words for training.')
await bot.send_message(session.get_user_id(), 'Add more words with /addwords command or')
await bot.send_message(session.get_user_id(), 'or /test words you learned before.')
return True
sentences = False
if n >= 0: # One of the lists selected
lists = mysql_connect.get_list_names(query.from_user.id)
list_name = lists[int(callback_data['data'])]
logger.info("{} learns {}", query.from_user.id, list_name)
text_hid = mysql_connect.fetchone('SELECT text_hid FROM user_texts WHERE user=%s AND list_name=%s',
(session.get_user_id(), list_name))
if text_hid is not None:
summary = mysql_connect.fetchone('SELECT summary FROM text_summary WHERE user=%s AND hid=%s',
(session.get_user_id(), text_hid[0]))
if summary is not None:
# (word, definition, mode, hid)]
session.words_to_learn = list()
session.words_to_learn.append((summary[0], list_name, 20, text_hid[0]))
k = to_one_row_keyboard(['Words', 'Summary'], [0, 1],
['text_words', 'text_summary'])
await bot.send_message(session.get_user_id(),
'You created a summary for text _{}_.\n'
'Would you like to learn words or continue with your summary?'
.format(list_name),
reply_markup=k)
return
hids = mysql_connect.get_hids_for_list(query.from_user.id, list_name)
logger.info("{} has {} words from list {}", query.from_user.id, len(hids), list_name)
hids_all = sr.get_items_to_learn(
(session.get_user_id(), session.active_lang()),
upper_recall_limit=upper_recall_limit)
logger.info("{} has {} words to learn", query.from_user.id, len(hids_all))
hids = list(set(hids) & set(hids_all))
logger.info("{} has {} words from list {} to learn", query.from_user.id, len(hids), list_name)
# hids = list() #FIXME NOW delete after testing!!!
if len(hids) == 0:
sentence_hids = mysql_connect.get_sentence_hids(query.from_user.id, list_name)
sentence_hids = ilt.get_objects(sentence_hids, '1 day', session.get_user_id(),
session.active_lang(), "SENTENCE", 10)
logger.info("{} has {} sentences from list {} to learn", query.from_user.id, len(sentence_hids), list_name)
await bot.send_message(query.from_user.id, "You have {} sentences from list {} to learn"
.format(len(sentence_hids), list_name))
sentences = True
if len(sentence_hids) > 0:
session.current_level = 10 #Syntax learning
await learn_sentences(query.from_user.id, list_name, session, sentence_hids)
else:
session.current_level = 20 #Text learning
await texts.text_summarization(query.from_user.id, list_name, session)
if not sentences:
words = mysql_connect.fetch_by_hids(session.get_user_id(), hids)
session.words_to_learn = words
session.current_word = 0
if not session.has_more_words_to_learn():
# Case 2: doing reading errors
await bot.send_message(session.get_user_id(), "Let's revise some words")
await reading.do_reading_errors(query, callback_data)
else:
# Case 1: reading exercises
await start_learning(session)
