Eigener Twitter Bot auf dem Raspberry Pi

Dein eigener Twitter Bot auf dem Raspberry Pi

Grundsätzlich sollte man natürlich mit einem Twitter Bot vorsichtig sein und lieber manuell twittern.
Dies gibt dem Ganzen auch eher eine persönliche “Note”.
Allerdings kann es manchmal nützlich sein, einen Bot zu nutzen.
Und wenn man dann auch noch einen Raspberry Pi sein eigen nennt, ist dies schon die halbe Miete :-)

Was wir benötigen

Schauen wir uns erst einmal an, was wir für unser Projekt benötigen werden. Die Liste sieht vielleicht nach viel Arbeit aus, aber glaube mir, so wahnsinnig viel ist das gar nicht:

• Natürlich einen installierten Raspberry Pi
• Ein Twitter-Konto, über den die Tweets gesendet / gelesen werden sollen
• Einen Twitter Developer Zugang – wie man diesen erstellt, erfährst du in diesem Artikel
• Python3
• python3-pip
• Environment Umgebung (Optional, allerdings bezieht sich dieser Artikel auf diese Umgebung) – python3-venv
• Tweepy
• dotenv – um die Keys/Tokens nicht systemweit als Variable freigeben zu müssen
• Putty oder MobaXterm (oder ein anderes vergleichbares Tool)

Wir fangen an den Twitter Bot auf unserem Raspberry Pi zu installieren

Dazu verbinden wir uns natürlich erst einmal mit unserem Raspberry. Ich nutze dafür MobaXterm, aber natürlich funktioniert auch weiterhin Putty oder vergleichbares. Beachte bitte, dass du für die Installationen sudo Rechte benötigst. Welcher User später das Script ausführt ist im Prinzip egal. Lediglich die Rechte müssen entsprechend passen (auch für die Ordner).

Sobald du per ssh eingeloggt bist, prüfen wir direkt ob python3 schon installiert ist (sollte bei neuen Raspberry Installationen vorhanden sein):

python3 --version

Solltest du kein python3 installiert haben, müsstest du es installieren. Hier gibt es unterschiedliche Vorgehensweisen. Vor allem was auch die Version angeht, die du nutzen möchtest. In diesem Artikel möchte ich da aber nicht weiter drauf eingehen. Versuche einfach: sudo apt-get install python3.7.

Weiterhin benötigen wir pip – dies ist ein Tool, das Python-Programmierpakete/Bibliotheken installieren und verwalten kann, die wir in unserem Projekt benötigen werden.

sudo apt-get update && sudo apt install python3-pip

Um eine halbwegs “robuste” Programmierumgebung zu haben, laden wir noch einige Programmbibliotheken und dev-Tools nach:

sudo apt-get install build-essential libssl-dev libffi-dev python3-dev

Ich nutze für Python-Projekte gerne eine isolierte “virtuelle” Umgebung mit eigenen Abhängigkeiten und – falls notwendig – auch mit eigener PythonVersion (sehr praktisch um die Scripte unter anderen Versionen testen zu können)

Auch hier gibt es wieder mehrere Möglichkeiten die zum Ziel führen. Wir beschränken uns auf das Modul venv
Also installieren wir dies fix:

sudo apt-get install python3-venv

Nach dieser Installation können wir beginnen, unsere Umgebung zu erstellen. Dafür legen wir im Grunde lediglich einen neuen Ordner an. Ich nutze für dieses Tutorial den User “pi” und erstelle einfach in seinem Home Verzeichnis einen neuen Ordner und wechsle danach in diesen:

mkdir tutorial_twitter_bot
cd tutorial_twitter_bot

Wenn du jetzt in deinem neuen Ordner bist, kannst du die eigentliche virtuelle Umgebung erstellen. Wie du diese benennst, ist egal (DEINE_ENV ersetzen). Ich nutze dafür dwc_tut.

python3 -m venv DEINE_ENV

Jetzt werden einige Dateien/Ordner angelegt. Letztendlich sieht es dann in etwa so aus:

In den Ordnern sind alle benötigten Grundpakete/Elemente vorhanden um dein Projekt isoliert ausführen zu können. So vermischen sich keine Projekte untereinander bzw. auch nicht mit dem Server-System.

Damit wir auch in dieser Umgebung arbeiten können, starten wir diese nun: Hier musst du DEINE_ENV mit dem Namen der gerade erzeugten ersetzen (in meinem Fall: dwc_tut)

source ./DEINE_ENV/bin/activate

Achte auf den Prompt: dieser hat sich jetzt geändert und lautet so, wie du deine env genannt hast. Dies signalisiert dir, dass du dich in deiner isolierten Umgebung befindest. Möchtest du diese wieder verlassen, reicht ein einfaches deactivate aus und du siehst deinen ursprünglichen Prompt. Wir bleiben aber in unserer Umgebung (oder aktivieren diese wieder, falls du deactivate ausprobiert hast :-P )

Wir wollen nun endlich Tweepy installieren. Auch dies ist kein Hexenwerk – achte lediglich darauf, dass dein Prompt deiner virtuellen Umgebung entspricht. Denn hier wollen wir Tweepy ja hinzufügen. In meinem Beispiel beziehe ich mich auf die Version 3.10.0 von Tweepy. Neuere Versionen könnten möglicher Weise nicht mehr mit dem Beispielen hier funktionieren. Um immer die neueste Version zu installieren, benutzte pip install tweepy. Um die hier verwendete Version zu nutzen installiere es so:

pip install -Iv tweepy==3.10.0

Noch eine kleine Installation dann legen wir auch sofort los… Diese ist auch optional und muss nicht verwendet werden. Ich kann sie allerdings aus folgendem Grund empfehlen: Die benötigen Access-Keys und Token werden wir später in systemweiten Variablen hinterlegen und nicht im Script selbst. Somit wären diese dann auch wirklich systemweit nutzbar/einsehbar…
Mit dem Paket dotenv ermöglichen wir uns, diese Daten in eine .env Datei abzulegen und diese dann nur im Projekt nutzen zu können.

pip install python-dotenv

Jetzt haben wir alle benötigten Pakete/Bibliotheken in unserer virtuellen Umgebung installiert. Damit wir später auch genau wissen, was wir eigentlich benötigen, falls wir das Projekt weitergeben bzw. unter einer anderen Umgebung nutzen möchten, lassen wir uns jetzt noch final eine requirements.txt erstellen. Diese kann dann dazu genutzt werden, in anderen Umgebungen alle benötigten Abhängigkeiten zu installieren.

pip freeze > requirements.txt

Kleiner Hinweis, solltest du jetzt nachträglich noch Pakete installieren, müsstest du den freeze Befehl natürlich wiederholen.

Ich will Code sehen! Der Twitter Bot nimmt Formen an

Die Vorbereitungen sind endlich final abgeschlossen und wir werden jetzt beginnen unseren Bot Leben einzuhauchen.
Allerdings benötigen wir vorher noch den Zugang zum Twitter-Developer Bereich. Solltest du noch keinen haben, dann schaue bitte in diesem Artikel nach wie man einen erstellt und wo die Keys/Tokens zu finden sind.
Wir brauchen:

API key:
API Secret key:
Access token:
Acces token secret:

Die .env Datei mit unseren Keys und Token

Wie weiter oben schon erwähnt werden wir die Keys/Token nicht im Script fest hinterlegen, sondern in Systemvariablen schreiben. Ich beziehe mich hier auf die Variante über ein .env File, da die Variablen ansonsten für alle im System sichtbar und nutzbar wären. Dafür haben wir die Installation von dotenv benötigt!
Kurzes Beispiel, ich habe in der aktivierten dwc_tut Umgebung den Access-Key in systemweiten Variablen exportiert:

export CONSUMER_KEY=”zEk9htretrterwtwxVQJQrFO99″
export CONSUMER_SECRET=”GxRLFsdmzoKeltezzezewzeK8nsi9plnje1LoqZ7HQ”

Wenn ich diese Umgebung jetzt mit deactivate verlasse, und mir dann mit printenv die Systemvariablen anschaue, sehe ich folgendes:

Und genau dies möchte ich aus mehreren Gründen vermeiden….
Daher erstellen wir, in unserem Projektordner, eine neue Datei mit Namen .env :

nano .env

Als Inhalt kommen hier unsere Variablen und Deine Keys sowie die Token aus der Twitter-API:

API_KEY="DEIN API KEY"
API_SECRET_KEY="DEIN API SECRET KEY"
ACCESS_TOKEN="DEIN ACCESS TOKEN"
ACCESS_TOKEN_SECRET="DEIN ACCESS SECRET TOKEN"

Datei speichern nicht vergessen… achja… du musst natürlich nicht nano benutzen. Vi(m) geht natürlich auch. Aber vi und ich mögen uns nicht so sehr :-P

Die config_connection.py für den Twitter Bot – für alle weiteren Scripte notwendig

Du solltest dich jetzt weiterhin in deinem neuen angelegten Ordner befinden und die virtuelle Umgebung gestartet haben. Zur Erinnerung, dies erkennst du an dem veränderten Prompt.

Erstelle eine Datei config_connection.py mit nano config_connection.py und folgendem Inhalt: (kleiner Hinweis für alle nicht Python-Nutzer: Bei Python ist es enorm wichtig die TABs einzuhalten. Denn ansonsten wird das Script nicht funktionieren. Wer mit nano / vi dabei Probleme hat, sollte zum Beispiel Notepad++ oder VisualStudioCode benutzen. Danach die Datei mit MobaXterm / FileZilla usw. in den entsprechenden Ordner laden).

# tutorial_twitter_bot/config_connection.py
import tweepy
import os
from dotenv import load_dotenv

load_dotenv()
# Key und Token aus den env.Variabeln holen
api_key = os.getenv("API_KEY")
api_secret_key = os.getenv("API_SECRET_KEY")
access_token = os.getenv("ACCESS_TOKEN")
access_token_secret = os.getenv("ACCESS_TOKEN_SECRET")

auth = tweepy.OAuthHandler(api_key, api_secret_key)
auth.set_access_token(access_token, access_token_secret)

# Verbindung zur API herstellen
api = tweepy.API(auth, wait_on_rate_limit=True,
        wait_on_rate_limit_notify=True)
# testen ob die Verbindung auch klappt
if api.verify_credentials() == False:
    print("Fehler bei der Verbindung. Bitte prüfe die Keys und Token!")
else:
    print("Authentication OK")
    def dwc_create_api():
        return api

Wenn du Schritt für Schritt bisher alles erledigt hast, dann kannst du direkt testen ob deine Verbindung zur Twitter-API auch funktioniert.
Dies erfolgt mit:

python config_connection.py

Und noch ein Hinweis: du kannst in deiner virtuellen Umgebung “python” nutzen, da hier python3 als Standard läuft. In deiner “normalen” Umgebung wird mit “python” in der Regel die 2er Version gestartet. Daher müsstest du dort dann “python3” benutzen.

Im Idealfall solltest du jetzt so etwas sehen:

Bekommst du hingegen dies angezeigt, solltest du deine Einträge in der .env nochmal prüfen bzw. diese erstellen:

Uiuiuiui…. qualmt der Kopf? Kurze Pause für einen Kaffee? Ich hole mir auch mal fix einen… wenn der nicht schon wieder leer ist…

Unser erstes “echtes” Script für den Twitter Bot

Beginnen wir damit, ein Script zu erstellen, welches neue Follower automatisch zurück folgt.
Erstelle mit einem Editor deiner Wahl bitte die Datei dwc_follow.py und füge den Code hinein. Achte auch hier unbedingt auf die Formatierung / die Tab´s.

#!/usr/bin/env python
# tutorial_twitter_bot/dwc_follow.py

import tweepy
from config_connection import dwc_create_api
import time

def dwc_follow(api):
    print("Auf Follower warten und folgen")
    for follower in tweepy.Cursor(api.followers).items():
        if not follower.following:
            print(f"Folgen jetzt {follower.name}")
            follower.follow()

def main():
    api = dwc_create_api()
    while True:
        dwc_follow(api)
        print("Suchen und warten...")
        time.sleep(60)

if __name__ == "__main__":
    main()

Bevor wir dieses Script jetzt starten noch ein paar Erklärungen dazu.
Im oberen Bereich importieren wir die benötigten Bibliotheken sowie die zuvor erstellte api-Funktion (dwc_create_api) aus der Datei config_connection. Denn mit dieser stellen wir ja die Verbindung zu der Twitter-API her.

Die Funktion dwc_follow prüft unter anderem ob wir der Person, die uns jetzt folgt, auch schon folgen. Sollte dies nicht der Fall sein, sorgt der Bot dafür, dass wir dieser jetzt auch folgen. (Man man… so viele “folgen” in einem Satz….)

Die Funktion def_main macht eigentlich nicht wirklich viel mehr als zum einen die API zu initialisieren und dann auf einen “Follower” zu warten. Alle 60 Sekunden ruft sie die dwc_follow Funktion auf.
Das bedeutet, sollte uns JETZT jemand neu folgen, werden wir diese Person in spätestens 60 Sekunden zurück folgen.

Teste es einfach mal, indem du mit python dwc_follow.py das Script startest und dem Account mit einem anderen neu folgst (oder erst entfolgst und dann wieder folgst.)

Beenden kannst du das Script jederzeit mit STRG + C.

Bestimmte #Hashtags mit dem Twitter Bot retweeten

Ein weiteres Script, welches recht beliebt ist, sucht nach bestimmten #Hashtags und retweetet diese automatisch.
Hier kann man zum Beispiel andere Streamer unterstützen oder seiner eigenen Community einen #Hashtag geben den der Bot dann retweetet.
Auch hier die kleine Warnung: Achte darauf, dass du deine Community nicht vollspammst. Zum einen fände diese das sicher eher nervig und zum anderen mag Twitter dies auch nicht unbedingt…

Beginnen wir erneut mit dem erstellen einer Datei: dwc_retweet.py in Deinem Projekte-Ordner und fügen den folgenden Inhalt hinzu:
(TAB´s sind wichtig… ;-) )

#!/usr/bin/env python
# tutorial_twitter_bot/dwc_retweet.py

import tweepy
from config_connection import dwc_create_api
import time

class dwc_retweet_listener(tweepy.StreamListener):
    def __init__(self, api):
        self.api = api
        self.me = api.me()

    def on_status(self, tweet):
        print(f"Verarbeite Tweet ID: {tweet.id} von User: {tweet.user.name}")
        # Wenn der Tweet bereits ein retweet ist, oder mein eigener Account der Verfasser ist, wird er ignoriert
        if tweet.in_reply_to_status_id is not None or tweet.user.id == self.me.id:
            #print("nicht twittern")
            return
        # Wenn er noch nicht durch uns retweeted wurde, dann wird er es jetzt
        if not tweet.retweeted:            
            try:
                tweet.retweet()
                print(f"Tweet von {tweet.user.name} wurde erfolgreich retweeted")
                time.sleep(10) #keinen zu niedrigen Wert nehmen. Spam mag Twitter nicht...
            except tweepy.TweepError as error:
                print('\Retweet nicht erfolgreich. Fehler: ')
                print(error.reason)
                time.sleep(60 * 15) #Wartet nach einem Fehler 15 Minuten 

    def on_error(self, status):
        print(status)

def main(keywords):
    api = dwc_create_api()
    dwc_tweet_listener = dwc_retweet_listener(api)
    stream = tweepy.Stream(api.auth, dwc_tweet_listener)
    stream.filter(track=keywords, languages=["de"]) #Sprache sollte klar sein, die Wörter werden weiter unten definiert

if __name__ == "__main__":
    main(["DarkWolfCave", "Twitch"]) #nach diesen, durch ein [,] getrennten Wörtern, sucht der Bot (ODER Verknüpfung)

In der letzten Zeile kannst du die Hashtags angeben, nachdem der Bot suchen soll. Es ist eine sogenannte “OR” Verknüpfung. Das heißt, dass der Bot auf jedes Wort anspringt. Im Grunde sind dies auch keine wirklichen Hashtags.. denn wenn jemand im Text z.B. “Twitch ist toll” schreiben würde, dann retweetet der Bot diesen Beitrag auch. Unter “languages” kannst du noch einstellen welche Sprache der Beitrag sein soll.

Die beiden “sleep” Werte solltest du so lassen oder höher einstellen. Nur weniger wäre wegen der bereits erwähnten Spam-Flut nicht zu empfehlen.

Starten kannst du das Script wie gewohnt in deiner virtuellen Umgebung mit python dwc_retweet.py. Und beenden mit STRG + C.

Du siehst hier alle Tweets die der Bot mit dem entsprechenden Keyword gefunden hat. Aber nicht jeder wird retweetet. Manche sind bereits retweets und fallen somit raus. Schauen wir und den rot markierten Eintrag in dem Bild mal an.
Dieser Tweet wird auch verworfen da er von meinem eigenen Bot-Account ist (ok, UND weil es ein retweet war…).

Aber ich denke du hast verstanden wie, bzw. wann ein Beitrag retweetet wird.

Wir twittern random! Auch hier wieder mit unserem Twitter Bot auf dem Raspberry Pi

Manchmal möchte man automatische Tweets senden die zum Beispiel Zitate enthalten oder auf spezielle Aktionen hinweisen sollen. Damit diese aber nicht zu eintönig sind, sollen diese sich per Zufall abwechseln.
Ein, wirklich SEHR, einfaches Script dafür ist das Folgende. Hier gibt es zum Beispiel keine Prüfung damit ein Post nicht zweimal hintereinander gesendet wird. Aber für mal zwischendurch sollte dies dennoch reichen.
Und wenn du magst, kannst du natürlich auch den Code erweitern.

Wir erstellen also wieder eine neue Datei: dwc_random_tweet.py mit unserem Lieblingseditor und passen auf die TAB´s auf während wir copy&paste benutzen:

#!/usr/bin/env python
# tutorial_twitter_bot/dwc_random_tweet.py

import tweepy
from config_connection import dwc_create_api
import time
import random

def dwc_random_tweet(api, messages):
    message = random.choice(messages)
    try:
        api.update_status(status=message)
        print("Twittern erfolgreich! Nachricht: {}".format(message))
    except tweepy.TweepError as error:
                print('\Twittern nicht erfolgreich. Fehler: ')
                print(error.reason)
                time.sleep(60 * 15) #Wartet nach einem Fehler 15 Minuten 

while True:
    api = dwc_create_api()
    messages = [
        "Ich wünsche allen einen schönen Tag. #Tag #entspannen #Tutorial",
        "No place like 127.0.0.1 oder: No place like localhost. Bedeutung: Kein Platz ist so schön wie das eigene Zuhause. #Tutorial",
        "The code is documentation enough! #programming #Tutorial",
        "Stay Home! Und schau dir meine Tutorials an. #Tutorial",
    ]
    dwc_random_tweet(api, messages)
    print("Waiting...")
    time.sleep(60 * 60) #1 Stunde warten bis zum nächsten Tweet

Hier gibt es auch gar nicht viel zu erklären. Deine Nachrichten schreibst du in das Array “messages” – immer mit ” ” umschlossen und mit einem Komma getrennt. Achte auf die Länge. Sonst kürzt Twitter einfach. Wie gesagt, hier ist keinerlei Prüfung eingebaut.

Nach einem Tweet wartet der Bot 60 Minuten bis er erneut etwas sendet. Dies solltest du entsprechend anpassen und auch dabei wieder an die Twitter-Regeln und an deine Community denken.

Für alle Lesemuffel gibt es hier ein Video