Comment créer un bot Twitter en Python avec Tweepy – Real Python

Dans cet article, vous apprendrez à créer votre propre bot Twitter en Python avec Tweepy, un package qui fournit un moyen très pratique d’utiliser l’API de Twitter.

Twitter est l'un des réseaux sociaux les plus utilisés. Pour de nombreuses organisations et de nombreuses personnes, une excellente présence sur Twitter est un facteur clé pour garder leur audience active.

Une bonne présence sur Twitter implique de garder votre compte actif avec de nouveaux tweets et retweets, de suivre des comptes intéressants et de répondre rapidement aux messages de vos abonnés. Vous pouvez faire tout ce travail manuellement, mais cela peut prendre beaucoup de temps. Au lieu de cela, vous pouvez compter sur un Bot Twitter, un programme qui automatise tout ou partie de votre activité Twitter.

Dans cet article, vous apprendrez comment:

• Améliorez et automatisez vos interactions avec votre public Twitter
• Installer Tweepy
• Inscrivez-vous en tant que développeur Twitter pour utiliser son API
• Utiliser Tweepy pour invoquer l'API Twitter
• Construire des Bots Twitter
• Déployer les robots sur un serveur à l'aide de Docker et AWS

Bonjour tweepy

Pour commencer, voici comment utiliser Tweepy pour créer un tweet Bonjour tweepy:

importation tweepy

# S'authentifier sur Twitter
auth = tweepy.OAuthHandler("LA CLÉ DU CONSOMMATEUR", "CONSUMER_SECRET")
auth.set_access_token("JETON D'ACCÈS", "ACCESS_TOKEN_SECRET")

# Créer un objet API
api = tweepy.API(auth)

# Créer un tweet
api.état de mise à jour("Bonjour Tweepy")

Ceci est un exemple court, mais il montre les quatre étapes communes à tous les programmes Tweepy:

1. Importer le tweepy paquet
2. Définir les informations d'authentification
3. Créer un nouveau tweepy.API objet
4. Utilisez le api objet pour appeler l'API Twitter

Objets appartenant à la tweepy.API class offre un vaste ensemble de méthodes que vous pouvez utiliser pour accéder à presque toutes les fonctionnalités de Twitter. Dans l'extrait de code, nous avons utilisé état de mise à jour() pour créer un nouveau Tweet.

Nous verrons plus loin dans cet article comment fonctionne l'authentification et comment vous pouvez créer la clé d'authentification, le jeton et les secrets requis.

Ceci est juste un petit exemple de ce que vous pouvez faire avec Tweepy. A travers cet article, vous apprendrez à construire des programmes qui interagissent avec Twitter de manière beaucoup plus intéressante et complexe.

API Twitter

L’API de Twitter donne aux développeurs un accès à la plupart des fonctionnalités de Twitter. Vous pouvez utiliser l'API pour lire et écrire des informations relatives aux entités Twitter telles que les tweets, les utilisateurs et les tendances.

Techniquement, l’API expose des dizaines de points de terminaison HTTP liés à:

• Tweets
• Retweets
• Aime
• Messages directs
• Favoris
• Les tendances
• Médias

Comme nous le verrons plus tard, Tweepy offre un moyen d'appeler ces points de terminaison HTTP sans traiter de détails de bas niveau.

L'API Twitter utilise OAuth, un protocole d'autorisation ouvert largement utilisé, pour authentifier toutes les demandes. Avant d'appeler l'API Twitter, vous devez créer et configurer vos informations d'authentification. Plus loin dans cet article, vous trouverez des instructions détaillées à ce sujet.

Vous pouvez utiliser l'API Twitter pour créer différents types d'automatisations, tels que des robots, des outils d'analyse et d'autres outils. N'oubliez pas que Twitter impose certaines restrictions et règles concernant ce que vous pouvez et ne pouvez pas créer à l'aide de son API. Ceci est fait pour garantir aux utilisateurs une bonne expérience. Le développement d'outils pour spam, induire en erreur les utilisateurs, etc. est interdit.

L’API Twitter impose aussi limites de taux sur la fréquence à laquelle vous êtes autorisé à appeler des méthodes API. Si vous dépassez ces limites, vous devrez attendre entre 5 et 15 minutes pour pouvoir utiliser l'API à nouveau. Vous devez en tenir compte lors de la conception et de la mise en œuvre de bots pour éviter les attentes inutiles.

Vous trouverez plus d’informations sur les règles et les limites de l’API Twitter dans sa documentation officielle:

Qu'est-ce que Tweepy?

Tweepy est un package Python Open Source qui vous offre un moyen très pratique d'accéder à l'API Twitter avec Python. Tweepy comprend un ensemble de classes et de méthodes représentant les modèles et les points de terminaison d'API de Twitter. Il traite de manière transparente divers détails de la mise en œuvre, tels que:

• Encodage et décodage des données
• Requêtes HTTP
• Pagination des résultats
• Authentification OAuth
• Limites de taux
• Ruisseaux

Si vous n’utilisiez pas Tweepy, vous auriez à traiter avec des détails de bas niveau concernant les requêtes HTTP, la sérialisation des données, l’authentification et les limites de débit. Cela pourrait prendre beaucoup de temps et être source d'erreur. Grâce à Tweepy, vous pouvez vous concentrer sur les fonctionnalités que vous souhaitez créer.

Presque toutes les fonctionnalités fournies par l'API Twitter peuvent être utilisées via Tweepy. La seule limitation actuelle, à compter de la version 3.7.0, est que les messages directs ne fonctionnent pas correctement en raison de modifications récentes de l'API Twitter.

Utiliser Tweepy

Dans cette section, vous apprendrez à installer Tweepy pour le développement, à configurer les informations d'authentification et à interagir avec l'API Twitter.

Installation

Tweepy peut être installé en utilisant pépin, un gestionnaire de paquets Python. Dans cet article, nous allons utiliser un environnement virtuel (virtualenv) pour les projets à éviter en fonction des packages à l’échelle du système. Pour plus d'informations sur les environnements virtuels et les pip, consultez Python Virtual Environments: A Primer et What Is Pip? Un guide pour les nouveaux pythonistes.

Vous pouvez commencer en créant un projet appelé tweepy-bots. La première étape consiste à créer un répertoire et un environnement virtuel:

$ mkdir tweepy-bots
$ CD tweepy-bots
$ python3 -m venv venv

Les commandes ci-dessus créent l'environnement virtuel dans le répertoire du projet.

Ensuite, vous pouvez installer le paquet Tweepy. Tout d'abord, vous devez Activer l'environnement virtuel nouvellement créé et ensuite utiliser pépin faire l'installation:

$ la source ./venv/bin/activate
$ pip installer tweepy

Maintenant que Tweepy est installé, créons un conditions.txt fichier contenant les noms de vos dépendances. Vous pouvez utiliser la commande pip gel pour cette tâche:

$ pip gel> exigences.txt

Vous utiliserez ceci conditions.txt fichier lorsque vous déployez le projet.

Création d'informations d'authentification pour l'API Twitter

Comme nous l'avons vu précédemment, l'API Twitter requiert que toutes les demandes utilisent OAuth pour s'authentifier. Vous devez donc créer les informations d’authentification requises pour pouvoir utiliser l’API. Ces informations d'identification sont quatre chaînes de texte:

1. La clé du consommateur
2. Secret du consommateur
3. Jeton d'accès
4. Secret d'accès

Si vous avez déjà un compte d'utilisateur Twitter, suivez ces étapes pour créer la clé, le jeton et les secrets. Sinon, vous devez vous inscrire en tant qu'utilisateur Twitter avant de continuer.

Étape 1: Demander un compte développeur Twitter

Aller au Site de développeur Twitter faire une demande pour un compte développeur. Ici, vous devez sélectionner l'utilisateur Twitter responsable de ce compte. Ce devrait probablement être vous ou votre organisation. Voici à quoi ressemble cette page:

Dans ce cas, j'ai choisi d'utiliser mon propre compte, @ MikezGarcia.

Twitter demande ensuite des informations sur la manière dont vous envisagez d'utiliser le compte développeur, comme indiqué ci-dessous:

Vous devez spécifier le nom du compte développeur et indiquer si vous envisagez de l'utiliser à des fins personnelles ou pour votre organisation.

Étape 2: Créer une application

Twitter accorde des informations d'authentification aux applications, pas aux comptes. Une application peut être n’importe quel outil ou bot utilisant l’API de Twitter. Vous devez donc enregistrer votre application pour pouvoir effectuer des appels API.

Pour enregistrer votre application, allez à votre page d'applications Twitter et sélectionnez le Créer une application option.

Vous devez fournir les informations suivantes sur votre application et son objectif:

• Nom de l'application: un nom identifiant votre application (tel que examplebot)
• Description de l'application: le but de votre application (comme Un exemple de bot pour un article de Real Python)
• Votre URL de site Web ou celle de votre application: requis, mais il peut s'agir de l'URL de votre site personnel, car les bots n'ont pas besoin d'une URL pour fonctionner.
• Utilisation de l'application: comment les utilisateurs utiliseront votre application (tels que Cette application est un bot qui répondra automatiquement aux utilisateurs)

Étape 3: Créez les informations d'identification d'authentification

Pour créer les informations d'authentification, allez à votre page d'applications Twitter. Voici ce que le Page des applications ressemble à:

Ici vous trouverez le Détails bouton de votre application. En cliquant sur ce bouton, vous passez à la page suivante, où vous pouvez générer les informations d'identification.

En sélectionnant le Clés et jetons onglet, vous pouvez générer et copier la clé, le jeton et les secrets pour les utiliser dans votre code:

Après avoir généré les informations d'identification, enregistrez-les pour les utiliser ultérieurement dans votre code.

Vous pouvez tester les informations d'identification à l'aide de l'extrait suivant:

importation tweepy

# S'authentifier sur Twitter
auth = tweepy.OAuthHandler("pGBDoaaEpkliVKBOLwjtcmHGc", 
    "xF3g1wrP50b6BlZEd20u4oVfjgH1FGQcuWUzlQO5aUWOufvlhw")
auth.set_access_token("622518493-6VcLIPprbQbv9wkcBBPvCle8vsjU9fE85Dq9oStl", 
    "tH9aKQbQQ1iRdYTcLSsPwitl44BkAc6jilrsU0ifnXvZhq")

api = tweepy.API(auth)

essayer:
    api.verify_credentials()
    impression("Authentification OK")
sauf:
    impression("Erreur lors de l'authentification")

Dans cet extrait, les informations d'identification sont testées à l'aide de verify_credentials (). Si tout se passe bien, vous devriez voir un message disant Authentification OK.

Examen de la fonctionnalité Tweepy

Tweepy vous donne une interface pour accéder à l'API Twitter depuis Python. Pour ce faire, il encapsule une grande partie de la complexité de l’API Twitter et ajoute une couche de modèle et d’autres fonctionnalités utiles.

Comme, au fil du temps, les noms de divers concepts Twitter ont évolué, certains anciens noms sont toujours utilisés dans Tweepy. Alors gardez à l'esprit que, dans le contexte de cet article, ces équivalences sont les suivantes:

• UNE statut est un tweet .
• UNE relation amicale est un relation de suivi.
• UNE préféré est un comme.

Maintenant que vous savez comment Tweepy nomme les choses, voyons comment cela fonctionne.

La fonctionnalité de Tweepy peut être divisée en groupes suivants:

• OAuth
• La classe API
• Des modèles
• Les curseurs
• Ruisseaux

Vous allez maintenant examiner ces groupes pour en savoir plus sur les fonctionnalités qu’ils offrent.

OAuth

Tweepy prend en charge tous les détails d'utilisation d'OAuth requis par l'API Twitter pour authentifier chaque demande. Il fournit un OAuthHandler classe que vous pouvez utiliser pour définir les informations d'identification à utiliser dans tous les appels d'API.

Cet extrait de code montre comment vous pouvez créer un OAuthHandler objet pouvant être utilisé par la suite pour les appels d'API:

importation tweepy

# S'authentifier sur Twitter
auth = tweepy.OAuthHandler("LA CLÉ DU CONSOMMATEUR", "CONSUMER_SECRET")
auth.set_access_token("JETON D'ACCÈS", "ACCESS_TOKEN_SECRET")

Ici, vous dites à Tweepy d’utiliser les identifiants que vous avez créés dans Étape 3: Créez les informations d'identification d'authentification. Vous devez remplacer LA CLÉ DU CONSOMMATEUR, CONSUMER_SECRET, JETON D'ACCÈS, et ACCESS_TOKEN_SECRET avec les valeurs que vous avez générées précédemment.

La classe API

le API La classe a de nombreuses méthodes qui fournissent un accès aux points de terminaison des API Twitter. En utilisant ces méthodes, vous pouvez accéder aux fonctionnalités de l’API Twitter.

L'extrait de code suivant crée un API objet que vous pouvez utiliser pour appeler les méthodes de l'API Twitter. Réglage wait_on_rate_limit et wait_on_rate_limit_notify à Vrai demande à l'objet API d'imprimer un message et d'attendre si la limite de débit est dépassée:

importation tweepy

# S'authentifier sur Twitter
auth = tweepy.OAuthHandler("LA CLÉ DU CONSOMMATEUR", "CONSUMER_SECRET")
auth.set_access_token("JETON D'ACCÈS", "ACCESS_TOKEN_SECRET")

# Créer un objet API
api = tweepy.API(auth, wait_on_rate_limit=Vrai,
    wait_on_rate_limit_notify=Vrai)

Dans le code ci-dessus, nous avons défini les informations d’authentification et créé un api objet. Vous pouvez appeler les méthodes de cet objet pour effectuer n’importe quel appel d’API.

le API Les méthodes peuvent être regroupées dans les catégories suivantes:

• Méthodes pour les chronologies utilisateur
• Méthodes pour les tweets
• Méthodes pour les utilisateurs
• Méthodes pour les suiveurs
• Méthodes pour votre compte
• Méthodes pour les goûts
• Méthodes de blocage des utilisateurs
• Méthodes de recherche
• Méthodes pour les tendances
• Méthodes de streaming

Dans les sous-sections suivantes, vous allez passer en revue différents groupes de méthodes API. Vous pouvez visiter la documentation sur les classes d'API pour obtenir une liste détaillée de toutes les méthodes de l'API.

Méthodes pour les calendriers utilisateur

Ces méthodes traitent de la lecture de tweets, de mentions et de retweets à partir de votre chronologie ou de la chronologie de tout autre utilisateur, tant qu’elle est publique.

Cet extrait de code imprime l'auteur et le texte des derniers tweets de votre chronologie personnelle:

chronologie = api.home_timeline()
pour tweet dans chronologie:
    impression(F"tweet.user.name    m'a dit tweet.text")

home_timeline (), une méthode API Tweepy, est utilisée pour obtenir les 20 dernières entrées de votre chronologie. 20 est la valeur par défaut dans Tweepy. Vous verrez plus tard comment obtenir plus de 20 résultats et travailler avec des résultats paginés.

Méthodes pour les Tweets

Ces méthodes ont trait à la création, à la récupération et au retweet de tweets.

Le code suivant utilise Tweepy pour créer un tweet avec du texte:

api.état de mise à jour("Test tweet de Tweepy Python")

Nous avons utilisé état de mise à jour() créer un nouveau tweet à partir d'une chaîne Python.

Méthodes pour les utilisateurs

Les méthodes de ce groupe vous permettent de rechercher des utilisateurs avec des critères de filtre, d'extraire des informations sur l'utilisateur et de répertorier les abonnés de n'importe quel utilisateur, tant que ce compte est public.

L'extrait ci-dessous va chercher mon utilisateur, @ MikezGarcia, puis imprime ses détails ainsi que ses 20 derniers abonnés:

utilisateur = api.get_user("MikezGarcia")

impression("Détails de l'utilisateur:")
impression(utilisateur.prénom)
impression(utilisateur.la description)
impression(utilisateur.emplacement)

impression("20 derniers abonnés:")
pour disciple dans utilisateur.suiveurs():
    impression(disciple.prénom)

get_user () renvoie un objet contenant les détails de l'utilisateur. Cet objet renvoyé possède également des méthodes pour accéder aux informations relatives à l'utilisateur. Vous avez utilisé le suiveurs attribut pour obtenir la liste des adeptes.

Méthodes pour les suiveurs

Ce groupe de méthodes traite du suivi et du non-suivi des utilisateurs, l’interrogation des abonnés d’un utilisateur et la liste des comptes suivis par tous les utilisateurs.

Ce code montre comment utiliser Tweepy pour commencer à suivre @realpython:

api.create_friendship("realpython")

create_friendship () ajoute @realpython à la liste des comptes que vous suivez.

Méthodes pour votre compte

Ces méthodes vous permettent de lire et d’écrire les détails de votre profil.

Par exemple, vous pouvez utiliser cet extrait de code pour mettre à jour la description de votre profil:

api.mettre à jour le profil(la description="J'aime le Python")

L'argument du mot clé la description est passé à mettre à jour le profil() changer la description de votre profil en "J'aime le Python".

Méthodes pour les J'aime

En utilisant ces méthodes API, vous pouvez marquer n'importe quel tweet comme Aimé ou enlever le Comme cochez si cela a déjà été ajouté.

Vous pouvez marquer le tweet le plus récent dans votre journal local comme Aimé comme suit:

tweets = api.home_timeline(compter=1)
tweet = tweets[[[[0]
impression(F"J'aime le tweet tweet.id    de tweet.author.name")
api.create_favorite(tweet.identifiant)

Ce code utilise home_timeline () pour obtenir le tweet le plus récent. Puis le tweet.id est passé à create_favorite () marquer le tweet comme Aimé.

Méthodes de blocage des utilisateurs

Ce groupe de méthodes traite du blocage et du déblocage des utilisateurs, ainsi que de la liste des utilisateurs bloqués.

Voici comment vous pouvez voir les utilisateurs que vous avez bloqués:

pour bloc dans api.des blocs():
    impression(bloc.prénom)

Ce code parcourt la liste des comptes que vous avez bloqués. Vous pouvez obtenir cette liste en utilisant blocs ().

Méthodes de recherches

En utilisant ces méthodes, vous pouvez rechercher des tweets à l'aide de filtres de texte, de langue et autres.

Par exemple, vous pouvez essayer ce code pour obtenir les 10 derniers tweets publics en anglais contenant le mot "Python":

pour tweet dans api.chercher(q="Python", lang="fr", rpp=dix):
    impression(F"tweet.user.name:tweet.text")

Vous avez utilisé chercher() filtrer les tweets correspondant aux critères souhaités. Cela recherchera dans n'importe quel tweet public, pas seulement dans les tweets de personnes que vous suivez.

Méthodes pour les tendances

Ce groupe de méthodes vous permet de répertorier les tendances actuelles pour n’importe quel lieu géographique.

Par exemple, voici comment répertorier les sujets de tendance mondiaux:

trends_result = api.trends_place(1)
pour tendance dans trends_result[[[[0][[[["les tendances"]:
    impression(tendance[[[["prénom"])

En utilisant trends_place (), vous obtenez la liste des tendances pour n’importe quel lieu, en passant comme unique argument l’identifiant de lieu. Ici, 1 signifie dans le monde entier. Vous pouvez voir la liste complète des emplacements disponibles en utilisant api.trends_available ().

Méthodes de streaming

Diffusion vous permet de regarder activement les tweets correspondant à certains critères de temps réél. Cela signifie que s’il n’ya pas de nouveau tweet correspondant aux critères, le programme attendra la création d’un nouveau tweet, puis le traitera.

Pour utiliser le streaming, vous devez créer deux objets:

1. le objet de flux utilise l'API Twitter pour obtenir des tweets correspondant à certains critères. Cet objet est la source de tweets qui sont ensuite traités par un écouteur de flux.
2. le écouteur de flux reçoit les tweets du flux.

Voici comment vous faites cela:

classe MyStreamListener(tweepy.StreamListener):
    def __init__(soi, api):
        soi.api = api
        soi.moi = api.moi()

    def on_status(soi, tweet):
        tweet = JSON.charges(Les données)
        impression(F"tweet.user.name:tweet.text")

    def on_error(soi, statut):
        impression("Erreur détectée")

tweets_listener = MyStreamListener(api)
courant = tweepy.Courant(api.auth, tweets_listener)
courant.filtre(Piste=[[[["Python", "Django", "Tweepy"], les langues=[[[["fr"])

Vous avez déclaré une nouvelle classe, MyStreamListener. Cette classe est utilisée pour l'écouteur de flux tweets_listener. En prolongeant le nombre de Tweepy StreamLister, nous avons réutilisé du code commun à tous les écouteurs de flux. Les tweets du flux sont traités par on_status ().

Nous avons créé le flux en utilisant tweepy.Stream, en passant les informations d’authentification et notre auditeur de flux. Pour commencer à recevoir des tweets à partir du flux, vous devez appeler le filtre(), en passant les critères à utiliser pour filtrer les tweets. Ensuite, pour chaque nouveau tweet correspondant aux critères, l’objet flux appelle l’appel de l’écouteur. on_status ().

Des modèles

Tweepy utilise ses propres classes de modèle pour encapsuler les réponses de différentes méthodes de l'API Twitter. Cela vous donne un moyen pratique d’utiliser les résultats des opérations de l’API.

Les classes de modèle sont:

• Utilisateur
• Statut
• Relation amicale
• Résultats de la recherche

Supposons que vous souhaitiez récupérer chaque tweet dans lequel vous êtes mentionné, puis marquer chaque tweet comme Aimé et suivez son auteur. Vous pouvez faire ça comme ça:

tweets = api.mentions_timeline()
pour tweet dans tweets:
    tweet.préféré()
    tweet.utilisateur.suivre()

Depuis chaque tweet objet retourné par mentions_timeline () appartient à la Statut classe, vous pouvez utiliser:

• préféré() pour le marquer comme Aimé
• utilisateur obtenir son auteur

Cet attribut utilisateur, tweet.user, est aussi un objet qui appartient à Utilisateurpour pouvoir utiliser suivre() pour ajouter l'auteur du tweet à la liste des personnes que vous suivez.

L'utilisation des modèles Tweepy vous permet de créer un code concis et compréhensible.

Les curseurs

De nombreux points finaux des API Twitter utilisent la pagination pour renvoyer leurs résultats. Par défaut, chaque méthode retourne la première page, qui contient généralement quelques dizaines d'éléments.

Les curseurs Tweepy suppriment une partie de la complexité du travail avec des résultats paginés. Les curseurs sont implémentés en tant que classe Tweepy nommée Le curseur. Pour utiliser un curseur, vous sélectionnez la méthode d'API à utiliser pour récupérer les éléments et le nombre d'éléments souhaités. le Le curseur object prend soin d'extraire les différentes pages de résultats de manière transparente.

Ce code montre comment, en utilisant un curseur, vous pouvez obtenir non seulement la première page de votre timeline, mais également les 100 derniers tweets:

pour tweet dans tweepy.Le curseur(api.home_timeline).articles(100):
    impression(F"tweet.user.name    m'a dit: tweet.text")

Un objet curseur est créé en utilisant tweepy.Cursor. Le constructeur de classe reçoit une méthode API à utiliser comme source des résultats. Dans l'exemple, nous avons utilisé home_timeline () en tant que source puisque nous voulions des tweets de la chronologie. le Le curseur l'objet a un articles() méthode qui renvoie une variable que vous pouvez utiliser pour parcourir les résultats. Tu peux passer articles() le nombre d'éléments de résultat que vous souhaitez obtenir.

Comment faire un bot Twitter en Python avec Tweepy

Maintenant que vous savez comment fonctionne Tweepy, voyons comment créer un bot Twitter en Python avec Tweepy. Les bots travaillent par regarder en permanence pour une activité Twitter et réagissant automatiquement à cela.

Regarder l'activité sur Twitter

Il y a deux façons de surveiller en permanence l'activité Twitter:

1. Utiliser des flux: être averti lorsqu'un nouveau contenu, tel que des tweets, correspondant à certains critères est créé
2. Utilisation de polling: faire périodiquement des appels API Tweepy et ensuite vérifier leurs résultats pour voir s'ils contiennent quelque chose de nouveau

Quelle option choisir dépend de votre cas d'utilisation. L’utilisation de flux est l’option la plus efficace, mais vous ne pouvez alors suivre que les activités liées aux tweets, ce qui réduit leur flexibilité. Dans cette section, les deux options sont utilisées pour construire différents robots.

Présentation des exemples de robots

Dans cet article, vous apprendrez à construire trois robots différents qui effectuent des actions automatiques pour réagir à certains événements de Twitter:

1. Le suiveur bot suit automatiquement toute personne qui vous suit.
2. Le Bot Fav & Retweet aime automatiquement et retweet les tweets qui correspondent à certains critères.
3. La réponse aux mentions Bot répond automatiquement aux tweets vous mentionnant qui contiennent les mots Aidez-moi ou soutien.

Nous allons utiliser un répertoire nommé bots pour stocker tous les fichiers Python du projet comme indiqué ci-dessous:

tweepy-bots /
│
├── bots /
├── config.py
└── suivrefollowers.py
└── favretweet.py
Ore └── autoreply.py
│
└── exigences.txt

La section suivante explique les config module.

Le module de configuration

Tous les robots que nous construisons ont certaines fonctionnalités en commun. Par exemple, ils doivent s'authentifier auprès de l'API Twitter.

Vous pouvez créer un module Python réutilisable contenant la logique commune à tous les robots. Nous avons nommé ce module config.

Ce module lit les informations d'authentification à partir des variables d'environnement et crée l'objet API Tweepy. En lisant les informations d'identification des variables d'environnement, vous évitez de les coder en dur dans le code source, ce qui le rend beaucoup plus sécurisé.

Les robots liront les informations d'identification de ces variables d'environnement:

• LA CLÉ DU CONSOMMATEUR
• CONSUMER_SECRET
• JETON D'ACCÈS
• ACCESS_TOKEN_SECRET

Vous verrez plus tard comment définir ces variables pour qu'elles correspondent aux informations d'identification que vous avez précédemment générées pour votre application Twitter.

Ci-dessous le code source complet pour le config module. Il contient create_api (), une fonction qui lit les informations d’authentification des variables d’environnement et crée l’objet API Tweepy:

# tweepy-bots / bots / config.py
importation tweepy
importation enregistrement
importation os

enregistreur = enregistrement.getLogger()

def create_api():
    La clé du consommateur = os.getenv("LA CLÉ DU CONSOMMATEUR")
    consommateur_secret = os.getenv("CONSUMER_SECRET")
    jeton d'accès = os.getenv("JETON D'ACCÈS")
    access_token_secret = os.getenv("ACCESS_TOKEN_SECRET")

    auth = tweepy.OAuthHandler(La clé du consommateur, consommateur_secret)
    auth.set_access_token(jeton d'accès, access_token_secret)
    api = tweepy.API(auth, wait_on_rate_limit=Vrai, 
        wait_on_rate_limit_notify=Vrai)
    essayer:
        api.verify_credentials()
    sauf Exception comme e:
        enregistreur.Erreur("Erreur lors de la création de l'API", exc_info=Vrai)
        élever e
    enregistreur.Info("API créée")
    revenir api

Ce code utilise os.getenv () lire les variables d'environnement puis crée le Tweepy auth objet. Ensuite, l'objet API est créé.

Qui passe wait_on_rate_limit et wait_on_rate_limit_notify dans la création du tweepy.API objet fait attendre Tweepy et affiche un message lorsque la limite de débit est dépassée.

Avant de retourner l'objet API, create_api () appels verify_credentials () pour vérifier que les informations d'identification sont valides.

Ce module et, comme vous le verrez plus loin, le code source du bot, utilisez le enregistrement Module Python pour informer les erreurs et les messages d’information qui vous aideront à les déboguer en cas de problème. Vous pouvez en savoir plus à ce sujet dans Logging in Python.

Le suiveur bot

Ce bot récupère votre liste d’abonnés sur Twitter toutes les minutes, puis effectue une itération pour suivre chaque utilisateur que vous ne suivez pas déjà.

Code source du bot

Voici le code source complet de ce bot. Il utilise le déjà créé config module, l'API Tweepy et les curseurs:

#! / usr / bin / env python
# tweepy-bots / bots / abonnés suiveurs.py

importation tweepy
importation enregistrement
de config importation create_api
importation temps

enregistrement.basicConfig(niveau=enregistrement.INFO)
enregistreur = enregistrement.getLogger()

def suivre(api):
    enregistreur.Info("Récupération et suivi des adeptes")
    pour disciple dans tweepy.Le curseur(api.suiveurs).articles():
        si ne pas disciple.Suivant:
            enregistreur.Info(F"Suivant follower.name")
            disciple.suivre()
            revenir

def principale():
    api = create_api()
    tandis que Vrai:
        suivre(api)
        enregistreur.Info("Attendre...")
        temps.dormir(60)

si __prénom__ == "__principale__":
    principale()

principale() crée un objet API Tweepy à l'aide de create_api () du config module que vous avez précédemment créé. Puis, dans une boucle, follow_followers () s'appelle une fois par minute.

follow_followers () utilise un curseur Tweepy et la méthode de l'API Tweepy suiveurs() pour obtenir votre liste d'adeptes. Cette liste contient un modèle d'utilisateur Tweepy pour chaque utilisateur qui vous suit.

Ensuite, le bot parcourt la liste et utilise Suivant pour vérifier si vous suivez déjà chaque utilisateur. Les utilisateurs qui ne sont pas déjà suivis sont suivis en utilisant suivre().

Lancer le bot

Pour exécuter le bot, vous devez d’abord créer les variables d’environnement pour les informations d’authentification. Vous pouvez le faire en exécutant ces commandes depuis un terminal et en remplaçant les valeurs par vos informations d'identification réelles:

$ exportation LA CLÉ DU CONSOMMATEUR="pGBDoaaEpkliVKBOLwjtcmHGc"
$ exportation CONSUMER_SECRET="xF3g1wrP50b6BlZEd20u4oVfjgH1FGQcuWUzlQO5aUWOufvlhw"
$ exportation JETON D'ACCÈS="622518493-6VcLIPprbQbv9wkcBBPvCle8vsjU9fE85Dq9oStl"
$ exportation ACCESS_TOKEN_SECRET="tH9aKQbQQ1iRdYTcLSsPwitl44BkAc6jilrsU0ifnXvZhq"

Après avoir exécuté les commandes, vos variables d’environnement contiendront les informations d’identification nécessaires pour utiliser l’API Twitter.

Ensuite, vous devez activer votre environnement virtuel et exécuter le fichier principal du bot, bots / abonnés suiveurs.py:

$ la source ./venv/bin/activate
$ bots python / abonnés suivis.py

Pendant son fonctionnement, le bot suivra quiconque vous suivra. Vous pouvez vérifier que cela fonctionne en désengageant quelqu'un qui vous suit. Après une minute, ils seront à nouveau suivis. Vous pouvez arrêter le bot en utilisant Ctrl-C.

Le Bot Fav & Retweet

Ce bot utilise le flux Tweepy introduit précédemment pour surveiller activement les tweets contenant certains mots clés. Pour chaque tweet, si vous n'êtes pas l'auteur du tweet, il sera marqué comme Aimé puis retweet.

Vous pouvez utiliser ce bot pour alimenter votre compte avec un contenu en rapport avec vos intérêts.

Code source du bot

Ci-dessous, vous pouvez voir le code source complet de ce bot. Il utilise un flux pour filtrer les tweets contenant les mots "Python" ou "Tweepy". Chaque tweet du flux est marqué comme Aimé et retweeté:

#! / usr / bin / env python
# tweepy-bots / bots / favretweet.py

importation tweepy
importation enregistrement
de config importation create_api
importation JSON

enregistrement.basicConfig(niveau=enregistrement.INFO)
enregistreur = enregistrement.getLogger()

classe FavRetweetListener(tweepy.StreamListener):
    def __init__(soi, api):
        soi.moi = api.moi()

    def on_status(soi, tweet):
        enregistreur.Info(F"Traitement du tweet id tweet.id")
        si tweet.in_reply_to_status_id est ne pas Aucun ou 
            tweet.utilisateur.identifiant == soi.moi.identifiant:
            revenir
        essayer:
            tweet.préféré()
            tweet.retweet()
        sauf Exception comme e:
            enregistreur.Erreur("Erreur sur fav et retweet", exc_info=Vrai)

    def on_error(soi, statut):
        enregistreur.Erreur(statut)

def principale(mots clés):
    api = create_api()
    tweets_listener = FavRetweetListener(api)
    courant = tweepy.Courant(api.auth, tweets_listener)
    courant.filtre(Piste=mots clés, les langues=[[[["en '])

si __prénom__ == "__principale__":
    principale([[[["Python", "Tweepy"])

Comme avec le bot précédent, la fonction principale utilise create_api () du config module pour créer un objet API Tweepy.

Un flux Tweepy est créé pour filtrer les tweets en anglais et inclure certains des mots-clés spécifiés dans l'argument de la fonction principale. "Python" ou "Tweepy" dans ce cas.

le on_status () de FavRetweetListener traite les tweets du flux. Cette méthode reçoit un objet de statut et utilise préféré() et retweet () marquer le tweet comme Aimé et retweet.

Pour éviter de retweeter et d’aimer les tweets qui sont des réponses à d’autres tweets, on_status () utilise un si Pour voir si in_reply_to_status_id n'est pas Aucun. En outre, le code vérifie si vous êtes l'auteur du tweet pour éviter les retweet et aimer votre propre contenu.

Vous pouvez exécuter ce bot en utilisant les mêmes instructions que pour le bot précédent, en modifiant le programme Python en favretweet.py.

La réponse aux mentions Bot

Ce bot récupère périodiquement les tweets dans lesquels vous êtes mentionné. Si le tweet n'est pas une réponse à un autre tweet et qu'il contient les mots "Aidez-moi" ou "soutien", puis l'auteur du tweet sera suivi, et on répondra au tweet avec un autre tweet disant "S'il vous plaît nous rejoindre via DM".

Vous pouvez utiliser ce bot pour automatiser le processus initial de réponse aux questions de vos abonnés.

Code source du bot

Voici le code source complet de ce bot. Il utilise un curseur pour récupérer vos mentions:

#! / usr / bin / env python
# tweepy-bots / bots / autoreply.py

importation tweepy
importation enregistrement
de config importation create_api
importation temps

enregistrement.basicConfig(niveau=enregistrement.INFO)
enregistreur = enregistrement.getLogger()

def check_mentions(api, mots clés, depuis_id):
    enregistreur.Info("Récupération de mentions")
    new_since_id = depuis_id
    pour tweet dans tweepy.Le curseur(api.mentions_timeline,
        depuis_id=depuis_id).articles():
        new_since_id = max(tweet.identifiant, new_since_id)
        si tweet.in_reply_to_status_id est ne pas Aucun:
            continuer
        si tout(mot-clé dans tweet.texte.inférieur() pour mot-clé dans mots clés):
            enregistreur.Info(F"Répondre à tweet.user.name")

            si ne pas tweet.utilisateur.Suivant:
                tweet.utilisateur.suivre()

            api.état de mise à jour(
                statut="S'il vous plaît nous rejoindre via DM",
                in_reply_to_status_id=tweet.identifiant,
            )
    revenir new_since_id

def principale():
    api = create_api()
    depuis_id = 1
    tandis que Vrai:
        impression(depuis_id)
        depuis_id = check_mentions(api, [[[["Aidez-moi", "soutien"], depuis_id)
        enregistreur.Info("Attendre...")
        temps.dormir(60)

si __prénom__ == "__principale__":
    principale()

Comme avec les autres bots, la fonction principale crée un objet API Tweepy. Après cela, il initialise la variable depuis_id avec la valeur 1. Cette variable est utilisée pour extraire uniquement les mentions créées après celles déjà traitées.

Dans une boucle, check_mentions () s'appelle une fois par minute.

Cette fonction utilise un curseur Tweepy et mentions_timeline () pour obtenir tous les tweets vous mentionnant qui ont un identifiant plus grand que le depuis_id variable.

Pour chaque tweet qui vous mentionne, son auteur est suivi en utilisant tweet.user.follow () si vous ne les suivez pas déjà.

Puis un répondre au tweet est créé en utilisant état de mise à jour()en passant le identifiant du tweet original comme in_reply_to_status_id.

check_mentions () renvoie le plus grand tweet traité identifiant. Cette information sera utilisée comme depuis_id lors du prochain appel, recherchez uniquement les tweets plus récents que ceux déjà récupérés.

Vous pouvez exécuter le bot en utilisant les mêmes instructions que précédemment. Il suffit de changer le programme Python pour autoreply.py.

Déploiement de robots sur un serveur à l'aide de Docker

Pouvoir exécuter vos robots Twitter sur votre ordinateur local est très utile pour le développement, mais pour la production, vous devrez probablement exécuter vos robots sur un serveur. Cette section explique comment vous pouvez conditionner votre bot et ses dépendances en utilisant Docker puis déployez-le sur un serveur.

Docker permet de conditionner n'importe quelle application dans une image Docker contenant non seulement l'application elle-même, mais également toutes ses dépendances. Vous pouvez en apprendre plus sur Docker et sa configuration dans Docker in Action – Plus en forme, plus heureux, plus productif

Construire l'image de Docker

Pour conditionner votre bot ou votre application, vous devez créer un Dockerfile dans le répertoire racine du projet. Ce fichier contient un ensemble d’instructions permettant de créer l’image Docker contenant votre application.

Voici à quoi devrait ressembler la structure de votre projet:

tweepy-bots /
│
├── bots /
├── config.py
└── suivrefollowers.py
└── favretweet.py
Ore └── autoreply.py
│
├── exigences.txt
└── Dockerfile

Comme vous pouvez le voir, le Dockerfile et conditions.txt vivre dans le répertoire principal de votre projet

Vous pouvez utiliser le fichier Docker suivant pour créer l'image du bot Fav & Retweet. Il utilise Python: 3.7-alpine comme image de base. Nous avons choisi cette image comme base car elle est très petite et contient Python3.7 et pip. Ce fichier Docker copie ensuite le code du bot et le conditions.txt fichier à l'image. Enfin, les dépendances sont installées dans l’image à l’aide de pip3:

DE    python: 3.7-alpine

COPIE bots / config.py / bots /
COPIE bots / favretweet.py / bots /
COPIE exigences.txt / tmp
COURIR pip3 installe -r /tmp/requirements.txt

WORKDIR    / bots
CMD [[[["python3", "favretweet.py"]

La dernière ligne indique quelle commande doit être exécutée lorsque cette image est utilisée.

Maintenant, vous pouvez construire l'image en utilisant cette commande:

$ docker construire. -t fav-retweet-bot

Puis, en utilisant le images de docker commande, vous pouvez voir les détails de l’image nouvellement générée.

Enfin, vous pouvez utiliser le docker run commande pour tester l’image en lui transmettant les variables d’environnement contenant les informations d’authentification:

$ docker run -it -e LA CLÉ DU CONSOMMATEUR="uDRNy31oWfoiKV9AvPoNavy0I" 
 -e CONSUMER_SECRET="lnAL5VAgZLWNspQVpd3X6tEo47PRCmsPEwuxpvLCLSR08DMa4O" 
 -e JETON D'ACCÈS="622518593-j7gWSqzQO31ju7Bf7idB47NlZeSENsuADGU9B69I" 
 -e ACCESS_TOKEN_SECRET="iutFsxvP5IglRckJ1I1why6017xMNkzxqBID48Azw0GvT" 
 fav-retweet-bot

Pendant qu’il est en cours d’exécution, les journaux du bot sont affichés à l’écran.

Cette même procédure peut être utilisée pour créer l'image Docker pour d'autres robots.

Exemple: déploiement d'un bot Twitter sur Amazon AWS

Maintenant que l'image Docker est prête, il existe de nombreuses façons de la déployer pour s'exécuter sur n'importe quel serveur. Dans cette section, vous verrez une méthode que vous pouvez utiliser pour déployer un bot sur un serveur Amazon AWS. Cette configuration utilise un Amazon AWS Instance EC2, comme un serveur virtuel, pour exécuter l’image Docker.

Étape 1: Exportez l'image Docker

À partir de l'ordinateur sur lequel vous avez créé l'image Docker, exécutez ces commandes pour l'exporter dans un fichier et le compresser. Vous utiliserez ce fichier ultérieurement pour télécharger l'image sur votre instance EC2:

$ docker image save fav-retweet-bot: dernier -o fav-retweet-bot.tar
$ gzip fav-retweet-bot.tar

Maintenant, l'image a été compressée dans fav-retweet-bot.tar.gz.

Étape 2: Créer une instance Amazon EC2

La première étape dans AWS consiste à créer une nouvelle instance EC2. Le bot s'exécutera dans cette instance. Connectez-vous à votre console AWS, choisissez le service EC2, puis sélectionnez Les instances. You’ll see something like this:

Clique le Launch instance button and select Ubuntu Server 18.04 as the base image:

Now you can choose the instance type. This depends on the computing resources needed by your bot. For the bots described in this article, the t2.micro instance type is a good starting point. Select it and click Review and Launch:

On the next page, you can review and check your configuration. Then click the lancement button to begin the creation of your EC2 instance:

After you’ve clicked lancement, you’ll be asked to create a key pair. It’s used to allow you to connect to your instance and deploy the bot Docker image. Sélectionner Create a new key pair, enter a key pair name, and download the key pair.

Remember where you’re downloading the key pair. You’ll need it later.

Then click the Launch instances button to proceed:

You will see a page saying that your instance is being created. Clique le View instances button to see the status of your instance:

At first, your instance state will be en attendant. You have to wait until it transitions to fonctionnement:

Step 3: Install Docker in Your EC2 Instance

Now you have to connect to your instance using SSH to install Docker on it.

If, in the previous screen, you right click on your instance, you’ll find a context menu. Sélectionnez le Relier option to see how to connect using SSH:

This dialog shows how to connect to your instance:

First, change the permissions of your key pair file using the following command. Otherwise, you won’t be able to connect to your EC2 instance using this key pair:

$ chmod 400 mykeypair.pem

Then connect to your instance using SSH. You can copy the command you need to execute from the Connect To Your Instance dialog:

$ ssh -i "mykeypair.pem" ubuntu@ec2-3-86-66-73.compute-1.amazonaws.com

Once you’re connected, run the following commands to install Docker in the instance:

ubuntu@ip-172-31-44-227:~$ sudo apt-get update
ubuntu@ip-172-31-44-227:~$ sudo apt install docker.io
ubuntu@ip-172-31-44-227:~$ sudo adduser ubuntu docker
ubuntu@ip-172-31-44-227:~$ sortie

It’s important that you exit the SSH session after the installation, so that in the next login your user permissions will be reloaded.

Step 4: Upload Your Bot’s Docker Image

From your local computer, upload the bot Docker image to your instance using scp. This can take some time depending on your internet connection:

$ scp -i "mykeypair.pem" fav-retweet-bot.tar.gz 
    ubuntu@ec2-3-86-66-73.compute-1.amazonaws.com:/tmp

When the image upload finishes, log in again to your instance using SSH:

$ ssh -i "mykeypair.pem" ubuntu@ec2-3-86-66-73.compute-1.amazonaws.com

Run these commands in your instance to decompress and import the Docker image:

ubuntu@ip-172-31-44-227:~$ gunzip /tmp/fav-retweet-bot.tar.gz 
ubuntu@ip-172-31-44-227:~$ docker image load -i /tmp/fav-retweet-bot.tar

Step 5: Run Your Bot’s Docker Image

The final step to deploy the bot is to run the Docker image in your EC2 instance, passing it the authentication credentials.

You can do this using the docker commander. Passing the flags -d et --restart-always assures that the bot will keep running if you disconnect from the SSH session or if the instance is restarted:

ubuntu@ip-172-31-44-227:~$ docker run -d --restart always 
-e CONSUMER_KEY="uDRNy31oWfoiKV9AvPoNavy0I" 
-e CONSUMER_SECRET="lnAL5VAgZLWNspQVpd3X6tEo47PRCmsPEwuxpvLCLSR08DMa4O" 
-e ACCESS_TOKEN="622518593-j7gWSqzQO31ju7Bf7idB47NlZeSENsuADGU9B69I" 
-e ACCESS_TOKEN_SECRET="iutFsxvP5IglRckJ1I1why6017xMNkzxqBID48Azw0GvT" 
fav-retweet-bot

En utilisant docker ps, you can check that the bot is running and find its container identifiant. Finally, using the docker logs command and the container identifiant, you can check the output from the bot to see if it works properly:

$ ubuntu@ip-172-31-44-227:~$ docker logs e6aefe73a885
INFO:root:API created
INFO:root:Processing tweet id 1118276911262785538
INFO:root:Processing tweet id 1118276942162214918
INFO:root:Processing tweet id 1118276990853951488
INFO:root:Processing tweet id 1118277032360722433
INFO:root:Processing tweet id 1118277034466324480

Now, even if you disconnect from the SSH session or turn off your computer, the bot will continue to run on your AWS EC2 instance.

Free AWS Resources

To save resources and money (if your AWS free tier period has ended), you can stop or terminate your EC2 instance:

Stopping it will allow you to restart it in the future, but it will still consume some resources related to your instance storage. By contrast, if you Terminate an EC2 instance, then all its resources will be released, but you won’t be able to restart it.

There’s a lot more to using AWS, like creating an AWS image of your instance, but that goes beyond the scope of this article.

Wrapping Up

Building your own Twitter bots allows you to take your Twitter presence to the next level. By using bots, you can automate content creation and other Twitter activities. This can save you a lot of time and give your audience a better experience.

The Tweepy package hides many low level details of the Twitter API, allowing you to focus on the logic of your Twitter bots.

In this article, you learned how to:

• Improve and automate your interactions with your Twitter audience
• Install Tweepy
• Sign up as a Twitter developer to use its API
• Use Tweepy to invoke the Twitter API
• Build Twitter bots
• Deploy the bots to a server using Docker and AWS

You can use the bots in this article as a starting point to automate part of your Twitter activity. Don’t forget to take a look at the whole Tweepy API documentation and use your imagination to make more complex bots that are meaningful to your use case.