Forem: Evan J

How to Make a Twitter Bot Using Python

Evan J — Thu, 01 Jul 2021 14:46:28 +0000

Hello!
This tutorial will demonstrate how to create a simple Twitter bot using the Tweepy library in Python.
This tutorial will be separated into four parts:

Prerequisites
Setting up a Twitter Developer Account
Creating the Application using Python
Running the Application

Prerequisites

Tweepy
Twitter Developer Account (Will explain in the next section)

Setting up a Twitter Developer Account

To create a Twitter bot you must apply for a Twitter Developer Account detailed in this link.
You must describe the use-cases that you intend to satisfy using their API. This application process can take anywhere from an hour to a day, so be patient!
Once accepted you will get an email detailing how to access the developer portal. Login to the developer portal and follow the steps to create a Twitter app.
Make sure your app has Read + Write + Read and post direct messages permissions by going to this screen:

Once it is created and the permissions are set, hit the Key 🗝 icon next to your app, and you should see this screen:

Generate and take note of the API key/secret and the access token/secret. I recommend putting them in a text document, as you cannot access them again once they are generated.
Next we will go over creating the application.

Creating the Application using Python

We will be creating a Twitter bot that simply tweets Hello world!
The file structure by the end of this tutorial will look like:

├───twitterbot
  └───.env             # File that contains our keys
  └───main.py          # Our main application
  └───requirements.txt # The packages we will be using

To start out, create an empty directory using:

$ sudo mkdir twitterbot

And cd into the directory using:

$ cd twitterbot

Create two files called main.py and requirements.txt.
In requirements.txt, insert the line:

tweepy==3.10.0
python-dotenv==0.17.1

Then, to install the required packages, run:

$ pip install -r requirements.txt

tweepy is the library that utilizes the Twitter API, and python-dotenv is the library that allows environment variables to be utilized in your program.
Second, we will go over where to put the keys/tokens.
Create a file called .env and paste the following with the keys you generated in the earlier steps:

consumer_key=XXX        # Found in the API/Secret section
consumer_secret=XXX     # Found in the API/Secret section
access_token=XXX        # Found in the Access Token/Secret section
access_token_secret=XXX # Found in the Access Token/Secret section

It is a good practice to utilize environment variables when dealing with sensitive credentials like this. Never put your credentials directly in your code.
Next we will go over how to utilize the credentials in our code. In our main.py file, add the following:

import os

import tweepy
from dotenv import load_dotenv

# Loads the .env file for the credentials
load_dotenv()

# Credentials set in the .env file
consumer_key = os.environ.get('consumer_key')
consumer_secret = os.environ.get('consumer_secret')
access_token = os.environ.get('access_token')
access_token_secret = os.environ.get('access_token_secret')

We will now implement the tweepy library to use these credentials and authenticate with Twitter:

auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)

# Create API object
api = tweepy.API(auth)

# Checks if the credentials entered are correct
def authenticate():
    if not api.verify_credentials():
        print('Authentication: FAILED')
        return False
    else:
        print('Authentication: OK')
        return True

Next, we will implement a function that handles the tweet itself as well as a main function:

def tweet():
    # If authenticate returns true, execute the following
    if authenticate():
        # Calls the API to tweet the following
        api.update_status('Hello World!')
        print('Tweet has been sent!')
    # If authenticate returns false, print the following
    else:
        print('Tweet has not been sent.')

if __name__ == "__main__":
    tweet()

Running the Application

Now that all of our code has been implemented, you can run the program using python main.py and you should see the following:

Authentication: OK
Tweet has been sent!

And you should see that your tweet has been sent:

Congratulations! You have successfully created a Twitter bot using Python!
If you need to view the files we created for any reason, check it out on GitHub:

ejach / twitterbot

This is an example Twitter bot that uses the tweepy library. It was written for an article that can be read on dev.to.

twitterbot

This is an example Twitter bot that uses the tweepy library. It was written for an article that can be read on dev.to.

View on GitHub

How to Deploy a Python Flask App on Heroku Using Docker

Evan J — Fri, 25 Jun 2021 15:19:42 +0000

Hello!
Today I will demonstrate how to deploy a containerized Python Flask application to Heroku using Docker.
This tutorial is separated into four parts:

Prerequisites
Creating the Flask application using Python
Containerizing the application using Docker
Deploying the container to Heroku

Prerequisites

Flask
A Docker installation
A Heroku Account / Heroku CLI installation

Creating the Flask application using Python

We will be creating a "Hello World!" application to maintain simplicity.
The file structure by the end of this tutorial will look like:

├───FlaskApp
  └───app.py           # Our main application
  └───main.py          # Used by gunicorn to run the app
  └───requirements.txt # The packages we will be using
  └───Dockerfile       # Used to create the Docker container
  └───Procfile         # Used to deploy the container to Heroku

To start out, create an empty directory using:

$ sudo mkdir FlaskApp

And cd into the directory using:

$ cd FlaskApp

Create two files called app.py and requirements.txt.
In requirements.txt, insert the line:

flask==2.0.1
gunicorn==20.1.0

Then, to install the required packages, run:

$ pip install -r requirements.txt

Then open up app.py in your favorite code editor and add the following code:

#Import the flask module
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    statement = 'Hello World!'
    return statement


#Calls the run method, runs the app on port 5000
app.run(host='0.0.0.0', port='5000')

Next, create a file called main.py and add the following code:

from app import app

# Gets the app from app.py and runs it
app.run()

Then run the program using:

$ gunicorn --bind 0.0.0.0:5000 main:app

And you should get an output that looks like:

[2021-06-25 10:33:51 -0400] [1607] [INFO] Starting gunicorn 20.1.0
[2021-06-25 10:33:51 -0400] [1607] [INFO] Listening at: http://0.0.0.0:5000 (1607)
[2021-06-25 10:33:51 -0400] [1607] [INFO] Using worker: sync
[2021-06-25 10:33:51 -0400] [1609] [INFO] Booting worker with pid: 1609

After accessing the URL that was provided upon executing at http://yourip:5000, the page should look something like:

Now that your Python Application is up and running, let's go over how to containerize it using Docker.

Containerizing the application using Docker

In your FlaskApp directory, create a file with no file extension called Dockerfile and add the following:

#Create a ubuntu base image with python 3 installed.
FROM python:3.8

#Set the working directory
WORKDIR /

#copy all the files
COPY . .

#Install the dependencies
RUN apt-get -y update
RUN apt-get update && apt-get install -y python3 python3-pip
RUN pip3 install -r requirements.txt

#Expose the required port
EXPOSE 5000

#Run the command
CMD gunicorn main:app

After this, build the Docker image by running:

$ docker build -t flask-app .

And then run it using:

$ docker run flask-app

And you should get the same output as if you were running it normally:

2021-06-25T15:08:47.958205+00:00 app[web.1]: [2021-06-25 15:08:47 +0000] [5] [INFO] Starting gunicorn 20.1.0
2021-06-25T15:08:47.958983+00:00 app[web.1]: [2021-06-25 15:08:47 +0000] [5] [INFO] Listening at: http://0.0.0.0:5000 (5)
2021-06-25T15:08:47.958983+00:00 app[web.1]: [2021-06-25 15:08:47 +0000] [5] [INFO] Using worker: sync
2021-06-25T15:08:47.962897+00:00 app[web.1]: [2021-06-25 15:08:47 +0000] [7] [INFO] Booting worker with pid: 7

And you should get the expected output at the given IP address at http://yourip:5000:

Congratulations! You have successfully created a Flask application and containerized it using Docker!
Now we will go over how to deploy this container to Heroku using their container registry.

Deploying the container to Heroku

Given that the Heroku CLI is installed as stated in the prerequisites, run:

$ heroku login

And you will be prompted to enter your Heroku credentials.
Once logged in, create an application by running:

$ heroku create <your_app_name>

Next, login to the Heroku container registry by running:

$ heroku container:login

Which should produce:

Login Succeeded

In your FlaskApp directory, create a file with no extension called Procfile and add:

web: gunicorn main:app 0.0.0.0:$PORT

After that, in our app.py file, we need to add/modify the following lines marked with arrows:

# Import OS to get the port environment variable from the Procfile
import os # <-----
# Import the flask module
from flask import Flask

# Create a Flask constructor. It takes name of the current module as the argument
app = Flask(__name__)

@app.route('/')
def hello_world():
    statement = 'Hello World!'
    return statement


# Create the main driver function
port = int(os.environ.get("PORT", 5000)) # <-----
app.run(host='0.0.0.0', port=port)       # <-----

After editing the file, we must push the container to Heroku using:

$ heroku container:push web --app <your_app_name>

After your app's container builds, release it to Heroku using:

$ heroku container:release web --app <your_app_name>

Which will produce the following:

Releasing images web to <your_app_name>... done

Once it is released, you can access the logs of your new container using:

$ heroku logs --tail --app <your_app_name>

And you should see something along the lines of:

2021-06-25T15:08:45.662062+00:00 heroku[web.1]: Starting process with command `/bin/sh -c gunicorn\ main:app`
2021-06-25T15:08:47.958205+00:00 app[web.1]: [2021-06-25 15:08:47 +0000] [5] [INFO] Starting gunicorn 20.1.0
2021-06-25T15:08:47.958983+00:00 app[web.1]: [2021-06-25 15:08:47 +0000] [5] [INFO] Listening at: http://0.0.0.0:34683 (5)
2021-06-25T15:08:47.958983+00:00 app[web.1]: [2021-06-25 15:08:47 +0000] [5] [INFO] Using worker: sync
2021-06-25T15:08:47.962897+00:00 app[web.1]: [2021-06-25 15:08:47 +0000] [7] [INFO] Booting worker with pid: 7
2021-06-25T15:08:48.409823+00:00 heroku[web.1]: State changed from starting to up

And you should now be able to access your application through your new app's URL with the expected output of:

Congratulations! This tutorial has taught you how to create a Python Flask application, containerize it, and then deploy it to Heroku.