© khak/Shutterstock.com
Vous avez peut-être vu un tweet précédé d’un petit tag”automatisé”. Cette balise indique qu’un robot a créé le tweet au nom d’un utilisateur qui a déterminé le type de messages que ce bot doit publier et à quel moment. Bien que l’idée d’avoir un robot personnel qui crée des tweets pour vous semble être un défi de taille, c’est en fait étonnamment facile ! Alors, voici comment vous pouvez faire fonctionner votre propre bot Twitter.
Prérequis
Tout d’abord, vous devrez effectuer quelques tâches prérequises qui vous permettront de configurer l’API de Twitter. Pour commencer, vous aurez besoin d’un compte développeur. Ceux-ci sont faciles à obtenir; Twitter les distribue gratuitement. Suivez ce lien pour commencer votre parcours de développeur Twitter. (Non, vraiment. J’ai un compte de développeur Twitter juste pour cet article.)
Ensuite, vous devrez créer un projet dans le portail des développeurs. Pour ce faire, vous devrez entrer quelques informations concernant votre projet. Par exemple, vous devrez fournir le pseudo du compte que vous souhaitez inscrire au projet et l’adresse e-mail associée. Vous devrez également identifier le pays à partir duquel vous exploiterez votre projet, votre cas d’utilisation spécifique et si vous travaillerez avec des entités gouvernementales. Enfin, vous devrez vérifier votre adresse e-mail une fois que vous aurez rempli le formulaire ci-dessous.
Vous devrez également créer une application avec les informations d’identification dont vous avez besoin pour utiliser l’API Twitter V2.0. Ceci est simplement réalisé; vous serez accueilli par un écran vous demandant de nommer votre application pour obtenir une clé API dès que vous aurez terminé la vérification de l’e-mail.
Vous devrez également télécharger les dépendances Python, que vous pouvez trouver ici. Si vous ne le faites pas, vous ne pourrez même pas commencer puisque vous ne pourrez pas télécharger les packages dont vous avez besoin pour créer un bot Twitter.
Étape 1 : Tweetez au nom de votre Bot
Bien que cela puisse sembler oxymorique de tweeter au nom de votre bot, vous devez essayer les fonctionnalités de votre bot avant de pouvoir commencer à le créer. Par exemple, vous ne voudriez pas parcourir la moitié de votre script Python pour découvrir qu’il y a une erreur critique dans votre clé API et que vous avez besoin de l’aide de l’assistance Twitter.
Twitter a créé un site Web que vous pouvez utiliser pour tweeter manuellement au nom de votre bot à l’aide de la fonctionnalité de l’API de bot. Ce site Web tweetera un fait de chien sur le compte Twitter auquel vous vous êtes connecté si le compte est attaché à un clé API de bot fonctionnelle. Le reste de cet article vous apprendra comment créer essentiellement votre propre version de ce site Web qui s’exécute sur votre base de données et tweete automatiquement plutôt que de lancer un tweet manuellement.
Étape 2 : Gérer les jetons Oauth 2.0 avec un Base de données
La première chose que vous devez faire est de gérer les jetons de votre application. Les jetons OAuth 2.0 ne sont valides que pendant deux heures après leur génération. Étant donné que les robots sont généralement programmés pour publier eux-mêmes une ou plusieurs fois par jour, sans intervention du créateur, ils doivent être capables de gérer eux-mêmes la génération, le stockage et l’actualisation des clés.
Puisque vous Si vous avez besoin d’un endroit pour stocker les jetons générés, vous devrez configurer une base de données dans laquelle votre application pourra puiser pour voir si elle contient des jetons utilisables et pour que davantage de jetons soient stockés au fur et à mesure qu’ils sont générés. Ceci est particulièrement important si votre bot est conçu pour tweeter plus d’une fois toutes les deux heures.
Si votre bot ne tweete qu’une fois toutes les deux heures, les jetons auront déjà expiré au moment où votre bot commencera à tweeter de nouveau. Vous aurez toujours besoin d’un endroit pour stocker les jetons pendant que votre bot les gère et pour stocker vos jetons d’actualisation, de sorte que vous ne pouvez pas vous passer du développement d’une base de données pour vos jetons en faisant en sorte que votre bot tweete moins souvent.
Vous pouvez utiliser Render pour créer votre base de données, ce qui rend une base de données Redis compatible avec Twitter. Vous pouvez consulter leurs tarifs et programmes ici. Vous devrez également créer un programme pour vous connecter à Redis depuis l’extérieur des programmes de Render.
Vous pouvez afficher toutes les informations dont vous avez besoin pour configurer et interfacer avec votre instance Redis dans Documentation de Render.
Une fois que vous avez créé votre base de données, vous aurez besoin utiliser votre clé externe pour définir la variable d’environnement de votre terminal sur votre Redis. Vous pouvez le faire en saisissant la chaîne suivante dans votre terminal.
export
REDIS_URL=’external_connection_string’
Vous voudrez remplacer’external_connection_string’par la variable externe qui ressemble à ceci : rediss://username :[email protected]:port (c’est-à-dire rediss://example :[email protected]:4040).
Étape 3 : Installez les packages prérequis
Vous devrez installez des packages vous permettant d’interfacer avec l’API Twitter depuis l’extérieur des sites Web de Twitter. Une fois que vous avez configuré votre environnement Redis avec votre terminal, vous devrez saisir les éléments suivants dans votre terminal :
pip install requests redis requests_oauthlib flask
Étape 4 : Création de votre Fichier main.py
Nous utiliserons Python comme langage de codage pour créer ce robot. Cependant, Python n’est pas le seul langage que vous pouvez utiliser pour créer des bots Twitter. Pourtant, si vous connaissez un autre langage de programmation, vous ne seriez pas ici… n’est-ce pas ?
Maintenant que vous avez vos packages prérequis, vous devrez créer un fichier main.py pour votre bot. Vous pouvez le faire en saisissant les chaînes suivantes dans votre terminal :
mkdir bot-name-variable
cd bot-name-variable
touch main.py
Remplacez simplement”bot-name-variable » avec quelque chose qui décrit votre bot Twitter, comme « dog-fact-twitter-bot » ou « pandas-hourly-twitter ». Le monde vous appartient en ce qui concerne les noms, mais assurez-vous de pouvoir vous en souvenir plus tard.
Étape 5 : Modifier votre bot Twitter
Ensuite, vous devrez modifier le main.py fichier dans le studio de code de votre choix. C’est à vous de décider quel studio de code vous utilisez. Assurez-vous que toutes vos bases de données Python sont téléchargées et prêtes à l’emploi, car elles seront nécessaires pour votre bot Twitter, même si vous copiez et collez notre code dans le studio.
Tout d’abord, vous devrez importez tous les packages nécessaires au fonctionnement de votre bot Twitter. Vous pouvez le faire avec le bloc de code suivant.
import base64
import hashlib
import os
import re
import json
import requests
import redis
from requests.auth import AuthBase, HTTPBasicAuth
from requests_oauthlib import OAuth2Session, TokenUpdated
from flask import Flask, request, redirect, session, url_for, render_template
Puisque vous utiliserez une base de données Redis, vous aurez besoin pour l’enregistrer dans sa propre variable, que Twitter vous recommande poliment de nommer”r”. La définition de la variable peut être effectuée avec le bloc de code suivant.
r=redis.from_url(os.environ[“REDIS_URL”])
Maintenant, vous aurez besoin d’une variable que votre code peut utiliser pour initialiser votre Application Twitter. Utilisez le bloc de code suivant pour ce faire.
app=Flask(__name__)
app.secret_key=os.urandom(50)
Vous devrez autoriser OAuth 2.0 pour autoriser les tweets au nom d’un autre utilisateur. Vous pouvez le faire en suivant les étapes décrites dans le portail des développeurs sous”Paramètres d’authentification de l’utilisateur”.
Le bot aura besoin d’un URI de redirection, également appelé URL de rappel. Pour tester le bot localement, saisissez ce qui suit :
http://127.0.0.1:5000/oauth/callback
Sinon, vous pouvez le définir sur le site Web que vous utiliserez pour publier des tweets en votre nom. Le site affichera l’ID client et l’ID secret OAuth 2.0 sous le menu de vos clés et jetons. Ouvrez votre terminal pour créer un environnement pour ceux-ci en saisissant ce qui suit dans votre terminal :
export CLIENT_ID=’CLIENT_ID’
export CLIENT_SECRET=’CLIENT_SECRET_ID’
export REDIRECT_URI=’http://127.0.0.1:5000/oauth/callback’
Vous devrez le saisir avec les variables remplacées par vos identifiants client et secret.
Maintenant, revenez à votre fichier Python et créez des variables pour ces environnements. Cela permettra à votre bot de récupérer facilement les environnements que vous avez créés pour exécuter votre programme. Vous pouvez utiliser le code suivant pour le faire.
client_id=os.environ.get(“CLIENT_ID”)
client_secret=os.environ.get(“CLIENT_SECRET_ID”)
auth_url=”https://twitter.com/i/oauth2/authorize”
token_url=”https://api.twitter.com/2/oauth2/token”
redirect_uri=os.environ.get(“REDIRECT_URI”)
N’oubliez pas de remplacer toutes les informations d’environnement par les ID et l’URI de redirection pour votre bot.
L’étape suivante consiste à définir vos champs d’application. Les portées déterminent quand et où les variables sont accessibles. Vous pouvez définir vos champs d’application à l’aide du code suivant :
scopes=[“tweet.read”,”users.read”,”tweet.write”,”offline.access”]
tweet.read autorise le bot pour lire les tweets, users.read permet au bot d’obtenir des informations sur les utilisateurs, tweet.write permet au bot d’écrire des tweets et offline.access permet au bot de rester connecté à Twitter pendant plus de deux heures.
OAuth 2.0 de Twitter est compatible PCKE. Vous devrez donc définir un vérificateur de code pour l’utiliser. Vous pouvez le faire avec le code suivant :
code_verifier=base64.urlsafe_b64encode(os.urandom(30)).decode(“utf-8”)
code_verifier=re.sub(“[^a-zA-Z0-9]+”,””, code_verifier)
Vous devrez également réussir un défi de code pour vérifier avec OAuth 2.0. Vous pouvez le faire avec le code suivant :
code_challenge=hashlib.sha256(code_verifier.encode(“utf-8”)).digest()
code_challenge=base64.urlsafe_b64encode(code_challenge).decode(“utf-8”)
code_challenge=code_challenge.replace(“=”,””)
Pour que le bot gère et crée des Tweets, vous aurez besoin d’avoir le truc pour créer des jetons. Vous pouvez le faire avec ce code :
def make_token() :
return OAuth2Session(client_id, redirect_uri=redirect_uri, scope=scopes)
C’est là que le code devient un peu risqué pour les nouvelles personnes. Vous devrez déterminer ce que votre bot publiera et d’où il obtiendra ces informations.
Si vous avez l’intention de tirer vos informations d’une API existante, vous pouvez créer une variable qui tire de l’API et crée un fichier.json à partir duquel elle peut publier. Par exemple, Twitter a une API dog-fact qu’il utilise comme exemple. Vous pouvez tirer des faits sur les chiens de cette API en utilisant le code suivant :
def parse_dog_fact() :
url=http://dog-api.kinduff.com/api/facts
dog_fact=requests.request (“GET”, url).json()
return dog_fact[“facts”][0]
Maintenant, vous voulez que le compte publie le Tweet. Si vous continuez avec Dog-Facts-Bot, vous pouvez utiliser le code suivant. Sinon, passez à l’étape 6.
def post_tweet(payload, token):
print(“Tweeting !”)
return requests.request(
“POST”,
“https ://api.twitter.com/2/tweets”,
json=payload,
headers={
“Authorization”:”Bearer {}”.format(token[“access_token”]),
“Content-Type”:”application/json”,
},
)
Maintenant, vous avez besoin d’une page Web sur laquelle votre bot peut atterrir et qui permettra au bot de s’authentifier auprès de l’API de Twitter. Vous devrez donc créer un site Web. Il n’a pas besoin d’être sophistiqué, mais il doit avoir API d’authentification de Twitter intégrée afin que le bot puisse y accéder et s’authentifier en votre nom.
Ensuite, vous devrez créer une chaîne de code permettant au bot de se connecter à la page. Vous pouvez le faire avec le code suivant :
@app.route(“/”)
def demo() :
global twitter
twitter=make_token()
authorization_url, state=twitter.authorization_url(
auth_url, code_challenge=code_challenge, code_challenge_method=”S256″
)
session[“oauth_state”]=état
return redirect(authorization_url)
Enfin, vous avez besoin du bot pour transformer les faits sur les chiens qu’il récupère en une charge utile JSON que le bot peut publier sur Twitter. Codez ce qui suit :
@app.route(“/oauth/callback”, method=[“GET”])
def callback() :
code=request.args.get(“code”)
token=twitter.fetch_token(
token_url=token_url,
client_secret=client_secret,
code_verifier=code_verifier,
code=code,
)
st_token='”{ }”‘.format(token)
j_token=json.loads(st_token)
r.set(“token”, j_token)
dog_fact=parse_dog_fact()
charge utile={“text”:”{}”.format(dog_fact)}
response=post_tweet(payload, token).json()
retourne la réponse
if __name__==”__main__”:
app.run()
Avec cela, votre bot est complet ! Il vous suffit de l’automatiser pour que le script s’exécute indépendamment.
Pour tester le fichier localement, saisissez ce qui suit dans votre terminal :
python main.py
Si votre code réussit, vous verrez la charge utile JSON dans votre navigateur comme celle ci-dessous :
{“data” :{“id”:”56258425364861″,”text”:”Les chiens ne sont pas daltoniens. Ils peuvent voir plusieurs nuances de jaune et de bleu. }}
Étape 6 : Publier un Tweet avec l’API Tweepy
Vous pouvez également utiliser l’API Tweepy pour créer des tweets sans rien demander à une autre source. Vous pouvez le faire en installant d’abord l’API de Tweepy en saisissant ce qui suit dans votre terminal :
pip install tweepy
Cela installera l’API de Tweepy et vous préparera à tweeter. Ensuite, vous devrez authentifier vos identifiants OAuth dans votre fichier Python. Faites cela avec le code suivant avec toutes les clés remplacées par les clés de votre bot Twitter :
import tweepy
API_KEY :’API_KEY’
CONSUMER_SECRET=’API_SECRET_KEY’
ACCESS_KEY=’ACCESS_KEY’
ACCESS_SECRET=’ACCESS_SECRET_KEY’
auth=tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.set_access_token(ACCESS_KEY, ACCESS_SECRET)
api=tweepy.API(auth)
api.update_status(“Hello, World!”)
Étape 7 : Automatiser votre bot
Maintenant que vous avez un bot qui publiera sur Twitter lorsqu’il s’exécutera, vous devez l’automatiser pour qu’il s’exécute tout seul à chaque si souvent et publie un tweet sans votre contribution. Pour ce faire, vous devrez créer un nouveau fichier Python.
touchez twit_auto.py
Vous pouvez le nommer comme vous voulez ; nous sommes allés avec quelque chose qui décrit avec précision ce qu’il fait. Vous devrez entrer ceci dans votre terminal pour créer un nouveau fichier Python.
La première chose que vous voulez que ce script fasse est d’importer votre main.py. Ensuite, vous en avez besoin pour importer les autres packages dont il a besoin pour s’exécuter.
import main
import redis
import json
import os
Maintenant, vous voulez une variable nommée”twitter”qui”make_token.”
twitter=main.make_token()
client_id=os.environ.get(“CLIENT_ID”)
client_secret=os.environ.get(“CLIENT_SECRET”)
token_url=”https://api.twitter.com/2/oauth2/token”
Ensuite, vous devez accéder à Redis et obtenir le jeton, que nous avons nommé à juste titre”token”.
t=main.r. get(“token”)
bb_t=t.decode(“utf8”).replace(“‘”,'”‘)
data=json.loads(bb_t)
Les jetons OAuth 2.0 ne sont valides pendant deux heures. Vous aurez donc besoin du programme pour actualiser votre jeton à l’aide des jetons d’actualisation de Twitter.
refreshed_token=twitter.refresh_token(
client_id=client_id,
client_secret=client_secret,
token_url=token_url,
refresh_token=data[“refresh_token”],
)
Vous en aurez besoin pour charger le jeton dans un objet JSON avant de pouvoir le sauvegarder dans Redis avec la valeur du jeton. Vous pouvez le faire avec le code suivant :
st_refreshed_token='”{}”‘.format(refreshed_token)
j_refreshed_token=json.loads(st_refreshed_token)
main.r.set(“token”, j_refreshed_token)
Maintenant , vous devrez forcer le programme à extraire un fait de chien de votre API et à le publier sur Twitter. Code suivant :
dog_fact=main.parse_dog_fact()
payload={“text”:”{}”.format(dog_fact)}
main.post_tweet(payload, refreshed_token)
A tester le fichier localement, entrez ce qui suit dans votre terminal :
python twit_auto.py
Ensuite, il vous suffit de configurer le code pour qu’il s’exécute tout seul aussi longtemps que vous le souhaitez, et vous avez vous-même un bot Twitter !
Réflexions finales
Il existe des centaines d’autres types de bots Twitter que vous pouvez créer, et il existe également de nombreux tutoriels sur la façon de coder différents types des robots Twitter. Plus vous en apprendrez sur Python, plus vous pourrez personnaliser et modifier votre bot Twitter. Alors, gardez cela à l’esprit lorsque vous recherchez des robots Twitter. Il y a plus d’une façon de faire le travail !