def handle(self, handler_input): # type: (HandlerInput) -> Response curr_req = handler_input.request_envelope.request # delegate directive for reorder intent reorder_intent = Intent( name="ReorderMedicinesIntent", slots={}, confirmation_status=IntentConfirmationStatus.NONE) reorder_intent_directive = DelegateDirective(reorder_intent) # delegate intent for stop intent stop_intent = Intent(name="AMAZON.StopIntent", slots={}, confirmation_status=IntentConfirmationStatus.NONE) stop_intent_directive = DelegateDirective(stop_intent) # delegate directive intent for current intent current_intent = Intent( name=curr_req.intent.name, slots=curr_req.intent.slots, confirmation_status=curr_req.intent.confirmation_status) confirm_intent_directive = DelegateDirective(current_intent) med_data = Utils.get_remaining_stock() speech, reorder_meds = data.get_remaining_stock_intent_response( med_data) # add reorder meds to session attributes to enable access from reorder intent handler handler_input.attributes_manager.session_attributes[ 'reorder_meds'] = reorder_meds # if user has allowed the intent to reorder medicines, then set dialog_state in the request to completed # to allow the dialog model to end if curr_req.intent.confirmation_status == IntentConfirmationStatus.CONFIRMED: handler_input.request_envelope.request.dialog_state = 'COMPLETED' # got to AMAZON.StopIntent when the user denies intent confirmation and stop the dialog model if curr_req.intent.confirmation_status == IntentConfirmationStatus.DENIED: return (handler_input.response_builder.speak("Okay").add_directive( stop_intent_directive).response) if handler_input.request_envelope.request.dialog_state != "COMPLETED": return (handler_input.response_builder.add_directive( confirm_intent_directive).speak(speech).response) else: return (handler_input.response_builder.speak(speech).add_directive( reorder_intent_directive).response)
def setUp(self): self.test_locale = "foo_locale" self.test_request_type = "LaunchRequest" self.test_dialog_state = DialogState.COMPLETED self.test_intent_name = "foo_intent" self.test_slot_name = "foo_slot" self.test_slot_value = "foo_slot_value" self.test_slot = Slot(name=self.test_slot_name, value=self.test_slot_value) self.test_api_access_token = "foo_api_access_token" self.test_access_token = "foo_account_linking_access_token" self.test_device_id = "foo_device_id" self.test_supported_interfaces = SupportedInterfaces( display=DisplayInterface(template_version="test_template", markup_version="test_markup")) self.test_new_session = False self.test_launch_request = LaunchRequest(locale=self.test_locale) self.test_intent_request = IntentRequest( dialog_state=self.test_dialog_state, intent=Intent(name=self.test_intent_name, slots={ self.test_slot_name: Slot(name=self.test_slot_name, value=self.test_slot_value) })) self.test_request_envelope = RequestEnvelope( session=Session(new=self.test_new_session), context=Context( system=SystemState(user=User( access_token=self.test_access_token), api_access_token=self.test_api_access_token, device=Device(device_id=self.test_device_id, supported_interfaces=self. test_supported_interfaces))))
def handle(self, handler_input): sess_attrs = handler_input.attributes_manager.session_attributes intent_to_explore = sess_attrs.get("explore_intent", "") i18n = get_i18n(handler_input) if intent_to_explore == ExploreIntents.EXPLORE_SETUP_INTENT: slots = {"code": Slot(name="code")} intent = Intent(name='SetupIntent', slots=slots) handler_input.response_builder.add_directive(DelegateDirective(updated_intent=intent)) return handler_input.response_builder.response if intent_to_explore == ExploreIntents.EXPLORE_MESSAGE_INTENT: intent = Intent(name='MessageIntent') handler_input.response_builder.add_directive(DelegateDirective(updated_intent=intent)) return handler_input.response_builder.response return handler_input.response_builder.speak(i18n.SUGGEST_WHAT_TO_DO).ask(i18n.FALLBACK).response
def build_request(self): """ Builds the request Returns: (IntentRequest) the build IntentRequest """ return IntentRequest(request_id=self.request_id, timestamp=datetime.datetime.now(), locale=self.skill_settings.locale, intent=Intent(self.intent_name, self.slots, IntentConfirmationStatus.NONE))
def handle(self, handler_input): i18n = Constants.i18n telethon_service = TelethonService() sess_attrs = handler_input.attributes_manager.session_attributes user_is_authorized = sess_attrs.get("ACCOUNT").get("AUTHORIZED") account = sess_attrs.get("ACCOUNT") slots = handler_input.request_envelope.request.intent.slots reprompt = None if user_is_authorized: speech_text = i18n.ALREADY_AUTHORIZED handler_input.response_builder.speak(speech_text) \ .set_should_end_session(False).ask(i18n.FALLBACK) return handler_input.response_builder.response if not account.get("PHONE_NUMBER"): speech_text = i18n.NO_PHONE should_end = True elif not slots.get("code").value: try: phone_code_hash = telethon_service.send_code_request() except TelethonException as error: return handle_telethon_error_response( error, handler_input).response_builder.response sess_attrs["PHONE_CODE_HASH"] = phone_code_hash updated_intent = Intent("AuthorizationIntent", slots) elicit_directive = ElicitSlotDirective(updated_intent, "code") handler_input.response_builder.add_directive(elicit_directive) speech_text = i18n.WHAT_IS_CODE reprompt = i18n.WHAT_IS_CODE_REPROMPT should_end = False else: phone_code_hash = sess_attrs.get("PHONE_CODE_HASH") try: ok = telethon_service.sign_user_in( slots.get("code").value, phone_code_hash) except TelethonException as error: return handle_telethon_error_response( error, handler_input).response_builder.response if ok: sess_attrs["ACCOUNT"]["AUTHORIZED"] = True speech_text = i18n.AUTHORIZED reprompt = i18n.FALLBACK should_end = False else: speech_text = i18n.WRONG_CODE should_end = True handler_input.response_builder.speak(speech_text) \ .set_should_end_session(should_end) if reprompt: handler_input.response_builder.ask(reprompt) return handler_input.response_builder.response
def test_is_intent_name_not_match(): test_intent_name = "TestIntent" test_handler_input = HandlerInput(request_envelope=RequestEnvelope( request=IntentRequest(intent=Intent(name=test_intent_name)))) intent_name_wrapper = is_intent_name("TestIntent1") assert not intent_name_wrapper( test_handler_input), "is_intent_name matcher matched with the " \ "incorrect intent name"
def test_is_intent_name_match(): test_intent_name = "TestIntent" test_handler_input = HandlerInput(request_envelope=RequestEnvelope( request=IntentRequest(intent=Intent(name=test_intent_name)))) intent_name_wrapper = is_intent_name(test_intent_name) assert intent_name_wrapper( test_handler_input), "is_intent_name matcher didn't match with the " \ "correct intent name"
def test_is_intent_not_match_canfulfill_intent(): test_intent_name = "TestIntent" test_handler_input = HandlerInput( request_envelope=RequestEnvelope(request=IntentRequest( intent=Intent(name=test_intent_name)))) canfulfill_intent_name_wrapper = is_canfulfill_intent_name(test_intent_name) assert not canfulfill_intent_name_wrapper( test_handler_input), "is_canfulfill_intent_name matcher matched with the " \ "incorrect request type"
def create_handler_input(slots: Dict[str, Slot], attributes: Dict) -> HandlerInput: request_envelope = RequestEnvelope(version="v1", session=Session(attributes=attributes), request=IntentRequest( request_id=str(uuid4()), intent=Intent(name="test intent", slots=slots))) attributes_manager = AttributesManager(request_envelope=request_envelope) handler_input = HandlerInput(request_envelope=request_envelope, attributes_manager=attributes_manager) return handler_input
def bet_handler(handler_input): # handles that a bet has been set and remembers amount request_id_holder = handler_input.request_envelope.request.request_id directive_header = Header(request_id=request_id_holder) slots = handler_input.request_envelope.request.intent.slots bet = slots["amount"].value gm.player_chips.bet = int(bet) if not game_functions.can_bet(gm.player_chips.bet, gm.player_chips): output = f"""Sorry but you do not have enough for that bet. You have a total of {gm.player_chips.total}, how much would you like to bet?""" # speech = SpeakDirective(speech=output) # directive_request = SendDirectiveRequest( # header=directive_header, directive=speech # ) # directive_service_client = ( # handler_input.service_client_factory.get_directive_service() # ) # directive_service_client.enqueue(directive_request) return (handler_input.response_builder.speak(output).add_directive( ElicitSlotDirective( slot_to_elicit="amount", updated_intent=Intent( name="Betting", confirmation_status=IntentConfirmationStatus.NONE, slots={ "amount": Slot( name="amount", confirmation_status=SlotConfirmationStatus.NONE, ) }, ), )).response) p_hand = gm.player_hand.hand_held() a_hand = gm.alexa_hand.holding() print("alexa: ", gm.alexa_hand.holding()) print("player: ", gm.player_hand.holding()) print("chips : ", gm.player_chips.total, "bet :", gm.player_chips.bet) output = f"""Okay you bet {bet}. You have {p_hand}. I have a {a_hand[1][1]} of {a_hand[1][0]} showing. What you like to Hit or Stand?""" return (handler_input.response_builder.speak( output).set_should_end_session(False).response)
def ready_game_handler(handler_input): # handles the start of the game setting up how many rounds # current_intent gets details about returned intent for checking use .name, .slots etc current_intent = handler_input.request_envelope.request.intent game_session_attr = handler_input.attributes_manager.session_attributes logger.info("In ReadyGameHandler") if ( current_intent.slots["game_length"].name in required_slots and current_intent.slots["game_length"].value not in rounds_allowed ): return ( handler_input.response_builder.speak( "ok how big a deck of cards should I use? " "Five is a short game, Fifteen is X minutes, Twenty-Five " "is the about XX minutes but gives the most accurate score " ) .ask("five ten or fifteen") .add_directive( ElicitSlotDirective( slot_to_elicit="game_length", updated_intent=Intent( name="ReadyGame", confirmation_status=IntentConfirmationStatus.NONE, slots={ "game_length": Slot( name="game_length", confirmation_status=SlotConfirmationStatus.NONE, ) }, ), ) ) .response ) # game_session_attr['DECK_SIZE'] = current_intent.slots["game_length"].value # game_session_attr['GAME_RUNNING'] = 1 return handler_input.response_builder.add_directive( DelegateDirective(updated_intent=current_intent) ).response
def create_intent_request(round_index: int, user_utterance: str) -> IntentRequest: """Creates an intent request.""" intent_request = IntentRequest( request_id='{}.{}'.format(REQUEST_ID_BASE, round_index), timestamp=datetime.datetime.utcnow(), locale='en-US', dialog_state=None, intent=Intent( name='ConverseIntent', slots=dict(Text=Slot( name='Text', value=user_utterance, confirmation_status=SlotConfirmationStatus.NONE, resolutions=Resolutions(resolutions_per_authority=[ Resolution( authority='{}.TEXT'.format(RESOLUTION_AUTHORITY_BASE), status=Status(code=StatusCode.ER_SUCCESS_NO_MATCH)) ]))), confirmation_status=IntentConfirmationStatus.NONE)) return intent_request
def handle(self, handler_input): self.telethon_service = TelethonService() sess_attrs = handler_input.attributes_manager.session_attributes i18n = Constants.i18n slots = handler_input.request_envelope.request.intent.slots if not sess_attrs.get("ENTITY_IDS"): speech_text = i18n.NO_TELETHON_ID return handler_input.response_builder.speak(speech_text) \ .set_should_end_session(False).ask(i18n.FALLBACK).response if slots.get("message").value: if sess_attrs.get("TELEGRAMS_COUNTER") is None: # User is replying on last unread dialog index = len(sess_attrs.get("CONTACTS")) - 1 else: # User is replying to some other dialog index = sess_attrs.get("TELEGRAMS_COUNTER") - 1 contact = sess_attrs.get("CONTACTS")[index] entity_id = sess_attrs.get("ENTITY_IDS")[index] self.telethon_service \ .send_telegram(entity_id, slots.get("message").value) next_telegram = MessageIntentHandler().get_telegram(handler_input) speech_text = i18n.TELEGRAM_SENT.format(contact) + next_telegram reprompt = i18n.FALLBACK else: speech_text = i18n.get_random_acceptance_ack( ) + ", " + i18n.MESSAGE_2 reprompt = i18n.get_random_dont_understand( ) + ", " + i18n.MESSAGE_2 updated_intent = Intent("ReplyIntent", slots) elicit_directive = ElicitSlotDirective(updated_intent, "message") handler_input.response_builder.add_directive(elicit_directive) handler_input.response_builder.speak(speech_text) \ .set_should_end_session(False).ask(reprompt) return handler_input.response_builder.response
def handle(self, handler_input): # type: (HandlerInput) -> Response logger.info("In HelpIntentHandler") # Create a GravityIntent object so we can get back to the GravityIntentHandler gravIntent = Intent(name="GravityIntent") # extract our saved values from the S3 repository savedAttrs = handler_input.attributes_manager.persistent_attributes logger.info(f"In HelpIntentHandler: savedAttrs is {savedAttrs}. ") # Get any slot values from the user slots = handler_input.request_envelope.request.intent.slots logger.info(f"In HelpIntentHandler: slots={slots} ") handler_input.response_builder.speak(data.HELP_MESSAGE).ask( data.HELP_MESSAGE).set_card( SimpleCard(data.SKILL_TITLE, data.CARD_HELP)) handler_input.response_builder.add_directive( DelegateDirective(updated_intent=gravIntent)) return handler_input.response_builder.response
def handle(self, handler_input): sess_attrs = handler_input.attributes_manager.session_attributes slots = handler_input.request_envelope.request.intent.slots updated_intent = Intent("SpeedIntent", slots) i18n = Constants.i18n for slot_name in slots: slot = slots[slot_name] if slot_name == "speed_dial_number" and slots.get( "message").value is None: if slot.value is None: slot_to_elicit = "speed_dial_number" speech_text = i18n.SPEED_DIAL reprompt = i18n.SPEED_DIAL_REPROMPT else: num = int(slot.value) try: speech_text, reprompt, slot_to_elicit = handle_speed_dial_number_input( num, sess_attrs, i18n) except SpeedDialException as error: return handler_input.response_builder \ .speak(error.args[0]).set_should_end_session(True).response directive = ElicitSlotDirective(updated_intent, slot_to_elicit) handler_input.response_builder.add_directive(directive) if slot.name == "message" and slot.value: try: m = slot.value speech_text, reprompt = send_telegram(m, sess_attrs, i18n) except TelethonException as error: return handle_telethon_error_response(error, handler_input) handler_input.response_builder.speak(speech_text) \ .set_should_end_session(False).ask(reprompt) return handler_input.response_builder.response
def handle(self, handler_input): """Handle the intent; fetch and serve appropriate response. If a mass is taking place today, does not end the current session. issues a ElicitSlotDirective to continue the dialog, asking the user if they would like a reminder. If no mass, then ends the current session. Args: handler_input (ask_sdk_core.handler_input.HandlerInput): Input from Alexa. Returns: ask_sdk_model.response.Response: Response for this intent and device. """ LOGGER.info("In NextMassHandler") userSession = session.KilianUserSession(handler_input) # Get response: envelope = handler_input.request_envelope speech, reprompt, cardTitle, cardText, cardImage, displayText = \ events.MassResponse(userSession).getNextMassResponse() # If mass, prompt for a reminder; if not, return response. nextMass = events.MassResponse(userSession).getNextMass() if nextMass: msg = "Found a 'next mass' for today, constructing reminder request" LOGGER.debug(msg) speech += (". Would you like me to remind you " "30 minutes prior to mass?") handler_input.response_builder.speak(speech).ask( reprompt).set_card( StandardCard( title=cardTitle, text=cardText, image=cardImage)).set_should_end_session(False) #currentIntent = envelope.request.intent msg = "Reprompt message constructed. Now constructing nextIntent" LOGGER.debug(msg) nextIntent = Intent( name="NotifyNextMassIntent", confirmation_status=IntentConfirmationStatus.NONE, slots={ "DESIRES_REMINDER": Slot(name="DESIRES_REMINDER", confirmation_status=SlotConfirmationStatus.NONE) }) #handler_input.response_builder.add_directive( # DelegateDirective(updated_intent=nextIntent) #) msg = "nextMass constructed, now adding ElicitSlotDirective" LOGGER.debug(msg) handler_input.response_builder.add_directive( ElicitSlotDirective(slot_to_elicit="DESIRES_REMINDER", updated_intent=nextIntent)) msg = "Asking user if they want a reminder, and queuing follow-up intent." LOGGER.info(msg) msg = "Response looks like: \n{}".format( handler_input.response_builder.response) LOGGER.debug(msg) return handler_input.response_builder.response LOGGER.debug("No 'next mass' found for today. No reminder.") # No next mass, so ... no reminder needed: handler_input.response_builder.speak(speech).set_card( StandardCard(title=cardTitle, text=cardText, image=cardImage)) # Display Directive for display devices (Echo Show, etc): directiveBuilder = display.Directive( mainUrl= "https://st-killian-resources.s3.amazonaws.com/displayTemplateMedia/massGifts_340.jpg", # pylint: disable=C0301 backgroundUrl= "https://st-killian-resources.s3.amazonaws.com/displayTemplateMedia/dispBG_512.jpg", # pylint: disable=C0301 title=cardTitle, text=displayText) displayDirective = directiveBuilder.getDirective() # Check for displayDirective support: envelope = handler_input.request_envelope supported = envelope.context.system.device.supported_interfaces.to_dict( ) if supported.get('display'): LOGGER.info( "display interface supported, adding display directive.") handler_input.response_builder.add_directive(displayDirective) else: LOGGER.info( "display interface not supported, withholding directive.") handler_input.response_builder.set_should_end_session(True) return handler_input.response_builder.response
def handle(self, handler_input): """Handler for Processing a saved calibration value""" # save our current Intent so we can get back here if we have to calIntent = handler_input.request_envelope.request.intent logger.info(f"In CalibrateIntentHandler: calIntent is {calIntent}. ") # Create a GravityIntent object so we can get back to the GravityIntentHandler gravIntent = Intent(name="GravityIntent") # extract our saved values from the S3 repository savedAttrs = handler_input.attributes_manager.persistent_attributes logger.info(f"In CalibrateIntentHandler: savedAttrs is {savedAttrs}.") defaultAsked = savedAttrs.get('defaultAsked', False) # Get any slot values from the user slots = handler_input.request_envelope.request.intent.slots logger.info(f"In CalibrateIntentHandler: slots={slots}") # if we have a slot, get its value if slots: calTemp = slots["caliDefault"].value else: calTemp = None # if we already asked the user, then the reply is in the caliDefault slot # it could be a number, or something else if defaultAsked: # See if it is a number try: calTempFloat = float(calTemp) # Yes, we have a number. Return it to GravityIntent as the new calibration temperature savedAttrs[ 'calibration'] = calTemp # return the new calibration in GravityIntent's slot gravSlots = {} for name, value in savedAttrs.items(): gravSlot = Slot(name=name, value=value) if name == "gravity" or name == "temperature" or name == "calibration": gravSlots[gravSlot.name] = { 'confirmation_status': gravSlot.confirmation_status, 'name': gravSlot.name, 'resolutions': gravSlot.resolutions, 'value': gravSlot.value } gravIntent.slots = gravSlots logger.info( f"In CalibrateIntentHandler: Returning new calibration to {gravIntent}. " ) handler_input.response_builder.add_directive( DelegateDirective(updated_intent=gravIntent)) return handler_input.response_builder.response except: # This intent's slot was not a number. If it is some form of agreement, pass the save calibration back to GravityIntent calResolutions = slots["caliDefault"].resolutions userResponse = calResolutions.resolutions_per_authority[ 0].status.code # Did the user say something we recognize as an affirmative? if userResponse == StatusCode.ER_SUCCESS_MATCH: gravSlots = {} for name, value in savedAttrs.items(): gravSlot = Slot(name=name, value=value) if name == "gravity" or name == "temperature" or name == "calibration": gravSlots[gravSlot.name] = { 'confirmation_status': gravSlot.confirmation_status, 'name': gravSlot.name, 'resolutions': gravSlot.resolutions, 'value': gravSlot.value } gravIntent.slots = gravSlots logger.info( f"In CalibrateIntentHandler: Using default calibration to {gravIntent}." ) handler_input.response_builder.add_directive( DelegateDirective(updated_intent=gravIntent)) return handler_input.response_builder.response else: # Otherwise, try to get something we understand speech = f"Sorry, you said {calTemp}. Please reply with a new calibration temperature or reply 'yes' to use the default." reprompt = "Please say 'yes' or reply with a new calibration temperature." handler_input.response_builder.speak(speech).ask( reprompt).set_should_end_session(False).set_card( SimpleCard(data.SKILL_TITLE, reprompt)) handler_input.response_builder.add_directive( ElicitSlotDirective(slot_to_elicit="caliDefault", updated_intent=calIntent)) return handler_input.response_builder.response # At this point, we haven't ask the user anything # Set the "asked" flag savedAttrs['defaultAsked'] = True handler_input.attributes_manager.persistent_attributes = savedAttrs handler_input.attributes_manager.save_persistent_attributes() # Ask the user to confirm the default or provide a new calibration temperature speech = f"You have a default calibration temperature of {calTemp}. Do you want to use the default?" reprompt = "Please say 'yes' or reply with a new calibration temperature." handler_input.response_builder.speak(speech).ask( reprompt).set_should_end_session(False).set_card( SimpleCard(data.SKILL_TITLE, reprompt)) handler_input.response_builder.add_directive( ElicitSlotDirective(slot_to_elicit="caliDefault", updated_intent=calIntent)) return handler_input.response_builder.response
def handle(self, handler_input): """Handler for Processing the gravity correction""" # Create an Intent object for GravityIntent gravIntent = handler_input.request_envelope.request.intent logger.info(f"In GravityIntentHandler: gravIntent is {gravIntent}. ") # Obtain the request object request = handler_input.request_envelope.request # Get any slot values from the user slots = handler_input.request_envelope.request.intent.slots logger.info(f"In GravityIntentHandler: slots={slots}") # extract slot values gravity = slots["gravity"].value temp = slots["temperature"].value calTemp = slots["calibration"].value logger.info( f"In GravityIntentHandler: gravity is {gravity} and temp {temp}") # extract any saved values from the S3 repository savedAttrs = handler_input.attributes_manager.persistent_attributes defaultAsked = savedAttrs.get('defaultAsked', False) # In an effort to vary the user experience, keep track of the number of times we have asked for a slot # so that we can escalate our responses gravityAsked = savedAttrs.get('gravityAsked', 0) tempAsked = savedAttrs.get('tempAsked', 0) caliAsked = savedAttrs.get('caliAsked', 0) logger.info( f"In GravityIntentHandler: gravityAsked is {gravityAsked}, tempAsked {tempAsked}, and caliAsked {caliAsked}" ) # See if we have a default calibration temperature savedCalibration = savedAttrs.get('calibration', 0) if savedCalibration == 0: calDefault = False else: calDefault = True try: gravityFloat = float(gravity) except: gravityAsked += 1 speech = data.GRAVITY_MESSAGES[gravityAsked].format(gravity) reprompt = "What was the gravity measure again? " if gravityAsked >= 3: gravityAsked = 0 savedAttrs['gravityAsked'] = gravityAsked handler_input.attributes_manager.persistent_attributes = savedAttrs handler_input.attributes_manager.save_persistent_attributes() handler_input.response_builder.speak(speech).ask(reprompt) handler_input.response_builder.add_directive( ElicitSlotDirective(slot_to_elicit="gravity", updated_intent=gravIntent)) handler_input.response_builder.set_should_end_session(False) return handler_input.response_builder.response try: tempFloat = float(temp) except: tempAsked += 1 if tempAsked < 3: speech = data.TEMPERATURE_MESSAGES[tempAsked].format( util.saySpecificGravity(gravity)) else: speech = data.TEMPERATURE_MESSAGES[tempAsked].format(temp) reprompt = "at what temperature was your gravity measurement taken?" if tempAsked >= 3: tempAsked = 0 savedAttrs['tempAsked'] = tempAsked handler_input.attributes_manager.persistent_attributes = savedAttrs handler_input.attributes_manager.save_persistent_attributes() handler_input.response_builder.speak(speech).ask( reprompt).set_should_end_session(False) handler_input.response_builder.add_directive( ElicitSlotDirective(slot_to_elicit="temperature", updated_intent=gravIntent)) return handler_input.response_builder.response # Try to use a specified calibration temperature. # if there is none, try to use a saved calibration temperature. # if that fails, ask the user for a calibration temperature logger.info( f"in GravityIntentHandler: calTemp is {calTemp} and calDefault is {calDefault}" ) # If we have not yet asked about the calibration temperature, delegate control to the Calibrate Intent if not defaultAsked and calDefault: # Save the responses we have to the S3 repository, so the Calibration Intent can return them back to us savedAttrs['gravity'] = gravity savedAttrs['temperature'] = temp savedAttrs['defaultAsked'] = False handler_input.attributes_manager.persistent_attributes = savedAttrs handler_input.attributes_manager.save_persistent_attributes() # build an Intent object for CalibrateIntent calIntent = Intent(name="CalibrateIntent") calSlots = {} calSlot = Slot(name="caliDefault", value=savedCalibration) calSlots[calSlot.name] = { 'confirmation_status': calSlot.confirmation_status, 'name': calSlot.name, 'resolutions': calSlot.resolutions, 'value': calSlot.value } calIntent.slots = calSlots # Delegate CalibrateIntent logger.info( f"in GravityIntentHandler: about to delegate CalibrateIntent. Intent is {calIntent} " ) handler_input.response_builder.add_directive( DelegateDirective(updated_intent=calIntent)) return handler_input.response_builder.response # end of "if not defaultAsked:" try: calTempFloat = float(calTemp) except: caliAsked += 1 speech = data.CALIBRATE_MESSAGES[caliAsked].format( util.saySpecificGravity(gravity), temp) reprompt = "You can say something like, '60'" if caliAsked >= 3: caliAsked = 0 savedAttrs['caliAsked'] = caliAsked handler_input.attributes_manager.persistent_attributes = savedAttrs handler_input.attributes_manager.save_persistent_attributes() handler_input.response_builder.speak(speech).ask( reprompt).set_should_end_session(False) handler_input.response_builder.add_directive( ElicitSlotDirective(slot_to_elicit="calibration", updated_intent=gravIntent)) return handler_input.response_builder.response if util.validateSG(gravityFloat) == 0: speech = data.GRAVITY_MESSAGES[3].format(gravity) reprompt = "Please enter a valid specific gravity. " handler_input.response_builder.speak(speech).ask( reprompt).set_should_end_session(False) handler_input.response_builder.add_directive( ElicitSlotDirective(slot_to_elicit="gravity", updated_intent=gravIntent)) return handler_input.response_builder.response tempFloat = util.validateTemp(tempFloat) calTempFloat = util.validateTemp(calTempFloat) if tempFloat == 0: speech = data.TEMPERATURE_MESSAGES[3].format(temp) reprompt = "Please enter a valid temperature. " handler_input.response_builder.speak(speech).ask( reprompt).set_should_end_session(False) handler_input.response_builder.add_directive( ElicitSlotDirective(slot_to_elicit="temperature", updated_intent=gravIntent)) return handler_input.response_builder.response if calTempFloat == 0: speech = data.CALIBRATE_MESSAGES[3].format(calTemp) reprompt = "Please enter a valid calibration temperature. " handler_input.response_builder.speak(speech).ask( reprompt).set_should_end_session(False) handler_input.response_builder.add_directive( ElicitSlotDirective(slot_to_elicit="calibration", updated_intent=gravIntent)) return handler_input.response_builder.response # We have all the validated values, save them in the S3 repository savedAttrs['gravity'] = gravity savedAttrs['temperature'] = temp savedAttrs['calibration'] = calTemp savedAttrs['defaultAsked'] = False savedAttrs['gravityAsked'] = 0 savedAttrs['tempAsked'] = 0 savedAttrs['caliAsked'] = 0 handler_input.attributes_manager.persistent_attributes = savedAttrs handler_input.attributes_manager.save_persistent_attributes() logger.info("In GravityIntentHandler: Saved response in S3 repository") # Calculate the corrected gravity numeratorValue = 1.00130346 - (0.000134722124 * tempFloat) + ( 0.00000204052596 * tempFloat**2) - (0.00000000232820948 * tempFloat**3) denominatorValue = 1.00130346 - (0.000134722124 * calTempFloat) + ( 0.00000204052596 * calTempFloat**2) - (0.00000000232820948 * calTempFloat**3) corrGravity = gravityFloat * (numeratorValue / denominatorValue) logger.info( f"In GravityIntentHandler: corrected gravity is {corrGravity}. ") speech = f"your corrected gravity is {util.saySpecificGravity(round(corrGravity))}. " speech += data.EXIT_SKILL_MESSAGE cardText = f"your corrected gravity is {int(round(corrGravity))*0.001}." handler_input.response_builder.speak(speech).set_should_end_session( True).set_card(SimpleCard(data.SKILL_TITLE, cardText)) return handler_input.response_builder.response
from ask_sdk_model import ui, Response, DialogState from ask_sdk_model.ui import SimpleCard from ask_sdk_model.dialog import ElicitSlotDirective, DelegateDirective from ask_sdk_model import (Intent, IntentConfirmationStatus, Slot, SlotConfirmationStatus) from ask_sdk_model.slu.entityresolution.resolution import Resolution from ask_sdk_model.slu.entityresolution import StatusCode from alexa import data, util sb = CustomSkillBuilder(persistence_adapter=s3_adapter) # Set the skill id so not just anyone can invoke this function sb.skill_id = "amzn1.ask.skill.92878a4c-6715-4eed-9b71-7805480315a0" gravIntent = Intent() calIntent = Intent(name="CalibrateIntent") logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) class LaunchRequestHandler(AbstractRequestHandler): """Determine if this is a Launch Request.""" def can_handle(self, handler_input): # type: (HandlerInput) -> bool # Indicate can handle Launch requests logger.info( f"In LaunchRequestHandler.can_handle request is {handler_input.request_envelope.request} " ) return is_request_type("LaunchRequest")(handler_input)
def handle(self, handler_input): intent = Intent(name="AMAZON.StopIntent") handler_input.response_builder.add_directive(DelegateDirective(updated_intent=intent)) return handler_input.response_builder.response
def handle(self, handler_input): try: check_for_account(handler_input) except AccountException as error: return handler_input.response_builder \ .speak(error.args[0]).set_should_end_session(True).response slots = handler_input.request_envelope.request.intent.slots updated_intent = Intent("SendIntent", slots) sess_attrs = handler_input.attributes_manager.session_attributes locale = handler_input.request_envelope.request.locale i18n = Constants.i18n for slot_name in slots: slot = slots[slot_name] if slot_name == "first_name" and slots["message"].value is None: if slot.value is None: slot_to_elicit = "first_name" speech_text = i18n.FIRST_NAME reprompt = i18n.FIRST_NAME_REPROMPT else: if not sess_attrs.get("FIRST_NAMES"): if locale == 'de-DE': # On German Alexa we get "vier" if user says a speed dial number # On English Alexa we get "4"... --> need that also for German slot.value = parse_spoken_numbers_to_integers(slot.value) is_speed_dial = slot.value.isdigit() if is_speed_dial: try: num = int(slot.value) speech_text, reprompt, slot_to_elicit = \ handle_speed_dial_number_input( num, sess_attrs, i18n) except SpeedDialException as error: return handler_input.response_builder \ .speak(error.args[0]).set_should_end_session(True).response else: speech_text, reprompt, slot_to_elicit = self \ .handle_first_name_input(slot.value, sess_attrs, i18n) else: one_two_or_three = slots.get("one_two_or_three") if one_two_or_three.value not in ["1", "2", "3"]: speech_text = i18n.MAX_NO_CONTACT handler_input.response_builder\ .speak(speech_text).set_should_end_session(True) return handler_input.response_builder.response speech_text, reprompt = self \ .get_users_choice(one_two_or_three, i18n, sess_attrs) slot_to_elicit = "message" directive = ElicitSlotDirective(updated_intent, slot_to_elicit) handler_input.response_builder.add_directive(directive) if slot.name == "message" and slot.value: try: m = slot.value speech_text, reprompt = send_telegram(m, sess_attrs, i18n) except TelethonException as error: return handle_telethon_error_response(error, handler_input) handler_input.response_builder.speak(speech_text) \ .set_should_end_session(False).ask(reprompt) return handler_input.response_builder.response