def intent_task_specified(self, intent):

        # check to see if we parsed a value
        content_present = intent['slots']['TASK'].get('resolutions')
        task = None
        if content_present:
            resolution = intent['slots']['TASK']['resolutions'][
                'resolutionsPerAuthority'][0]
            # if we have a task match
            if resolution.get('values'):
                values = resolution['values'][0]
                task = values['value']['id']

        # caught an incorrect value
        if task == None:

            self.session_attributes = self.session_attributes

            card_title = "Invalid Task"
            speech_output = "We could not understand your exercise. Could you please repeat?"
            should_end_session = False

            return helper.build_response(
                self.session_attributes,
                helper.build_speechlet_response(card_title, speech_output,
                                                None, should_end_session))

        # Store task preemptively to pass to pg.generate
        self.session_attributes['state']['task'] = task

        card_title = "Task Chosen"
        speech_output = pg.generate(self.session_attributes,
                                    'specifying_a_task')
        reprompt_text = "I'm ready for your input."
        should_end_session = False

        # Assign the next state
        self.session_attributes['state'] = {
            'value': 'attempt_task',
            'task': task,
            'word': self.word,
            'sen': self.sen_complete,
            'dfn': self.def_complete,
            'syn': self.syn_complete
        }
        # Populate prev_state
        self.session_attributes = helper.dump_state(self.session_attributes)

        return helper.build_response(
            self.session_attributes,
            helper.build_speechlet_response(card_title, speech_output,
                                            reprompt_text, should_end_session))
 def intent_task_specified(self, intent):
 
     resolution = intent['slots']['TASK']['resolutions']['resolutionsPerAuthority'][0]
     values = resolution['values'][0]
     task = values['value']['id']
     
     # Store task preemptively to pass to pg.generate
     self.session_attributes['state']['task'] = task
 
     card_title         = "Task Chosen"
     speech_output      = pg.generate(self.session_attributes, 'specifying_a_task')
     reprompt_text      = "I'm ready for your input."
     should_end_session = False
     
     # Assign the next state
     self.session_attributes['state'] = {
         'value': 'attempt_task',
         'task' : task,
         'word' : self.word,
         'sen'  : '0',
         'dfn'  : '0',
         'syn'  : '0'
     }
     # Populate prev state
     self.session_attributes = helper.dump_state(self.session_attributes)
     
     return helper.build_response(self.session_attributes, helper.build_speechlet_response(
             card_title, speech_output, reprompt_text, should_end_session))
Esempio n. 3
0
    def intent_try_again(self):
        session_attributes = {}
        card_title = "Agree to Try Again"
        # Introduce the task attempt
        speech_output = pg.generate(self.session_attributes,
                                    'agreeing_to_try_again')
        reprompt_text = "I'm ready for your input."
        should_end_session = False

        # Assign the next state
        self.session_attributes['state'] = {
            'value': 'attempt_task',
            'task': self.task,
            'word': self.word,
            'sen': self.sen_complete,
            'dfn': self.def_complete,
            'syn': self.syn_complete
        }
        # Populate prev_state
        self.session_attributes = helper.dump_state(self.session_attributes)

        return helper.build_response(
            self.session_attributes,
            helper.build_speechlet_response(card_title, speech_output,
                                            reprompt_text, should_end_session))
Esempio n. 4
0
def basic_light(intent, session):
    slot = intent["slots"]
    my_state = ""
    if "State" in slot and "value" in slot["State"]:
        my_state = slot['State']
    if "pcState" in slot and "value" in slot["pcState"]:
        my_state = slot['pcState']

    my_state = my_state["value"]
    print(my_state)

    if my_state == "on" or my_state == "off":
        speech_output = "Light is now " + my_state
        reprompt_text = "Light is now " + my_state
        publish(my_state)
    elif my_state == "sleep" or my_state == "wake up":
        speech_output = "The pc is now " + my_state
        reprompt_text = "The pc is now " + my_state
        publish(my_state)
    else:
        speech_output = "Please try again."
        reprompt_text = "Please try again."
    return helper.build_response({},
                                 helper.build_speechlet_response(
                                     intent['name'], speech_output,
                                     reprompt_text, True))
    def intent_word_skipped(self, intent):

        #Get User data
        words = db.getUserData(self.userId)
        # Get a new word from the database
        word = db.get_random_word(self.userId)
        #update user info
        #db.addUserData(self.userId, word)

        # Assign that word to the state before passing to speech_output
        self.session_attributes['state']['word'] = word

        card_title = "Word Skipped"
        speech_output = pg.generate(self.session_attributes, 'skip_word')
        reprompt_text = "Is this word satisfactory?"
        should_end_session = False

        # Initialize the select word class
        self.session_attributes['state'] = {
            'value': 'select_word',
            'word': word
        }
        # Dump the state to prev_state
        self.session_attributes = helper.dump_state(self.session_attributes)

        return helper.build_response(
            self.session_attributes,
            helper.build_speechlet_response(card_title, speech_output,
                                            reprompt_text, should_end_session))
 def intent_exit(self):
     card_title = "Session Ended"
     speech_output = pg.generate(self.session_attributes, 'stop')
     # Setting this to true ends the session and exits the skill.
     should_end_session = True
     return helper.build_response({},
                                  helper.build_speechlet_response(
                                      card_title, speech_output, None,
                                      should_end_session))
Esempio n. 7
0
def switch_light(intent, session):
    import lambda_function
    speech_output = "Light is switched"
    reprompt_text = "Light is switched"
    publish("switch")
    return helper.build_response({},
                                 helper.build_speechlet_response(
                                     intent['name'], speech_output,
                                     reprompt_text, True))
Esempio n. 8
0
def handle_session_end_request():
    card_title = "Session Ended"
    speech_output = ""
    # Setting this to true ends the session and exits the skill.
    should_end_session = True
    return helper.build_response({},
                                 helper.build_speechlet_response(
                                     card_title, speech_output, None,
                                     should_end_session))
    def intent_help(self):
        card_title = "Help"
        speech_output = pg.generate(self.session_attributes, 'help')
        should_end_session = False

        self.session_attributes = self.session_attributes

        return helper.build_response(
            self.session_attributes,
            helper.build_speechlet_response(card_title, speech_output, None,
                                            should_end_session))
Esempio n. 10
0
    def intent_cancel(self):
        card_title = "Cancel"
        speech_output = "Bringing you back to the previous step"
        should_end_session = False

        # Go back to the last state
        self.session_attributes['state'] = self.session_attributes[
            'prev_state']

        return helper.build_response(
            self.session_attributes,
            helper.build_speechlet_response(card_title, speech_output, None,
                                            should_end_session))
Esempio n. 11
0
def get_welcome_response():
    """ If we wanted to initialize the session to have some attributes we could
    add those here
    """

    session_attributes = {}
    card_title = "Welcome"
    speech_output = "Indicates action."
    reprompt_text = "Indicates action."
    return helper.build_response(
        session_attributes,
        helper.build_speechlet_response(card_title, speech_output,
                                        reprompt_text, False))
    def intent_help(self):

        card_title = "Repeat Tasks"
        speech_output = pg.generate(self.session_attributes,
                                    'what_are_the_tasks')
        should_end_session = False

        # Stay in state
        self.session_attributes = self.session_attributes

        return helper.build_response(
            self.session_attributes,
            helper.build_speechlet_response(card_title, speech_output, None,
                                            should_end_session))
Esempio n. 13
0
    def intent_unhandled(self):

        card_title = "Unhandled Intent"
        speech_output = (
            "We weren't able to understand what you were saying. " +
            "Would you mind saying it another way?")
        reprompt_text = (
            "We still weren't able to understand what you were saying. " +
            "Please say it another way.")
        should_end_session = False
        return helper.build_response(
            self.session_attributes,
            helper.build_speechlet_response(card_title, speech_output,
                                            reprompt_text, should_end_session))
    def intent_help(self):
    
        example = db.get_word_info(self.word)[self.task][0]

        card_title = "Example"
        # Just use the value in the database
        speech_output = pg.generate(self.session_attributes, 'give_an_example_answer', example)
        should_end_session = False

        # Stay in state
        self.session_attributes = self.session_attributes

        return helper.build_response(self.session_attributes, helper.build_speechlet_response(
            card_title, speech_output, None, should_end_session))
 def intent_word_confirmed(self, intent):
     
     card_title         = "Word Confirmed"
     speech_output      = pg.generate(self.session_attributes, 'confirming_word')
     reprompt_text      = "Please select a task."
     should_end_session = False
     
     # Assign the next state
     self.session_attributes['state'] = {
         'value': 'select_task',
         'word' : self.word,
         'sen'  : '0',
         'dfn'  : '0',
         'syn'  : '0'
     }
     # Populate prev_state
     self.session_attributes = helper.dump_state(self.session_attributes)
     
     return helper.build_response(self.session_attributes, helper.build_speechlet_response(
             card_title, speech_output, reprompt_text, should_end_session))
 def intent_unhandled(self):
 
     card_title         = "Try Again"
     speech_output      = pg.generate(self.session_attributes, 'try_again')
     reprompt_text      = "Would you like to try again?"
     should_end_session = False
     
     # Assign the next state            
     self.session_attributes['state'] = {
         'value': 'try_again',
         'task' : self.task,
         'word' : self.word,
         'sen'  : self.sen_complete,
         'dfn'  : self.def_complete,
         'syn'  : self.syn_complete
     }
     # Dump the state to prev_state
     self.session_attributes = helper.dump_state(self.session_attributes)
     
     return helper.build_response(self.session_attributes, helper.build_speechlet_response(
         card_title, speech_output, reprompt_text, should_end_session))
Esempio n. 17
0
    def intent_next_task(self):

        card_title = "Next Task after Fail"
        # Just use the value in the database
        speech_output = pg.generate(self.session_attributes, 'go_to_next_task')
        should_end_session = False

        # Assign the next state
        self.session_attributes['state'] = {
            'value': 'select_task',
            'word': self.word,
            'sen': self.sen_complete,
            'dfn': self.def_complete,
            'syn': self.syn_complete
        }
        # Dump the state to prev_state
        self.session_attributes = helper.dump_state(self.session_attributes)

        return helper.build_response(
            self.session_attributes,
            helper.build_speechlet_response(card_title, speech_output, None,
                                            should_end_session))
    def intent_verify(self, intent):

        # Get the answer from the intent
        answer = intent['slots']['ANSWER']['value']

        # Query the database for the correct answer set
        query = db.get_word_info(self.word)
        # Set the query to the value for this task
        query_task = query[self.task]
        # Set the query_syn to the synonym list of the word
        query_syn = query['syn']
        # Call the verification function with this info
        success = True
        try:
            verifier = Verification(self.word, query_syn, answer, query_task)
            if self.task == 'syn':
                success = verifier.synonym()
            if self.task == 'exa':
                success = verifier.sample()
            if self.task == 'def':
                success = verifier.definition()
        except:
            success = True

        self.session_attributes = self.session_attributes
        card_title = ""
        speech_output = ""
        should_end_session = False
        if (success):

            # Set the task as completed
            if (self.task == "syn"):
                self.syn_complete = '1'
            elif (self.task == "def"):
                self.def_complete = '1'
            else:
                self.sen_complete = '1'

            # Check to see if all tasks are completed
            if (self.sen_complete == '1' and self.def_complete == '1' and self.syn_complete == '1'):
                
                #Get User data
                words = (db.getUserData(self.userId))
                # Get a new word from the database
                self.word = db.get_random_word(self.userId)
                #update user info
                #db.addUserData(self.userId, self.word)
                
                # Update the word for the session attributes
                self.session_attributes['state']['word'] = self.word

                card_title = "Tasks Complete"
                speech_output = pg.generate(self.session_attributes, 'tasks_complete')
                reprompt_text = "Is this word satisfactory?"
                                
                # Initialize the select word class
                self.session_attributes['state'] = {
                    'value': 'select_word',
                    'word' : self.word
                }
                # Dump the state to prev_state
                self.session_attributes = helper.dump_state(self.session_attributes)

            # Move on to the next task for this word
            else:

                card_title = "Next Task"
                speech_output = pg.generate(self.session_attributes, 'next_task')
                reprompt_text = "Please choose a new task for this word."
                                            
                # Assign the next state
                self.session_attributes['state'] = {
                    'value': 'select_task',
                    'word' : self.word,
                    'sen'  : self.sen_complete,
                    'dfn'  : self.def_complete,
                    'syn'  : self.syn_complete
                }
                # Dump the state to prev_state
                self.session_attributes = helper.dump_state(self.session_attributes)

        # Prompt the user to try again
        else:
            card_title    = "Try Again"
            speech_output = pg.generate(self.session_attributes, 'try_again')
            reprompt_text = "Would you like to try again?"
            
            # Assign the next state            
            self.session_attributes['state'] = {
                'value': 'try_again',
                'task' : self.task,
                'word' : self.word,
                'sen'  : self.sen_complete,
                'dfn'  : self.def_complete,
                'syn'  : self.syn_complete
            }
            # Dump the state to prev_state
            self.session_attributes = helper.dump_state(self.session_attributes)

        # Return
        return helper.build_response(self.session_attributes, helper.build_speechlet_response(
            card_title, speech_output, reprompt_text, should_end_session))