Créer et déployer une compétence Alexa – Real Python

Les enceintes intelligentes pour la maison étaient une idée nouvelle il y a quelques années à peine. Aujourd’hui, ils sont devenus un élément central du domicile et du bureau de nombreuses personnes et leur adoption ne devrait que se développer. Parmi les appareils les plus populaires figurent ceux contrôlés par Amazon Alexa. Dans ce didacticiel, vous deviendrez Développeur Alexa Python en déployant votre propre compétence Alexa, une application avec laquelle les utilisateurs interagiront à l'aide de commandes vocales sur les appareils Amazon Alexa.

Dans ce didacticiel, vous apprendrez:

• Quoi les principaux composants d'une compétence Alexa sont
• Comment pour configurer une compétence Alexa et créer des intentions
• Quoi le ask_sdk_core Le package Alexa Python est
• Comment utiliser ask_sdk_core pour créer la logique métier de votre compétence Alexa Python
• Comment pour créer, déployer et tester vos compétences Alexa Python à l'aide de la console de développement en ligne

Premiers pas avec le développement d'Alexa Python

Pour suivre ce didacticiel, vous devez créer un compte de développeur Alexa gratuit. Sur cette page, vous suivrez les étapes suivantes:

1. Clique le Commencer bouton.
2. Clique le S'inscrire sur la page suivante.
3. Cliquez sur Créez votre compte Amazon.
4. Remplissez le formulaire avec les détails requis.
5. Cliquez sur Soumettre pour terminer le processus d'inscription.

Vous devrez également vous familiariser avec des concepts tels que les listes et les dictionnaires en Python, ainsi qu'avec la notation d'objet JavaScript (JSON). Si vous débutez avec JSON, consultez la section Utilisation des données JSON en Python.

Commençons!

Comprendre les compétences Alexa

Un développeur Alexa Python doit être familier avec un certain nombre de composants de compétences Alexa différents, mais les deux composants les plus importants sont les interface et le un service:

1. L'interface de compétences traite les entrées vocales de l'utilisateur et les associe à une intention.
2. Le service des compétences contient toute la logique métier qui détermine la réponse pour une entrée utilisateur donnée et la renvoie en tant qu'objet JSON.

L'interface de compétence sera le l'extrémité avant de votre compétence Alexa. C'est ici que vous définirez les intentions et les phrases d'invocation qui exécuteront une certaine fonction. Il s'agit essentiellement de la partie de la compétence chargée d'interagir avec les utilisateurs.

Le service de compétences sera le backend de votre compétence Alexa. Lorsqu'une intention spécifique est déclenchée par l'utilisateur, il envoie ces informations sous forme de demande au service de compétences. Celui-ci contiendra la logique métier à renvoyer ainsi que des informations précieuses au frontend, qui seront finalement retransmises à l'utilisateur.

Configuration de votre environnement

Il est temps de commencer à développer votre première compétence Alexa Python! Connectez-vous à la console développeur Alexa et cliquez sur le Créer une compétence pour commencer. Sur la page suivante, entrez le Nom de la compétence, qui sera Joke Bot:

Ce sera le phrase d'invocation de vos compétences. C'est la phrase qu'un utilisateur prononcera pour commencer à utiliser votre compétence Alexa. Vous pouvez changer cela en quelque chose d'autre plus tard si vous le souhaitez. Notez également que les compétences Alexa peuvent interagir dans de nombreuses langues, ce que vous pouvez voir sur le Langage par défaut menu déroulant. Pour l'instant, réglez-le sur Anglais (US).

Ensuite, vous devrez choisir un modèle à ajouter à votre compétence. Celles-ci des modèles sont comme des modèles préconçus par l'équipe Amazon pour vous aider à démarrer le développement d'Alexa Python, en fonction de certains cas d'utilisation courants. Pour ce didacticiel, vous devez sélectionner le Douane modèle.

Enfin, vous devez sélectionner une méthode pour héberger le backend de votre compétence Alexa. Ce service contiendra la logique métier de votre application.

Pour l'instant, sélectionnez Hébergé par Alexa (Python) comme backend pour votre compétence Alexa. Cela vous fournira automatiquement un backend hébergé au sein du niveau gratuit AWS afin que vous n'ayez rien à payer d'avance ou à configurer un backend compliqué pour le moment.

Enfin, cliquez sur le Créer une compétence pour continuer. On pourrait vous demander de remplir un CAPTCHA ici, alors remplissez-le également. Après environ une minute, vous devriez être redirigé vers le Construire section de la console développeur.

Comprendre le modèle de compétence Alexa

Une fois que vous vous êtes connecté à la console de développement Alexa et que vous avez sélectionné ou créé une compétence, vous serez accueilli avec le Construire section. Cette section vous offre de nombreuses options et commandes pour configurer le modèle d'interaction de la compétence. Les composants de ce modèle d'interaction vous permettent de définir comment les utilisateurs interagiront avec votre compétence. Ces propriétés sont accessibles via le panneau de gauche, qui ressemble à ceci:

En tant que développeur Alexa Python, vous devez connaître quelques composants d'un modèle d'interaction de compétences Alexa. Le premier est le invocation. C'est ce que les utilisateurs diront pour commencer à interagir avec votre compétence Alexa. Par exemple, l'utilisateur dira «Joke Bot» pour invoquer la compétence Alexa que vous allez créer dans ce didacticiel. Vous pouvez changer cela depuis le Invocation section à tout moment.

Un autre élément est le intention, qui représente la fonctionnalité principale de votre application. Votre application aura un ensemble d'intentions qui représentera les types d'actions que votre compétence peut effectuer. Pour fournir des informations contextuelles pour une intention donnée, vous utiliserez un fente, qui est une variable d'une expression.

Prenons l'exemple suivant. Un exemple d'énoncé pour invoquer l'intention météo pourrait être: «Parlez-moi de la météo». Pour rendre la compétence plus utile, vous pouvez définir l'intention d'être, «Parlez-moi de la météo à Chicago», où le mot «Chicago» sera passé comme variable de slot, ce qui améliore l'expérience utilisateur.

Enfin, il existe types d'emplacement, qui définissent la manière dont les données d'un emplacement sont traitées et reconnues. Par exemple, le AMAZON.DATE le type d'emplacement convertit facilement les mots qui indiquent une date – comme «aujourd'hui,« demain »et autres – en un format de date standard (comme« 2019-07-05 »). Vous pouvez consulter la page de référence officielle des types d'emplacements pour en savoir plus.

À ce stade, le Intentions le panneau doit être ouvert. Si ce n'est pas le cas, vous pouvez l'ouvrir en sélectionnant Intentions à partir de la barre latérale à gauche. Vous remarquerez que cinq intentions sont déjà configurées par défaut:

le Intentions panneau comprend un HelloWorldIntent et cinq Intentions intégrées. Les intentions intégrées sont là pour vous rappeler de prendre en compte certains cas courants qui sont importants pour créer un bot convivial. Voici un bref aperçu:

1. AMAZON.CancelIntent permet à l'utilisateur d'annuler une transaction ou une tâche. Les exemples incluent, «Ça ne fait rien», «Oubliez ça», «Quitter» et «Annuler», bien qu'il y en ait d'autres.
2. AMAZON.HelpIntent fournit de l'aide sur la façon d'utiliser la compétence. Cela pourrait être utilisé pour renvoyer une phrase qui sert de manuel à l'utilisateur sur la façon d'interagir avec vos compétences.
3. AMAZON.StopIntent permet à l'utilisateur de quitter la compétence.
4. AMAZON.NavigateHomeIntent dirige l'utilisateur vers l'écran d'accueil de l'appareil (si un écran est utilisé) et met fin à la session de compétences.

Par défaut, aucun exemple d'énoncés n'est attribué pour déclencher ces intentions. Vous devrez donc également les ajouter. Considérez cela comme faisant partie de votre formation en tant que développeur Alexa Python. Vous pouvez en savoir plus sur ces intentions intégrées dans la documentation officielle.

Affichage d'un exemple d'intention

Plus loin dans ce didacticiel, vous apprendrez à créer une nouvelle intention, mais pour l'instant, c'est une bonne idée de jeter un œil à certaines intentions existantes qui font partie de chaque nouvelle compétence que vous créez. Pour commencer, cliquez sur le HelloWorldIntent pour voir ses propriétés:

Vous pouvez voir les exemples d'énoncés qu'un utilisateur peut parler pour invoquer cette intention. Lorsque cette intention est invoquée, ces informations sont envoyées au service backend de votre compétence Alexa, qui exécutera ensuite la logique métier requise et retournera une réponse.

En dessous, vous avez la possibilité de configurer Stratégie de délégation de dialogue, qui vous permet de déléguer un dialogue que vous définissez à une intention particulière. Bien que vous ne couvriez pas cela dans ce didacticiel, vous pouvez en savoir plus à ce sujet dans la documentation officielle.

Ensuite, vous avez la possibilité de définir fentes pour certaines données particulières que votre intention est censée collecter. Par exemple, si vous deviez créer une intention qui indique la météo d'un jour donné, vous auriez un Date fente ici qui collecterait les informations de date et les enverrait à votre service backend.

Chaque fois que vous modifiez une intention, vous devez cliquer sur le Enregistrer le modèle pour l'enregistrer. Ensuite, vous pouvez cliquer sur le Créer un modèle pour aller de l'avant et tester vos compétences Alexa Python.

Il est utile de savoir que le modèle d'interaction d'une compétence peut être complètement représenté au format JSON. Pour voir la structure actuelle de votre compétence Alexa, cliquez sur le Éditeur JSON option depuis le panneau latéral gauche de la console:

Si vous apportez une modification directement à l'aide de l'éditeur JSON, les modifications sont également reflétées dans l'interface utilisateur de la console du développeur. Pour tester ce comportement, ajoutez une nouvelle intention et cliquez sur Enregistrer le modèle.

Une fois que vous avez apporté toutes les modifications nécessaires au modèle d'interaction de votre compétence, vous pouvez ouvrir le Tester section de la console développeur pour tester vos compétences. Les tests sont une partie importante pour devenir un développeur Alexa Python, alors assurez-vous de ne pas sauter cette étape! Clique le Tester dans la barre de navigation supérieure de la console du développeur. Par défaut, les tests seront désactivés. Dans le menu déroulant, sélectionnez Développement pour commencer les tests:

Ici, vous pouvez tester votre compétence Alexa Python de plusieurs manières. Faisons un test rapide afin de vous faire une idée de la façon dont votre compétence Alexa va répondre à un énoncé.

Sélectionnez le Alexa Simulator dans le panneau de gauche, puis saisissez la phrase «Hey Alexa, ouvre Joke Bot». Vous pouvez le faire soit en le tapant dans la zone de saisie, soit en utilisant le Micro option. Après quelques secondes, une réponse vous sera retournée:

En plus de la réponse vocale, vous pouvez également voir le Entrée JSON qui a été envoyé au service backend de votre compétence Alexa, ainsi que le Sortie JSON qui a été renvoyé à la console:

Voici ce qui s'est passé jusqu'à présent:

• L'objet d'entrée JSON a été construit à partir de données d'entrée que l'utilisateur a saisies par la voix ou le texte.
• Le simulateur Alexa empaqueté l'entrée avec d'autres métadonnées pertinentes et l'a envoyée au service principal. Vous pouvez le voir dans le Entrée JSON boîte.
• Le service backend a reçu l'objet JSON d'entrée et l'a analysé pour vérifier le type de la demande. Ensuite, il a transmis le JSON à la fonction de gestionnaire d'intention appropriée.
• La fonction de gestionnaire d'intention traité l'entrée et rassemblé la réponse requise, qui est renvoyée en tant que réponse JSON au simulateur Alexa. Vous pouvez le voir dans le Sortie JSON boîte.
• Le simulateur Alexa analysé ce JSON et vous lire la réponse vocale.

Maintenant que vous avez un aperçu des différents composants d'une compétence Alexa et comment les informations circulent d'une partie à l'autre, il est temps de commencer à construire votre Joke Bot! Dans la section suivante, vous mettrez à l'épreuve vos compétences de développeur Alexa Python en créant une nouvelle intention.

Créer de nouvelles intentions

Commençons par créer le JokeIntent, qui renverra une plaisanterie aléatoire d'une liste à l'utilisateur. Ouvrez le Construire section de votre console de développeur Alexa. Cliquez ensuite sur le Ajouter bouton à côté du Intentions option du panneau latéral gauche:

Avec le Créer une intention personnalisée option sélectionnée, définissez le nom sur JokeIntent puis cliquez sur le Créer une intention personnalisée bouton:

Ensuite, vous devez ajouter exemples d'énoncés que l'utilisateur va parler pour invoquer cette intention. Il peut s'agir de phrases comme «Raconte-moi une blague» ou «Je veux entendre une blague». Tapez une phrase et cliquez sur le signe plus (+) pour l'ajouter comme exemple d'énoncé. Voici à quoi cela devrait ressembler:

Vous pouvez ajouter plus d'exemples d'énoncés, mais pour l'instant, ils feront très bien l'affaire. Enfin, cliquez sur le Enregistrer le modèle dans le coin supérieur gauche de la fenêtre pour enregistrer ces modifications.

N'oubliez pas, vous devrez construisez votre modèle avant de pouvoir le tester. Clique le Créer un modèle pour reconstruire le modèle d'interaction de votre compétence Alexa Python. Vous verrez une notification de progression en bas à droite de la fenêtre de votre navigateur. Une fois le processus de génération réussi, vous devriez voir une autre notification contextuelle indiquant l'état du processus de génération.

Vous pouvez vérifier si le JokeIntent est déclenché avec succès ou non. Clique le Évaluer le modèle dans le coin supérieur droit de la console développeur. Une petite fenêtre apparaîtra sur le côté vous permettant de vérifier quelle intention sera déclenchée par un énoncé d'entrée donné. Tapez l'un des exemples d'énoncés pour vous assurer que le JokeIntent est appelé avec succès.

Pour supprimer la fenêtre contextuelle d'évaluation, cliquez sur le bouton Évaluer le modèle bouton à nouveau.

Maintenant que vous avez réussi à créer une intention, il est temps d'écrire le code Python qui gérera cette intention et retournera une blague en réponse.

Construire le backend de compétences

Maintenant que vous avez créé une intention qui peut être déclenchée par l'utilisateur, vous devez ajouter Fonctionnalité dans le backend de compétences pour gérer cette intention et renvoyer des informations utiles. Ouvrez le Code section de la console développeur Alexa pour commencer.

Lorsque vous ouvrez le Code section de la console développeur, vous pouvez voir un éditeur de code en ligne avec certains fichiers déjà configurés pour vous permettre de commencer. En particulier, vous verrez les trois fichiers suivants dans le lambda sous-répertoire:

1. lambda_function.py: Il s'agit du principal point d'entrée du service backend. Toutes les données de demande de l'intention Alexa sont reçues ici et sont censées être renvoyées uniquement à partir de ce fichier.
2. requirements.txt: Ce fichier contient la liste des packages Python utilisés dans ce projet. Cela est particulièrement utile si vous choisissez de configurer votre propre service backend au lieu d'utiliser ce qui est fourni par Amazon. Pour en savoir plus sur les fichiers d'exigences, consultez Utilisation des fichiers d'exigences.
3. utils.py: Ce fichier contient certaines fonctions utilitaires requises pour que la fonction lambda interagisse avec le service Amazon S3. Il contient un exemple de code sur la façon de récupérer des données à partir d'un compartiment Amazon S3, que vous pourriez trouver utile plus tard. Pour l'instant, ce fichier n'est pas utilisé dans lambda_function.py.

Pour l'instant, vous n'apporterez des modifications lambda_function.py, regardons de plus près la structure du fichier:

    sept importation enregistrement
    8 importation ask_sdk_core.utils comme ask_utils
    9 
dix de ask_sdk_core.skill_builder importation SkillBuilder
11 de ask_sdk_core.dispatch_components importation AbstractRequestHandler
12 de ask_sdk_core.dispatch_components importation AbstractExceptionHandler
13 de ask_sdk_core.handler_input importation HandlerInput
14 
15 de ask_sdk_model importation Réponse
16 
17 enregistreur = enregistrement.getLogger(__Nom__)
18 enregistreur.setLevel(enregistrement.INFO)
19 
20 
21 classe LaunchRequestHandler(AbstractRequestHandler):
22     "" "Gestionnaire de lancement de compétences." ""
23     def peut gérer(soi, handler_input):
24         # type: (HandlerInput) -> bool
25 
26         revenir ask_utils.is_request_type("LaunchRequest") (handler_input)
27 
28     def manipuler(soi, handler_input):
29         # type: (HandlerInput) -> Réponse
30         speak_output = "Bienvenue, vous pouvez dire Bonjour ou Aide." 
31                        "Lequel aimeriez-vous essayer?"
32 
33         revenir (
34             handler_input.response_builder
35                 .parler(speak_output)
36                 .demander(speak_output)
37                 .réponse
38         )
39 ...

Tout d'abord, vous importez les utilitaires nécessaires fournis dans le ask_sdk_core Package Alexa Python. Ensuite, vous devez effectuer trois tâches principales dans lambda_function.py pour gérer une demande d'une intention reçue du front-end de la compétence Alexa:

1. Créez une classe de gestionnaire d'intention, qui hérite de la AbstractRequestHandler classe, avec fonctions peut gérer() et manipuler(). Il existe déjà quelques classes de gestionnaires définies dans lambda_function.py, tel que LaunchRequestHandler, HelpIntentHandler, etc. Ceux-ci gèrent les intentions fondamentales d'une compétence Alexa. Un point important à noter ici est que vous devez créer une nouvelle classe de gestionnaire d'intention pour chacune des intentions que vous définissez.
2. Créer un SkillBuilder objet, qui sert de point d'entrée à votre compétence Alexa Python. Cela achemine toutes les charges utiles de demande et de réponse entrantes vers les gestionnaires d'intention que vous définissez.
3. Passer la classe de gestionnaire d'intention comme argument pour .add_request_handler () afin qu'ils soient appelés dans l'ordre chaque fois qu'une nouvelle demande est reçue. le SkillBuilder est un singleton, donc une seule instance est nécessaire pour gérer le routage de toutes les demandes entrantes.

C'est le bon moment pour passer lambda_function.py. Vous remarquerez que le même schéma est répété maintes et maintes fois pour gérer différentes intentions qui peuvent être déclenchées par votre compétence Alexa Python.

Maintenant que vous avez une vue d'ensemble de toutes les différentes choses que vous devez faire pour gérer une intention dans votre backend, il est temps d'écrire le code qui gérera le JokeIntent que vous avez construit dans la section précédente.

Création du gestionnaire JokeIntent

Étant donné que les utilitaires importants du ask_sdk_core Le package Alexa Python a déjà été importé, vous n'avez pas besoin de les réimporter. Si vous souhaitez en savoir plus sur ces derniers en profondeur, vous pouvez consulter la documentation officielle.

Ensuite, vous allez créer un nouveau gestionnaire d'intention qui traitera la demande reçue du JokeIntent. Dans l'extrait de code ci-dessous, le gestionnaire d'intention retournera simplement avec un exemple de phrase. Cela indique que la réponse à la JokeIntent a été reçu du backend. Ajoutez le code suivant à lambda_function.py au-dessus de la définition de classe de LaunchRequestHandler ():

20 classe JokeIntentHandler(AbstractRequestHandler):
21     def peut gérer(soi, handler_input):
22         revenir ask_utils.is_intent_name("JokeIntent") (handler_input)
23 
24     def manipuler(soi, handler_input):
25         speak_output = "Voici un exemple de blague pour vous."
26 
27         revenir (
28             handler_input.response_builder
29                 .parler(speak_output)
30                 .demander(speak_output)
31                 .réponse
32         )

Voyons ce que fait chaque section. Dans ligne 20 vous créez une nouvelle classe de gestionnaire d'intention pour le JokeIntent, qui est une classe enfant du AbstractRequestHandler classe. Lorsque vous créez une intention dans le frontend, vous devez créer une classe de gestionnaire d'intention dans le backend qui peut gérer les demandes d'Alexa. Le code que vous écrivez pour cela doit faire deux choses:

1. JokeIntentHandler.can_handle () reconnaît chaque demande entrante envoyée par Alexa.
2. JokeIntentHandler.handle () renvoie une réponse appropriée.

Dans ligne 21 vous définissez .peut gérer(). Cela prend handler_input comme paramètre, qui est un objet de type dict () qui contient toutes les informations de demande d'entrée. Ensuite, il utilise ask_utils.is_intent_name () ou ask_utils.is_request_type () pour vérifier si l'entrée JSON reçue peut être gérée ou non par cette fonction de gestionnaire d'intention.

Tu utilises .is_intent_name () et passez au nom de l'intention. Cela renvoie un prédicat, qui est un objet fonction qui renvoie Vrai si le donné handler_input provient de l'intention indiquée. Si cela est vrai, alors le SkillBuilder l'objet appellera JokeIntentHandler.handle ().

Cette déclaration appelle par la suite .manipuler(), que vous définissez dans ligne 24. Cette méthode reçoit la demande d'entrée ainsi que toute autre information importante qui pourrait être nécessaire. Il contient la logique métier requise pour gérer avec succès une intention particulière. Dans le cas du JokeIntent, cette méthode est requise pour renvoyer une réponse contenant une blague au frontend d'Alexa.

le speak_ouput La variable contient la phrase qui sera prononcée à l'utilisateur par le frontend de la compétence Alexa. parler (speak_output) indique ce que le frontend d'Alexa jouera à l'utilisateur comme parole. ask ("Question à poser ...") peut être utilisé pour poser une question de suivi. Dans cette méthode, un objet de classe response_builder renvoie la réponse à la compétence Alexa.

Notez que la valeur de speak_output est réglé sur une réponse fixe en ce moment. Vous allez modifier cela plus tard pour renvoyer une blague aléatoire à partir d'une liste de blagues.

Voici à quoi ressemble votre code dans un éditeur:

Une fois que vous avez créé une classe de gestionnaire d'intention, vous devez la passer comme argument à SkillBuilder.add_request_handler. Faites défiler vers le bas de lambda_function.py et ajoutez la ligne suivante:

sb.add_request_handler(JokeIntentHandler())

Une chose importante à noter ici est que le placement de cette ligne est important, car le code est traité de haut en bas. Assurez-vous donc que l'appel de votre gestionnaire d'intention personnalisé est supérieur à l'appel de InstantReflectHandler () classe. Voici à quoi cela devrait ressembler:

171 sb = SkillBuilder()
172 
173 sb.add_request_handler(LaunchRequestHandler())
174 sb.add_request_handler(JokeIntentHandler())
175 sb.add_request_handler(HelloWorldIntentHandler())
176 sb.add_request_handler(HelpIntentHandler())
177 sb.add_request_handler(CancelOrStopIntentHandler())
178 sb.add_request_handler(SessionEndedRequestHandler())
179 
180 # Assurez-vous que IntentReflectorHandler est le dernier pour
181 # Ne remplace pas vos gestionnaires d'intentions personnalisés
182 sb.add_request_handler(IntentReflectorHandler())
183 
184 sb.add_exception_handler(CatchAllExceptionHandler())
185 
186 ...

Bon, il est temps de tester votre code! Clique le Déployer pour enregistrer les modifications et déployer le service backend. Vous allez vérifier si cela fonctionnera comme prévu à partir du frontend de compétences Alexa.

Une fois le processus de déploiement réussi, retournez au Tester section de la console développeur et invoquer la JokeIntent. N'oubliez pas, entrez la phrase d'énoncé pour invoquer votre compétence Alexa Python, puis entrez une phrase pour exécuter une intention:

Si vous obtenez une réponse similaire à celle de l'image ci-dessus, cela signifie que vous avez réussi à créer un gestionnaire d'intention pour le JokeIntent dans le service backend de votre compétence. Toutes nos félicitations! Maintenant, tout ce qui reste à faire est de renvoyer une blague aléatoire d'une liste vers le front de compétences.

Ajout de blagues

Ouvrez le Code section de la console développeur. Ensuite, ajoutez le blagues variable dans lambda_function.py:

15 de ask_sdk_model importation Réponse
16 
17 enregistreur = enregistrement.getLogger(__Nom__)
18 enregistreur.setLevel(enregistrement.INFO)
19 
20 blagues = [[[[
21         "Avez-vous entendu parler du point-virgule qui a enfreint la loi? Il a été condamné à deux peines consécutives.",
22         "J'ai mangé une horloge hier, cela prenait beaucoup de temps.",
23         "Je viens d'écrire une chanson sur les tortillas; en fait, c'est plus un rap.",
24         "Je me suis réveillé ce matin et j'ai oublié de quel côté le soleil se lève, puis il m'a frappé.",
25         "J'ai récemment décidé de vendre mon aspirateur car il ne faisait que ramasser de la poussière.",
26         "Si tu ne devrais pas manger le soir, pourquoi mettent-ils une lumière dans le frigo?",
27         ]
28 
29 classe JokeIntentHandler(AbstractRequestHandler):
30 ...

Ici, blagues est une variable de type liste contenant des blagues à une ligne. Assurez-vous d'ajouter ceci en dehors d'une définition de fonction ou de classe pour qu'il ait portée mondiale.

Ensuite, vous allez ajouter la fonctionnalité qui .manipuler() doit choisir au hasard une blague dans la liste des blagues et la renvoyer à l'utilisateur. Modifier le corps de JokeIntentHandler.handle () avec le code suivant:

29 classe JokeIntentHandler(AbstractRequestHandler):
30     def peut gérer(soi, handler_input):
31         revenir ask_utils.is_intent_name("JokeIntent") (handler_input)
32 
33     def manipuler(soi, handler_input):
34         speak_output = Aléatoire.choix(blagues)
35 
36         revenir (
37             handler_input.response_builder
38                 .parler(speak_output)
39                 .demander(speak_output)
40                 .réponse
41         )

Dans le corps de .manipuler(), vous sélectionnez une blague aléatoire dans la liste blagues en utilisant random.choice () et le renvoyer en réponse à l'interface de compétences Alexa.

Enfin, importez le Aléatoire package en ajoutant une instruction d'importation en haut de lambda_function.py:

15 de ask_sdk_model importation Réponse
16 
17 importation Aléatoire
18 
19 enregistreur = enregistrement.getLogger(__Nom__)
20 enregistreur.setLevel(enregistrement.INFO)
21 
22 ...

Voici à quoi l'éditeur doit ressembler à ce point:

Il y a une dernière modification à apporter avant le test. Vous devez autoriser Alexa à reconnaissance que la compétence a été déclenchée. Pour ce faire, regardez à l'intérieur LaunchRequestHandler.handle () pour le speak_output variable et définissez sa valeur sur le texte dans la ligne en surbrillance ci-dessous:

45 classe LaunchRequestHandler(AbstractRequestHandler):
46     "" "Gestionnaire de lancement de compétences." ""
47     def peut gérer(soi, handler_input):
48         # type: (HandlerInput) -> bool
49 
50         revenir ask_utils.is_request_type("LaunchRequest") (handler_input)
51 
52     def manipuler(soi, handler_input):
53         # type: (HandlerInput) -> Réponse
54         speak_output = "Hé là! Je suis un Joke Bot. Vous pouvez me demander de vous raconter une blague aléatoire qui pourrait simplement améliorer votre journée!"
55 
56         revenir (
57             handler_input.response_builder
58                 .parler(speak_output)
59                 .demander(speak_output)
60                 .réponse
61         )
62 ...

Votre Joke Bot est prêt pour les tests finaux! Clique le Déployer pour enregistrer les modifications et revenir au Tester section de la console développeur. Cette fois, vous devriez voir un nouveau message d'accueil lorsque votre compétence est invoquée pour la première fois. Ensuite, lorsque vous demandez au bot de vous raconter une blague, cela devrait vous donner une blague différente à chaque fois:

C'est ça! Vous avez créé avec succès votre première compétence en tant que développeur Alexa Python!

Conclusion

Félicitations pour vos premiers pas dans le développement d'Alexa Python! Vous avez maintenant créé avec succès votre propre compétence Alexa Python. Vous savez maintenant comment créer une nouvelle compétence, créer des intentions, écrire du code Python pour gérer ces intentions et renvoyer des informations précieuses à l'utilisateur.

Améliorez vos compétences en essayant certaines des solutions suivantes:

• Augmenter la liste des blagues dans le backend.
• Créer une nouvelle intention nommée Trivia qui répondra par une anecdote amusante.
• Publier vos compétences sur Amazon Marketplace.

Les possibilités sont infinies, alors allez-y et plongez! Pour en savoir plus sur le développement d'Alexa Python, consultez les documents officiels. Vous pouvez également consulter Comment créer un robot Twitter en Python avec Tweepy et Comment créer un robot Discord en Python pour en savoir plus sur la façon de créer des robots pour différentes plates-formes à l'aide de Python.