[PYTHON] Enseignez à Alexa la journée des ordures dans Nakano Ward en reliant lambda

Chose que tu veux faire

Appelle lambda d'Alexa et renvoie le jour des ordures dans Nakano Ward. Je l'ai écrit pour que même les gens qui ne l'ont jamais touché puissent le faire à partir de zéro.

alexa.png

J'ai essayé d'introduire le développement avec ALEXA, je vais donc le résumer à ma manière Je l'ai fait en référence à cet article. C'était très instructif car il était expliqué en détail, Je suis tombé sur le chemin en raison d'un changement dans les spécifications AWS, je décrirai donc également ce domaine dans cet article.

Les choses nécessaires

Alexa Skill Kit

Extraire ** variables ** de l'audio reçu de l'écho Créez une compétence à transmettre à lambda.

Créer des compétences

Appuyez sur ʻAlexa Skills Kit` du développeur Amazon

alexa-Page-3.png

Appuyez sur Create Skill depuis la console développeur Amazon

alexa-Page-2.png

Entrez ce qui suit et appuyez sur Créer une compétence

Nom de la compétence: TrashDay Langue par défaut: japonais Sélectionnez un modèle à ajouter à votre compétence: «Personnalisé» Choisissez comment héberger les ressources backend de votre compétence: ʻUser-defined provisioning` (cette fois d'hébergement sur lambda indépendamment)

alexa-Page-4.png

Nom d'appel

Entrez le nom de l'appel pour appeler la compétence

Nom de l'appel de compétence: Thermy Gomi

"Alexa, ouvre Thermy Gomie" active la compétence alexa2-Page-2.png

Type de fente

Préparez à l'avance les variables incluses dans l'instruction lors de l'appel de l'action.

Cliquez sur «Ajouter» à côté du type de logement pour en créer un nouveau. alexa2-Page-3.png

Définissez le nom du type de logement sur type et appuyez sur Créer un type de logement personnalisé alexa2-Page-4.png

Ajout des valeurs d'emplacement suivantes. La valeur d'Alexa n'est pas essentielle (un peu ludique * décrit plus loin). alexa2-Page-1.png

Intention

Définit l'action à effectuer par la compétence appelée (= Thermy Gomi). Cette fois, seule l'action qui répond au jour de la poubelle sera créée.

Cliquez sur «Ajouter» à côté de l'intention pour en créer un nouveau. alexa2-Page-5.png

Définissez le nom de l'intention sur TellTrashDay et appuyez sur Créer une intention personnalisée alexa2-Page-6.png

Définissez le nom de l'emplacement d'intention sur «type» et sélectionnez le type d'emplacement «type» créé précédemment. alexa2-Page-7.png

Ajout de ce qui suit à l'exemple de discours. Notez qu'il y a un ** espace demi-largeur ** après {type}. alexa2-Page-8.png

De ce qui précède, la partie {type} est extraite en tant que variable lorsque vous faites une instruction dans l'exemple d'énoncé.

AWS lambda

Héberge une fonction qui sélectionne et répond à une réponse en fonction des variables transmises par Alexa.

Créer une fonction

Passez de la console de gestion AWS à l'écran lambda et appuyez sur Créer une fonction alexa2-Page-9.png

Sélectionnez ʻalexa-skills-kit-color-expert-python` fourni par AWS Il dispose d'un exemple d'application intégré qui demande à Alexa sa couleur préférée. alexa2-Page-10.png

Définissez le nom de l'application et TopicNameParameter sur TrashDay et appuyez sur Deploy TopicNameParameter est stocké dans le paramètre passé par CloudFormation, Il n'y a aucune preuve qu'il est utilisé dans la fonction, donc toute valeur est correcte. alexa2-Page-11.png

Déployer TrashDay.py

Sélectionnez une fonction dans le menu de gauche et appuyez sur la fonction avec le nom d'application mentionné précédemment. alexa2-Page-12.png

Sélectionnez la fonction lambda et remplacez l'éditeur en bas de l'écran par le contenu de TrashDay.py alexa2-Page-13.png

TrashDay.py


# coding:utf-8
"""
This sample demonstrates a simple skill built with the Amazon Alexa Skills Kit.
The Intent Schema, Custom Slots, and Sample Utterances for this skill, as well
as testing instructions are located at http://amzn.to/1LzFrj6

For additional samples, visit the Alexa Skills Kit Getting Started guide at
http://amzn.to/1LGWsLG
"""

from __future__ import print_function


# --------------- Helpers that build all of the responses ----------------------

###Fonctions utilisées pour revenir à Alexa après le traitement de chaque intention
def build_speechlet_response(title, output, reprompt_text, should_end_session):
    return {
        'outputSpeech': {
            'type': 'PlainText',
            'text': output
        },
        'card': {
            'type': 'Simple',
            'title': "SessionSpeechlet - " + title,
            'content': "SessionSpeechlet - " + output
        },
        'reprompt': {
            'outputSpeech': {
                'type': 'PlainText',
                'text': reprompt_text
            }
        },
        'shouldEndSession': should_end_session
    }

### build_speechlet_Une fonction qui stocke le JSON créé par response dans le JSON for response et le renvoie.
def build_response(session_attributes, speechlet_response):
    return {
        'version': '1.0',
        'sessionAttributes': session_attributes,
        'response': speechlet_response
    }


# --------------- Functions that control the skill's behavior ------------------

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 = "Salut, c'est Thermy Gomie," \
                    "Nous répondrons au jour désigné de la poubelle que vous souhaitez jeter!" 
    
    # If the user either does not reply to the welcome message or says something
    # that is not understood, they will be prompted again with this text.
    reprompt_text = "Nous répondrons au jour désigné de la poubelle que vous souhaitez jeter!" 

    should_end_session = False
    return build_response(session_attributes, build_speechlet_response(
        card_title, speech_output, reprompt_text, should_end_session))


def handle_session_end_request():
    card_title = "Session Ended"
    speech_output = "Reviens s'il te plait" 

    # Setting this to true ends the session and exits the skill.
    should_end_session = True
    return build_response({}, build_speechlet_response(
        card_title, speech_output, None, should_end_session))


# --------------- Events ------------------

def on_session_started(session_started_request, session):
    """ Called when the session starts """

    print("on_session_started requestId=" + session_started_request['requestId']
          + ", sessionId=" + session['sessionId'])


def on_launch(launch_request, session):
    """ Called when the user launches the skill without specifying what they
    want
    """

    print("on_launch requestId=" + launch_request['requestId'] +
          ", sessionId=" + session['sessionId'])
    # Dispatch to your skill's launch
    return get_welcome_response()

###Une fonction qui détermine l'intention correspondant à une instruction et se branche sur chaque fonction
def on_intent(intent_request, session):
    """ Called when the user specifies an intent for this skill """

    print("on_intent requestId=" + intent_request['requestId'] +
          ", sessionId=" + session['sessionId'])

    intent = intent_request['intent']
    intent_name = intent_request['intent']['name']

    # Dispatch to your skill's intent handlers

    ###Branche à chaque intention, y compris TellTrashDay
    if intent_name == "TellTrashDay":
        return set_TellTrashDay_text(intent, session)
    elif intent_name == "AMAZON.HelpIntent":
        return get_welcome_response()
    elif intent_name == "AMAZON.CancelIntent" or intent_name == "AMAZON.StopIntent":
        return handle_session_end_request()
    else:
        raise ValueError("Invalid intent")


def on_session_ended(session_ended_request, session):
    """ Called when the user ends the session.

    Is not called when the skill returns should_end_session=true
    """
    print("on_session_ended requestId=" + session_ended_request['requestId'] +
          ", sessionId=" + session['sessionId'])
    # add cleanup logic here


# --------------- Main handler ------------------
###La première fonction à être exécutée lors de l'appel de lambda
###La demande d'informations à lambda est stockée dans l'événement
def lambda_handler(event, context):
    """ Route the incoming request based on type (LaunchRequest, IntentRequest,
    etc.) The JSON body of the request is provided in the event parameter.
    """
    # get applicationId from request.json
    print("event.session.application.applicationId=" +
          event['session']['application']['applicationId'])

    """
    Uncomment this if statement and populate with your skill's application ID to
    prevent someone else from configuring a skill that sends requests to this
    function.
    """
    # if (event['session']['application']['applicationId'] !=
    #         "amzn1.echo-sdk-ams.app.[unique-value-here]"):
    #     raise ValueError("Invalid Application ID")

    if event['session']['new']:
        on_session_started({'requestId': event['request']['requestId']},
                           event['session'])
    ###Appelle uniquement les noms de compétences et est exécuté lorsqu'aucune intention n'est incluse
    if event['request']['type'] == "LaunchRequest":
        return on_launch(event['request'], event['session'])
    ###Exécuté lorsque l'utilisateur fait une déclaration correspondant à l'intention
    elif event['request']['type'] == "IntentRequest":
        return on_intent(event['request'], event['session'])
    ###Exécuté à la sortie, en l'absence d'intention de réponse ou en cas d'erreur
    elif event['request']['type'] == "SessionEndedRequest":
        return on_session_ended(event['request'], event['session'])


###Une fonction qui renvoie le garbage day qui correspond au type de slot
def set_TellTrashDay_text(intent, session):
    """ Sets the color in the session and prepares the speech to reply to the
    user.
    """

    card_title = intent['name']
    session_attributes = {}
    should_end_session = False
    speech_output = "Dis-le vite, tu peux te jeter dans une corbeille"

    ###Liste des déchets en feu
    burn_list = ['brûler', 'Brut', 'De vieux papiers']
    ###Liste des déchets non brûlants
    notburn_list = ['Ininflammable', 'De plastique', 'Plastique', 'Plastique']
    ###Liste des déchets en aluminium
    can_list = ['De canette d'aluminium', 'Canettes en aluminium', 'De boîtes vides', 'De bouteilles en PET', 'De la bouteille', 'Pouvez', 'pouvez', 'スチールPouvez']
    ###Liste des ordures en carton
    paper_list = ['Papier carton', 'Journal', 'De papier usagé', 'papier', 'papier']
    ###Liste des déchets dangereux
    glass_list = ['De verre', 'Métal', 'De poterie']
    ###Si tu le dis
    alexa_list = ['Alexa', 'Alexa']

    if 'type' in intent['slots']:
        ### 3rd part was 'name' so changed to 'value'
        trash_type = intent['slots']['type']['value'] 

        if trash_type in burn_list:
            speech_output = 'Mardi et vendredi'
        elif trash_type in notburn_list:
            speech_output = 'C'est lundi'
        elif trash_type in can_list:
            speech_output = 'C'est mercredi'
        elif trash_type in paper_list:
            speech_output = 'C'est lundi'
        elif trash_type in glass_list:
            speech_output = 'C'est samedi'
        elif trash_type in alexa_list:
            speech_output = 'Je pense que je veux être une poubelle spatiale'
    else:
        speech_output = "Je suis désolé, je ne sais pas ce que tu dis"

    print(speech_output)
    reprompt_text = speech_output
    return build_response(session_attributes, build_speechlet_response(
        card_title, speech_output, reprompt_text, should_end_session))

Spécifiez le kit de compétences Alexa pour être le déclencheur

Appuyez sur «Ajouter un déclencheur» alexa2-Page-14.png

Revenez à la console du développeur Alexa et copiez l'ID de compétence du point de terminaison alexa2-Page-16.png

Revenez à AWS, sélectionnez ʻAlexa Skills Kit, collez l'ID de compétence copié et appuyez sur Ajouter` alexa2-Page-15.png

S'il est ajouté normalement, le réglage du côté lambda est terminé. Un autre souffle.

Spécifiez lambda pour le point de terminaison

Enfin, spécifiez la fonction lambda créée précédemment du côté Alexa.

Copiez l'ARN en haut de l'écran AWS lambda alexa2-Page-18.png

Coller dans la région par défaut des points de terminaison Alexa alexa2-Page-17.png

Appuyez sur Save Endpoint

Maintenant que tous les paramètres sont terminés, enregistrez le modèle et construisez le modèle. alexa2-Page-19.png

tester

Testez la console développeur alexa pour voir si cela fonctionne.

Modification de l'étape où le test de compétence est activé en «en cours de développement» alexa2-Page-20.png

Activez la compétence et essayez l'action que vous avez ajoutée à l'intention. alexa2-Page-21.png

Ça a marché! !!

L'humour est parfait. alexa2-Page-22.png

Au fait, même si vous ne publiez pas vos compétences dans le magasin Avec mon écho, je pourrais utiliser la compétence sans rien définir. (Quand j'ai testé sur le navigateur, mon écho a répondu et j'ai été surpris lol) Il semble qu'il soit automatiquement lié à votre compte Amazon.

dépannage

Erreur de codage s'il y a du japonais dans la fonction lambda

# Coding: utf-8 est ajouté au début du code pour que le japonais puisse être lu.

Si ça ne marche pas

Étant donné que l'entrée JSON est affichée sur l'écran de test Alexa, vous pouvez isoler la cause en la copiant dans le test lambda et en l'essayant.

Recommended Posts

Enseignez à Alexa la journée des ordures dans Nakano Ward en reliant lambda
"Classer les déchets par image!" Journal de création d'application day4 ~ Préparez le frontal avec Bootstrap ~