Twitter Replying Bot that generates color grids

Mohamed Adel — Wed, 02 Nov 2022 14:30:01 +0000

Yet another tweepy tutorial, but we are not complaining.

a little background: i like to create random fractals art (NFT anyone) I can just can spend hours staring at one and seeing all different things. so what's a better way to share my creations? a twitter bot of course, but lets also make it do something else.

you can try it your self by tweeting 'make grid' to @machineation on twitter. the bot will hash your username then use it as a seed to generate a unique color grid based on the username. lets start.

requirements:

python >= 3.10
twitter developer account (not covered in the tutorial)
tweepy
numpy
pillow

if your not familiar with twitter developer account, please Check this because creating the developer account, app, and getting the authentication are not covered in this tutorial.

lets start by installing the required packages..feel free to use virtual environment or pip3 if you have both version of python.

pip install tweepy numpy pillow

after everything is installed, lets create a file called "bot.py" but you can name yours anything you like, and then lets import what we will need.

import tweepy, random, time, os, pathlib, numpy, hashlib
from PIL import Image

after that, we need to add the authentication and create the API object using tweepy. you can read about the tweepy authentication in the docs but essientially, you need the API Key, API Key Secret, Access Token and Access Token Secret

your keys are secret. don't include them in the script and upload them to to any publicly visible cloud. use .env or some other method to keep secrets. for simplicity, the tutorial doesn't cover that

auth = tweepy.OAuthHandler("xxxx", "xxxx")
auth.set_access_token("xxxx", "xxxx")

#create API object
api = tweepy.API(auth, wait_on_rate_limit=True)

wait_on_rate_limit – Whether or not to automatically wait for rate limits to replenish

In order not to reply to the same tweet multiple times and also to get only the mentions that the bot haven't seen yet, we will make sure to save the last mention tweet id. We will save it to a file so that even if we stopped the bot and then resumed, we will start from the mentions we haven't seen yet, not from the beginning.
Let's create 2 functions. One for reading the id from file and one to store the id.

def read_last_seen(FILE_NAME):
  file_read = open(FILE_NAME,'r')
  last_seen_id = int(file_read.read().strip())
  file_read.close()
  return last_seen_id

def store_last_seen(FILE_NAME, last_seen_id):
  file_write = open(FILE_NAME,'w')
  file_write.write(str(last_seen_id))
  file_write.write("\n")
  file_write.close()
  return

Notice that the first function for reading the id takes one parameter which is the file name, and the function to store the id takes 2 parameters, the file name and the id. in the future, if you want to have more functions that store and read different things, you can call the same functions and changing the parameters and we would change "last_seen_id" with "data" for example.

Now, Lets create the function to create the colors grid from the username. I opted to code it as a separate function.

def make_grid(handle):
    hash = int(hashlib.sha256(handle.encode('utf-8')).hexdigest(), 16) % 10**8
    numpy.random.seed(hash)
    # Generate 100x100 grid of random colours
    grid = numpy.random.randint(0,256, (100,100,3), dtype=numpy.uint8)
    im = Image.fromarray(grid).resize((1600,1600), resample=Image.Resampling.NEAREST)

    im.save(os.path.join(os.path.dirname(__file__), "grids/") + handle + '.png')

"handle": the parameter that will be the username that we will pass to the function.

"hash": we will hash the username using sha256 to use it as a random seed for numpy.

"grid": using numpy, we create a grid with random colors (seeded with the username hash). you can make it any size you want.

"im": using pillow to create the 1600x1600 image from the data. you can use any size you want.

we then save the png image in a folder in the same directory called "grids" with the username as the file name.

Next step, let's create the function that will:

Fetch the mentions since last stored tweet id.
Loop over the mentions.
Store the tweet id.
Check if the tweet is not by our bot.
Check if tweet contains specific words.
Check if the tweet doesn't contain extra words and reply with a message if so.
Reply to tweet depending on the matched word.

this means you can expand the bot to do other things based on the tweet content (command). But first, we need to set some variables.

def grid_tweet():
    bot_id = xxxxxxxxxxxx
    FILE_NAME = os.path.join(os.path.dirname(__file__), "grid_last_seen.txt")
    words = ["make grid"]
    message = "Here is your unique color grid, @{}"
    grid_unknown = "@{} If you want a grid, You just need to tweet 'make grid' to Me without any other words and I will create and send You one."

let's go over them:

bot_id

we set this variable so that we can check if the tweet author is not our bot. this way we make sure that if our bot tweeted the same words we are looking for, the bot doesn't reply to itself. you can get the bot id through different ways, but here is a simple one

Through the Browser
you can go to the bot page on twitter, right click anywhere inside the page and click "Inspect" then search for "identifier" in the elements which will look something like this
"identifier": "1572580999673831426"

FILE_NAME

this is the file we will use to read and store the last mention tweet id. This will be used to call the functions we already created and pass the variable to them. We can then have different files for different functions if we want.

words

The list of words we are looking for. you can add more separated with a comma. For our example we are only using "make grid".

message

the message we are going to include in our reply. we are using {} at the end to format it later and add the username to it.

grid_unknown

Another message if the tweet has extra words in addition to "make grid". also using {} to be formatted later with the username.

now let's create the rest of the code.

    while True:
        # Finding tweets that mention our bot
        mentions = api.mentions_timeline(since_id=read_last_seen(FILE_NAME)) 
        # Iterating through each mention tweet
        for mention in mentions:
            # Save the tweet id in the file
            store_last_seen(FILE_NAME, mention.id)
            # Check to see if the tweet author is not our bot
            if mention.author.id != bot_id:
                # Check if the tweet has any of the words we defined in our list after converting the tweet to lower case
                if True in [word in mention.text.lower() for word in words]:
                    # Removes the first part of the mention which is our bot username like so @username
                    command = mention.text.lower().split(' ',1)[1]
                    # Act based on the matched word/command. can later be used to add more functionality.
                    match command:
                        case "make grid":
                            try:
                                # Prints the username and tweet
                                print(f"{mention.author.screen_name} - {mention.text}")
                                print('Creating Grid')
                                # Calls our make_grid function and passing the username.
                                make_grid(mention.author.screen_name)
                                # Set the media to the image created by our function
                                media = os.path.join(os.path.dirname(__file__), "grids/") + mention.author.screen_name + '.png'
                                print("Attempting to reply...")
                                # Reply with the message after formatting to include username and the media
                                api.update_status_with_media(message.format(mention.author.screen_name), media, in_reply_to_status_id=mention.id_str)
                                print("Successfully replied :)")
                            # Error handling. for now it just prints the error.
                            except Exception as exc:
                                print(exc)
                        # If the tweet contains extra words in addition to our command
                        case other:
                            try:
                                print('tweet contains other words')
                                # Reply with the grid_unknown message
                                api.update_status(grid_unknown.format(mention.author.screen_name), in_reply_to_status_id=mention.id_str)
                                print("Successfully replied with explaination :)")
                            except Exception as exc:
                                print(exc)
        # Sleep for 2 minutes
        time.sleep(120)

so at the end, our file will look like this:

import tweepy, random, time, os, pathlib, numpy, hashlib
from PIL import Image

auth = tweepy.OAuthHandler("xxxx", "xxxx")
auth.set_access_token("xxxx", "xxxx")

#create API object
api = tweepy.API(auth, wait_on_rate_limit=True)

def read_last_seen(FILE_NAME):
  file_read = open(FILE_NAME,'r')
  last_seen_id = int(file_read.read().strip())
  file_read.close()
  return last_seen_id

def store_last_seen(FILE_NAME, last_seen_id):
  file_write = open(FILE_NAME,'w')
  file_write.write(str(last_seen_id))
  file_write.write("\n")
  file_write.close()
  return    

def make_grid(handle):
    hash = int(hashlib.sha256(handle.encode('utf-8')).hexdigest(), 16) % 10**8
    numpy.random.seed(hash)
    # Generate 100x100 grid of random colours
    grid = numpy.random.randint(0,256, (100,100,3), dtype=numpy.uint8)
    im = Image.fromarray(grid).resize((1600,1600), resample=Image.Resampling.NEAREST)

    im.save(os.path.join(os.path.dirname(__file__), "grids/") + handle + '.png')
def grid_tweet():
    bot_id = xxxxxxxxxxxx
    FILE_NAME = os.path.join(os.path.dirname(__file__), "grid_last_seen.txt")
    words = ["make grid"]
    message = "Here is your unique color grid, @{}"
    grid_unknown = "@{} If you want a grid, You just need to tweet 'make grid' to Me without any other words and I will create and send You one."
    while True:
        # Finding tweets that mention our bot
        mentions = api.mentions_timeline(since_id=read_last_seen(FILE_NAME)) 
        # Iterating through each mention tweet
        for mention in mentions:
            # Save the tweet id in the file
            store_last_seen(FILE_NAME, mention.id)
            # Check to see if the tweet author is not our bot
            if mention.author.id != bot_id:
                # Check if the tweet has any of the words we defined in our list after converting the tweet to lower case
                if True in [word in mention.text.lower() for word in words]:
                    # Removes the first part of the mention which is our bot username like so @username
                    command = mention.text.lower().split(' ',1)[1]
                    # Act based on the matched word/command. can later be used to add more functionality.
                    match command:
                        case "make grid":
                            try:
                                # Prints the username and tweet
                                print(f"{mention.author.screen_name} - {mention.text}")
                                print('Creating Grid')
                                # Calls our make_grid function and passing the username.
                                make_grid(mention.author.screen_name)
                                # Set the media to the image created by our function
                                media = os.path.join(os.path.dirname(__file__), "grids/") + mention.author.screen_name + '.png'
                                print("Attempting to reply...")
                                # Reply with the message after formatting to include username and the media
                                api.update_status_with_media(message.format(mention.author.screen_name), media, in_reply_to_status_id=mention.id_str)
                                print("Successfully replied :)")
                            # Error handling. for now it just prints the error.
                            except Exception as exc:
                                print(exc)
                        # If the tweet contains extra words in addition to our command
                        case other:
                            try:
                                print('tweet contains other words')
                                # Reply with the grid_unknown message
                                api.update_status(grid_unknown.format(mention.author.screen_name), in_reply_to_status_id=mention.id_str)
                                print("Successfully replied with explaination :)")
                            except Exception as exc:
                                print(exc)
        # Sleep for 2 minutes
        time.sleep(120)

if __name__ == "__main__":
    print('The mighty Machineation is starting...')
    grid_tweet()

and that's it..now all you have to do is start it with:
pyhton bot.py
and tweet from a different account to your bot saying "make grid" and it should reply in a couple of minutes with the color grid.

Twitter Bot that is generating unique color grids

Mohamed Adel — Thu, 27 Oct 2022 15:18:51 +0000

The NFT craze came and went and whether you believe in them or not, no one can deny the possibilities and the coding behind the technology.
I have always been amazed by Fractals and random computer generated art.so what is better than creating a twitter bot that shares the Fractals I generate with the world? a bot that responds to mentions and generate something.

The basic and simple idea behind it is by using tweepy and creating a bot that fetches mentions and check if certain words (command) and then creates something and send it back to the user who tweeted at the bot. that is exactly what I did..just for fun.

if you mention @machineation on twitter with "make grid" then the bot will take your twitter username, hash it, then create a random color grid seeded by the username.

I don't know if that would be an interesting post/tutorial to show how to code such a bot. If anyone is interested, then i will invest some time in it for sure.

Personal Website

Mohamed Adel — Tue, 31 May 2022 18:28:03 +0000

i have been playing with computers all my life. i am from the late dial-up internet era. the modem dialing sounds still feel like the beginning of an adventure to me.

i had the opportunity to shift careers in the last couple of years and got a nice deal freelancing remotely for a abroad company, doing web developments. i manage the server side of things and do what every full stack developer does..breaks things, then fix them.

the idea was to get my freelancing career started and have some extra job on the side, so where does that begins? a website of course.

easier said than done. life happens and i find myself stuck between completing tasks, fighting through life, or just napping..with the occasional gaming now and then (eve online, csgo anyone?)

i still don't know what i can show in my portfolio and what not, so i just wanted to get one going. so i worked on something that has a tribute to couple of things that a like, and an Easter egg...all would be kinda appreciated by fellow developers and geeks, but not so much for any potential clients. its a lot of fun doing stuff like that.

mohamedation

DEV Community: Mohamed Adel