Implémenter le bot de discussion Slack en Python

Une implémentation générique du bot pour les Webhooks sortants de Slack en Python, "djehuty/[djehuty-slack](https://github.com/xica/ djehuty-slack) "a été publié, je vais donc le partager.

Avec Hubot?

Je voulais utiliser un module côté serveur implémenté par Python en interne directement à partir du bot.

Configurer l'intégration des Webhooks sortants de Slack

Ajouter une intégration

Avant de préparer un bot, il est nécessaire de définir en premier lieu les paramètres d'interaction avec le bot côté Slack. L'une des intégrations de Slack est "Outgoing Webhooks", qui est un mécanisme pour POST demandant une entrée commençant par un mot spécifique vers une URL spécifiée. djehuty utilise cette intégration.

Dans les paramètres des Webhooks sortants, vous pouvez définir le canal, le mot de déclenchement, etc. pour activer cette intégration. Si vous avez un compte Slack, vous pouvez probablement choisir d'ajouter une intégration à partir d'ici (https://slack.com/services/new).

Les Webhooks sortants se trouvent en bas de la liste.

paramètres d'intégration

djehuty reconnaît la première chaîne ASCII trouvée après le mot de déclenchement défini ici comme ligne de commande. Par exemple, si vous définissez "mybot:" dans le mot déclencheur, dans Slack

mybot:yo -g hello

Si vous entrez, etc., djehuty le reconnaîtra comme la ligne de commande "yo -g hello". Pour l'URL, vous pouvez définir l'URL du serveur d'applications que vous avez préparé avec '/ slack' ajouté ultérieurement.

Vérifier le jeton Webhooks sortants

Vous pouvez également voir le jeton sur cet écran pour indiquer qu'il provient d'une demande de votre compte Slack. Étant donné que la mise en œuvre de djehuty-slack vérifie également ce jeton et vérifie la demande, il est bon de vérifier le jeton à l'avance ici.

djehuty

djehuty est un package Python qui aide à implémenter des serveurs d'applications spécialisés dans la prise en charge des soi-disant web hooks. Actuellement, il a une fonctionnalité très faible, mais en tant que fonctionnalité,

• Vous pouvez étendre librement le support pour le côté service qui lance un crochet Web sous la forme de "service" (dans Hubot, adaptateur).
• Vous pouvez étendre librement la fonction correspondant à une entrée spécifique sous forme de "commande".

Djehuty-slack est déjà implémenté en tant que service, donc si vous l'utilisez, vous pouvez facilement créer un bot qui renvoie une réponse correspondant aux Webhooks sortants de Slack. Peut être préparé en.

En ce qui concerne le nom du paquet, comme il a été implémenté sur la base de la pyramide, nous avons décidé d'en faire un nom associé égyptien (mythique) [thoth](http://ja.wikipedia.org/wiki/%E3%83%88%E3%83% BC% E3% 83% 88) était en cours d'implémentation comme si c'était le plus approprié, mais comme le paquet avec le même nom était déjà enregistré dans PyPI, il a fini par être un autre nom djehuty.

Préparer un serveur djehuty

Restez seul

Fondamentalement, ce n'est pas recommandé car les documents ne sont pas disponibles.

Pour le moment, djehuty implémente l'échafaudage pyramidal, vous pouvez donc facilement créer un projet en l'utilisant et le démarrer en tant qu'application pyramidale.

$ pip install djehuty
$ pcreate -s djehuty_server PROJECT_NAME
$ cd PROJECT_NAME
...
$ pserve development.ini

Pour fonctionner en tant que bot Slack, il est nécessaire de définir les variables de service et d'environnement correspondantes comme décrit dans le README de djehuty et djehuty-slack.

Courir avec Heroku

Les fichiers générés par l'échafaudage de djehuty incluent également des paramètres pour Heroku (requirements.txt, Procfile, fichier ini pour Heroku), c'est donc le vôtre en supposant que vous ferez vous-même le support SSL. C'est plus facile que de préparer l'environnement avec.

$ pip install djehuty
$ pcreate -s djehuty_server PROJECT_NAME
$ cd PROJECT_NAME
$ heroku create
...
$ git push heroku master

J'omettrai le déploiement sur Heroku et le paramétrage des variables d'environnement.

Utilisez l'exemple de bouton Heroku djehuty

Le référentiel djehuty-sample de l'exemple est le [Heroku Button](https://blog.heroku.com/archives/2014/8/7/heroku- button) est pris en charge, et djehuty-sample a déjà spécifié djehuty-slack comme service à utiliser, donc si vous avez un compte Heroku, vous pouvez préparer un serveur de chat bot pour Slack en appuyant simplement sur un bouton. Cependant, si vous envisagez de modifier le code ultérieurement pour ajouter des commandes, etc., il est préférable de bifurquer une fois avant le déploiement.

Lors du déploiement avec Heroku Button, il vous sera demandé de définir des variables d'environnement pour djehuty-slack, alors définissez le jeton qui peut être confirmé dans les paramètres des Webhooks sortants ici.

Quelle que soit la méthode que vous utilisez pour préparer le serveur, veillez à spécifier l'URL du serveur préparée avec '/ slack' ajouté au paramètre d'URL des Webhooks sortants.

Essayez le bot

Si Slack est configuré et que le serveur djehuty est configuré correctement, la commande devrait fonctionner. Si vous avez essayé djehuty-sample, la commande yo et la commande lgtm doivent être activées, alors entrez ce qui suit sur le canal spécifié dans les paramètres, et la chaîne de caractères yo sera renvoyée [LGTM]( Si l'image de http://www.lgtm.in/) est renvoyée au hasard, elle réussit.

YOUR_TRIGGER_WORD yo
YOUR_TRIGGER_WORD lgtm

Implémentez la commande

Quelle que soit la méthode que vous utilisez pour préparer le serveur, vous disposez déjà du package Python pour le serveur d'applications, vous pouvez donc ajouter des fonctionnalités de bot en y implémentant des commandes.

L'implémentation de la commande hérite de la classe fournie par djehuty, implémente la classe de commande et l'utilise comme setuptools entry_points. Il est activé en s'enregistrant dans -and-plugins).

djehuty.command.Command

Une classe appelée djehuty.command.Command est définie dans djehuty. djehuty utilise un framework appelé cliff pour sa fonction de gestion de ligne de commande, et djehuty.command.Command est considéré comme presque identique à cliff.command.Command. Vous pouvez. Donc, fondamentalement, l'implémentation de la classe de commande suit la documentation de cliff.

Étant donné que le nom de commande réel est spécifié en s'enregistrant dans entry_points décrit plus loin, le nom de la classe à implémenter par vous-même n'a pas besoin d'être le même.

Implémentation du contenu des commandes

On s'attend à ce que la classe concrète de djehuty.command.Command implémente une méthode appelée take_action, et djehuty utilise la valeur renvoyée par cette méthode comme message de réponse à Slack (c'est ce que cliff attend). Différent). Par exemple, l'implémentation qui renvoie la chaîne "yo" avec une mention à l'utilisateur qui l'a saisie est la suivante.

from djehuty.command import Command


class Yo(Command):
    '''echo yo'''  #cliff utilise la documentation de classe comme aide

    def take_action(self, parsed_args):
        return '@{} yo'.format(self.app_args.user)

parsed_args sera décrit plus tard. self.app_args contient des arguments communs pour les services, dans le cas de Slack le nom de l'utilisateur entré dans user et le nom du canal entré dans la salle.

En gros, c'est la seule implémentation de commande.

Implémentation des arguments de commande

Les commandes sont accompagnées d'arguments afin de pouvoir leur donner une valeur de manière dynamique. djehuty (ou cliff) prend également en charge l'implémentation d'arguments, vous pouvez donc ajouter de manière déclarative des arguments à vos propres commandes.

from djehuty.command import Command


class Yo(Command):
    '''echo yo'''

    def get_parser(self, prog_name):
        parser = Command.get_parser(self, prog_name)
        parser.add_argument('-g', '--greeting',
                            default='yo',
                            help='greeting message')
        return parser

    def take_action(self, parsed_args):
        return '@{} {}'.format(self.app_args.user, parsed_args.greeting)

Si vous implémentez une méthode appelée get_parser dans la classe concrète de djehuty.command.Command, la chaîne de caractères d'entrée est évaluée en fonction de l'implémentation et l'argument est passé à take_action comme parsed_args et peut être utilisé.

get_parser est fondamentalement

• Obtenez un analyseur en utilisant get_parser de la classe parent
• Ajouter un argument à l'analyseur
• Renvoie l'analyseur

C'est sous la forme de. Puisque l'analyseur est une instance de argparse.ArgumentParser et parsed_args est argparse.Namespace, reportez-vous à la documentation argparse pour la définition de l'argument et comment obtenir la valeur elle-même. chose. Je pense que vous pouvez avoir une idée de base de la façon de l'utiliser avec juste le code ci-dessus, mais il existe de nombreuses façons plus avancées de le définir.

Enregistrement des commandes

djehuty.command.Command est reconnu et activé par djehuty en l'enregistrant dans le mécanisme entry_points de setuptools comme décrit ci-dessus. L'enregistrement ajoute simplement la description à setup.py, donc si vous implémentez les commandes Misawa et Hartman dans commands.py dans un package appelé mydjehuty, l'argument entry_points pour setup dans mydjehuty / setup.py est: devenir de cette façon.

setup(
    name='mydjehuty',
    # ...
    entry_points={
        'djehuty.commands': [
            'misawa = mydjehuty.commands:Misawa',
            'hartman = mydjehuty.commands:Hartman',
        ],
    },
)

En tant que valeur de list avec'djehuty.commands 'comme clé

'Nom de la commande lors de l'utilisation réelle=Module implémenté(nom de fichier):Nom de classe implémenté'

Il vous suffit d'ajouter la chaîne de caractères.

Fonctionnement sur la console

L'installation de djehuty installe non seulement le code du framework et l'échafaudage pyramidal, mais également une CLI appelée djehuty. Puisqu'il s'agit d'une CLI qui ne prend en charge que les parties requête et réponse POST, le comportement de la commande implémentée peut être émulé sur la console.

$ djehuty yo
yo

Cependant, vous devez spécifier explicitement les arguments communs aux services tels que ceux implémentés dans des services tels que djehuty-slack.

$ djehuty -u kiri yo
@kiri yo

Package de commande uniquement

Il est possible d'implémenter un package Python qui implémente uniquement des commandes ainsi que dans votre propre serveur d'applications, et un échafaudage est également fourni à cet effet.

$ pcreate -s djehuty_command YOUR_COMMAND_PROJECT_NAME

Si l'implémentation peut être publiée avec une fonction qui ne dépend pas d'une organisation spécifique, elle peut également être publiée en tant que package de commandes à l'aide de this.

la fin

Si vous pouvez déployer le package contenant la commande implémentée sur le serveur d'applications et exécuter la commande implémentée à partir de Slack, cela aboutira. Implémentez librement vos fonctionnalités préférées en Python pour une bonne vie Slack.