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