def no_requests(ctx: Context, actor: Actor) -> bool:
"""Function to determine if
- user didn't asked to switch topic,
- user didn't ask to talk about something particular,
- user didn't requested high priority intents (like what_is_your_name)
- user didn't requested any special intents
- user didn't ask questions
"""
contain_no_special_requests = no_special_switch_off_requests(ctx, actor)
request_intents = [
"opinion_request",
"topic_switching",
"lets_chat_about",
"what_are_you_talking_about",
"Information_RequestIntent",
"Topic_SwitchIntent",
"Opinion_RequestIntent",
]
intents = common_utils.get_intents(int_ctx.get_last_human_utterance(
ctx, actor),
which="all")
is_not_request_intent = all(
[intent not in request_intents for intent in intents])
is_no_question = "?" not in int_ctx.get_last_human_utterance(ctx,
actor)["text"]
if contain_no_special_requests and is_not_request_intent and is_no_question:
return True
return False
def false_positive_condition(ctx: Context, actor: Actor, *args,
**kwargs) -> bool:
flag = (bool(
re.search(common_greeting.FALSE_POSITIVE_TURN_ON_RE,
int_ctx.get_last_human_utterance(ctx, actor)["text"]))
and int_ctx.get_human_utter_index(ctx, actor) == 0)
return flag
def sys_played_computer_game_condition(ctx: Context, actor: Actor, *args,
**kwargs) -> bool:
human_text = int_ctx.get_last_human_utterance(ctx, actor)["text"]
flag = bool(
re.search(played_computer_game_patterns_1_re, human_text)
and re.search(played_computer_game_patterns_2_re, human_text))
return flag
def chat_about_weather_condition(ctx: Context, actor: Actor, *args,
**kwargs) -> bool:
human_utter = get_last_human_utterance(ctx, actor)
bot_utter = get_last_bot_utterance(ctx, actor)
return bool(
if_chat_about_particular_topic(
human_utter, bot_utter, compiled_pattern=WEATHER_COMPILED_PATTERN))
def set_conf_and_can_cont_by_universal_policy(ctx: Context, actor: Actor):
DIALOG_BEGINNING_START_CONFIDENCE = 0.98
DIALOG_BEGINNING_CONTINUE_CONFIDENCE = 0.9
DIALOG_BEGINNING_SHORT_ANSWER_CONFIDENCE = 0.98
MIDDLE_DIALOG_START_CONFIDENCE = 0.7
if not is_begin_of_dialog(ctx, actor, begin_dialog_n=10):
confidence = 0.0
can_continue_flag = CAN_NOT_CONTINUE
elif is_first_our_response(ctx, actor):
confidence = DIALOG_BEGINNING_START_CONFIDENCE
can_continue_flag = CAN_CONTINUE_SCENARIO
elif not is_interrupted(ctx,
actor) and common_greeting.dont_tell_you_answer(
int_ctx.get_last_human_utterance(ctx, actor)):
confidence = DIALOG_BEGINNING_SHORT_ANSWER_CONFIDENCE
can_continue_flag = CAN_CONTINUE_SCENARIO
elif not is_interrupted(ctx, actor):
confidence = DIALOG_BEGINNING_CONTINUE_CONFIDENCE
can_continue_flag = CAN_CONTINUE_SCENARIO
else:
confidence = MIDDLE_DIALOG_START_CONFIDENCE
can_continue_flag = CAN_CONTINUE_SCENARIO
int_ctx.set_can_continue(ctx, actor, can_continue_flag)
int_ctx.set_confidence(ctx, actor, confidence)
def is_lets_chat_about_topic_human_initiative(ctx: Context,
actor: Actor) -> bool:
flag = universal_templates.if_chat_about_particular_topic(
int_ctx.get_last_human_utterance(ctx, actor),
int_ctx.get_last_bot_utterance(ctx, actor))
logger.debug(f"is_lets_chat_about_topic_human_initiative = {flag}")
return bool(flag)
def set_confidence_from_input(ctx: Context, actor: Actor, *args, **kwargs) -> Context:
intent, confidence = get_detected_intents(int_ctx.get_last_human_utterance(ctx, actor))
if intent in high_priority_intents["dff_intent_responder_skill"]:
int_ctx.set_confidence(ctx, actor, 1.0)
else:
int_ctx.set_confidence(ctx, actor, confidence)
return ctx
def intent_catcher_response(ctx: Context, actor: Actor, *args, **kwargs) -> str:
annotated_utterance = int_ctx.get_last_human_utterance(ctx, actor)
intention, confidence = get_detected_intents(annotated_utterance)
response = ""
if intention is not None and confidence > 0:
logger.debug(f"Intent is defined as {intention}")
dialog = int_ctx.get_dialog(ctx, actor)
dialog["seen"] = dialog["called_intents"][intention]
funcs = response_funcs.get_respond_funcs()[intention]
response = funcs(ctx, actor, intention)
# Special formatter which used in AWS Lambda to identify what was the intent
while "#+#" in response:
response = response[: response.rfind(" #+#")]
logger.info(f"Response: {response}; intent_name: {intention}")
try:
response += " #+#{}".format(intention)
except TypeError:
logger.error(f"TypeError intent_name: {intention} response: {response};")
response = "Hmmm... #+#{}".format(intention)
# todo: we need to know what intent was called
# current workaround is to use only one intent if several were detected
# and to append special token with intent_name
else:
logger.debug("Intent is not defined")
if response == "":
logger.error(f"response is empty for intents: {get_intents(annotated_utterance).items()}")
return response
def set_start_confidence(ctx: Context, actor: Actor) -> Context:
user_uttr = int_ctx.get_last_human_utterance(ctx, actor)
bot_uttr = int_ctx.get_last_bot_utterance(ctx, actor)
if if_chat_about_particular_topic(user_uttr, bot_uttr, compiled_pattern=ART_PATTERN):
int_ctx.set_confidence(ctx, actor, SUPER_CONFIDENCE)
elif re.findall(ART_PATTERN, user_uttr["text"]):
int_ctx.set_confidence(ctx, actor, HIGH_CONFIDENCE)
return ctx
def is_side_or_stop(ctx: Context, actor: Actor) -> bool:
"""
Check for side intents (including exit)
"""
intents = set(get_intents(int_ctx.get_last_human_utterance(ctx, actor), which="intent_catcher", probs=False))
side_intent_present = len(intents.intersection(SIDE_INTENTS)) > 0
logger.debug("Side intent detected, exiting")
return side_intent_present
def positive_or_negative_condition(ctx: Context, actor: Actor, *args,
**kwargs) -> bool:
# SYS_USR_ANSWERS_HOW_IS_HE_DOING
usr_sentiment = int_ctx.get_human_sentiment(ctx, actor)
pos_temp = is_positive_regexp_based(
int_ctx.get_last_human_utterance(ctx, actor))
neg_temp = is_negative_regexp_based(
int_ctx.get_last_human_utterance(ctx, actor))
bot_asked_how_are_you = any([
resp in int_ctx.get_last_bot_utterance(ctx, actor)["text"]
for resp in common_greeting.HOW_ARE_YOU_RESPONSES
])
if bot_asked_how_are_you and (usr_sentiment in ["positive", "negative"]
or pos_temp or neg_temp):
return True
return False
def is_no_human_abandon(ctx: Context, actor: Actor) -> bool:
"""Is dialog breakdown in human utterance or no. Uses MIDAS hold/abandon classes."""
midas_classes = common_utils.get_intents(int_ctx.get_last_human_utterance(
ctx, actor),
which="midas")
if "abandon" not in midas_classes:
return True
return False
def std_weekend_condition(ctx: Context, actor: Actor, *args, **kwargs) -> bool:
human_text = int_ctx.get_last_human_utterance(ctx, actor)["text"]
prev_was_about_topic = common_universal_templates.if_utterance_requests_topic(
int_ctx.get_last_bot_utterance(ctx, actor))
anything = re.search(re_patterns_human, human_text)
flag = bool(prev_was_about_topic and anything)
return flag
def how_are_you_condition(ctx: Context, actor: Actor, *args, **kwargs) -> bool:
prev_frindship_skill = int_ctx.get_last_bot_utterance(ctx, actor).get(
"active_skill", "") == "dff_friendship_skill"
how_are_you_found = common_greeting.HOW_ARE_YOU_TEMPLATE.search(
int_ctx.get_last_human_utterance(ctx, actor)["text"])
how_are_you_precise_found = common_greeting.HOW_ARE_YOU_PRECISE_TEMPLATE.search(
int_ctx.get_last_human_utterance(ctx, actor)["text"])
how_are_you_by_bot_found = common_greeting.HOW_ARE_YOU_TEMPLATE.search(
int_ctx.get_last_bot_utterance(ctx, actor)["text"])
any_you_in_user = common_greeting.ANY_YOU_TEMPLATE.search(
int_ctx.get_last_human_utterance(ctx, actor)["text"])
if how_are_you_precise_found:
return True
elif prev_frindship_skill and (how_are_you_found or
(how_are_you_by_bot_found
and any_you_in_user)):
return True
return False
def is_lets_chat_about_topic(ctx: Context, actor: Actor) -> bool:
flag = is_lets_chat_about_topic_human_initiative(ctx, actor)
last_human_uttr = int_ctx.get_last_human_utterance(ctx, actor)
last_bot_uttr_text = int_ctx.get_last_bot_utterance(ctx, actor)["text"]
is_bot_initiative = bool(
re.search(universal_templates.COMPILE_WHAT_TO_TALK_ABOUT,
last_bot_uttr_text))
flag = flag or (is_bot_initiative
and not common_utils.is_no(last_human_uttr))
logger.debug(f"is_lets_chat_about_topic = {flag}")
return bool(flag)
def intent_catcher_exists_condition(ctx: Context, actor: Actor, *args,
**kwargs) -> bool:
if ctx.validation:
return False
intents_by_catcher = common_utils.get_intents(
int_ctx.get_last_human_utterance(ctx, actor),
probs=False,
which="intent_catcher",
)
response_funcs = get_respond_funcs()
return bool(
any([intent in response_funcs for intent in intents_by_catcher]))
def thematic_funfact_response(ctx: Context, actor: Actor, *args, **kwargs) -> str:
response = ""
set_confidence(ctx, actor, CONF_HIGH)
set_can_continue(ctx, actor, MUST_CONTINUE)
entity = ctx.last_request.split("about")
if len(entity) > 1:
entity = entity[1]
human_utter = get_last_human_utterance(ctx, actor)
topic = get_topics(human_utter, which="cobot_topics")[0]
funfact = get_fact(entity, f"fact about {entity}")
if funfact:
link_question = make_question(topic)
response = f"{funfact} {link_question}"
if not response:
set_confidence(ctx, actor, CONF_ZERO)
return response
def forecast_response(ctx: Context, actor: Actor, *args, **kwargs) -> str:
location_name = ""
if homeland_forecast_requested_condition(ctx, actor):
dialog = get_dialog(ctx, actor)
if "human" in dialog and "profile" in dialog["human"]:
location_name = dialog["human"]["profile"].get("location", "")
else:
human_utter = get_last_human_utterance(ctx, actor)
location_name = retrieve_location_entity_from_utterance(human_utter)
if location_name:
forecast_intent_processing(ctx, actor)
response = f"{request_weather_service(location_name)}. {QUESTION_PHRASE}"
else:
set_can_continue(ctx, actor, CAN_CONTINUE_SCENARIO)
set_confidence(ctx, actor, MISSED_CITY_CONF)
response = SORRY_PHRASE
return response
def no_special_switch_off_requests(ctx: Context, actor: Actor) -> bool:
"""Function to determine if
- user didn't asked to switch topic,
- user didn't ask to talk about something particular,
- user didn't requested high priority intents (like what_is_your_name)
"""
intents_by_catcher = common_utils.get_intents(
int_ctx.get_last_human_utterance(ctx, actor),
probs=False,
which="intent_catcher")
is_high_priority_intent = any([
intent not in common_utils.service_intents
for intent in intents_by_catcher
])
is_switch = is_switch_topic(ctx, actor)
is_lets_chat = is_lets_chat_about_topic_human_initiative(ctx, actor)
if not (is_high_priority_intent or is_switch or is_lets_chat):
return True
return False
def is_question(ctx: Context, actor: Actor) -> bool:
text = int_ctx.get_last_human_utterance(ctx, actor)["text"]
flag = common_utils.is_question(text)
logger.debug(f"is_question = {flag}")
return bool(flag)
def sys_feel_great_condition(ctx: Context, actor: Actor, *args,
**kwargs) -> bool:
human_utterance = int_ctx.get_last_human_utterance(ctx, actor)
flag = common_utils.is_no(human_utterance)
return flag
def is_opinion_expression(ctx: Context, actor: Actor) -> bool:
flag = common_utils.is_opinion_expression(
int_ctx.get_last_human_utterance(ctx, actor))
logger.debug(f"is_opinion_expression = {flag}")
return bool(flag)
def is_switch_topic(ctx: Context, actor: Actor) -> bool:
flag = universal_templates.is_switch_topic(
int_ctx.get_last_human_utterance(ctx, actor))
logger.debug(f"is_switch_topic = {flag}")
return bool(flag)
def request_with_location_condition(ctx: Context, actor: Actor, *args,
**kwargs) -> bool:
human_utter = get_last_human_utterance(ctx, actor)
location_name = retrieve_location_entity_from_utterance(human_utter)
return bool(location_name)
def is_do_not_know_vars(ctx: Context, actor: Actor) -> bool:
flag = True
flag = flag and common_utils.is_donot_know(
int_ctx.get_last_human_utterance(ctx, actor))
return bool(flag)
def sys_slept_in_condition(ctx: Context, actor: Actor, *args,
**kwargs) -> bool:
human_text = int_ctx.get_last_human_utterance(ctx, actor)["text"]
flag = "slept" in human_text
return flag
def art_skill_switch(ctx: Context, actor: Actor) -> bool:
user_uttr = int_ctx.get_last_human_utterance(ctx, actor)
return re.findall(ART_PATTERN, user_uttr["text"])
def sys_play_regularly_condition(ctx: Context, actor: Actor, *args,
**kwargs) -> bool:
human_utterance = int_ctx.get_last_human_utterance(ctx, actor)
flag = common_utils.is_yes(human_utterance)
return flag
def sys_play_on_weekends_condition(ctx: Context, actor: Actor, *args,
**kwargs) -> bool:
human_utterance = int_ctx.get_last_human_utterance(ctx, actor)
flag = bool(was_game_mentioned(human_utterance))
return flag
def sys_cleaned_up_condition(ctx: Context, actor: Actor, *args,
**kwargs) -> bool:
human_text = int_ctx.get_last_human_utterance(ctx, actor)["text"]
flag = bool(re.search(cleaned_up_patterns_re, human_text))
return flag
