def handle(self, handler_input):
logger.info("HAN SM_CorrectQuestionHandler")
speech_list = []
player_obj = PlayerDict.load_player_obj(handler_input)
UserStats.update_player_stats(handler_input, correct = True, player_obj= player_obj)
SM_Attr.increment_sm_upper(handler_input)
ms_congrats = CongratUtils.get_answer_congrats(
handler_input, player_obj= player_obj, survival_mode=True)
logger.debug(ms_congrats)
ms_question = SMQuestions.get_question(
handler_input, first_question= False, player_obj= player_obj)
reprompt = GenQuestions.get_same_question(handler_input)
if len(ms_congrats):
sm_pause = Pauser.get_sm_pause_length(handler_input)
speech_list += Pauser.make_ms_pause_level_list(ms_congrats, sm_pause)
speech_list.append( ms_question)
SessionStats.update_consecutive_correct(handler_input, True)
ModeStats.update_mode_stats(handler_input, True)
speech = ' '.join(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (
handler_input.response_builder
.speak(speech)
.ask(reprompt)
.set_card( SimpleCard( card_title, card_text))
.response)
def handle(self, handler_input):
logger.info("HAN FP_CorrectAnswerHandler")
speech_list = []
player_obj = PlayerDict.load_player_obj(handler_input)
UserStats.update_player_stats(handler_input,
correct=True,
player_obj=player_obj)
ms_congrats = CongratUtils.get_answer_congrats(handler_input,
player_obj=player_obj)
ms_question = FPQuestions.get_question(handler_input)
reprompt = FPQuestions.get_rephrased_question(handler_input)
logger.debug(ms_congrats)
if ms_congrats != "":
speech_list += Pauser.make_ms_pause_level_list(
ms_congrats, 1, ms_question)
else:
speech_list.append(ms_question)
SessionStats.update_consecutive_correct(handler_input, correct=True)
ModeStats.update_mode_stats(handler_input, correct=True)
logger.debug(speech_list)
speech = ' '.join(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
def handle(self, handler_input):
logger.info("HAN ActDescriptHandler")
speech_list = []
activity = SlotUtils.get_resolved_value( handler_input, "activity")
if not activity:
logger.info("ActDescriptHandler: Non-resolved activity.")
ms_overall_descript = DescriptUtils.get_ms_overall_act_descript()
speech_list.append( ms_overall_descript)
else:
DescriptUtils.set_attr(handler_input, activity)
ms_act_descript = DescriptUtils.get_ms_corresponding_descript(activity)
speech_list.append( ms_act_descript)
prompt, reprompt = (
DescriptUtils.get_q_play_activity(activity) for _ in range(2))
prompt = CardFuncs.format_prompt(prompt)
speech_list.append( Pauser.get_p_level(4))
speech_list.append(prompt)
speech = ' '.join(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (
handler_input.response_builder
.speak( speech)
.ask( reprompt)
.set_card( SimpleCard( card_title, card_text))
.response)
def handle(self, handler_input):
logger.info("HAN FP_WrongAnswerHandler")
speech_list = []
player_obj = PlayerDict.load_player_obj(handler_input)
UserStats.update_player_stats(handler_input,
correct=False,
player_obj=player_obj)
WrongAnswer.record_wrong_question(handler_input)
ms_incorrect = IncorrectAnsUtils.get_buzz_and_incorrect()
ms_retry_question = AllQuestionIntros.get_retry_question(handler_input)
reprompt = GenQuestions.get_same_question(handler_input)
speech_list += Pauser.make_ms_pause_level_list(ms_incorrect, 1,
ms_retry_question)
SessionStats.update_consecutive_correct(handler_input, correct=False)
ModeStats.update_mode_stats(handler_input, correct=False)
logger.debug(speech_list)
speech = ' '.join(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
def handle(self, handler_input):
logger.info("HAN FP_AnsweredRequestedQuestionsHandler")
attr = handler_input.attributes_manager.session_attributes
speech_list = []
correct = QuestionChecker.check_answer(handler_input)
UserStats.update_player_stats(handler_input, correct)
ms_congrats = CongratUtils.get_player_congrats(handler_input, 2)
num_questions = attr.get('num_questions', '')
ms_answered_all_questions = FPSpeech.get_ms_answered_all_questions(
num_questions)
prompt, reprompt = (HelpUtils.get_q_what_todo() for _ in range(2))
prompt = CardFuncs.format_prompt(prompt)
speech_list += Pauser.make_ms_pause_level_list(
ms_congrats, 1, ms_answered_all_questions, 3, prompt)
SessionStats.update_consecutive_correct(handler_input, correct)
ModeStats.update_mode_stats(handler_input, correct)
ModeStats.translate_mode_stats_to_sesh(handler_input)
FreePlayAttr.set_attr_end_fp(handler_input)
speech = ' '.join(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
def handle(self, handler_input):
logger.info("HAN FP_SetNumberQuestionsHandler")
speech_list = []
FreePlayAttr.set_attr_free_play(
handler_input) # reset questions asked.
num_questions = SlotUtils.get_slot_val_by_name(handler_input,
'num_questions')
if num_questions is None:
ms_can_set_questions = FPNumQuestions.get_ms_can_set_num_questions(
)
prompt, reprompt = (FPNumQuestions.get_q_num_questions()
for _ in range(2))
speech_list += Pauser.make_ms_pause_level_list(
ms_can_set_questions, 2, prompt)
else:
FreePlayAttr.set_attr_num_questions(handler_input, num_questions)
ms_confirm = ConfirmUtils.get_random_confirmation(handler_input)
ms_ask_num_questions = FPNumQuestions.get_ms_ask_num_questions(
handler_input)
prompt = FPPrompts.get_q_fp_setup_prompt(handler_input)
reprompt = FPPrompts.get_q_fp_setup_reprompt(handler_input)
speech_list += Pauser.make_ms_pause_level_list(
ms_confirm, ms_ask_num_questions, 2, prompt)
ModeStats.translate_mode_stats_to_sesh(handler_input)
speech = ' '.join(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
def handle(self, handler_input):
logger.info("HAN CP_WrongAnswerHandler")
speech_list = []
player_obj = PlayerDict.load_player_obj(handler_input)
CP_Attr.update_last_question_attr(handler_input, correct=False)
UserStats.update_player_stats(handler_input,
correct=False,
player_obj=player_obj)
ms_wrong = IncorrectAnsUtils.get_ms_incorrect()
question = GenQuestions.get_same_question(handler_input)
reprompt = question
speech_list = (
ms_wrong,
1,
question,
)
SessionStats.update_consecutive_correct(handler_input, correct=False)
ModeStats.update_mode_stats(handler_input, correct=False)
WrongAnswer.record_wrong_question(handler_input)
PlayerDict.save_player_obj(handler_input, player_obj)
speech = get_linear_nlg(speech_list)
reprompt = GenQuestions.get_same_question(handler_input)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
def handle(self, handler_input):
logger.info("HAN CP_CorrectAnswerHandler")
attr = handler_input.attributes_manager.session_attributes
speech_list = []
practice_type = attr['practice_type']
if practice_type == custom_practice.data.PRACT_TYPES[0]:
CP_Attr.remove_question_from_incorrect_questions(
handler_input) ## Before updating last question
CP_Attr.update_last_question_attr(handler_input, correct=True)
player_obj = PlayerDict.load_player_obj(handler_input)
UserStats.update_player_stats(handler_input,
correct=True,
player_obj=player_obj)
ms_congrats = CongratUtils.get_answer_congrats(handler_input,
player_obj=player_obj)
ms_question = CP_Questions.get_question(handler_input,
player_object=player_obj,
practice_type=practice_type,
first_question=False)
reprompt = GenQuestions.get_same_question(handler_input)
speech_list = (ms_congrats, 1, ms_question)
SessionStats.update_consecutive_correct(handler_input, True)
ModeStats.update_mode_stats(handler_input, True)
PlayerDict.save_player_obj(handler_input, player_obj)
speech = get_linear_nlg(speech_list)
reprompt = GenQuestions.get_same_question(handler_input)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
def handle(self, handler_input):
logger.info("HAN RepeatHandler")
attr = handler_input.attributes_manager.session_attributes
speech_list = []
if 'recent_response' in attr:
return RepeatUtils.get_recent_response(handler_input)
ms_help = HelpUtils.get_ms_corresponding_help(handler_input)
ms_prompt, reprompt = (
HelpUtils.get_ms_corresponding_help(handler_input) for _ in range(2))
speech_list.append( fallback.data.MS_FALLBACK)
speech_list.append( Pauser.get_p_level(1))
## NOTE: This will need refinement if there are callbacks.
## Develop relevant methods from FallbackUtils.
speech_list.append( ms_help)
speech_list.append( ms_prompt)
speech = ' '.join(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (
handler_input.response_builder
.speak( speech)
.ask( reprompt)
.set_card( SimpleCard(
card_title, card_text))
.response)
def handle(self, handler_input):
# type (HandlerInput) -> Response
logger.info("HAN ExitIntentHandler")
speech_list = []
player_obj = PlayerDict.load_player_obj(handler_input)
## TODO: Implement sesh performance func.
ms_session_performance = ExitUtils.get_ms_session_performance(
handler_input)
ms_exit = ExitUtils.get_ms_exit_game()
speech_list.append(ms_session_performance)
speech_list.append(ms_exit)
speech = ' '.join(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
## Attr management @ very end.
ExitUtils.update_player_mode_statistics(handler_input, player_obj)
PlayerDict.save_player_obj(handler_input, player_obj)
ExitUtils.exit_skill_attr_management(handler_input)
return (handler_input.response_builder.speak(speech).set_card(
SimpleCard(card_title,
card_text)).set_should_end_session(True).response)
def handle(self, handler_input):
logger.info("HAN FP_SetTimesTablesHandler")
attr = handler_input.attributes_manager.session_attributes
speech_list = []
## Get & Set slots
lower_table, upper_table, tables_query = (
FreePlayAttr.get_times_table_input_slots(handler_input))
## Logic checks
retry_query = attr.get('inform_query_tables_format', False)
tables_provided = FreePlayLogic.check_tables_provided(
lower_table, upper_table, tables_query)
if tables_provided:
FreePlayAttr.set_attr_free_play(handler_input)
FreePlayAttr.set_attr_times_tables(handler_input, lower_table,
upper_table, tables_query)
if retry_query:
ms_potential_mistake = FPTimesTables.get_ms_potential_mistake_parsing_query(
)
speech_list += Pauser.make_ms_pause_level_list(
ms_potential_mistake, 2)
else:
ms_confirm = ConfirmUtils.get_random_confirmation(
handler_input)
speech_list.append(ms_confirm)
ms_using_tables = (FPTimesTables.get_ms_using_tables_from_input(
lower_table, upper_table, tables_query))
speech_list += Pauser.make_ms_pause_level_list(ms_using_tables, 2)
if retry_query:
ms_retry_query = FPTimesTables.get_ms_can_retry_query_format()
speech_list += Pauser.make_ms_pause_level_list(
ms_retry_query, 3.5)
FreePlayAttr.reset_attr_query_format(handler_input)
prompt = FPPrompts.get_q_fp_setup_prompt(handler_input)
reprompt = FPPrompts.get_q_fp_setup_reprompt(handler_input)
speech_list.append(prompt)
## Ask for times_tables slots
else:
q_times_tables, reprompt = (
FPTimesTables.get_q_times_tables_input() for _ in range(2))
q_times_tables = CardFuncs.format_prompt(q_times_tables)
speech_list.append(q_times_tables)
reprompt = LastPrompt.get_last_prompt(handler_input)
ModeStats.translate_mode_stats_to_sesh(handler_input)
speech = ' '.join(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
def handle(self, handler_input):
logger.info("HAN NoHandler")
ms_confirmation = ConfirmUtils.get_confirmation(punct=True)
prompt = HelpUtils.get_q_what_todo()
reprompt = HelpUtils.get_ms_help_overview()
speech_list = (ms_confirmation, 1, prompt)
speech = get_linear_nlg(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
def handle(self, handler_input):
logger.info("HAN CreateUserProfileHandler")
user_name = SlotUtils.get_first_slot_value(handler_input)
if not user_name:
logger.info("HAN RetryUserName")
ms_welcome = UserProfileUtils.get_ms_welcome(handler_input)
ms_retry_name = UserProfileUtils.get_ms_did_not_hear_name()
prompt, reprompt = (
UserProfileUtils.get_q_retry_name() for _ in range(2))
prompt = CardFuncs.format_prompt(prompt)
speech_list = (
ms_welcome,
0.5,
ms_retry_name,
1.75,
prompt
)
else:
logger.info("HAN CreatedProfile")
UserProfileUtils.set_sesh_attr(handler_input, user_name)
PlayerDict.create_new_player(handler_input, user_name)
ms_confirm = ConfirmUtils.get_player_confirmation(handler_input)
ms_created_first_profile = UserProfileUtils.get_ms_created_first_profile(handler_input)
ms_overview = HelpUtils.get_ms_act_descript()
prompt, reprompt = (
HelpUtils.get_q_what_todo() for _ in range(2))
prompt = CardFuncs.format_prompt(prompt)
speech_list = (
ms_confirm,
1,
ms_created_first_profile,
3,
ms_overview,
2.25,
prompt
)
speech = get_linear_nlg(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (
handler_input.response_builder
.speak(speech)
.ask(reprompt)
.set_card( SimpleCard( card_title, card_text))
.response)
def handle(self, handler_input):
logger.info("HAN CP_StartHandler")
player_obj = PlayerDict.load_player_obj(handler_input)
## Check Sufficient Data
## NOTE: make like to refacor this into a method that returns response object
## That will remove the nested loop below.
answered_questions = player_obj.get_answered_questions()
if answered_questions < custom_practice.data.MIN_DATA_REQUIRED:
prompt, reprompt = (HelpUtils.get_q_what_todo() for _ in range(2))
speech_list = (
CP_Welcome.get_ms_need_more_data(answered_questions),
2,
prompt,
)
else:
CP_Attr.set_attr_start_cp(handler_input)
CP_Attr.set_tbl_mean_err_list_attr(
handler_input, player_obj) # used in practice type
ms_welcome = CP_Welcome.get_ms_welcome(handler_input, player_obj)
practice_type = CP_PracticeType.get_practice_type(
handler_input, allow_incorrect_problems=True)
CP_Attr.save_practice_type(handler_input, practice_type)
CP_Attr.set_pract_type_attr(handler_input, player_obj,
practice_type)
CP_Attr.update_last_question_attr(handler_input, correct=True)
ms_practice_intro = CP_PractIntro.get_ms_practice_type_intro(
handler_input, practice_type)
question = CP_Questions.get_question(handler_input,
player_obj,
practice_type,
first_question=True)
reprompt = GenQuestions.get_same_question(handler_input)
speech_list = (
ms_welcome,
2.5,
ms_practice_intro,
2,
question,
)
speech = get_linear_nlg(speech_list)
reprompt = GenQuestions.get_same_question(handler_input)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
def handle(self, handler_input):
logger.info("HAN SM_WrongAnswerHandler")
player_obj = PlayerDict.load_player_obj(handler_input)
UserStats.update_player_stats(
handler_input, correct = False, player_obj= player_obj)
WrongAnswer.record_wrong_question(handler_input)
ms_incorrect = IncorrectAnsUtils.get_buzz_and_incorrect()
ms_correct_ans = GetAnswerSpeech.get_ms_answer(handler_input)
ms_score = SMEndGame.get_ms_game_score(handler_input)
ms_congrats = CongratUtils.get_player_congrats(handler_input, 1)
ms_results = SMEndGame.get_ms_score_results(
handler_input, player_obj= player_obj)
ms_thanks = get_ms_thanks(handler_input, mode = True, excite=True)
prompt, reprompt = (
HelpUtils.get_q_what_todo() for _ in range(2))
speech_list = (
ms_incorrect,
1,
ms_correct_ans,
2,
ms_congrats,
0.75,
ms_score,
1.25,
ms_results,
1.75,
ms_thanks,
4.5,
prompt,
)
SM_Attr.log_stats(handler_input)
SessionStats.update_consecutive_correct(handler_input, correct= False)
ModeStats.update_mode_stats(handler_input, correct= False)
UserStats.update_player_sm_stats(handler_input, player_obj= player_obj) #before translating mode stats
SM_Attr.set_attr_end_survival_mode(handler_input)
ModeStats.translate_mode_stats_to_sesh(handler_input)
speech = get_linear_nlg(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (
handler_input.response_builder
.speak(speech)
.ask(reprompt)
.set_card( SimpleCard( card_title, card_text))
.response)
def handle(self, handler_input):
logger.info("HAN SC_FinishedChallengeHandler")
speech_list = []
SC_Attr.save_end_time(handler_input)
sc_score_time = SC_Attr.get_sc_total_time(handler_input)
player_obj = PlayerDict.load_player_obj(handler_input)
SessionStats.update_consecutive_correct(handler_input, correct=True)
ModeStats.update_mode_stats(handler_input, correct=True)
UserStats.update_player_stats(handler_input,
correct=True,
player_obj=player_obj)
ms_congrats = CongratUtils.get_player_congrats(handler_input, 2)
ms_complete_time = SC_EndGame.get_ms_game_score(
handler_input, sc_score_time)
ms_score_results = SC_EndGame.get_ms_score_results(
handler_input, sc_score_time=sc_score_time, player_obj=player_obj)
ms_thanks = get_ms_thanks(handler_input, mode=True, excite=True)
prompt, reprompt = (HelpUtils.get_q_what_todo() for _ in range(2))
speech_list = (
ms_congrats,
1,
ms_complete_time,
1.5,
ms_score_results,
1.75,
ms_thanks,
4,
prompt,
)
SC_Attr.log_sc_stats(handler_input)
ModeStats.translate_mode_stats_to_sesh(handler_input)
UserStats.update_player_sc_stats(handler_input,
sc_score_time=sc_score_time,
player_obj=player_obj)
SC_Attr.set_attr_end_sc(handler_input)
PlayerDict.save_player_obj(handler_input, player_obj)
speech = get_linear_nlg(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
def handle(self, handler_input):
logger.info("HAN FP_ParametersIntent")
speech_list = []
ms_confirm = ConfirmUtils.get_confirmation(True)
ms_fp_params = FPSpeech.get_ms_fp_parameters(handler_input)
prompt, reprompt = (LastPrompt.get_last_prompt(handler_input)
for _ in range(2))
speech_list += Pauser.make_ms_pause_level_list(ms_confirm, 1,
ms_fp_params, 2.5,
prompt)
speech = ' '.join(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
def handle(self, handler_input):
logger.info("HAN ModeStatsHandler")
attr = handler_input.attributes_manager.session_attributes
speech_list = []
player_obj = PlayerDict.load_player_obj(handler_input)
mode = attr.get('mode', None)
activity = SlotUtils.get_resolved_value(handler_input, 'activity')
activity = activity if activity else mode
difficulty = True
if activity == 'survival':
speech_list += ModeSpeech.get_ms_sm_stats(player_obj, activity)
elif activity == 'speed':
difficulty = SlotUtils.get_resolved_value(handler_input,
'difficulty')
sc_difficulty = difficulty if difficulty else attr.get(
'sc_difficulty', None)
if (difficulty in speed_challenge.data.SC_DIFFICULTIES):
speech_list += ModeSpeech.get_ms_sc_stats(
player_obj, sc_difficulty, activity)
else:
reprompt = ModeSpeech.get_ms_sc_what_difficulty()
speech_list += reprompt
reprompt = get_linear_nlg(reprompt)
else:
ms_can_tell_record = ModeSpeech.get_ms_can_tell_record()
ms_example_saying = ModeSpeech.get_example_hear_records()
speech_list = [ms_can_tell_record, 2, ms_example_saying]
reprompt = HelpUtils.get_q_what_todo()
if activity in ('survival', 'speed') and (difficulty):
prompt, reprompt = (LastPrompt.get_last_prompt(handler_input)
for _ in range(2))
speech_list += Pauser.make_ms_pause_level_list(3, prompt)
speech = get_linear_nlg(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
def handle(self, handler_input):
logger.info("HAN FP_AddTimesTablesHandler")
attr = handler_input.attributes_manager.session_attributes
speech_list = []
lower_table, upper_table, tables_query = (
FreePlayAttr.get_times_table_input_slots(handler_input))
retry_query = attr.get('inform_query_tables_format', False)
if not tables_query:
ms_can_add = FPTimesTables.get_ms_can_add_tables()
speech_list += Pauser.make_ms_pause_level_list(ms_can_add, 2.5)
else:
FreePlayAttr.add_to_attr_times_tables(handler_input, lower_table,
upper_table, tables_query)
if retry_query:
ms_potential_mistake = FPTimesTables.get_ms_potential_mistake_parsing_query(
)
speech_list += Pauser.make_ms_pause_level_list(
ms_potential_mistake, 2)
ms_added_tables = FPTimesTables.get_ms_added_tables(tables_query)
speech_list += Pauser.make_ms_pause_level_list(
ms_added_tables, 1.5)
if retry_query:
ms_retry_query = FPTimesTables.get_ms_can_retry_query_format()
speech_list += Pauser.make_ms_pause_level_list(
ms_retry_query, 3.5)
FreePlayAttr.reset_attr_query_format(handler_input)
## May like to add only if tables query??
prompt = FPPrompts.get_q_fp_setup_prompt(handler_input)
reprompt = FPPrompts.get_q_fp_setup_reprompt(handler_input)
speech_list.append(prompt)
ModeStats.translate_mode_stats_to_sesh(handler_input)
speech = ' '.join(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
def handle(self, handler_input):
logger.info("HAN GetAnswerHandler")
speech_list = []
ms_answer = GetAnswerSpeech.get_ms_answer(handler_input)
next_question = FPQuestions.get_question(handler_input)
QuestionAttr.increment_questions_answered(handler_input,
False) # undo increment.
## NOTE: would not need to de-increment with better modulation.
speech_list += Pauser.make_ms_pause_level_list(ms_answer, 2,
next_question)
reprompt = next_question
speech = ' '.join(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
def handle(self, handler_input):
logger.info("HAN SC_CorrectAnswerHandler")
## TODO: Check sc attr and if anything needs to be incremented??
player_obj = PlayerDict.load_player_obj(handler_input)
UserStats.update_player_stats(handler_input,
correct=True,
player_obj=player_obj)
question = SC_Questions.get_question(handler_input)
reprompt = question
SessionStats.update_consecutive_correct(handler_input, correct=True)
ModeStats.update_mode_stats(handler_input, correct=True)
speech = question
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
def handle(self, handler_input):
speech_list = []
ms_confirm = ConfirmUtils.get_random_confirmation(handler_input)
prompt, reprompt = (HelpUtils.get_q_what_todo() for _ in range(2))
speech_list += Pauser.make_ms_pause_level_list(ms_confirm, 2, prompt)
ModeStats.translate_mode_stats_to_sesh(handler_input)
## Set end all attr
FreePlayAttr.set_attr_end_fp(handler_input)
SM_Attr.set_attr_end_survival_mode(handler_input)
SC_Attr.set_attr_end_sc(handler_input)
speech = ' '.join(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
def handle(self, handler_input):
# type (HandlerInput) -> Response
logger.info("HAN HelpHandler")
speech_list = []
ms_help = HelpUtils.get_ms_corresponding_help(handler_input)
prompt, reprompt = (
LastPrompt.get_last_prompt(handler_input) for _ in range(2))
speech_list += Pauser.make_ms_pause_level_list( ms_help, 3, prompt)
speech = ' '.join(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (
handler_input.response_builder
.speak(speech)
.ask(reprompt)
.set_card( SimpleCard(
card_title, card_text))
.response)
def handle(self, handler_input):
logger.info("HAN FallbackHandler")
FallbackUtils.log_fallback_intent(handler_input)
speech_list = []
# ms_help = HelpUtils.get_ms_corresponding_help(handler_input)
ms_prompt, reprompt = (LastPrompt.get_last_prompt(handler_input)
for _ in range(2))
speech_list.append(data.MS_FALLBACK)
speech_list.append(Pauser.get_p_level(1))
## NOTE: ms_help needs refinement if help after fallback handler.
## Develop relevant methods from FallbackUtils.
# speech_list.append( ms_help)
speech_list.append(ms_prompt)
speech = ' '.join(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
def handle(self, handler_input):
logger.info("HAN NumQuestionsAnsweredHandler")
attr = handler_input.attributes_manager.session_attributes
speech_list = []
questions_answered = attr.get('questions_answered', 0)
ms_confirm = ConfirmUtils.get_player_confirmation(handler_input)
ms_ans_questions = random.choice(
mult_questions.data.MT_NUM_QUESTIONS_ANS).format(
questions_answered)
prompt, reprompt = (LastPrompt.get_last_prompt(handler_input)
for _ in range(2))
speech_list += Pauser.make_ms_pause_level_list(ms_confirm, 1,
ms_ans_questions, 2,
prompt)
speech = ' '.join(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
def handle(self, handler_input):
logger.info("HAN SM_StartHandler")
speech_list = []
SM_Attr.set_attr_start_survival_mode(handler_input)
ModeStats.translate_mode_stats_to_sesh(handler_input)
ms_welcome = SM_WelcomeUtils.get_ms_welcome(handler_input)
ms_question = SMQuestions.get_question(handler_input, first_question= True)
reprompt = GenQuestions.get_same_question(handler_input)
speech_list += Pauser.make_ms_pause_level_list(
ms_welcome, 2, ms_question)
speech = ' '.join(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (
handler_input.response_builder
.speak( speech)
.ask( reprompt)
.set_card( SimpleCard( card_title, card_text))
.response)
def handle(self, handler_input):
logger.info("HAN SC_StartHandler")
speech_list = []
SC_Attr.set_attr_start_sc(handler_input)
player_obj = PlayerDict.load_player_obj(handler_input)
difficulty = SlotUtils.get_resolved_value(handler_input, 'difficulty')
if not difficulty:
ms_welcome = SC_WelcomeUtils.get_ms_welcome(player_obj)
q_difficulty, reprompt = (
SC_Difficulty.get_q_sc_difficulty(player_obj)
for _ in range(2))
speech_list += Pauser.make_ms_pause_level_list(
ms_welcome, 2, q_difficulty)
elif difficulty:
SC_Attr.set_sc_diff(handler_input, difficulty)
ms_confirmation = ConfirmUtils.get_confirmation(True)
ms_use_difficulty = SC_Difficulty.get_ms_using_difficulty(
difficulty)
SC_Questions.load_sc_questions(handler_input)
ms_start_timer = SC_WelcomeUtils.get_ms_starting_time()
question = SC_Questions.get_question(handler_input,
first_question=True)
reprompt = question
speech_list += Pauser.make_ms_pause_level_list(
ms_confirmation, 0.5, ms_use_difficulty, 2, ms_start_timer,
question)
SC_Attr.save_start_time(handler_input)
speech = ' '.join(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
def handle(self, handler_input):
logger.info("HAN FP_SetTableBoundsHandler")
speech_list = []
lower_bound, upper_bound = FreePlayAttr.get_table_bound_slots(
handler_input)
FreePlayAttr.set_table_bounds(handler_input, lower_bound, upper_bound)
bounds_provided = FreePlayLogic.check_table_bounds_provided(
lower_bound, upper_bound)
if bounds_provided:
confirm = ConfirmUtils.get_random_confirmation(handler_input)
ms_adjusted_table_bounds = FPUpperLowerBounds.get_ms_set_table_bounds(
lower_bound, upper_bound)
prompt = FPPrompts.get_q_fp_setup_prompt(handler_input)
reprompt = FPPrompts.get_q_fp_setup_reprompt(handler_input)
# QuestionAttr.increment_questions_answered(handler_input, increase=False)
## New question, but not counted as answered.
speech_list += Pauser.make_ms_pause_level_list(
confirm, 1, ms_adjusted_table_bounds, 2, prompt)
else:
ms_can_change_bounds = FPUpperLowerBounds.get_ms_can_change_table_bounds(
)
prompt, reprompt = (FPUpperLowerBounds.get_q_change_bounds()
for _ in range(2))
speech_list += Pauser.make_ms_pause_level_list(
ms_can_change_bounds, 2.5, prompt)
ModeStats.translate_mode_stats_to_sesh(handler_input)
speech = ' '.join(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
def return_unknown_slot_response(handler_input) -> object:
"""If cannot find answer slot, returns same response prompt.
NOTE: Can probably just return last response object.
"""
speech_list = []
attr = handler_input.attributes_manager.session_attributes
ms_not_understand = get_linear_nlg(fallback.data.MMT_NOT_UNDERSTAND)
if attr.get('mode', None) == 'free_play':
prompt, reprompt = (GenQuestions.get_same_question(handler_input)
for _ in range(2))
else:
prompt, reprompt = (LastPrompt.get_last_prompt(handler_input)
for _ in range(2))
speech_list += Pauser.make_ms_pause_level_list(ms_not_understand, 2,
prompt)
speech = ' '.join(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
def handle(self, handler_input):
logger.info("HAN FP_StartHandler")
attr = handler_input.attributes_manager.session_attributes
speech_list = []
## Set attr & get slots
FreePlayAttr.set_attr_free_play(handler_input)
## Get table_input to start game.
lower_table, upper_table, tables_query = (
FreePlayAttr.get_times_table_input_slots(handler_input))
FreePlayAttr.set_attr_times_tables(handler_input, lower_table,
upper_table, tables_query)
## Logic check
retry_query = attr.get('inform_query_tables_format', False)
tables_provided = FreePlayLogic.check_tables_provided(
lower_table, upper_table, tables_query)
tables_exist = FreePlayLogic.check_tables_exist(handler_input)
log_all(retry_query, tables_exist)
## Confirmation
if tables_provided or tables_exist:
if retry_query:
ms_potential_mistake = FPTimesTables.get_ms_potential_mistake_parsing_query(
)
speech_list += Pauser.make_ms_pause_level_list(
ms_potential_mistake, 2)
else:
ms_confirm = ConfirmUtils.get_confirmation(punct=True)
speech_list += Pauser.make_ms_pause_level_list(ms_confirm, 1)
if tables_provided:
ms_using_tables = (
FPTimesTables.get_ms_using_tables_from_input(
lower_table, upper_table, tables_query))
elif tables_exist:
ms_using_tables = None # Create method to use existing tables.
speech_list += Pauser.make_ms_pause_level_list(ms_using_tables, 2)
if retry_query:
ms_retry_query = FPTimesTables.get_ms_can_retry_query_format()
speech_list += Pauser.make_ms_pause_level_list(
ms_retry_query, 3.5)
FreePlayAttr.reset_attr_query_format(handler_input)
ms_first_problem = FPQuestions.get_question(handler_input,
first_question=True)
speech_list.append(ms_first_problem)
reprompt = FPQuestions.get_rephrased_question(handler_input)
if not tables_provided:
ms_welcome = FPSpeech.get_ms_welcome(handler_input)
q_times_tables, reprompt = (
FPTimesTables.get_q_times_tables_input() for _ in range(2))
q_times_tables = CardFuncs.format_prompt(q_times_tables)
speech_list += Pauser.make_ms_pause_level_list(
ms_welcome, 1.5, q_times_tables)
ModeStats.translate_mode_stats_to_sesh(handler_input)
speech = ' '.join(speech_list)
card_title, card_text = CardFuncs.get_card_info(handler_input, speech)
return (handler_input.response_builder.speak(speech).ask(
reprompt).set_card(SimpleCard(card_title, card_text)).response)
