Ich habe ein Backend-Plug-In für Pythons ChatBot-Tool Errbot erstellt, daher schreibe ich auf, wie es erstellt wird.
Da die neueste Version von Errbot nur die Python3-Serie unterstützt, verwendet dieses Dokument auch die Python3-Serie.
Ein Plug-In, das Errbot mit einem Chat-System (Slack, HipChat usw.) verbindet. Wichtige Chat-Systeme wie Slack und HipChat haben offizielle Backend-Plugins. (Ich glaube also nicht, dass dieses Dokument gelesen wird, es sei denn, es gibt ein gutes Geschäft ...)
Ich möchte, dass Bot darüber spricht! Informationen zum Erstellen eines normalen Plug-Ins finden Sie unter http://errbot.io/en/latest/user_guide/plugin_development/index.html.
Lesen Sie zunächst die Seite [Erweiterte] Backend-Entwicklung so oft wie möglich. Es ist kein so langes Dokument, aber Englischkenntnisse, Englischkenntnisse.
Nachfolgend finden Sie eine kurze Erklärung.
Alle Backend-Plugins erben von der ErrBot-Klasse.
Überschreiben Sie dann die in dieser ErrBot-Klasse vorhandenen Methoden so oft wie nötig und fahren Sie mit der Implementierung fort. Da die ErrBot-Klasse auch die Backend-Klasse erbt, müssen viele Methoden unerwartet implementiert werden.
In Bezug auf die geerbte Klasse gibt es viele Methoden mit "NotImplementedError", und der Entwickler implementiert sie entsprechend der Funktion des Chat-Systems, das er / sie unterstützen möchte.
Alle Backend-Plugins müssen ** Benutzer-IDs ** und ** Benutzer-IDs in Chatrooms ** verwalten. Die Methode "build_identifier" ist besonders wichtig und muss diese Bezeichnerinstanzen aus einer bestimmten Zeichenfolge zurückgeben.
Bitte beachten Sie, wie die Kennung in der folgenden Vorlage verwendet wird, ohne sich um die Details zu kümmern.
Lassen Sie uns ein Backend-Plug-In erstellen, das ein Chat-System namens hoge unterstützt.
Es ist lange her, über Qiita zu lesen! Für diejenigen, die sagen, Github ist auch verfügbar. Ein Einstellungsbeispiel für config.py ist ebenfalls enthalten. 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')
#Laden Sie die Hoge-Chat-Systembibliothek(Bibliothek existiert nicht)
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):
"""
Eine Klasse, die einen Benutzer eines Chat-Systems darstellt
Erstellen Sie die Backend-Klasse, ohne diese Klasse direkt zu instanziieren_In der Bezeichnermethode
Erstellen Sie ein Objekt
ref. http://errbot.io/en/latest/errbot.backends.base.html#errbot.backends.base.Identifier
"""
def __init__(self, username, bot):
"""
Benutzer initialisieren
Benutzername gibt den Namen an, der im Chat-System verwendet wird
"""
self._username = username
self._bot = bot
@property
def username(self):
"""
Gibt den Namen des Benutzers zurück
"""
self return._username
class HogeRoomOccupant(RoomOccupant, HogeUser):
"""
Eine Klasse, die einen Benutzer im Chatroom eines Chat-Systems darstellt
ref. http://errbot.io/en/latest/errbot.backends.base.html#errbot.backends.base.RoomOccupant
"""
def __init__(self, username, roomname, bot):
"""
Initialisieren Sie Benutzer in einem bestimmten Chatraum
"""
super().__init__(username, bot)
self._room = HogeRoom(roomname, bot)
@property
def room(self):
"""
Gibt Rauminformationen zurück
"""
return self._room
class HogeBackend(ErrBot):
"""
Backend-Klassenkörper
Ich werde hier die eigentliche Interaktion des Chat-Systems schreiben
"""
def __init__(self, config):
"""
Grundeinstellung
"""
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)
#Initialisieren Sie den Client durch Angabe eines Tokens
self.client = HogeChatClient.Client(self.token)
#Erstellen Sie die eigene Kennung des Bots
self.bot_identifier = HogeUser('BOT NAME', self)
def build_reply(self, mess, text=None, private=False):
"""
Verfassen Sie eine Antwortnachricht
"""
#Erstellen Sie eine Nachricht
response = self.build_message(text)
#Antwortquellen-ID
response.frm = self.bot_identifier
#Antwort an Kennung
response.to = mess.frm
return response
def prefix_groupchat_reply(self, message, identifier):
"""
Vorlage der Antwortnachricht zum Gruppenchat
"""
message.body = '@%s %s' % (identifier.username, message.text)
def build_message(self, text):
"""
Erstellen eines Nachrichtenobjekts
"""
return super().build_message(text)
def build_identifier(self, text_repf):
"""
Erstellen eines Identifier-Objekts
Das Hoge-Chat-System erstellt Identifier im folgenden Format
Nutzer: @<username>
Benutzer im Chatraum: @<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):
"""
Eine Methode, um neue Nachrichten vom Chat-System zu empfangen und zu verarbeiten
Dieser Aufschlag_Die einmalige Methode wird regelmäßig von ErrBot aufgerufen
Servieren Sie einer ähnlichen Override-Zielmethode_Es gibt auch für immer
ref. http://errbot.io/en/latest/errbot.backends.base.html#errbot.backends.base.Backend.serve_forever
"""
#Neue Nachrichten erhalten
mess = self.client.new_messages()
#Verarbeiten Sie die erfassten Nachrichten der Reihe nach
#Die Nachricht enthält auch den Benutzernamen und den gesprochenen Raumnamen
for msg in mess:
#Erstellen Sie ein Nachrichtenobjekt
m = Message(msg)
m.frm = HogeRoomOccupant(msg.username, msg.roomname, self)
m.to = HogeRoom(msg.roomname, self)
#Rückruf der Anrufnachricht
self.callback_message(m)
# @<username>Rückruf falls enthalten_Rufen Sie auch Erwähnung
#Beachten Sie, dass eine detaillierte Implementierung weggelassen wird
if '@' in msg:
mentions = [HogeUser(username, self), ...]
self.callback_mention(m, mentions)
def send_message(self, mess):
"""
Implementierung des Übertragungsteils zum Chat-System
"""
self.client.send(mess.body)
def connect(self):
"""
Geben Sie die Verbindung der Chat-Systembibliothek zurück
"""
return self.client
def query_room(self, room)
"""
Verarbeitung zum Zurückgeben von HogeRoom-Objekten aus der Raumzeichenfolge
"""
r = self.client.room_info(room)
return HogeRoom(r.name, self)
@property
def mode(self):
"""
Eindeutige Zeichenfolge, die das aktuelle Backend angibt
"""
return 'hoge'
@property
def rooms(self):
"""
Geben Sie die Room-Instanz zurück, in der sich der Bot befindet
"""
return []
def change_presense(self, status=ONLINE, message=''):
"""
Prozess wird aufgerufen, wenn sich der Eingabestatus des Bots ändert
"""
super().change_presence(status=status, message=message)
class HogeRoom(Room):
"""
Definition des Chatrooms des Hoge-Chat-Systems
Implementieren Sie die Möglichkeit für Bots, sich anzuschließen und Chatrooms zu erstellen
Nicht implementierbar, wenn der Chat-System-Client solche Funktionen nicht bereitstellt...
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 betritt den Raum
"""
self._bot.client.join_room(self._name)
def leave(self, reason=None):
"""
Bot geht aus dem Raum
"""
self._bot.client.leave_room(self._name)
def create(self):
"""
Bot schafft einen Raum
"""
self._bot.client.create_room(self._name)
def destroy(self):
"""
Bot zerstört den Raum
"""
self._bot.client.destroy_room(self._name)
@property
def exists(self):
"""
Ob der Raum existiert
"""
return self._bot.client.exist_room(self._name)
@property
def joined(self):
"""
Ob der Bot den Raum betritt
"""
return self._bot.client.is_joined(self._name)
@property
def topic(self):
"""
Raumthema abrufen
"""
return self._bot.client.room_info(self._name).topic
@topic.setter
def topic(self, topic):
"""
Raumthema einstellen
"""
return self._bot.client.set_room_topic(self._name, topic)
@property
def occupants(self):
"""
Holen Sie sich die Kennung des Benutzers, der im Raum existiert
"""
return [HogeUser(name, self._bot) \
for name in self._bot.client.get_room_usernames(self._name)]
def invite(self, *args):
"""
Laden Sie Benutzer in den Raum ein
"""
for ident in args:
self._bot.client.invite(self._name, ident.username)
Die Seite mit Errbot ist einfach, aber der Entwickler, der mit jedem Chat-System eine Brücke (Backend) erstellt, hat es schwer w
Recommended Posts