def want_music_response(vars):
try:
genre_flag, genre = get_genre(vars)
if genre_flag:
phrase = f"I think {genre} is cool. Do you like the whole genre of {genre} music?"
else:
phrase = "I guess you want to talk about music, right?"
state_utils.set_confidence(vars, MUST_CONTINUE_CONFIDENCE)
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_PROMPT)
return phrase
except Exception as exc:
logger.exception(exc)
sentry_sdk.capture_exception(exc)
state_utils.set_confidence(vars, CANNOT_CONTINUE_CONFIDENCE)
return error_response(vars)
def can_you_imagine_response(vars):
try:
shared_memory = state_utils.get_shared_memory(vars)
current_topic = shared_memory["current_topic"]
ack = condition_utils.get_not_used_and_save_sentiment_acknowledgement(
vars)
body = f"Can you imagine how much {current_topic} can change the world?"
state_utils.set_confidence(vars, confidence=CONF_100)
state_utils.set_can_continue(vars, CAN_CONTINUE_SCENARIO)
return " ".join([ack, body])
except Exception as exc:
logger.exception(exc)
sentry_sdk.capture_exception(exc)
return error_response(vars)
def recipe_response(vars):
try:
shared_memory = state_utils.get_shared_memory(vars)
used_meal = shared_memory.get("used_meals", "")
recipe = get_fact(used_meal, f"how to cook {used_meal}")
state_utils.set_confidence(vars, confidence=CONF_HIGH)
if not (used_meal and recipe):
state_utils.set_can_continue(vars, continue_flag=CAN_NOT_CONTINUE)
recipe = "Great! Enjoy your meal!"
else:
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_PROMPT)
return recipe
except Exception as exc:
logger.exception(exc)
sentry_sdk.capture_exception(exc)
return error_response(vars)
def ask_what_game_user_likes_response(vars):
response = ANSWER_TO_GENERAL_WISH_TO_DISCUSS_VIDEO_GAMES_AND_QUESTION_WHAT_GAME_YOU_PLAY
bot_text = state_utils.get_last_bot_utterance(vars).get("text", "").lower()
human_uttr = state_utils.get_last_bot_utterance(vars)
flags_set = False
if not if_chat_about_particular_topic(
human_uttr,
compiled_pattern=GAMES_WITH_AT_LEAST_1M_COPIES_SOLD_COMPILED_PATTERN
):
flags_set, response = common_nlg.maybe_set_confidence_and_continue_based_on_previous_bot_phrase(
vars, bot_text, response)
if not flags_set:
state_utils.set_confidence(vars, confidence=common_nlg.CONF_1)
state_utils.set_can_continue(
vars, continue_flag=common_constants.MUST_CONTINUE)
return response
def cuisine_fact_response(vars):
cuisine_fact = ""
try:
state_utils.set_confidence(vars, confidence=CONF_MIDDLE)
last_utt = state_utils.get_last_human_utterance(vars)
last_utt_lower = last_utt["text"].lower()
conceptnet_flag, food_item = check_conceptnet(vars)
if any([w.pos_ == "ADJ" for w in spacy_nlp(last_utt_lower)]):
for cuisine in list(CUISINES_FACTS.keys()):
if cuisine in last_utt_lower:
cuisine_fact = CUISINES_FACTS.get(cuisine, "")
state_utils.save_to_shared_memory(vars, cuisine=cuisine)
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
return cuisine_fact
if not cuisine_fact:
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
response = "You have such a refined taste in food! "
"I haven't tried it yet. What do you recommend to start with?"
state_utils.add_acknowledgement_to_response_parts(vars)
return response
elif conceptnet_flag:
entity_linking = last_utt["annotations"].get("entity_linking", [])
if entity_linking:
_facts = entity_linking[0].get("entity_pages", [])
if _facts:
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
response = f"You're a gourmet! I know about {food_item} that {_facts[0]}"
state_utils.add_acknowledgement_to_response_parts(vars)
return response
else:
return ""
else:
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
return (
"My favorite cuisine is French. I'm just in love "
"with pastry, especially with profiteroles! How about you?"
)
else:
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
return (
"My favorite cuisine is French. I'm just in love "
"with pastry, especially with profiteroles! How about you?"
)
except Exception as exc:
logger.exception(exc)
sentry_sdk.capture_exception(exc)
return error_response(vars)
def ask_about_dog_cat_response(vars):
response = ""
found_users_pet = retrieve_and_save(vars)
if found_users_pet in CATS_DOGS:
repl_pet = replace_pet(found_users_pet)
pet_phrase = choose_pet_phrase(vars, repl_pet)
response = f"{pet_phrase} Do you have a {found_users_pet}?".strip()
state_utils.save_to_shared_memory(vars, start=True)
if response:
state_utils.set_confidence(vars, confidence=CONF_1)
state_utils.set_can_continue(
vars, continue_flag=common_constants.MUST_CONTINUE)
else:
state_utils.set_confidence(vars, confidence=0.0)
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_NOT_CONTINUE)
return response
def tell_about_building_hogwarts_in_minecraft_ask_what_interesting_user_built(
vars,
must_continue=False,
):
response = (
"I had a great time building a copy of the Hogwarts castle "
"from Harry Potter. What is the most interesting thing you built?")
if must_continue:
state_utils.set_confidence(vars, confidence=common_nlg.CONF_1)
state_utils.set_can_continue(
vars, continue_flag=common_constants.MUST_CONTINUE)
else:
state_utils.set_confidence(vars,
confidence=common_nlg.CONF_092_CAN_CONTINUE)
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_CONTINUE_SCENARIO)
return response
def how_about_meal_response(vars):
shared_memory = state_utils.get_shared_memory(vars)
used_meals = shared_memory.get("used_meals", "")
meal = random.choice([i for i in MEALS if i != used_meals])
try:
state_utils.set_confidence(vars, confidence=CONF_HIGH)
state_utils.set_can_continue(vars, continue_flag=MUST_CONTINUE)
# first attempt to suggest a meal
state_utils.save_to_shared_memory(vars, used_meals=meal)
if not used_meals:
return f"I've recently found a couple easy and healthy meals. How about cooking {meal}?"
else:
return f"Okay. Give me one more chance. I recommend {meal}."
except Exception as exc:
logger.exception(exc)
sentry_sdk.capture_exception(exc)
return error_response(vars)
def ask_about_pet_response(vars):
retrieve_and_save(vars)
extract_breed(vars)
shared_memory = state_utils.get_shared_memory(vars)
user_uttr = state_utils.get_last_human_utterance(vars)
found_pet = re.findall(PETS_TEMPLATE, user_uttr["text"])
users_pet = shared_memory.get("users_pet", "")
used_pets_q = shared_memory.get("used_pets_q", [])
found_question = {}
flag = False
for elem in USER_PETS_Q:
if elem["what"] not in used_pets_q:
found_question = elem
found_attr = ""
if found_question and found_question["attr"]:
curr_attr = found_question["attr"]
found_attr = shared_memory.get(curr_attr, "")
found_keywords = False
if found_question and found_question["keywords"]:
keywords = found_question["keywords"]
found_keywords = any(
[keyword in user_uttr["text"] for keyword in keywords])
if not found_attr and not found_keywords:
flag = True
if (found_question.get("what", "") == "breed" and
(users_pet and users_pet not in CATS_DOGS)
or (found_pet and found_pet[0] not in CATS_DOGS)):
flag = False
if flag:
break
what_to_ask = found_question.get("what", "")
if what_to_ask != "name":
retrieve_and_save_name(vars)
prev_what_to_ask = ""
if used_pets_q:
prev_what_to_ask = used_pets_q[-1]
response = make_utt_with_ack(vars, prev_what_to_ask, what_to_ask)
if what_to_ask != "more_info":
used_pets_q.append(what_to_ask)
state_utils.save_to_shared_memory(vars, used_pets_q=used_pets_q)
state_utils.save_to_shared_memory(vars, start=True)
state_utils.set_confidence(vars, confidence=CONF_2)
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_CONTINUE_SCENARIO)
return response
def suggest_user_game_description_response(vars):
logger.info("called suggest_user_game_description_response")
game = gaming_memory.get_current_igdb_game(vars)
response = f"Would you like me to tell you short description of {game['name']}?"
human_uttr = state_utils.get_last_human_utterance(vars)
logger.info(
f"(suggest_user_game_description_response)human_uttr: {human_uttr['text']}"
)
if is_no(human_uttr):
state_utils.set_confidence(vars, confidence=common_nlg.CONF_1)
state_utils.set_can_continue(
vars, continue_flag=common_constants.MUST_CONTINUE)
else:
state_utils.set_confidence(vars,
confidence=common_nlg.CONF_092_CAN_CONTINUE)
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_CONTINUE_SCENARIO)
return response
def tell_how_to(vars, must_continue=True):
used_how_to_indices = state_utils.get_shared_memory(vars).get(
"used_how_to_indices", [])
remaining_indices = list(
set(range(len(MINECRAFT_HOW_TOS))) - set(used_how_to_indices))
assert remaining_indices, "Function `tell_how_to` should only be called if unused how tos remain"
i = random.choice(remaining_indices)
state_utils.save_to_shared_memory(vars, current_how_to_index=i)
if must_continue:
state_utils.set_confidence(vars, confidence=common_nlg.CONF_1)
state_utils.set_can_continue(
vars, continue_flag=common_constants.MUST_CONTINUE)
else:
state_utils.set_confidence(vars,
confidence=common_nlg.CONF_092_CAN_CONTINUE)
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_CONTINUE_SCENARIO)
return MINECRAFT_HOW_TOS[i]["question_to_user"]
def wikihow_question_response(vars):
response = ""
shared_memory = state_utils.get_shared_memory(vars)
curr_pages = shared_memory.get("curr_pages", [])
if not curr_pages:
found_entity_substr, _, found_entity_types = find_entity(
vars, "current")
if found_entity_substr and found_entity_substr in wikihowq_by_substr:
wikihow_questions = wikihowq_by_substr[found_entity_substr]
wikihow_articles = list(wikihow_questions.keys())
chosen_article = random.choice(wikihow_articles)
article_content = get_wikihow_content(chosen_article)
if article_content:
all_page_titles = article_content.keys()
found_title = ""
for title in all_page_titles:
if title != "intro":
found_title = title
break
if found_title:
state_utils.save_to_shared_memory(
vars, prev_wikihow_title=found_title)
used_wikihow_titles = [found_title]
state_utils.save_to_shared_memory(
vars, used_wikihow_titles=used_wikihow_titles)
response = wikihow_questions[chosen_article]
if not response:
response = f"Would you like to know how to {chosen_article.replace('-', ' ').lower()}?"
logger.info(
f"wikihow_question_response, chosen_article {chosen_article} response {response}"
)
state_utils.save_to_shared_memory(vars,
wikihow_article=chosen_article)
if response:
state_utils.save_to_shared_memory(vars, start=True)
state_utils.set_confidence(vars, confidence=CONF_DICT["WIKI_TOPIC"])
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_CONTINUE_PROMPT)
else:
state_utils.set_confidence(vars, confidence=CONF_DICT["UNDEFINED"])
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_NOT_CONTINUE)
return response
def intro_question_response(vars):
response = ""
shared_memory = state_utils.get_shared_memory(vars)
curr_pages = shared_memory.get("curr_pages", [])
if not curr_pages:
found_entity_substr, _, found_entity_types = find_entity(
vars, "current")
if found_entity_substr and found_entity_substr in questions_by_entity_substr:
response = questions_by_entity_substr[found_entity_substr]
if response:
state_utils.save_to_shared_memory(vars, start=True)
state_utils.set_confidence(vars, confidence=CONF_DICT["WIKI_TOPIC"])
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_CONTINUE_PROMPT)
else:
state_utils.set_confidence(vars, confidence=CONF_DICT["UNDEFINED"])
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_NOT_CONTINUE)
return response
def error_response(vars):
facts_memory["wikihow_content"] = []
facts_memory["wikipedia_content"] = []
state_utils.save_to_shared_memory(vars, cur_wikihow_page="")
state_utils.save_to_shared_memory(vars, cur_wikipedia_page="")
state_utils.save_to_shared_memory(vars, used_wikihow_nums={})
state_utils.save_to_shared_memory(vars, used_wikipedia_nums={})
state_utils.save_to_shared_memory(vars, start=False)
save_wiki_vars(vars, [], [], "", "", [], [], False)
state_utils.save_to_shared_memory(vars, wikihow_article="")
state_utils.save_to_shared_memory(vars, prev_wikihow_title="")
state_utils.save_to_shared_memory(vars, used_wikihow_titles=[])
state_utils.save_to_shared_memory(vars, interrupted_skill="")
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_NOT_CONTINUE)
state_utils.set_confidence(vars, 0)
delete_topic_info(vars)
return ""
def whats_your_fav_response(vars):
try:
shared_memory = state_utils.get_shared_memory(vars)
used_topics = shared_memory.get("used_topics", [])
curr_topic = ""
if used_topics:
curr_topic = used_topics[-1]
if curr_topic:
state_utils.set_confidence(vars, confidence=CONF_LOW)
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_PROMPT)
return f"What is your favorite {curr_topic}?"
else:
state_utils.set_confidence(vars, 0)
return error_response(vars)
except Exception as exc:
logger.exception(exc)
sentry_sdk.capture_exception(exc)
state_utils.set_confidence(vars, 0)
return error_response(vars)
def animal_facts_response(vars):
shared_memory = state_utils.get_shared_memory(vars)
users_wild_animal = shared_memory.get("users_wild_animal", "")
facts = shared_memory.get("wild_animal_facts", [])
isno = is_no(state_utils.get_last_human_utterance(vars))
used_wild_animal_facts = shared_memory.get("used_wild_animal_facts", [])
found_fact = {}
found_num = -1
for num, fact in enumerate(facts):
if num not in used_wild_animal_facts:
found_num = num
found_fact = fact
used_wild_animal_facts.append(num)
state_utils.save_to_shared_memory(vars, used_wild_animal_facts=used_wild_animal_facts)
break
logger.info(f"animal_facts_response, found_num {found_num} used_wild_animals_facts {used_wild_animal_facts}")
response = ""
facts_str = " ".join(found_fact["sentences"][:2]).strip().replace(" ", " ")
if found_num == 0:
facts_str = f"I know a lot about {users_wild_animal}. {facts_str}".strip().replace(" ", " ")
if found_num != len(facts) - 1:
next_fact = facts[found_num + 1]
next_title = next_fact.get("title", "")
if next_title:
question = ANIMALS_WIKI_Q.get(next_title, "").format(users_wild_animal)
else:
question = random.choice(ANIMALS_COBOT_Q)
question = question.format(users_wild_animal)
if isno and found_num != 0:
facts_str = ""
response = f"{facts_str} {question}".strip().replace(" ", " ")
else:
response = facts_str
if response:
state_utils.set_confidence(vars, confidence=CONF_1)
state_utils.set_can_continue(vars, continue_flag=common_constants.MUST_CONTINUE)
else:
state_utils.set_confidence(vars, confidence=CONF_4)
state_utils.set_can_continue(vars, continue_flag=common_constants.CAN_NOT_CONTINUE)
return response
def ask_user_when_he_started_to_play_minecraft_response(
vars, candidate_game_id_is_already_set):
shared_memory_ops.set_current_igdb_game_id_if_game_for_discussion_is_identified(
vars, candidate_game_id_is_already_set)
response = (
"Perfect taste! Minecraft is the best game ever! I dived into the game right after I was created. "
"And what about you? When did you start to play Minecraft?")
human_uttr = state_utils.get_last_human_utterance(vars)
bot_text = state_utils.get_last_bot_utterance(vars).get("text", "")
state_utils.add_acknowledgement_to_response_parts(vars)
flags_set = False
if not if_chat_about_particular_topic(
human_uttr, compiled_pattern=re.compile("minecraft", flags=re.I)):
flags_set, response = common_nlg.maybe_set_confidence_and_continue_based_on_previous_bot_phrase(
vars, bot_text, response)
logger.info(f"flags_set: {flags_set}")
if not flags_set:
state_utils.set_confidence(vars, confidence=common_nlg.CONF_1)
state_utils.set_can_continue(
vars, continue_flag=common_constants.MUST_CONTINUE)
return response
def do_you_like_topic_response(vars):
try:
shared_memory = state_utils.get_shared_memory(vars)
used_topics = list(
set(
shared_memory.get("used_topics", [])
+ ["thing", "day", "book genre", "singer", "actor", "song", "color", "team", "all time favorite movie"]
)
)
unused_topic = random.choice([t for t in FAV_STORIES_TOPICS if t not in used_topics])
state_utils.set_confidence(vars, confidence=CONF_MIDDLE)
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
state_utils.save_to_shared_memory(vars, used_topics=used_topics + [unused_topic])
if unused_topic not in "series":
unused_topic += "s"
return f"Do you like {unused_topic}?"
except Exception as exc:
logger.exception(exc)
sentry_sdk.capture_exception(exc)
state_utils.set_confidence(vars, 0)
return error_response(vars)
def what_eat_response(vars):
try:
shared_memory = state_utils.get_shared_memory(vars)
used_questions = shared_memory.get("fast_food_what_questions", [])
question = random.choice(
[i for i in FAST_FOOD_WHAT_QUESTIONS if i not in used_questions])
user_utt = state_utils.get_last_human_utterance(vars)["text"].lower()
bot_utt = state_utils.get_last_bot_utterance(vars)["text"].lower()
state_utils.save_to_shared_memory(
vars, fast_food_what_questions=used_questions + [question])
if "how often" in bot_utt:
if any([i in user_utt for i in ["times", "every"]]):
question = "Not so often as some people do! " + question
else:
question = "Okay. " + question
state_utils.set_confidence(vars, confidence=CONF_HIGH)
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_PROMPT)
return question
except Exception as exc:
logger.exception(exc)
sentry_sdk.capture_exception(exc)
return error_response(vars)
def i_think_it_can_change_the_world_response(vars):
try:
# get world_changes
shared_memory = state_utils.get_shared_memory(vars)
current_topic = shared_memory["current_topic"]
world_changes = science_topics[current_topic]["world_changes"]
ack = condition_utils.get_not_used_and_save_sentiment_acknowledgement(
vars)
if world_changes:
body = " ".join(["I think it can change the world a lot."] +
world_changes)
else:
body = "I think this is an insignificant technology and may not greatly affect the world."
state_utils.set_confidence(vars, confidence=CONF_100)
state_utils.set_can_continue(vars, CAN_CONTINUE_PROMPT)
return " ".join([ack, body])
except Exception as exc:
logger.exception(exc)
sentry_sdk.capture_exception(exc)
return error_response(vars)
def tell_about_pet_response(vars):
shared_memory = state_utils.get_shared_memory(vars)
my_pet = shared_memory.get("my_pet", "")
make_my_pets_info(vars)
if not my_pet:
my_pet = random.choice(["cat", "dog"])
state_utils.save_to_shared_memory(vars, my_pet=my_pet)
user_uttr = state_utils.get_last_human_utterance(vars)
my_pet = user_asked_about_pet(user_uttr, my_pet)
all_facts_used = False
used_facts = shared_memory.get("used_facts", {}).get(my_pet, [])
all_facts = MY_PET_FACTS[my_pet]
if len(all_facts) == len(used_facts):
all_facts_used = True
if all_facts_used:
if my_pet == "cat":
my_pet = "dog"
elif my_pet == "dog":
my_pet = "cat"
state_utils.save_to_shared_memory(vars, my_pet=my_pet)
my_pets_info = shared_memory["my_pets_info"]
sentence = my_pets_info[my_pet]["sentence"]
name = my_pets_info[my_pet]["name"]
breed = my_pets_info[my_pet]["breed"]
if my_pet == "cat":
state_utils.save_to_shared_memory(vars, cat_intro=True)
if my_pet == "dog":
state_utils.save_to_shared_memory(vars, dog_intro=True)
answer, _, conf, continue_flag = answer_users_question(vars)
if (name in answer and name in sentence) or (breed in answer and breed in sentence):
response = f"{sentence} Would you like to learn more about my {my_pet}?".strip()
else:
response = f"{answer} {sentence} Would you like to learn more about my {my_pet}?".strip()
state_utils.save_to_shared_memory(vars, start=True)
state_utils.set_confidence(vars, confidence=conf)
state_utils.set_can_continue(vars, continue_flag=continue_flag)
return response
def mention_pets_response(vars):
make_my_pets_info(vars)
replace_plural = {
"cats": "cat",
"dogs": "dog",
"rats": "rat",
"puppy": "dog",
"puppies": "dog",
"kitty": "cat",
"kitties": "cat",
}
text = state_utils.get_last_human_utterance(vars)["text"]
pet = re.findall(PETS_TEMPLATE, text)
if pet[0] in replace_plural:
found_pet = replace_plural[pet[0]]
else:
found_pet = pet[0]
response = f"Do you have a {found_pet}?"
state_utils.save_to_shared_memory(vars, start=True)
state_utils.set_confidence(vars, confidence=CONF_1)
state_utils.set_can_continue(vars,
continue_flag=common_constants.MUST_CONTINUE)
return response
def praise_user_achievement_in_minecraft_and_try_to_link_to_harry_potter_response(
vars):
disliked_skills = state_utils.get_disliked_skills(vars)
used_linkto_phrases_ids = shared_memory_ops.get_used_linkto_phrase_ids(
vars)
logger.info(
"(praise_user_achievement_in_minecraft_and_try_to_link_to_harry_potter_response)"
f"LINKTO_RESPONSES_TO_LINKTO_IDS: {shared_memory_ops.LINKTO_RESPONSES_TO_LINKTO_IDS}"
)
book_link_to_id = shared_memory_ops.LINKTO_RESPONSES_TO_LINKTO_IDS[
common_gaming.special_links_to_books["Harry Potter"][0]]
movie_link_to_id = shared_memory_ops.LINKTO_RESPONSES_TO_LINKTO_IDS[
common_gaming.special_links_to_movies["Harry Potter"][0]]
if "movie_skill" not in disliked_skills and movie_link_to_id not in used_linkto_phrases_ids:
response = "Sounds cool! " + common_gaming.special_links_to_movies[
"Harry Potter"][0]
shared_memory_ops.add_used_linkto_to_shared_memory(
vars, common_gaming.special_links_to_movies["Harry Potter"][0])
elif "dff_book_skill" not in disliked_skills and book_link_to_id not in used_linkto_phrases_ids:
response = "Sounds cool! " + common_gaming.special_links_to_books[
"Harry Potter"][0]
shared_memory_ops.add_used_linkto_to_shared_memory(
vars, common_gaming.special_links_to_books["Harry Potter"][0])
else:
response = ""
if response:
state_utils.set_confidence(
vars, confidence=common_nlg.CONF_09_DONT_UNDERSTAND_DONE)
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_NOT_CONTINUE)
else:
state_utils.set_confidence(vars, confidence=common_nlg.CONF_0)
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_NOT_CONTINUE)
shared_memory_ops.mark_current_bot_utterance_as_link_to_other_skill(vars)
state_utils.add_acknowledgement_to_response_parts(vars)
return response
def start_talk_response(vars):
used_titles = []
dialog = vars["agent"]["dialog"]
found_entity_substr, found_entity_id, found_entity_types, found_page_title, _ = continue_after_topic_skill(
dialog)
page_content, _ = get_page_content(found_page_title)
found_entity_substr_list = [found_entity_substr]
found_entity_types_list = [list(found_entity_types)]
curr_pages = [found_page_title]
chosen_title, chosen_page_title = get_title_info(vars, found_entity_substr,
found_entity_types, "",
[], page_content)
titles_q, titles_we_use, all_titles = get_titles(found_entity_substr,
found_entity_types,
page_content)
question = ""
if chosen_title:
question = make_question(chosen_title, titles_q, found_entity_substr,
[])
chosen_title, chosen_page_title = choose_title(vars, all_titles,
titles_we_use, "", [],
curr_pages)
response = question.strip()
if chosen_title:
used_titles.append(chosen_title)
save_wiki_vars(
vars,
found_entity_substr_list,
curr_pages,
chosen_title,
chosen_page_title,
used_titles,
found_entity_types_list,
False,
)
cross_link = state_utils.get_cross_link(vars,
service_name="dff_wiki_skill")
from_skill = cross_link.get("from_service", "")
if from_skill:
state_utils.save_to_shared_memory(vars, interrupted_skill=from_skill)
if response:
state_utils.save_to_shared_memory(vars, start=True)
state_utils.set_confidence(vars,
confidence=CONF_DICT["ENTITY_IN_HISTORY"])
if from_skill:
state_utils.set_can_continue(
vars, continue_flag=common_constants.MUST_CONTINUE)
else:
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_CONTINUE_PROMPT)
else:
state_utils.set_confidence(vars, confidence=CONF_DICT["UNDEFINED"])
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_NOT_CONTINUE)
return response
def explain_fav_response(vars):
utt = state_utils.get_last_human_utterance(vars)["text"].lower()
curr_topic = ""
curr_item = ""
_object = ""
wp_top = []
shared_memory = state_utils.get_shared_memory(vars)
used_topics = list(set(shared_memory.get("used_topics", [])))
if used_topics:
curr_topic = used_topics[-1]
curr_item = FAV_STORIES_TOPICS.get(curr_topic, "").get("name", "")
if curr_topic in CATEGORIES_OBJECTS:
_object = random.choice(CATEGORIES_OBJECTS[curr_topic])
try:
if utt == "why?":
state_utils.set_confidence(vars, confidence=CONF_HIGH)
state_utils.set_can_continue(vars, continue_flag=MUST_CONTINUE)
elif ("why" in utt) and ("?" in utt):
state_utils.set_confidence(vars, confidence=CONF_MIDDLE)
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
else:
state_utils.set_confidence(vars, confidence=CONF_LOW)
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
if curr_topic in ["movie", "show"]:
fake_utterance = f"I like to learn more about {curr_item} {_object} {curr_topic}"
wp_top = shared.get_object_top_wiki_parser(curr_item, _object, curr_topic, fake_utterance)
elif curr_topic == "sport":
wp_top = shared.get_genre_top_wiki_parser(_object, curr_item)
elif curr_topic == "team":
fake_utterance = f"I like to learn more about {curr_item}"
wp_top = shared.get_team_players_top_wiki_parser(curr_item, fake_utterance)
elif curr_topic in ["music", "song", "singer"]:
fake_utterance = f"I like to learn more about {curr_item} {_object} {curr_topic}"
wp_top = shared.get_object_top_wiki_parser(curr_item, _object, curr_topic, fake_utterance)
else:
wp_top = []
if wp_top:
res = " ".join(wp_top)
return f"I like its {_object}. {res} are my favorites. What do you think about them?"
else:
return "Hmm, I am just a fan of it!"
except Exception as exc:
logger.exception(exc)
sentry_sdk.capture_exception(exc)
state_utils.set_confidence(vars, 0)
return error_response(vars)
def country_response(vars):
shared_memory = state_utils.get_shared_memory(vars)
cuisine_discussed = shared_memory.get("cuisine", "")
try:
if cuisine_discussed:
if cuisine_discussed in CUISINES_COUNTRIES:
state_utils.set_confidence(vars, confidence=CONF_MIDDLE)
state_utils.set_can_continue(vars, continue_flag=CAN_NOT_CONTINUE)
return f"Have you ever been in {CUISINES_COUNTRIES[cuisine_discussed]}?"
else:
state_utils.set_can_continue(vars, continue_flag=CAN_NOT_CONTINUE)
return error_response(vars)
else:
state_utils.set_can_continue(vars, continue_flag=CAN_NOT_CONTINUE)
return error_response(vars)
except Exception as exc:
logger.exception(exc)
sentry_sdk.capture_exception(exc)
return error_response(vars)
def animal_questions_response(vars):
user_uttr = state_utils.get_last_human_utterance(vars)
bot_uttr = state_utils.get_last_bot_utterance(vars)
annotations = state_utils.get_last_human_utterance(vars)["annotations"]
shared_memory = state_utils.get_shared_memory(vars)
started = shared_memory.get("start", False)
users_wild_animal = shared_memory.get("users_wild_animal", "")
animal_wp = find_entity_by_types(annotations, {"Q55983715", "Q16521"})
animal_cnet = find_entity_conceptnet(annotations, ["animal"])
animal_in_list = find_in_animals_list(annotations)
found_bird = re.findall(r"(\bbird\b|\bbirds\b)", user_uttr["text"])
facts = []
if animal_wp and animal_wp not in ANIMAL_BADLIST:
facts = get_all_facts(annotations, "animal")
if facts:
state_utils.save_to_shared_memory(vars, wild_animal_facts=facts)
if animal_in_list and not facts:
facts = preprocess_fact_random_facts(annotations, animal_in_list)
if facts:
state_utils.save_to_shared_memory(vars, wild_animal_facts=facts)
cur_animal = ""
if animal_wp and animal_wp not in ANIMAL_BADLIST:
cur_animal = plural_nouns(animal_wp)
elif animal_cnet:
cur_animal = plural_nouns(animal_cnet)
elif users_wild_animal:
cur_animal = users_wild_animal
elif animal_in_list:
cur_animal = animal_in_list
elif found_bird:
cur_animal = found_bird[0]
if cur_animal:
state_utils.save_to_shared_memory(vars, users_wild_animal=cur_animal)
response = ""
used_wild_q = shared_memory.get("used_wild_q", [])
for num, question_info in enumerate(WILD_ANIMALS_Q):
if num not in used_wild_q:
statement = question_info["statement"].format(cur_animal)
question = question_info["question"].format(cur_animal)
response = f"{statement} {question}".strip().replace(" ", " ")
used_wild_q.append(num)
state_utils.save_to_shared_memory(vars, used_wild_q=used_wild_q)
break
state_utils.save_to_shared_memory(vars, start=True)
state_utils.save_to_shared_memory(vars, is_wild=True)
if_chat = if_chat_about_particular_topic(user_uttr, bot_uttr, compiled_pattern=ANIMAL_MENTION_TEMPLATE)
if response:
if if_chat:
state_utils.set_confidence(vars, confidence=CONF_1)
state_utils.set_can_continue(vars, continue_flag=common_constants.MUST_CONTINUE)
elif started:
state_utils.set_confidence(vars, confidence=CONF_2)
state_utils.set_can_continue(vars, continue_flag=common_constants.CAN_CONTINUE_SCENARIO)
else:
state_utils.set_confidence(vars, confidence=CONF_3)
state_utils.set_can_continue(vars, continue_flag=common_constants.CAN_CONTINUE_PROMPT)
else:
state_utils.set_confidence(vars, confidence=CONF_4)
state_utils.set_can_continue(vars, continue_flag=common_constants.CAN_NOT_CONTINUE)
logger.info(f"animal_questions_response: {response}")
return response
def facts_response(vars, topic_config, wikihow_cache, wikipedia_cache):
shared_memory = state_utils.get_shared_memory(vars)
user_uttr = state_utils.get_last_human_utterance(vars)
bot_uttr = state_utils.get_last_bot_utterance(vars)
prev_active_skill = bot_uttr.get("active_skill", "")
if prev_active_skill not in {"dff_wiki_skill", "dff_music_skill"}:
delete_topic_info(vars)
isyes = is_yes(user_uttr) or re.findall(CONTINUE_PATTERN,
user_uttr["text"])
response = ""
cur_mode = shared_memory.get("cur_mode", "smalltalk")
wikipedia_page = shared_memory.get("cur_wikipedia_page", "")
wikihow_page = shared_memory.get("cur_wikihow_page", "")
found_topic = shared_memory.get("special_topic", "")
utt_can_continue = common_constants.CAN_CONTINUE_SCENARIO
utt_conf = CONF_DICT["WIKI_TOPIC"]
first_utt = False
entity_substr = ""
entity_types = []
if not found_topic:
found_topic, first_utt, utt_can_continue, utt_conf = check_switch(
vars, topic_config)
extract_and_save_entity(vars, topic_config, found_topic)
extract_and_save_subtopic(vars, topic_config, found_topic)
extract_and_save_wikipage(vars, True)
if found_topic and cur_mode == "smalltalk":
if "triggers" in topic_config[found_topic]:
triggers = topic_config[found_topic]["triggers"]
entity_substr, entity_types, wikipedia_page, wikihow_page = find_trigger(
vars, triggers)
facts = topic_config[found_topic].get("facts", {})
if facts and not wikihow_page and not wikipedia_page:
entity_substr = facts.get("entity_substr", "")
entity_types = facts.get("entity_types", [])
wikihow_page = facts.get("wikihow_page", "")
wikipedia_page = facts.get("wikipedia_page", "")
logger.info(f"wikipedia_page {wikipedia_page}")
if not wikihow_page:
wikihow_page = shared_memory.get("cur_wikihow_page", "")
if wikihow_page:
if wikihow_page in wikihow_cache:
page_content = wikihow_cache[wikihow_page]
else:
page_content = get_wikihow_content(wikihow_page)
wikihow_page_content_list = preprocess_wikihow_page(page_content)
memory["wikihow_content"] = wikihow_page_content_list
state_utils.save_to_shared_memory(vars,
cur_wikihow_page=wikihow_page)
if not wikipedia_page:
wikipedia_page = shared_memory.get("cur_wikipedia_page", "")
if wikipedia_page:
if wikipedia_page in wikipedia_cache:
page_content = wikipedia_cache[wikipedia_page].get(
"page_content", {})
else:
page_content, _ = get_page_content(wikipedia_page)
if not entity_substr:
entity_substr = wikipedia_page.lower()
titles_info = topic_config[found_topic].get("titles_info", [])
predefined_titles = []
for titles_info_elem in titles_info:
if wikipedia_page in titles_info_elem["pages"]:
predefined_titles = titles_info_elem["titles"]
break
wikipedia_page_content_list = preprocess_wikipedia_page(
entity_substr, entity_types, page_content, predefined_titles)
memory["wikipedia_content"] = wikipedia_page_content_list
state_utils.save_to_shared_memory(
vars, cur_wikipedia_page=wikipedia_page)
logger.info(
f"wikihow_page {wikihow_page} wikipedia_page {wikipedia_page}")
if found_topic:
used_wikihow_nums_dict = shared_memory.get("used_wikihow_nums", {})
used_wikihow_nums = used_wikihow_nums_dict.get(wikihow_page, [])
used_wikipedia_nums_dict = shared_memory.get("used_wikipedia_nums", {})
used_wikipedia_nums = used_wikipedia_nums_dict.get(wikipedia_page, [])
wikihow_page_content_list = memory.get("wikihow_content", [])
wikipedia_page_content_list = memory.get("wikipedia_content", [])
logger.info(
f"response, used_wikihow_nums {used_wikihow_nums} used_wikipedia_nums {used_wikipedia_nums}"
)
logger.info(
f"response, wikipedia_page_content_list {wikipedia_page_content_list[:3]} "
f"wikihow_page_content_list {wikihow_page_content_list[:3]}")
if wikihow_page and wikihow_page_content_list:
for num, fact in enumerate(wikihow_page_content_list):
if num not in used_wikihow_nums:
facts_str = fact.get("facts_str", "")
question = fact.get("question", "")
response = f"{facts_str} {question}".strip().replace(
" ", " ")
used_wikihow_nums.append(num)
used_wikihow_nums_dict[wikihow_page] = used_wikihow_nums
state_utils.save_to_shared_memory(
vars, used_wikihow_nums=used_wikihow_nums_dict)
break
if not response and wikipedia_page and wikipedia_page_content_list:
for num, fact in enumerate(wikipedia_page_content_list):
if num not in used_wikipedia_nums:
facts_str = fact.get("facts_str", "")
question = fact.get("question", "")
response = f"{facts_str} {question}".strip().replace(
" ", " ")
used_wikipedia_nums.append(num)
used_wikipedia_nums_dict[
wikipedia_page] = used_wikipedia_nums
state_utils.save_to_shared_memory(
vars, used_wikipedia_nums=used_wikipedia_nums_dict)
break
cur_mode = "facts"
if len(wikihow_page_content_list) == len(used_wikihow_nums) and len(
wikipedia_page_content_list) == len(used_wikipedia_nums):
cur_mode = "smalltalk"
if len(wikihow_page_content_list) == len(used_wikihow_nums):
state_utils.save_to_shared_memory(vars, cur_wikihow_page="")
memory["wikihow_content"] = []
if len(wikipedia_page_content_list) == len(used_wikipedia_nums):
state_utils.save_to_shared_memory(vars, cur_wikipedia_page="")
memory["wikipedia_content"] = []
answer = answer_users_question(vars, topic_config)
response = f"{answer} {response}".strip().replace(" ", " ")
if not shared_memory.get("special_topic", ""):
found_topic, first_utt, utt_can_continue, utt_conf = check_switch(
vars, topic_config)
state_utils.save_to_shared_memory(vars, special_topic=found_topic)
if response:
state_utils.save_to_shared_memory(vars, cur_mode=cur_mode)
state_utils.set_confidence(vars, confidence=utt_conf)
if isyes or (first_utt and utt_can_continue == "must"):
state_utils.set_can_continue(
vars, continue_flag=common_constants.MUST_CONTINUE)
else:
state_utils.set_can_continue(vars, continue_flag=utt_can_continue)
else:
state_utils.set_confidence(vars, confidence=CONF_DICT["UNDEFINED"])
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_NOT_CONTINUE)
state_utils.add_acknowledgement_to_response_parts(vars)
return response
def scenario_end_response(vars):
response = "I was very happy to tell you about my pets! You are a wonderful person!"
state_utils.set_confidence(vars, confidence=CONF_2)
state_utils.set_can_continue(vars, continue_flag=common_constants.CAN_CONTINUE_SCENARIO)
return response
def make_fact_response(vars):
shared_memory = state_utils.get_shared_memory(vars)
user_uttr = state_utils.get_last_human_utterance(vars)
bot_uttr = state_utils.get_last_bot_utterance(vars)
(
found_entity_substr_list,
prev_title,
prev_page_title,
found_entity_types_list,
used_titles,
curr_pages,
page_content_list,
main_pages_list,
new_page,
) = get_page_info(vars, "response")
logger.info(
f"tell_fact_response, found_entity_substr {found_entity_substr_list} prev_title {prev_title} "
f"prev_page_title {prev_page_title} found_entity_types {found_entity_types_list} used_titles "
f"{used_titles} curr_pages {curr_pages}")
titles_q, titles_we_use, all_titles = {}, [], []
if found_entity_substr_list and found_entity_types_list and page_content_list:
titles_q, titles_we_use, all_titles = get_titles(
found_entity_substr_list[-1], found_entity_types_list[-1],
page_content_list[-1])
logger.info(
f"all_titles {all_titles} titles_q {titles_q} titles_we_use {titles_we_use}"
)
chosen_title, chosen_page_title = choose_title(vars, all_titles,
titles_we_use, prev_title,
used_titles, curr_pages)
logger.info(f"chosen_title {chosen_title} main_pages {main_pages_list}")
if chosen_title:
new_page = False
if GO_TO_MAIN_PAGE and not any([
set(found_entity_types).intersection(ANIMAL_TYPES_SET)
for found_entity_types in found_entity_types_list
]):
chosen_main_pages = main_pages_list[-1].get(chosen_page_title, [])
if chosen_main_pages:
chosen_main_page = random.choice(chosen_main_pages)
curr_pages.append(chosen_main_page)
new_page = True
found_entity_substr_list.append(chosen_main_page.lower())
found_entity_types_list.append([])
used_titles.append(chosen_title)
save_wiki_vars(
vars,
found_entity_substr_list,
curr_pages,
chosen_title,
chosen_page_title,
used_titles,
found_entity_types_list,
new_page,
)
else:
save_wiki_vars(vars, [], [], "", "", [], [], False)
question = ""
if found_entity_substr_list and chosen_title:
question = make_question(chosen_title, titles_q,
found_entity_substr_list[-1], used_titles)
if new_page:
if len(page_content_list) == 1:
response = make_response(vars, prev_page_title,
page_content_list[-1], question)
else:
response = make_response(vars, prev_page_title,
page_content_list[-2], question)
else:
response = make_response(vars, prev_page_title, page_content_list[-1],
question)
started = shared_memory.get("start", False)
has_q = is_any_question_sentence_in_utterance(
user_uttr) and not re.findall(r"(let's|let us)", user_uttr["text"])
_, conf_type = if_switch_wiki_skill(user_uttr, bot_uttr)
cross_link = state_utils.get_cross_link(vars,
service_name="dff_wiki_skill")
from_skill = cross_link.get("from_service", "")
if from_skill:
state_utils.save_to_shared_memory(vars, interrupted_skill=from_skill)
interrupted_skill = shared_memory.get("interrupted_skill", "")
logger.info(f"interrupted_skill {interrupted_skill}")
if interrupted_skill:
state_utils.set_cross_link(vars,
to_service_name=interrupted_skill,
from_service_name="dff_wiki_skill")
must_switch = if_must_switch(user_uttr, bot_uttr)
if response:
if not started and has_q:
state_utils.set_confidence(
vars, confidence=CONF_DICT["USER_QUESTION_IN_BEGIN"])
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_CONTINUE_PROMPT)
else:
if not started:
state_utils.set_confidence(vars,
confidence=CONF_DICT[conf_type])
else:
state_utils.set_confidence(vars,
confidence=CONF_DICT["IN_SCENARIO"])
if interrupted_skill or must_switch:
state_utils.set_can_continue(
vars, continue_flag=common_constants.MUST_CONTINUE)
else:
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_CONTINUE_SCENARIO)
state_utils.save_to_shared_memory(vars, start=True)
else:
state_utils.set_confidence(vars, confidence=CONF_DICT["UNDEFINED"])
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_NOT_CONTINUE)
return response
