Erstellen eines Slack Bot mit Python

German (Deutsch) translation by Katharina Grigorovich-Nevolina (you can also view the original English article)

Final product image — What You'll Be Creating

Slack wurde 2014 gegründet und wird als die am schnellsten wachsende Geschäftsanwendung in der Geschichte angepriesen. Derzeit nutzen über 50.000 zahlende Unternehmen das Produkt - einschließlich meines derzeitigen Arbeitsplatzes.

Slack hat sich wirklich von seinen Vorgängern unterschieden, die sich mehr darauf konzentrierten, ein Messaging-System mit einigen Sprach- und Videofunktionen zu sein. Slack hat wirklich neue Maßstäbe gesetzt und arbeitet fleißig daran, auf einem sehr leistungsstarken App-Verzeichnis aufzubauen. Das App-Verzeichnis enthält Hunderte bis Tausende von Integrationen, die eine unglaubliche Flexibilität bieten, um die Effizienz Ihres Unternehmens zu verbessern.

Das Ziel dieses Artikels ist es zu demonstrieren, wie Sie Ihre eigene einzigartige Integration mit Slack erstellen können, indem Sie Python für die Logik nutzen.

Um mich auf das Verständnis der Mechanik der Grundlagen eines Slack Bot zu konzentrieren, werde ich mich auf einen benutzerdefinierten Bot konzentrieren.

Warum erstellt man einen Slack Bot?

Obwohl Slack über ein erstklassiges App-Verzeichnis verfügt, verfügt jedes Unternehmen über einzigartige Geschäftsprozesse. Dies führt dazu, dass viele Unternehmen einfach nicht die perfekte Anwendung für sie finden können.

Hier kommt der Bau eines eigenen Slack Bot ins Spiel.

Die Aufgabe eines Slack-Bots besteht darin, Ereignisse zu empfangen und zu verarbeiten, die durch die Slack-Interaktion Ihres Teams generiert wurden. Slack bietet mindestens 50 verschiedene Ereignistypen, z.B.

message: Eine Nachricht wurde an einen Kanal gesendet.
team_join: Ein neues Mitglied ist dem Team beigetreten.
member_joined_channel: Ein Benutzer ist einem öffentlichen oder privaten Kanal beigetreten.

Und natürlich gibt es noch viele weitere Ereignistypen, mit denen Ihr Bot optional umgehen und reagieren kann. Zum Beispiel ist das team_join-Ereignis ein fantastisches Ereignis, mit dem ein vollständiger Onboarding-Prozess beginnen kann.

Das Ziel dieses Artikels zeigt, wie ein Slack Bot mit dem message-Ereignis interagiert, um bestimmte Aktionen auszuführen, wenn Teammitglieder mit dem Bot interagieren.

Auswahl des richtigen Slack-Bot-Typs

In diesem Artikel werde ich eine Python-Anwendung und einen Slack Bot erstellen, die Ihrem Teamprojekt hinzugefügt werden können, um auf das message-Ereignis zu reagieren.

Zu Beginn muss ich einen Bot auf Slack erstellen. Es können zwei Arten von Bots erstellt werden:

ein benutzerdefinierter Bot
Erstellen einer Anwendung und Hinzufügen eines Bot-Benutzers

In diesem Artikel wird ein benutzerdefinierter Bot erstellt, da ein Anwendungsbot-Benutzer besser geeignet wäre, wenn ich eine Anwendung auf Slack schreiben und veröffentlichen möchte. Da ich möchte, dass dieser Bot für mein Team privat ist, reicht ein benutzerdefinierter Bot aus.

Erstellen Sie einen benutzerdefinierten Slack Bot

Hier kann ein benutzerdefinierter Bot erstellt werden: https://my.slack.com/apps/A0F7YS25R-bots. Wenn Sie bereits bei Ihrem Slack-Konto angemeldet sind, klicken Sie links auf die Schaltfläche Konfiguration hinzufügen. Andernfalls melden Sie sich bei Ihrem Slack-Konto an, bevor Sie fortfahren. Wenn Sie kein Slack-Konto haben, können Sie sich kostenlos anmelden.

Dadurch gelangen Sie zu einer neuen Seite, auf der Sie einen Benutzernamen für Ihren Bot angeben müssen. Geben Sie jetzt Ihren Benutzernamen ein und achten Sie darauf, dass Sie die Namensrichtlinien von Slack befolgen. Wenn Sie einen fantastischen Bot-Namen ausgewählt haben, klicken Sie auf Bot-Konfiguration hinzufügen.

Nachdem Sie Ihren Bot erfolgreich erstellt haben, leitet Slack Sie zu einer Seite weiter, auf der Sie Ihren Bot weiter anpassen können. Ich überlasse diesen Teil deinem kreativen Selbst. Das einzige, was auf dieser Seite benötigt wird, ist das API-Token, das mit xoxb- beginnt. Ich würde dieses Token entweder zur späteren Verwendung an einen sicheren Ort kopieren oder diese Seite einfach offen lassen, bis wir das Token für die Python-Anwendung benötigen.

Einrichten Ihrer Python-Anwendung

Laut der offiziellen Dokumentation von Slack für das Slack Developer Kit für Python wird derzeit Version 2.7 unterstützt. Es wird erwähnt, dass Version 3 in naher Zukunft unterstützt wird.

Ich habe bereits Version 2.7 installiert, daher werde ich mich vorerst an diese Version von Python halten. Wenn Ihre Python-Installation bereits eingerichtet und betriebsbereit ist, können Sie mit dem nächsten Schritt fortfahren. Andernfalls besuchen Sie bitte die Python-Download-Seite und laden Sie die entsprechende Version für Ihr Betriebssystem herunter.

Um das Slack Developer Kit zu installieren, werde ich PyPi verwenden, um die Installation des Slack Client zu vereinfachen. Unter einigen Betriebssystemen kann der Befehl pip direkt an einer Eingabeaufforderung ausgeführt werden. Wenn nicht, müssten Sie den gesamten Pfad zum pip-Programm referenzieren.

Auf meinem Windows-System habe ich beispielsweise den folgenden Befehl ausgeführt, um den Slack-Client an einer Eingabeaufforderung zu installieren (unter Bezugnahme auf den vollständigen Pfad zur Datei pip.exe): \Python27\Scripts\pip install slackclient.

Als Nächstes möchten Sie einen Speicherort für Ihre Anwendung auswählen. Ich benutze gerne GitHub, deshalb habe ich einen python-Hauptordner erstellt, der alle meine verschiedenen Python-Anwendungen enthält. In diesem Ordner habe ich einen Unterordner namens slackbot erstellt.

Sobald ich ausgewählt habe, wo meine Anwendung gehostet werden soll, werde ich den Kern meiner Anwendung in einer Datei namens slackbot.py speichern.

Ihr erster Slack API-Aufruf

Es ist Zeit, die Finger auf die Tastatur zu legen, sich mit Slack zu verbinden und unseren ersten API-Aufruf zu tätigen. Kommen wir gleich zum Code und ich erkläre, was danach passiert:

from slackclient import SlackClient

slack_client = SlackClient("xoxb-*******************")

api_call = slack_client.api_call("users.list")
if api_call.get('ok'):
	users = api_call.get('members')
	for user in users:
		print user.get('name')

Der Code beginnt mit dem Importieren der Slack Client-Bibliothek, gefolgt von der Instanziierung der SlackClient-Klasse mit dem zuvor gespeicherten API-Token Ihres Slack Bot. Stellen Sie sicher, dass Sie das Beispiel-Token in diesem Beispiel durch Ihr Token ersetzen.

Das SlackClient-Objekt wird in einer lokalen Variablen namens slack_client gespeichert, die zur weiteren Interaktion mit Slack verwendet wird.

Mit dem slack_client wird ein API-Aufruf ausgeführt, um eine Liste der Benutzer Ihres Teams abzurufen. Wenn der API-Aufruf erfolgreich war, wird die Liste der Teammitglieder in der users-Variablen gespeichert. Die user-Variable ist ein Array, das mithilfe einer for-Schleife den Namen jedes Teammitglieds in die Konsolenanwendung druckt.

Slack unterstützt verschiedene Arten von Interaktionen mit dem System. Der erste, den wir gerade abgeschlossen haben, hat einen API-Aufruf durchgeführt. Slack bietet viele andere Arten von API-Aufrufen: Web-API, Ereignis-API, Konversations-API, Echtzeit-Messaging-API und SCIM-API. Der API-Aufruf zum Abrufen der Liste der Benutzer nutzte die SCIM-API.

Im nächsten Beispiel werde ich zeigen, wie das Echtzeit-Messaging-System verwendet wird. Sobald wir mit dem Erstellen des endgültigen Bots beginnen, wird die Conversations-API verwendet, um Nachrichten als Antwort auf die Befehle zu senden, auf die unser Bot reagiert.

Verbindung zum Echtzeit-Messaging-System herstellen

Das RTM-System bietet viel Leistung, da Slack Ereignisse sendet, die Ihre Anwendung verarbeiten und sofort darauf reagieren kann. Natürlich gibt es so viele Ereignisse, dass Ihr Bot möglicherweise nicht jedes Ereignis behandeln muss. Um die vielen verschiedenen Ereignisse zu demonstrieren, die einfach bei der Verbindung auftreten, gibt das folgende Beispiel jedes empfangene Ereignis aus.

Schauen wir uns sofort den Code an, um eine Verbindung herzustellen und Slack-Ereignisse zu empfangen:

from slackclient import SlackClient
import time

slack_client = SlackClient("xoxb-****************")

if slack_client.rtm_connect(with_team_state=False):
	print "Successfully connected, listening for events"
	while True:
		print slack_client.rtm_read()
		
		time.sleep(1)
else:
	print "Connection Failed"

Wie im vorherigen Beispiel beginnt dieser Code mit dem Importieren der Slack Client-Bibliothek und instanziiert die SlackClient-Klasse mit demselben API-Token wie zuvor. In diesem Beispiel wird auch die Zeitbibliothek importiert, die später im Code verwendet wird.

Nachdem der SlackClient erfolgreich erstellt wurde, ruft die nächste Codezeile die Methode rtm_connect auf. Dies erfolgt mit einer if-Anweisung. Wenn die Verbindung aus irgendeinem Grund fehlschlägt, wird eine Fehlermeldung an die Konsole ausgegeben. Bei Erfolg wird eine Erfolgsmeldung gedruckt, um uns mitzuteilen, dass wir verbunden und bereit sind, mit Slack-Ereignissen zu interagieren.

Eine endlose while-Schleife wird dann gestartet. Innerhalb dieser Schleife rufe ich die Methode rtm_read der Slack Client-Bibliothek auf.

Die Ergebnisse dieses Aufrufs werden an der Konsole protokolliert. Danach schläft die Anwendung 1 Sekunde lang, bevor sie das nächste potenzielle Ereignis von Slack liest. Unten sehen Sie ein Beispiel dafür, wie es aussieht, Ereignisse beim ersten Verbinden zu lesen:

Successfully connected, listening for events
[]
[{u'type': u'hello'}]
[{u'url': u'wss://lbmulti-yeo0.lb.slack-msgs.com/websocket/Rm8R-Q0PLxK_8UQmBo0Apru-AtL7qnICzeNazVUDQGUCnIY8N51kO07ZUw37jZc4KvXJlu4c1EWDNwTtrXkLzkwn0GBmak_RATHLSFVCCCcht0YLqlgZAS0-6cb1marGhznvmnQStgdW6rd3yub0CpCzmJdgIkRPgIOIB2JurYA=', u'type': u'reconnect_url'}]
[{u'type': u'presence_change', u'user': u'U6RM1S17T', u'presence': u'active'}]
[]
[]

Wenn der Bot verbunden ist, sendet Slack drei Ereignisse, wie oben gezeigt. Da sich dies in einer while-Schleife befindet, erhält es, wenn kein Ereignis vorliegt, ein leeres Array, wie oben gezeigt, mit den leeren Klammern [].

Nachdem wir nun ein grundlegendes Verständnis für das Tätigen eines API-Aufrufs und das Herstellen einer Verbindung zum Echtzeit-Messaging-System von Slack haben, ist es an der Zeit, einen voll funktionsfähigen Slack-Bot aufzubauen.

Mein Slack Bot hört Ereignisse mit dem RTM-System ab. Wenn ein Nachrichtenereignis empfangen wird, das an meinen Bot gerichtet ist, antwortet meine Anwendung dem Benutzer mit einer Antwort auf den empfangenen Befehl.

Den Slack Bot erstellen

Um einen vollständigen Bot zu erstellen, ist ziemlich viel Code erforderlich. Um den endgültigen Code zu organisieren und zu vereinfachen, werde ich die Funktionalität in drei verschiedene Klassen aufteilen: Bot, Event und Command. Diese Klassen sollten durch Ihre eigene Anwendung erweiterbar sein und die Funktionalität Ihres eigenen Bots verbessern. Lassen Sie uns den Zweck jeder der drei verschiedenen Klassen untersuchen:

Die Bot-Klasse ist für die Verbindung zu Slack verantwortlich und beginnt die while-Schleife, um auf Ereignisse zu warten.
Die Ereignisklasse ist dafür verantwortlich, die von Slack empfangenen Ereignisse zu lesen und sie zu analysieren, um nur Nachrichtenereignisse zu behandeln, die direkt an unseren Bot gerichtet sind. Wenn eine Nachricht empfangen wird, ruft sie die Command-Klasse auf und sendet einen API-Aufruf mit der Antwort der Command-Klasse.
Die Befehlsklasse empfängt den Text vom Ereignis und stellt eine angepasste Nachricht bereit, die auf dem empfangenen Befehl basiert. Diese Nachricht wird dann an die ursprüngliche Slack Channel Event-Klasse zurückgesendet, um an den ursprünglichen Kanal der Nachricht gesendet zu werden.

Initialisierung des Slack Bot

Ich hatte zuvor erwähnt, dass mein Python-Anwendungseinstiegspunkt in der Datei slackbot.py platziert ist. Diese Datei enthält das Nötigste, um die Anwendung ins Rollen zu bringen, dh die Bot-Klasse zu instanziieren, die den Rest des Prozesses abwickelt:

1	import bot
2
3	bot.Bot()

Erstellen der Bot-Klasse

Die Bot-Klasse enthält das Herzstück der Konfiguration und Einrichtung des Bots. Schauen wir uns die gesamte Bot-Klasse an, die ich in eine bot.py-Datei eingefügt habe:

import time
import event
from slackclient import SlackClient

class Bot(object):
    def __init__(self):
		self.slack_client = SlackClient("xoxb-*****************")
		self.bot_name = "jamiestest"
		self.bot_id = self.get_bot_id()
		
		if self.bot_id is None:
			exit("Error, could not find " + self.bot_name)
	
		self.event = event.Event(self)
		self.listen()
	
	def get_bot_id(self):
		api_call = self.slack_client.api_call("users.list")
		if api_call.get('ok'):
			# retrieve all users so we can find our bot
			users = api_call.get('members')
			for user in users:
				if 'name' in user and user.get('name') == self.bot_name:
					return "<@" + user.get('id') + ">"
			
			return None
			
	def listen(self):
		if self.slack_client.rtm_connect(with_team_state=False):
			print "Successfully connected, listening for commands"
			while True:
				self.event.wait_for_event()
				
				time.sleep(1)
		else:
			exit("Error, Connection Failed")

Die Datei importiert zunächst die erforderlichen Bibliotheken: time, event und SlackClient. Die Ereignisbibliothek wird als nächstes erstellt.

Mit den importierten Bibliotheken wird nun die Bot-Klasse erstellt. Der Konstruktor der Klasse in der Funktion __init__ richtet einige Variablen ein, die im Rest des Codes verwendet werden. Dies umfasst den slack_client, den bot_name und die bot_id.

Der Name des Bots wird verwendet, um die ID des Bots zu ermitteln. Die ID wird später verwendet, um Ereignisse zu analysieren, die direkt auf den Bot gerichtet sind. Wenn die Anwendung den Bot nicht finden kann, wird die Anwendung mit einem Fehler beendet, da sie ohne die ID nicht fortgesetzt werden kann.

Die Ereignisklasse wird dann instanziiert, um etwas später in der Klasse verwendet zu werden. Als letztes ruft der Konstruktor die listen-Funktion auf, die eine Verbindung zum RTM-System herstellt und die Endlosschleife beginnt, die auf Ereignisse wartet, die der Bot verarbeiten wird.

Die nächste Funktion, get_bot_id, ähnelt dem ersten Beispiel, das die Benutzer durchläuft. Diesmal wird die ID unseres Bots ermittelt, indem der Name in der Benutzerliste gefunden und die ID zurückgegeben wird. Falls der Bot nicht gefunden werden kann, wird None zurückgegeben, wodurch der vorherige Code beendet wird, weil der Bot nicht gefunden werden konnte.

Die letzte Funktion in der Bot-Klasse ist die oben erwähnte listen-Funktion. Diese Funktion sieht dem zweiten Beispiel sehr ähnlich, in dem wir uns zuerst mit dem RTM-System von Slack verbunden haben. Der Hauptunterschied in diesem Beispiel besteht darin, dass die Funktion wait_for_event aufgerufen wird, die als Nächstes in der Ereignisklasse untersucht wird.

Dies vervollständigt die Bot-Klasse und macht sie für das Erstellen des SlackClient und das Starten der Endlosschleife verantwortlich, die auf Ereignisse wartet. Es macht jedoch nichts mit diesen Ereignissen und überlässt diese Verantwortung der Ereignisklasse.

Die Event-Klasse

Der Zweck der Event-Klasse besteht darin, alle vom RTM-System von Slack zurückgegebenen Ereignisse zu lesen. Jedes empfangene Ereignis wird auf eine Nachricht untersucht, die einen Verweis auf die ID des Bots enthält. Das Folgende ist die Ereignisklasse, die ich in eine event.py-Datei eingefügt habe:

import command

class Event:
    def __init__(self, bot):
		self.bot = bot
		self.command = command.Command()
	
	def wait_for_event(self):
		events = self.bot.slack_client.rtm_read()
		
		if events and len(events) > 0:
			for event in events:
				#print event
				self.parse_event(event)
				
	def parse_event(self, event):
		if event and 'text' in event and self.bot.bot_id in event['text']:
			self.handle_event(event['user'], event['text'].split(self.bot.bot_id)[1].strip().lower(), event['channel'])
	
	def handle_event(self, user, command, channel):
		if command and channel:
			print "Received command: " + command + " in channel: " + channel + " from user: " + user
			response = self.command.handle_command(user, command)
			self.bot.slack_client.api_call("chat.postMessage", channel=channel, text=response, as_user=True)

Diese Klasse beginnt mit dem Import der letzten Klasse, die untersucht werden soll, der Command-Klasse. Der Konstruktor der Event-Klasse erhält einen einzelnen Parameter: einen Verweis auf das Bot-Objekt. Dies wird in einer Variablen gespeichert, auf die die anderen Funktionen dieser Klasse zugreifen können. Innerhalb der Funktion __init__ wird eine weitere Variable erstellt, die die zuvor importierte Befehlsklasse instanziiert.

Die nächste Funktion, wait_for_event, ist die Funktion, die von der Klassen-listen-Funktion des Bots aufgerufen wurde. Diese Funktion liest alle Ereignisse, die vom RTM-System von Slack empfangen wurden. Die Funktion rtm_read() gibt ein Array von Ereignissen zurück. Die Funktion wait_for_event prüft, ob das Array Ereignisse enthält. In diesem Fall werden die Ereignisse durchlaufen und die interne Funktion parse_event des Ereignisses aufgerufen.

Die Funktion parse_event empfängt das Ereignis als Eingabe. Anschließend wird im Ereignis text nach einer Eigenschaft gesucht. Wenn diese Eigenschaft vorhanden ist, wird überprüft, ob die text-Eigenschaft einen Verweis auf die ID unseres Bots enthält. Wenn diese Bedingung erfüllt ist, ruft diese Funktion die letzte Funktion in dieser Klasse auf, die Funktion handle_event.

Vor dem Aufruf der Funktion handle_event verwendet die Eigenschaft text die Funktion Python split, wobei das Zeichenfolgentrennzeichen durch die ID des Bots dargestellt wird. Dadurch wird die text-Eigenschaft in ein Array konvertiert. Das erste Element im Array ist die Zeichenfolge, die den Text mit der Bot-ID enthält. Das zweite Element enthält den Rest der Nachricht. Dieses Element wird als Befehl an die oben genannte Funktion handle_event übergeben.

Die letzte Funktion, handle_event, akzeptiert drei Eigenschaften: den Benutzer, der die Nachricht gesendet hat, den Befehl, der gesendet wurde, und den Kanal, in dem sie gesendet wurde.

Die Funktion handle_event stellt sicher, dass der Befehl und der Kanal gültige Werte enthalten. Wenn dies der Fall ist, wird eine benutzerfreundliche Debug-Nachricht an die Konsole ausgegeben, die angibt, welcher Befehl empfangen wurde, auf welchem Kanal er gesendet wurde und welcher Benutzer ihn gesendet hat.

Nach der benutzerfreundlichen Debug-Nachricht ruft die Funktion handle_event die Hauptfunktion aus der zuvor erwähnten Befehlsklasse auf. Das Ergebnis dieser Funktion wird von der Funktion handle_event verwendet, indem ein API-Aufruf ausgeführt wird, der die Antwort der Befehlsklassenfunktion an den Kanal sendet, der das Ereignis ausgelöst hat.

Schauen wir uns nun die Command-Klasse an, um zu sehen, wie sie eine benutzerdefinierte Antwort basierend auf dem vom Benutzer empfangenen Befehl generiert.

Die Command-Klasse

Um unseren Bot zu vervollständigen, ist es Zeit, die letzte Klasse, Command, in einer treffend benannten Datei command.py zu erstellen:

class Command(object):
    def __init__(self):
		self.commands = { 
			"jump" : self.jump,
			"help" : self.help
		}

	def handle_command(self, user, command):
		response = "<@" + user + ">: "
	
		if command in self.commands:
			response += self.commands[command]()
		else:
			response += "Sorry I don't understand the command: " + command + ". " + self.help()
		
		return response
		
	def jump(self):
		return "Kris Kross will make you jump jump"
	
	def help(self):
		response = "Currently I support the following commands:\r\n"
		
		for command in self.commands:
			response += command + "\r\n"
			
		return response

Ich mag es wirklich, wie sich diese Klasse entwickelt hat, weil sie eine solide Grundlage bietet, die leicht erweiterbar ist, um viel mehr Befehle zu verarbeiten, als ich oben beschrieben habe.

Der Konstruktor der Command-Klasse erstellt ein Schlüsselwörterbuch mit einem zugehörigen Funktionsnamen, das ausgeführt wird, wenn der Befehl von der Event-Klasse empfangen wird. In diesem abgekürzten Beispiel enthält das commands-Wörterbuch zwei Befehle: Sprung und Hilfe. Dieses Wörterbuch kann um andere Befehle erweitert werden, die Sie mit Ihrem eigenen Bot verarbeiten möchten.

Die nächste Funktion, handle_command, ist die Funktion, die aufgerufen wird, wenn ein erfolgreiches Ereignis, das eine an unseren Bot gerichtete Nachricht enthält, von der Klasse handle_event des Ereignisses aufgerufen wird.

Die Funktion handle_command akzeptiert zwei Parameter: den Benutzer, der die Nachricht gesendet hat, und den Befehl. Die Funktion beginnt mit dem Erstellen einer Antwortzeichenfolge, die eine Nachricht an den Benutzer weiterleitet, der den Befehl gesendet hat. Die Funktion prüft dann, ob der empfangene Befehl ein gültiger Befehl im Wörterbuch der im Konstruktor definierten Befehle ist.

Wenn der Befehl gültig ist, wird die diesem Befehl zugeordnete Funktion aufgerufen, wobei die Zeichenfolge an die zuvor erstellte response-Variable angehängt wird.

Wenn der Befehl nicht vorhanden ist, wird die Antwort angehängt, um anzuzeigen, dass der Befehl ungültig ist. Es ruft auch die help-Befehlsfunktion auf, um dem Benutzer zu helfen, zu verstehen, welche Befehle von diesem Bot unterstützt werden.

Die verbleibenden Funktionen, jump und help, generieren eine benutzerdefinierte Antwort, die an den Benutzer gesendet wird, der den Befehl initiiert hat.

Wie bereits im Konstruktor erwähnt, kann das Befehlswörterbuch um einen neuen Befehl erweitert werden. Um diesen Vorgang abzuschließen, muss eine zugehörige Funktion erstellt werden, die von der Funktion handle_command automatisch aufgerufen wird.

Testen des Slack Bot

Nachdem die gesamte Codierung abgeschlossen ist, ist es Zeit, unseren neuen Bot zu testen. Zu Beginn müssen wir unser Haupt-Python-Skript ausführen: slackbot.py. Führen Sie dieses Skript an einer Eingabeaufforderung mit Python aus, z.B. python slackbot.py.

Dadurch wird unser Bot gestartet und eine Verbindung zum Echtzeit-Messaging-System von Slack hergestellt. Bei Erfolg sollte unsere Debug-Nachricht auf der Konsole gedruckt werden, um anzuzeigen, dass unser Slack-Bot bereit ist, Befehle zu empfangen.

Um einen Befehl auszuführen, muss unser Bot in einen öffentlichen oder privaten Kanal eingeladen werden. Sobald sich der Bot im Kanal befindet, kann ein Benutzer den Bot anweisen, zu springen oder um Hilfe zu bitten. In meinem Fall würde ich sagen: @jamietest jump. Der Bot würde treffend antworten: @endyourif: Kris Kross will make you jump jump bringen.

Dieser Bot ist nicht auf einen einzelnen Kanal beschränkt. Da der Kanal aus der Ereignismeldung analysiert wird, können Befehle von vielen verschiedenen Kanälen verarbeitet werden.

Jetzt sind Sie an der Reihe, Ihren Bot auszuprobieren und zu sehen, was Sie damit machen können!

Schlussfolgerung

Mein Bot ist jetzt fertig. Ich habe Ihnen hoffentlich die Kraft gezeigt, einen Slack-Bot zu erstellen. Da mehrere Klassen (Bot, Event und Command) jeweils ein einzelnes Problem behandeln, kann die Befehlsklasse erweitert werden, um viel mehr Befehle zu verarbeiten.

Um den vollständigen Quellcode anzuzeigen, habe ich ein GitHub-Repository erstellt.

Denken Sie daran, zögern Sie nicht, zu sehen, was wir zum Verkauf und zum Studium in Envato Market anbieten, und zögern Sie nicht, Fragen zu stellen und Ihr wertvolles Feedback über den unten stehenden Feed zu geben.

Der Himmel ist wirklich endlos, wie dieser Bot erweitert werden kann. Nachfolgend finden Sie eine kurze Liste von Ideen, um die anfängliche Einrichtung von Klassen zu erweitern:

Um einen neuen Befehl hinzuzufügen, erstellen Sie eine neue Funktion nach dem Muster der jump- und help-Funktionen innerhalb der Command-Klasse. Wenn die Funktion erstellt wird, muss sie dem Wörterbuch der verfügbaren Befehle hinzugefügt werden.
Eine weitere großartige Möglichkeit, Ihren Bot weiter zu verbessern, besteht darin, die Funktionalität der Funktion parse_event in der Event-Klasse zu erweitern. Derzeit sucht diese Funktion explizit nach einem Nachrichtenereignis, das unsere Bot-ID im Text enthält. Diese Funktion könnte weiter erweitert werden, um nach anderen Ereignissen zu suchen, z. B. team_join. Dieses Ereignis kann einen neuen Befehl (in der Befehlsklasse) aufrufen, der dem neuen Teammitglied die Onboarding-Dokumente und -Richtlinien Ihres Unternehmens zur Verfügung stellt.
Wenn Sie eine benutzerdefinierte Anwendung erstellen möchten oder Ihre eigenen Slack-Befehle erstellen möchten, können Sie die Erstellung einer benutzerdefinierten Anwendung und das Hinzufügen eines Bot-Benutzers zur Anwendung untersuchen. Viele der Codebeispiele funktionieren mit beiden Bot-Typen.

Ich hoffe, Ihnen hat dieser Artikel über das Erstellen eines Slack Bot mit Python gefallen. Verwenden Sie das Kommentarformular unten, um Ihren Mitlesern mitzuteilen, wie Sie die obigen Beispiele erweitert haben, um einen äußerst robusten Slack Bot zu erstellen!