J'ai créé un plug-in Backend pour l'outil ChatBot de Python Errbot, donc je vais écrire comment le faire.
Étant donné que la dernière version d'Errbot ne prend en charge que la série Python3, ce document utilise également la série Python3.
Un plug-in qui connecte Errbot à un système de chat (Slack, HipChat, etc.). Les principaux systèmes de chat tels que Slack et HipChat ont des plugins backend officiels. (Donc je ne pense pas que ce document sera lu à moins qu'il y ait une bonne affaire ...)
Je veux que Bot en parle! Voir http://errbot.io/en/latest/user_guide/plugin_development/index.html pour savoir comment créer un plug-in normal tel que.
Tout d'abord, lisez autant que possible la page [Advanced] Backend development. Ce n'est pas un document si long, mais des compétences en anglais, en anglais.
Voici une brève explication.
Tous les plugins Backend héritent de la classe ʻErrBot. Ensuite, remplacez les méthodes existantes dans cette classe ʻErrBot autant que nécessaire et poursuivez l'implémentation. Puisque la classe ʻErrBot hérite également de la classe Backend`, il y a beaucoup de méthodes qui doivent être implémentées de manière inattendue.
En regardant la classe héritée, il existe de nombreuses méthodes qui ont NotImplementedError, et le développeur les implémente en fonction de la fonction du système de chat qu'il / elle souhaite prendre en charge.
Tous les plugins Backend doivent gérer les ** identifiants utilisateur ** et ** identifiants utilisateur dans les salles de chat **. La méthode build_identifier est particulièrement importante et doit renvoyer ces instances d'identifiant à partir d'une chaîne particulière.
Veuillez ressentir comment utiliser l'identifiant avec le modèle suivant sans vous soucier des détails.
Créons un plug-in Backend qui prend en charge un système de chat appelé hoge.
Ça fait longtemps à lire sur Qiita! Pour ceux qui disent, Github est également disponible. Un exemple de configuration de config.py est également inclus. https://github.com/deko2369/errbot-backend-plugin-template
# -*- coding: utf-8 -*-
from errbot.backends.base import Message, ONLINE, Room, \
RoomOccupant, Identifier
from errbot.core import ErrBot
# Can't use __name__ because of Yapsy
log = logging.getLogger('errbot.backends.hoge')
#Charger la bibliothèque du système de chat Hoge(La bibliothèque n'existe pas)
try:
import HogeChatClient
except ImportError:
log.exception("Could not start the hoge backend")
log.fatal(
"You need to install the HogeChatClient package in order "
"to use the Hoge backend. "
"You should be able to install this package using: "
"pip install HogeChatClient"
)
sys.exit(1)
class HogeUser(Identifier):
"""
Une classe qui représente un utilisateur d'un système de chat
Construisez la classe Backend sans instancier directement cette classe_Dans la méthode de l'identifiant
Créer un objet
ref. http://errbot.io/en/latest/errbot.backends.base.html#errbot.backends.base.Identifier
"""
def __init__(self, username, bot):
"""
Initialiser l'utilisateur
username spécifie le nom utilisé dans le système de chat
"""
self._username = username
self._bot = bot
@property
def username(self):
"""
Renvoie le nom de l'utilisateur
"""
self return._username
class HogeRoomOccupant(RoomOccupant, HogeUser):
"""
Une classe qui représente un utilisateur dans la salle de chat d'un système de chat
ref. http://errbot.io/en/latest/errbot.backends.base.html#errbot.backends.base.RoomOccupant
"""
def __init__(self, username, roomname, bot):
"""
Initialiser les utilisateurs dans un salon de discussion particulier
"""
super().__init__(username, bot)
self._room = HogeRoom(roomname, bot)
@property
def room(self):
"""
Renvoie les informations de la chambre
"""
return self._room
class HogeBackend(ErrBot):
"""
Corps de la classe backend
J'écrirai ici l'interaction réelle du système de chat
"""
def __init__(self, config):
"""
Réglage initial
"""
super().__init__(config)
identity = config.BOT_IDENTIY
self.token = identity.get('token', None)
if not self.token:
log.fatal(
'You need to set your token in the BOT_IDENTITY setting '
'in your config.py .'
)
sys.exit(1)
#Initialiser le client en spécifiant le jeton
self.client = HogeChatClient.Client(self.token)
#Créer le propre identifiant du bot
self.bot_identifier = HogeUser('BOT NAME', self)
def build_reply(self, mess, text=None, private=False):
"""
Rédiger un message de réponse
"""
#Construire un message
response = self.build_message(text)
#Identifiant de la source de réponse
response.frm = self.bot_identifier
#Répondre à l'identifiant
response.to = mess.frm
return response
def prefix_groupchat_reply(self, message, identifier):
"""
Modèle de message de réponse au chat de groupe
"""
message.body = '@%s %s' % (identifier.username, message.text)
def build_message(self, text):
"""
Créer un objet de message
"""
return super().build_message(text)
def build_identifier(self, text_repf):
"""
Créer un objet Identifier
Le système de chat Hoge crée l'identifiant dans le format suivant
utilisateur: @<username>
Utilisateurs dans la salle de chat: @<username>#<roomname>
"""
text = text_repr.strip()
if text.startswith('@') and '#' not in text:
return HogeUser(text.split('@')[1], self)
elif '#' in text:
username, roomname = text.split('#')
return HogeRoomOccupant(username.split('@')[1], roomname, self)
raise RuntimeError('Unrecognized identifier: %s' % text)
def serve_once(self):
"""
Une méthode pour recevoir de nouveaux messages du système de chat et les traiter
Ce service_La méthode once est appelée régulièrement par ErrBot
Servir avec une méthode cible de remplacement similaire_Il y a aussi pour toujours
ref. http://errbot.io/en/latest/errbot.backends.base.html#errbot.backends.base.Backend.serve_forever
"""
#Recevez de nouveaux messages
mess = self.client.new_messages()
#Traitez les messages acquis dans l'ordre
#Le message contient également le nom d'utilisateur et le nom de la salle prononcés
for msg in mess:
#Créer un objet Message
m = Message(msg)
m.frm = HogeRoomOccupant(msg.username, msg.roomname, self)
m.to = HogeRoom(msg.roomname, self)
#Rappel de message d'appel
self.callback_message(m)
# @<username>Rappel si contient_Appelez également la mention
#Notez que l'implémentation détaillée est omise
if '@' in msg:
mentions = [HogeUser(username, self), ...]
self.callback_mention(m, mentions)
def send_message(self, mess):
"""
Implémentation de la partie transmission vers le système de chat
"""
self.client.send(mess.body)
def connect(self):
"""
Renvoyer la connexion de la bibliothèque du système de chat
"""
return self.client
def query_room(self, room)
"""
Traitement pour renvoyer des objets HogeRoom à partir de la chaîne de pièce
"""
r = self.client.room_info(room)
return HogeRoom(r.name, self)
@property
def mode(self):
"""
Chaîne unique indiquant le backend actuel
"""
return 'hoge'
@property
def rooms(self):
"""
Renvoie l'instance Room dans laquelle se trouve le bot
"""
return []
def change_presense(self, status=ONLINE, message=''):
"""
Processus appelé lorsque le statut d'entrée du bot change
"""
super().change_presence(status=status, message=message)
class HogeRoom(Room):
"""
Définition de la salle de chat du système de chat Hoge
Implémentez la possibilité pour les bots de se joindre et de créer des salles de discussion
Non réalisable si le client du système de chat ne fournit pas une telle fonctionnalité...
ref. http://errbot.io/en/latest/errbot.backends.base.html#errbot.backends.base.Room
"""
def __init__(self, name, bot):
self._name = name
self._bot = bot
def join(self, username=None, password=None):
"""
bot rejoint la salle
"""
self._bot.client.join_room(self._name)
def leave(self, reason=None):
"""
bot part de la pièce
"""
self._bot.client.leave_room(self._name)
def create(self):
"""
bot crée une pièce
"""
self._bot.client.create_room(self._name)
def destroy(self):
"""
le bot détruit la pièce
"""
self._bot.client.destroy_room(self._name)
@property
def exists(self):
"""
Si la pièce existe
"""
return self._bot.client.exist_room(self._name)
@property
def joined(self):
"""
Si le bot rejoint la salle
"""
return self._bot.client.is_joined(self._name)
@property
def topic(self):
"""
Obtenir le sujet de la salle
"""
return self._bot.client.room_info(self._name).topic
@topic.setter
def topic(self, topic):
"""
Définir le thème de la salle
"""
return self._bot.client.set_room_topic(self._name, topic)
@property
def occupants(self):
"""
Obtenez l'identifiant de l'utilisateur qui existe dans la salle
"""
return [HogeUser(name, self._bot) \
for name in self._bot.client.get_room_usernames(self._name)]
def invite(self, *args):
"""
Inviter des utilisateurs dans la salle
"""
for ident in args:
self._bot.client.invite(self._name, ident.username)
Le côté utilisant Errbot est facile, mais les développeurs qui font un pont (Backend) avec chaque système de chat ont du mal à
Recommended Posts