DEV Community: Vinicius Koji Enari

Maintaining a Python Package with GitHub Actions

Vinicius Koji Enari — Sat, 20 May 2023 16:43:04 +0000

What I built

A hangman game created using Python and distributed as a Python package through PyPI. It utilizes GitHub actions to test and lint the code whenever there is a push or pull request to the main branch. Additionally, whenever a new release is created, the new version of the package is automatically deployed to PyPI.

Category Submission:

Wacky Wildcards

App Link

Package on PyPI: https://pypi.org/project/hangman-package/

Screenshots

Demonstration of the game in GitHub Codespaces:

Description

The game can be installed using pip.

pip install hangman-package

To play, you just need to import the package, create an instance of the Hangman class and call the play method.

from hangman import Hangman

hangman = Hangman()
hangman.play()

You can pass a list of words to the Hangman class to utilize custom words. By default, the words are a list of programming language names.

hangman = Hangman(words=['apple', 'banana', 'orange', 'melon'])

Link to Source Code

Github repository: https://github.com/viniciusenari/hangman-package

Permissive License

MIT License

Background (What made you decide to build this particular app? What inspired you?)

I wanted to build something with GitHub Actions to learn the basics of how it works. Since I am most comfortable working with Python, I looked for workflow templates available for Python and found two that could be helpful in maintaining a Python package.

I wasn't sure what to build for a package, so I ended up going with the first idea that came to mind—a hangman game. While it's not an original idea, it served its purpose of allowing me to utilize and learn more about GitHub Actions.

How I built it (How did you utilize GitHub Actions or GitHub Codespaces? Did you learn something new along the way? Pick up a new skill?)

I utilized two GitHub actions workflows, one for testing and linting and another one for publishing my package. The workflow for testing and linting is triggered whenever there is a push or a pull request to the main branch. It utilizes the pytest library to run tests and flake8 to lint, ensuring that the code follows conventions and works correctly. It runs against multiple Python versions.

The workflow for publishing is triggered when a new release is created. It utilizes the build command to create a distributable version of the package and publishes it to PyPI.

Overall, I learned how to utilize these workflows to automate important tasks in my development process, making it easier to maintain code quality and distribute my package.

In addition to GitHub Actions, I also utilized GitHub Codespaces to experiment with my package. Without needing to rely on my local development environment, I was able to test the package.

Additional Resources/Info

https://en.wikipedia.org/wiki/Hangman_(game)

What is the best way to evaluate someone's technical skills?

Vinicius Koji Enari — Wed, 15 Feb 2023 17:01:21 +0000

Introduction 👋🏼

As someone entering the job market and going through multiple hiring processes recently, I started questioning the various methods companies use to evaluate candidates' technical skills. Why do companies use different methods to interview, and what advantages and disadvantages each approach has? I'm writing this article to express my views on each method as an interviewee and learn more insights from you in the comments section.

The Goal 🎯

Before discussing the different interview methods, I want to discuss the goal of the interview process.
I believe there are four criteria that companies want to evaluate the candidates on, they are:

Technical Knowledge
Problem-solving skills
Communication
Cultural fit

What criteria are more significant will depend on the company and the role. Different interview methods assess some criteria better than others, so you must consider what you want to evaluate before choosing a way to interview candidates.

The Different Methods to Evaluate Technical Skills

In the following sections, I will discuss some of the types of interviews I encountered and how each assesses the different interview types.

Online Coding Assessments 👨‍💻

Online coding assessments typically involve solving a set of coding problems within a limited time frame using a coding platform. These problems usually focus on the use of data structures and algorithms and can be found on websites such as Leetcode and HackerRank.

Skill	Explanation
Technical Knowledge	Online coding assessments test a candidate's knowledge of programming, data structures, and algorithms. Still, they may not necessarily assess the specific technical skills required for the role.
Problem-solving skills	While these assessments can provide insight into a candidate's problem-solving abilities, it is possible for a candidate to perform well simply by recognizing and implementing a solution that they have seen before, rather than demonstrating their ability to solve new problems.
Communication	Online coding assessments do not directly evaluate a candidate's communication skills.
Cultural fit	Online coding assessments do not assess a candidate's cultural fit with the company.

Coding Assessment with Interviewer 👨‍💻👨‍💼

Also known as "pair programming," coding assessment with an interviewer are similar to the coding assessments discussed before. Still, the difference is that there will be an interviewer present. This format allows the interviewer to observe the candidate's thought process and approach to problem-solving, as well as their coding skills and technical knowledge. The interviewer may ask questions and guide the candidate through the coding problems.

It provides a more in-depth evaluation of a candidate's problem-solving skills than online coding assessments since the interviewer can assess the candidate's thought process and understanding of the problem.

Skill	Explanation
Technical Knowledge	Similar to online coding assessments, coding assessments with an interviewer test a candidate's knowledge of programming, data structures, and algorithms but may not directly assess the technical skills required for the role.
Problem-solving skills	It provides a more in-depth evaluation of a candidate's problem-solving skills than online coding assessments since the interviewer can assess the candidate's thought process and understanding of the problem.
Communication	While coding assessments with an interviewer provide insight into a candidate's ability to communicate their solution, it is only one aspect of communication. It may not fully evaluate their overall communication skills.
Cultural fit	It can evaluate cultural fit depending on the interviewer's approach, who may ask questions to assess the candidate's fit with the company before or after the coding portion of the assessment.

System Design Interviews 🌐🛠️

While I have only encountered system design interviews twice, I am familiar with their general format. During this interview, the interviewer asks the candidate to create a high-level architecture for a system, often using examples such as YouTube, Twitter, or Spotify.

It is important to note that candidates are not expected to replicate the exact architecture of these products. Instead, they are evaluated on their understanding of system architecture and ability to weigh different trade-offs between various approaches. These interviews aim to test a candidate's problem-solving skills, ability to create efficient solutions, and communication skills in explaining their designs to the interviewer.

Skill	Explanation
Technical Knowledge	A system design interview assesses a candidate's technical knowledge in designing complex real-world software architecture, which encompasses multiple subjects, including data storage, scalability, and security.
Problem-solving skills	It evaluates a candidate's problem-solving skills by assessing their ability to design solutions for large-scale, real-world problems. Through them, an interviewer can assess how the candidate breaks down the problem, consider different constraints and trade-offs, and make architectural decisions.
Communication	It tests candidates' ability to effectively communicate their design choices, explain trade-offs, and justify their decisions.
Cultural fit	They do not directly assess cultural fit, but the interviewer may include questions to evaluate it

Take Home Project 🏠

This type of interview involves providing the candidate with a prompt to develop a project that aligns with the role's requirements. The project may vary depending on the position, such as a webpage, an API, or a mobile app. It should be developed using the required programming languages and frameworks. Typically, candidates are given several days to complete the project and submit it for evaluation.

Take-home projects allow candidates to demonstrate their skills and problem-solving abilities in a more realistic environment and at their own pace. They also enable the candidate to showcase their creativity and personal style in their approach to solving the problem.

However, there are some downsides to taking home projects. The interviewer cannot assess the candidate's ability to think on their feet or how they or work under pressure. The candidate may receive help from outside sources, such as friends or online forums, which can compromise the integrity of the evaluation.

Skill	Explanation
Technical Knowledge	Evaluates the candidate's knowledge of the programming language and frameworks used in the role, as well as general software development concepts
Problem-solving skills	Assesses the candidate's ability to solve problems and design software based on the prompt. This includes breaking down the problem, identifying constraints and trade-offs, and creating a solution that meets the requirements.
Communication	Focuses on how well candidates document their code and explain their design choices. It may not evaluate verbal communication directly, but the quality of written communication can indicate the ability to communicate effectively.
Cultural fit	Does not directly assess cultural fit. Still, the project prompt may reflect the team's values and provide insight into the candidate's approach to work.

Resume/Portfolio interview 📄

Resume/portfolio interviews consist of the interviewer conversing with the candidate, focusing on their previous roles, technologies they have worked with, and projects they have been involved in. The interviewer will usually review the candidate's resume and portfolio and ask questions related to their prior experiences or ask some questions prepared before the interview to obtain more specific insights about the candidate.

In addition to assessing the candidate's technical abilities, these interviews may also evaluate their problem-solving approach. The interviewer may ask the candidate to share any experience where they encountered a challenge and ask them to explain how they dealt with it. Additionally, the interviewer may evaluate the candidate's teamwork approach and how they collaborated with their team members in previous projects by asking questions about it.

Resume/portfolio conversations offer a chance for candidates to have a more personalized discussion about their technical and soft skills. However, it's essential to remember that this interview format does not allow an in-depth evaluation of a candidate's technical skills.

Skill	Explanation
Technical Knowledge	By having the candidate talk about his past experiences, the interviewer understands what programming languages, frameworks, and tools the candidate are familiar with.
Problem-solving skills	The interviewer may ask about specific problems the candidate has faced and how they solved them, providing them with some understanding of the candidate's problem-solving skills.
Communication	The interviewer may ask about how the candidate communicates with team members, how they document their work, and how they present ideas to other people
Cultural fit	Through questions, the interviewer may assess how well the candidate's work style and values align with the team's culture and the company's mission. The interviewer may ask about how the candidate collaborates with others, how they handle conflict and their approach to problem-solving in a team setting.

Conclusion 🏁

This article discussed various methods employed to interview and evaluate candidates for technical positions. While companies developed these techniques to ensure fairness and accuracy in assessing candidates, they all have certain limitations. Companies often combine different interviewing methods to achieve a more just and accurate candidate assessment. There may be more effective evaluation methods that are not yet widely adopted. Still, it is essential to acknowledge that companies have limited resources for the hiring process. The current techniques may be the most practical given the company's resources. Still, it is always worth considering whether there are more efficient ways to conduct interviews.

Automating Content Creation with Python: Uploading a Video to Youtube

Vinicius Koji Enari — Wed, 25 Jan 2023 18:52:48 +0000

This is the last part of the series on building a YouTube content creation bot that utilizes Twitch clips. If you have yet to see it, be sure to start with the first part.

Uploading the Video to Youtube

Generating Title, Description, Tags and Thumbnail

We have completed the video, but before uploading it, several other fields must be filled out when uploading it to YouTube, such as the title, description, tags, and thumbnail. But, these can also be created from the information we obtained through the Twitch API.

Title

A simple title can be created by including the name of the game the compilation of clips is from, and the number of clips included. Additionally, we can specify that these are the top most-watched clips of the week.

Example: "Top <quantity> Most-Watched <game_name> Clips of the Week"

Description

In the description, I want to include the time range when the clips were created, the languages the clips were taken from and provide a list of the clips and their URLs. Additionally, it is possible to add timestamps for each clip by utilizing the individual duration of each clip to calculate the values.

Here is an example of a description created from the clips' information:

Thumbnail

The thumbnail is an image that represents the video and can be created in various ways. The template I used consists of displaying the words "Top <number_of_clips> <game_name> Twitch Clips" on it and featuring a grid of individual clip thumbnails as the background. The number of thumbnails in the grid is determined by the floor(sqrt(number_of_clips)) function. I used abbreviations for some games with longer names to save space and make the thumbnail more appealing. For instance, instead of displaying "League of Legends" in the thumbnail, it will show "LOL."

Here is an example of the thumbnail:

If you want to check the specific code for creating the title, description, tags and thumbnail here is the link

Uploading with the Youtube API

Now that I have the video and all the relevant metadata, I will upload the video to Youtube. For this, I utilized the Youtube API. I will not go into detail on how to do it since they already provide an excellent guide for how to start using the Youtube API with Python. You need to download the Python libraries to authenticate with Google, set up a project on Google Cloud and then you will be able to download the API credentials as JSON file.

Google provides code snippets for many actions that you may want to make using the API in this website: developers.google.com/youtube/v3/code_samples/code_snippets. I utilized the code they already provided under the "videos" resource and "insert" method. The only problem is that when the video takes long to upload, there will be an error. To fix that, I found you need to put in place a resumable upload that will resume the video upload if it times out. Here is a sample code.

Besides the video, I also need to upload the category ID (for gaming, it's 20) and the privacy status (I set it to "Public" so the video will be discoverable immediately after upload). After the video is uploaded, I'll use the returned video ID to upload the thumbnail in a separate request.

This is a snippet of the code I used to upload videos to YouTube

def upload_thumbnail(self, video_id, file_path):
        print('Uploading thumbnail...')
        request = self.youtube.thumbnails().set(
            videoId=video_id,
            media_body=file_path
        )
        response = request.execute()
        print(response)

def upload_video(self, file_path, video_content):
    body = dict(
        snippet=dict(
            title=video_content.title,
            description=video_content.description,
            tags=video_content.tags,
            categoryId=video_content.category_id
        ),

        status=dict(
            privacyStatus=video_content.privacy_status
        )
    )

    insert_request = self.youtube.videos().insert(
        part=",".join(body.keys()),
        body=body,
        media_body= MediaFileUpload(
            file_path, chunksize=-1, resumable=True)
    )

    video_id = self.resumable_upload(insert_request)
    self.upload_thumbnail(video_id, 'files/youtube/thumbnail.png')

Takeaways

With this, I end the series about my project that automates collecting Twitch clips, creating a video compilation, and uploading it to YouTube. Overall, this project shows the power of automation and APIs to create and distribute content efficiently and effectively. Despite this, the project still has several limitations that prevent it from being on par with channels managed by humans. Here are some examples:

When it gets clips using the Twitch API for a specific category, many clips that are returned are from people who were streaming under that category. Still, the clip is unrelated to that category. For example, a streamer playing League of Legends might only show their camera between games. An event unrelated to the game might occur, resulting in a famous clip under the "League of Legends" category.
Many clips may need knowledge of the streamer's context to be understood, making them less suitable to include in compilations that an audience may view without that context.
Many YouTube channels that post similar content edit the clips to make them more entertaining. They do this by zooming in on important moments, highlighting areas of interest with red circles, adding sound effects, and many other things.

I hope you enjoyed reading this. If you have any questions, please leave them in the comments. If you want to check the source code or look at the Youtube channel I created to test it, here are the links:

GitHub Repository: github.com/viniciusenari/twitch-highlights-bot
YouTube Channel: youtube.com/@mostwatchedtwitchclips

Automating Content Creation with Python: Editing with MoviePy

Vinicius Koji Enari — Wed, 25 Jan 2023 18:52:16 +0000

This is a continuation of a multi-part series on building a YouTube content creation bot that utilizes Twitch clips. If you have yet to see it, be sure to start with the first part.

Compiling the Clips into a Video

With the clips downloaded, the next step is to merge them into a single video. I used the MoviePy Python library. The editing process involves three steps:

Create overlays for each clip with the broadcaster's title and name.
Superimpose the overlay on the top of the corresponding clip.
Concatenate all the clips together to produce a single video.

This way, you will have a final video with the title, and broadcaster name on every clip and all clips merged into one video.

Creating Overlays

I used the Python library Pillow to create the overlays for the clips. Although MoviePy also allows adding text to clips, it relies on the ImageMagick library, which requires manual installation. I preferred Pillow as it is easier to install, although it may be less efficient.

I made a transparent image of 1980x1080 resolution to create an overlay with Pillow. I added the title and broadcaster's name at the bottom left corner. If the title is too long, it will be truncated, and a "..." will be added to the end. After an overlay is created, it is saved in a dedicated directory.

Here's an example of the code:

from PIL import Image, ImageDraw, ImageFont

def create_overlay(self, clip_content):
    title = clip_content.title
    broadcaster_name = clip_content.broadcaster_name
    if len(title) > 40: title = title[:40] + '...'

    # Create a 1980x1080 transparent image
    overlay = Image.new('RGBA', (1920, 1080), color = (255,255,255,0))

    # Load fonts and create font objects
    fnt_clip_name = ImageFont.truetype(font_clip_name, 62)
    fnt_streamer_name = ImageFont.truetype(font_broadcaster, 50)

    d = ImageDraw.Draw(overlay)

    d.text((100, 930), title, font=fnt_clip_name, stroke_width=3, stroke_fill=(0, 0, 0), fill=(255, 255, 255))
    d.text((100, 1000), broadcaster_name, font=fnt_streamer_name, stroke_width=3, stroke_fill=(0, 0, 0), fill=(255, 255, 255))

    if not os.path.exists('files/overlays'): os.makedirs('files/overlays')
    filename = clip_content.title.replace(" ", "_").replace("/","_").lower()
    overlay.save(f'files/overlays/{filename}.png')

Superimposing the Overlay

Using the MoviePy library, I superimposed the overlays on the clips. The process is straightforward: I created a MoviePy VideoFileClip and ImageClip, for the clip and overlay. Then, I combined them into a CompositeVideoClip.

from moviepy.editor import VideoFileClip, ImageClip, CompositeVideoClip

def create_video(self, clip_content):
    clip = VideoFileClip(clip_content.path, target_resolution=(1080, 1980))
    filename = clip_content.title.replace(" ", "_").replace("/","_").lower()
    img_clip = ImageClip(f'files/overlays/{filename}.png').set_duration(5)
    video = CompositeVideoClip([clip, img_clip])
    return video

Resulting in the following:

Concatenating the Clips

Now that all individual clips have an overlay, the next step is to concatenate them. The MoviePy library offers the concatenate_videoclips function, which, when used on an array of MoviePy clip objects, returns a single clip composed of all the other clips played one after another. Using the method='compose' parameter ensures that if the clips have different resolutions, MoviePy will resize them to result in a seamless final product.

The final step is to convert the clip object into an actual video file. The write_videofile method is used to do that. It takes various parameters such as fps, codec, threads, preset, and bitrate. The values for these parameters have been chosen after experimenting to find the best results. It's worth noting that what worked for me may not be the best for others, so one should experiment with different parameters to find the best results for their specific use case.

Here is the code for concatenating the clips. I create an overlay for each clip, superimpose it to the clip, and append it to an array. It then concatenates all clips on the array and writes a video file from the concatenated clip.

from moviepy.editor import concatenate_videoclips

render_settings = {
    'fps' : 60,
    'codec' : "mpeg4",
    'threads' : 8,
    'preset' : "ultrafast",
    'bitrate' : '20000k'
}

def create_video_compilation(self, clips, amount):
    for clip in clips[:amount]:
        self.create_overlay(clip)
        self.clips.append(self.create_video(clip))

    video = concatenate_videoclips(self.clips, method='compose')
    if not os.path.exists('files/youtube'): os.makedirs('files/youtube')
    video.write_videofile(f'files/youtube/video.mp4', fps = render_settings['fps'], codec = render_settings['codec'], threads = render_settings['threads'], preset = render_settings['preset'], bitrate = render_settings['bitrate'])

Conclusion

In the article, I covered how to use MoviePy to edit videos and create a compilation from before downloaded clips. In the next part, I will cover how you can use the Youtube API to upload videos with a custom title, description, thumbnail, and tags. Remember to leave a comment if you have any questions.

Automating Content Creation with Python: Obtaining Clips from Twitch

Vinicius Koji Enari — Wed, 25 Jan 2023 18:51:49 +0000

This is a continuation of a multi-part series on building a YouTube content creation bot that utilizes Twitch clips. If you have yet to see it, be sure to start with the first part.

Retrieving and Downloading the Most Viewed Clips

Using the Twitch API

As before mentioned, I used the Twitch API to retrieve the most viewed clips. To access the Twitch API, you must first have a Twitch account and register an application on dev.twitch.tv/console. You will get a Client ID and a Client Secret. Once you have these credentials, you can make a post request to https://id.twitch.tv/oauth2/token to receive a token in response. With this token, you can make requests to the Twitch API endpoints.

You can refer to this more in-depth guide on how to get started using the Twitch API.

In Python, you can use the requests library to request to authenticate.

import requests

class TwitchAPI():

    def __init__(self):
        self.headers = None

    def auth(self, client_id, client_secret):
        headers = {
            'Content-Type': 'application/x-www-form-urlencoded',
        }

        data = f'client_id={client_id}&client_secret={client_secret}&grant_type=client_credentials'

        try:
            response = requests.post('https://id.twitch.tv/oauth2/token', headers=headers, data=data)
            response.raise_for_status()
        except requests.exceptions.HTTPError as err:
            raise SystemExit(err)
        except requests.exceptions.RequestException as err:
            raise SystemExit(err)
            
        bearer = response.json()['access_token']

        self.headers = {
            'Authorization': f'Bearer {bearer}',
            'Client-Id': client_id,
        }

Retrieving Clips

The Twitch API offers an endpoint that enables developers to retrieve information about specific clips. This endpoint allows developers to query for clips from a broadcaster or game or by using particular clip IDs. In this application, the request query parameters that were utilized include:

game_id to query for clips from a specific game.
started_at and ended_at to select a particular period in which the clips were created.
first to specify the number of clips that must be returned.

You can use the Get Top Games endpoint from the Twitch API to get information about the most watched games on Twitch at the moment, which includes the games' IDs. If you want to know the ID of a game that is not on the top games being watched, you can use the Get Games endpoint. For my project, getting the IDs of the top games is enough since they are the games that are more likely to attract an audience to a YouTube channel. You can store the game IDs in a Python dictionary and then use this data to query for the top clips.

Below is an example of how you can store the game's IDs in a dictionary

import requests
from project.twitch_api import TwitchAPI
from project.utils import client_id, client_secret

api = TwitchAPI()
api.auth(client_id, client_secret)

def get_top_games(self):
    url = 'https://api.twitch.tv/helix/games/top'
    response = requests.get(url, params={'first':100}, headers=api.headers)

    games_id = {}
    for game in response.json()['data']:
        games_id[game['name']] = game['id']

    return games_id

games_id = get_top_games()

The last step before obtaining the clips is to add an option to filter them by language, as the API does not allow queries for clips in a particular language. This way, it will be easier to create compilations of clips that target more specific audiences, as opposed to having clips in different languages.

In summary, the process involves requesting clips, filtering them based on desired languages, saving relevant information, and continuing until it has the desired number of clips. The information of each clip in a ClipContent object

class ClipContent:

    def __init__(self, url, broadcaster_id, broadcaster_name, game_id, creator_name, title, thumbnail_url, duration, path):
        self.url = url
        self.broadcaster_id = broadcaster_id
        self.broadcaster_name = broadcaster_name
        self.game_id = game_id
        self.title = title
        self.thumbnail_url = thumbnail_url
        self.duration = duration
        self.path = path

If you want to check how I implemented it, you can find the code on my GitHub repository at this link

Downloading the Clips

Having obtained information about the clips, one can proceed to download them. There is no direct method to download clips via the API. Still, it is possible to do so using its information. A technique that works most of the time involves utilizing the thumbnail URL of each clip.

A clip thumbnail URL looks like this:
https://clips-media-assets2.twitch.tv/jTk1-Xmig5ji1Dll05ivnA/AT-cm%7CjTk1-Xmig5ji1Dll05ivnA-preview-260x147.jpg

Removing the "-preview-260x147.jpg" from the URL and adding a ".mp4" extension can generate a valid address for downloading the clip. This method may not work for older clips, but it has worked for recent clips in my testing.

Here is an example of how you can download the clip from the thumbnail URL using Python.

def download_clip(clip):
    index = clip.thumbnail_url.find('-preview')
    clip_url = clip.thumbnail_url[:index] + '.mp4'
    r = requests.get(clip_url)

    if r.headers['Content-Type'] == 'binary/octet-stream':
        if not os.path.exists('files/clips'): os.makedirs('files/clips')
        with open(clip.path, 'wb') as f:
            f.write(r.content)

    else:
        print(f'Failed to download clip from thumb: {clip.thumbnail_url}')

Conclusion

In this part of the series, I covered how to use the Twitch API to get information on the most popular clips and download them. In the next part, I will cover how I use the MoviePy library to edit videos. Please comment or reach out if you have any questions.

Automating Content Creation with Python: A Guide to Building a Twitch Highlights Bot

Vinicius Koji Enari — Wed, 25 Jan 2023 18:51:17 +0000

Introduction

Motivation

A few months ago, I came across a post by @joaomaranhao here on dev.to. He described how he used Python to automate a Youtube channel. His project inspired me to start my project to automate a YouTube channel, focusing on different kinds of content and utilizing other methods to obtain and edit videos.

The Project

You probably know what Twitch is, but in case you don't know, Twitch is a live streaming platform that is used for streaming games. Still, it includes various content, such as music, art, talk shows, and even software development.

One of the features available on Twitch is the ability for viewers to make video clips from live streams. By clicking on a button on the bottom right corner of the video player, users can create a video clip by selecting a 5 to 60 seconds segment of the last couple minutes of a live stream. Then they can share it with other people. Video clips are often created so people can share funny and unique moments with others.

Many Youtube channels post compilations of clips from Twitch. You can watch the video below as an example.

My project does that. It gets the most watched clips of the week for a particular game, combines them into a video compilation, and then uploads the final product to Youtube with auto-generated titles, descriptions, tags, and thumbnails.

Technologies Used

Python - The primary programming language for the bot as it provides a lot of libraries that can be used to interact with different platforms and APIs, process data, and build efficient scripts. In this project, I used version 3.11, but some earlier versions should work.
Twitch API - The Twitch API allows developers to access and interact with the Twitch platform. The bot uses the Twitch API to search for and retrieve the most watched clips from Twitch.
MoviePy - A Python library used for video editing. The bot is using this library to create the video compilation by merging the clips obtained from Twitch.
Pillow - A Python library that allows for image processing. It is being used to handle image processing tasks, such as creating thumbnails and title overlays.
Youtube API/ Google Cloud - The YouTube API is a specific API that allows developers to interact with YouTube. Google Cloud refers to the broader suite of cloud computing services offered by Google. The bot is using the YouTube API to upload the final video compilation to YouTube. One must set up a Google Cloud project to use the Youtube API.

Check the other parts

This article will be divided into several sections to provide a comprehensive guide to how I developed this bot. You can check the second part, which will delve into how to use the Twitch API to get information on the most popular clips and download them here.

Github Repository and Youtube Channel

If you want to check the source code or look at the Youtube channel I created to test it, here are the links:

GitHub Repository: github.com/viniciusenari/twitch-highlights-bot
YouTube Channel: youtube.com/@mostwatchedtwitchclips

How I update my Twitter profile automatically using Python.

Vinicius Koji Enari — Fri, 12 Aug 2022 18:25:28 +0000

Introduction

I find automating tasks one of the coolest things about programming. Lately, I've been thinking about ways to utilize APIs to automatize some things, and I came up with the idea of making my Twitter profile banner image change automatically from time to time. It would be like having access to a Twitter feature that no one has, the capability of having a slideshow as a banner instead of a single image.

I will use NASA's Astronomy Picture of the Day API to obtain the images I will use. This API provides a different image daily, making it appropriate for this specific purpose. Also, by using this API, I know that my Twitter banner will repeat no pictures. You can use images from other APIs or your own.

Obtaining access to the APIs

Before starting, you'll need access to the Twitter API and the NASA API.

Twitter API

To access the Twitter API, you must go to Twitter's developers portal. Make sure to log into the portal with the same account you want your banner to change automatically. I'll not cover step-by-step what you need to do to obtain access to the Twitter API, but here is guide. You'll need to apply for Elevated Access to the API (step four) because the request to update one's profile is part of the v1.1 endpoints. It is not difficult to obtain elevated access. You'll have to explain how you will use the API so they know you are following their terms of conduct.

NASA's API

Next, you will need access to NASA Open APIs. NASA's APIs are free to use. It is possible to utilize the API without your API Key by utilizing "DEMO_KEY" as the key.
For example:
https://api.nasa.gov/planetary/apod?api_key=DEMO_KEY

The only limitation is that with the demo key, you can only make 30 requests per hour and 50 requests per day per IP address, while with your API key, you can make up to 1000 requests per hour. The demo key provides enough requests for this project to work since I'm only making one request per day. But I decided to utilize my API key anyway because I would make multiple requests per hour while writing and testing the code. Also, it is easy to obtain.

To obtain access to the NASA API:
Go to api.nasa.gov.
Scroll the page down until you find a form called Generate API Key.
Fill in your personal information and click on signup. You should receive an API key right after.

Implementation

Prerequisites

The are three libraries that you will need.
Tweepy for more easily use of the Twitter API,
requests to obtain the information from the NASA API through an HTTP request,
python-dotenv, which I used to store and access my private keys without exposing them publicly.
You can manually install these libraries or if you cloned my Github repository, install through the requirements.txt file.



pip install tweepy
pip install requests
pip install python-dotenv



pip install requirements.txt

If you are using python-dotenv, you must create a .env file and write your API keys and access token. Example:



TWITTER_API_KEY="YOUR_TWITTER_API_KEY"
TWITTER_API_KEY_SECRET="YOUR_TWITTER_API_KEY_SECRET"
TWITTER_ACCESS_TOKEN="YOUR_TWITTER_ACCESS_TOKEN"
TWITTER_ACCESS_TOKEN_SECRET="YOUR_TWITTER_ACCESS_TOKEN_SECRET"

NASA_API_KEY="YOUR_NASA_API_KEY"

Getting the content from NASA's API



import requests
from dotenv import load_dotenv
import os
load_dotenv()

api_key = os.getenv('NASA_API_KEY')

json = requests.get(f'https://api.nasa.gov/planetary/apod?api_key={api_key}').json()

if json['media_type'] == 'image':
    title = json['title']
    imageURL = json['hdurl']
    content = Content(title, imageURL)

In the code above, I send an HTTP request and obtain a JSON containing information about today's astronomy picture of the day. Here is an example of what today's JSON looks like using the demo key. From this, I get the image's title and URL. There are two URLs. The difference is that hdurl is in a higher resolution.
I'm checking if the value of 'media-type' is 'image' because sometimes the API returns a video instead of an image. In that case, I'll skip that day and not update the banner.

Download the image



img_data = requests.get(url).content
if not os.path.exists('tmp'): os.makedirs('tmp')
with open('tmp/banner.jpg', 'wb') as handler:
    handler.write(img_data)

If it does not exist, I create a folder called 'tmp' in the main directory, where I will save the banner image. I get the image from the URL I obtained from the NASA API.

Auth on Twitter API



import tweepy
from dotenv import load_dotenv
import os
load_dotenv()

api_key = os.getenv("TWITTER_API_KEY")
api_key_secret = os.getenv("TWITTER_API_KEY_SECRET")
access_token = os.getenv("TWITTER_ACCESS_TOKEN")
access_token_secret = os.getenv("TWITTER_ACCESS_TOKEN_SECRET")

auth = tweepy.OAuthHandler(api_key, api_key_secret)
auth.set_access_token(access_token, access_token_secret)
api = tweepy.API(auth)

Using Tweepy to handle the authentication, I pass my API key and secret to Tweepy's OAuthHandler object, set my access token, and then create an API instance.

Updating profile



text = f'Banner photo: {content.title}\nfrom: https://apod.nasa.gov/apod/astropix.html'
api.update_profile_banner(filename = 'tmp/banner.jpg')
api.update_profile(description = text)

Now that I have created an API instance using Tweepy, obtained the content from the NASA API, and downloaded the image, all I have to do is update the banner. I'm also updating my bio to display the title of the picture.

Deploying and setting a scheduler

By running this code, your profile banner and bio will be updated. You'll have to run it daily, so your profile is updated daily. I deployed the code on Heroku and used a scheduler to run the main script every day. Heroku allows you to have up to 5 free projects, so I did not have to pay to use this alternative.

First, create a new app.

On your app's deploy tab, choose how you want to deploy your project. I linked my app to the Github repository. Still, you can also use the Heroku CLI to deploy your project if it is not on Github.

Under the settings tabs, there is a field to add your config vars. You must add your API keys, access tokens, and secrets there. These variables will then become accessible as if they were in a .env file.

You can open the console on the top right and run the main script of your project to test if it applies the changes to your Twitter profile by running it on Heroku.



$ python main.py

Next, you'll have to go to the Addons page and look for an addon called Heroku scheduler. Open the scheduler page and click on install. You'll have to select the project you want to use this addon.

To use any addon on Heroku, you need to have added your credit card info to your account billing settings. Still, it will not charge you since this addon is free unless you run the application many times a month.

Finally, go back to your app overview tab. You should see the Heroku scheduler under the installed addons. Open it and click on create a new job. You will then have to fill in what command you want to run and at what interval it will run.

Conclusion

Thank you for reading. Let me know in the comments if you have any questions or suggestions.

Here is the GitHub repository:

https://github.com/viniciusenari/twitter-profile-updater