DEV Community: Gerry Aballa

The only Playwright Test Automation using Python Cheatsheet you need

Gerry Aballa — Thu, 28 Sep 2023 09:05:16 +0000

Playwright is a Python library that provides a high-level API for automating web browsers like Chromium, Firefox, and WebKit.

While learning and practicing using Playwright in Python environments, I came up with this cheatsheet of the most common practices I came about.

I need help updating this list periodically as code always changes! Feel free to contribute!

Playwright using Python Cheatsheet

Automate Your Facebook Presence with this Python Bot

Gerry Aballa — Sun, 24 Sep 2023 06:01:17 +0000

Github Repo
Meet me on this Facebook Page

Are you tired of manually posting updates to your Facebook Page every day? Do you want to streamline your social media management? If so, you're in luck! In this blog post, I'll introduce you to a Python script that allows you to automate your Facebook Page posts using the Facebook Graph API.

Prerequisites

Before using the script, you need the following:

Facebook Page and Developer Account: You should have a Facebook Page where you want to make posts, and a Facebook Developer Account to obtain the necessary credentials.
Access Tokens: You need a Facebook Page Access Token, which you can get by creating a Facebook App and configuring permissions.
Python Libraries: Make sure you have the required Python libraries installed. You can install them using pip:

   pip install -r requirements.txt

Configuration

In the keys.py file, replace the placeholders with your Facebook Page ID and Page Access Token.

# keys.py

PAGE_ID = 'your_page_id'
PAGE_ACCESS_TOKEN = 'your_access_token'

Usage

Set the message and link you want to post in the script:

   post_message = 'Hello Python 🐍. I bet you are awesome today!🚀🚀.\nI am a bot 🤖. Meet me on Github'
   post_data = {
       'message': post_message,
       'link': 'https://github.com/Gerry-Aballa/Facebook-GraphAPI-Bot',
       'access_token': keys.PAGE_ACCESS_TOKEN
   }

Schedule the post time using the schedule.every().day.at() method. By default, it's set to post at 8:00 AM every day. You can adjust the time to your preference.
Run the script:

   python3 facebook.py

The script will run indefinitely, posting your message and link at the scheduled time each day.

Keep Your Access Tokens Secure

Remember to keep your Facebook Page Access Token and other sensitive information secure. Avoid sharing them in public repositories or exposing them to unauthorised users. Consider using secure methods like environment variables in production environments.

With this Python script, you can take the hassle out of Facebook Page management and focus on creating engaging content for your audience.

Automate your posts, stay connected, and watch your online presence thrive!

A guide to your first open source contribution 🚀✨

Gerry Aballa — Tue, 12 Sep 2023 14:19:38 +0000

This project aims to simplify and guide the way beginners make their first contribution. If you are looking to make your first contribution, follow the steps below.

Requirements

Get the Project repository here
Install Git on your machine

1. Fork this repository

Fork this repository by clicking on the fork button on the top of this page. This will create a copy of this repository in your account.

2. Clone the repository

Now clone the forked repository to your machine. Go to your GitHub account, open the forked repository, click on the code button and then click the copy to clipboard icon.

Open a terminal and run the following git command:

git clone "url you just copied"

Where "url you just copied" (without the quotation marks) is the url to this repository (your fork of this project). See the previous steps to obtain the url.

For example:

git clone git@github.com:this-is-you/initial-contribution.git

where this-is-you is your GitHub username. Here you're copying the contents of the first-contributions repository on GitHub to your computer.

3. Create a branch

Change to the repository directory on your computer (if you are not already there):

cd initial-contribution

Now create a branch using the git switch command:

git switch -c your-new-branch-name

For example:

git switch -c add-automation-mantis

4. Make changes and commit the changes

Now open Contributions.md file in a text editor, add your name to it. Don't add it at the beginning or end of the file. Put it anywhere in between. Now, save the file.
If you go to the project directory and execute the command git status, you'll see there are changes.

Add those changes to the branch you just created using the git add command:

git add Contributions.md

Now commit those changes using the git commit command:

git commit -m "Add your-name to Contributions list"

replacing your-name with your name.

5. Push changes to github

Push your changes using the command git push:

git push -u origin your-branch-name

replacing your-branch-name with the name of the branch you created earlier.

If you get any errors while pushing, click here:

### Authentication Error

remote: Support for password authentication was removed on August 13, 2021. Please use a personal access token instead.
remote: Please see https://github.blog/2020-12-15-token-authentication-requirements-for-git-operations/ for more information.
fatal: Authentication failed for 'https://github.com//initial-contribution.git/'

Go to GitHub's tutorial on generating and configuring an SSH key to your account.

6. Submit your changes for review

If you go to your repository on GitHub, you'll see a Compare & pull request button. Click on that button.

Now submit the pull request.

What next

Soon I'll be merging all your changes into the main branch of this project. You will get a notification email once the changes have been merged.
You are allowed to delete the created branch.

Congrats! You just completed the standard fork -> clone -> edit -> pull request workflow that you'll often encounter as a contributor!

Tip!

Complete this twice to earn your first Github badge

Automate Your Twitter(X) Presence: Building a Tweet Scheduler Bot in Python

Gerry Aballa — Thu, 07 Sep 2023 18:00:21 +0000

Github Repo
Twitter Page

Are you looking for a way to keep your Twitter followers engaged with regular updates or reminders? Perhaps you want to share daily quotes, interesting facts, or simply say "good morning" to your audience at the same time every day. With a simple Python script, you can automate your daily tweets and make your social media presence consistent and reliable.

The Daily Tweet Bot

I've created a Python script that acts as a Twitter bot, allowing you to schedule and automate daily tweets. This script is perfect for individuals, businesses, or organizations that want to maintain a steady and timely social media presence. Whether you're a developer, marketer, or just an avid Twitter user, this bot can save you time and ensure your messages reach your followers every day.

How It Works

The bot uses the following key components:

Tweepy Library: It leverages the Tweepy library, which provides an easy way to interact with the Twitter API.
Scheduling: The script employs the schedule library, which allows you to schedule tasks to be executed at specific times. In this case, we schedule the tweet to be sent every day at 8 AM East Africa Time (EAT).
Customizable Content: You can easily customize the tweet content to include any message you desire. Whether it's a daily quote, a weather update, or just a friendly greeting, the choice is yours.

Getting Started

Here's how you can start using this Twitter bot:

Set Up Your Twitter Developer Account: If you haven't already, create a Twitter Developer Account and set up a Twitter App. This will provide you with the API keys and access tokens needed for authentication.
Install Dependencies: Ensure you have the required Python libraries installed. Use pip to install tweepy and schedule.

   pip install -r requirements.txt

API Keys and Tokens: Create a keys.py file and populate it with your Twitter API keys and access tokens.
Customize Your Tweet: Modify the sendPost() function in the script to craft the tweet you want to send daily.
Schedule the Script: Use a task scheduler or cloud-based service (e.g., AWS Lambda or Google Cloud Functions) to run the script daily at 8 AM EAT.
Start the Bot: Launch the script, and it will automatically post your tweet at the specified time each day.

Responsible Usage

While this bot can be a powerful tool for maintaining a consistent Twitter presence, it's essential to use it responsibly. Be mindful of Twitter's rules and guidelines, and avoid spammy behavior. Ensure that your automated tweets provide value to your followers and contribute positively to your online presence.

Get the Code

You can find the code for this Twitter bot on GitHub. Feel free to explore, contribute, or adapt it to suit your specific needs.

With this simple Python script, you can streamline your social media management and ensure that your daily tweets go out like clockwork. Happy tweeting! 🐦🤖

A Simple Python Dice Rolling Simulator

Gerry Aballa — Mon, 04 Sep 2023 17:08:16 +0000

Dice games have been popular for centuries, and rolling dice is a fundamental part of many board games and tabletop role-playing games. In this blog, we'll explore a simple Python program that simulates rolling a 6-sided die and displays the result using ASCII art. This entertaining project can be a fun addition to your Python coding repertoire and is a great way to practice your programming skills.

Github link:
terminal-dice-roller

The Code:
Let's break down the code step by step.

Dice Art: ```python

DICE_ART = {
1: (
"┌─────────┐",
"│ │",
"│ ● │",
"│ │",
"└─────────┘",
),
# ... (similar entries for values 2 to 6)
}

   This dictionary (`DICE_ART`) contains ASCII art representations of the six faces of a standard six-sided die. Each face is represented as a tuple of strings, which will be used later to display the dice face when rolled.

2. **Constants**:
   ```python


   DIE_HEIGHT = len(DICE_ART[1])
   DIE_WIDTH = len(DICE_ART[1][0])
   DIE_FACE_SEPARATOR = " "

These constants define the height and width of a die face and the separator character used between multiple dice faces when displayed.

roll_dice() Function: ```python

def roll_dice():
"""Simulate rolling a 6-sided die and return the result."""
return random.randint(1, 6)

   The `roll_dice()` function generates a random integer between 1 and 6 to simulate rolling a standard six-sided die.

4. **`display_dice(die_value)` Function**:
   ```python


   def display_dice(die_value):
       """Display the ASCII art for the given die value."""
       if die_value in DICE_ART:
           die_face = DICE_ART[die_value]
           for line in die_face:
               print(line)

This function takes the result of rolling the die and displays the corresponding ASCII art representation. It checks if the provided die_value exists in the DICE_ART dictionary and prints the associated art line by line.

main() Function: ```python

def main():
print("Welcome to the Dice Rolling Simulator!")

   while True:
       user_input = input("Press Enter to roll the dice or 'q' to quit: ").strip()

       if user_input == 'q':
           print("Goodbye!")
           break

       if user_input == '':
           die_value = roll_dice()
           display_dice(die_value)
       else:
           print("Invalid input. Press Enter to roll or 'q' to quit.")

   The `main()` function serves as the entry point of the program. It displays a welcome message and enters a loop that waits for user input. The user can press Enter to roll the dice or 'q' to quit. It handles user input validation and calls the appropriate functions.

6. **`if __name__ == "__main__":`**:
   This conditional statement ensures that the `main()` function is executed only if the script is run directly, not if it's imported as a module into another script.

**Example**
![A simple python dice rolling simulator](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/t2slx6qgoob16qiiv88n.png)

**Attention**
You can further enhance this project by adding features like keeping track of the roll history or integrating it into a larger game. You can contribute to this [repo](https://github.com/Gerry-Aballa/terminal-dice-roller) by implementing these. Happy coding and rolling!

How to Get Started With Node and NVM on MacOS (M1/ M2) in 2023

Gerry Aballa — Thu, 08 Dec 2022 06:41:01 +0000

What are Node and NVM?

Node.Js, commonly known as Node, is a JavaScript runtime for building server-side or desktop applications. Node Version Manager(NVM) allows you to manage Node versions on your device. It is important because different projects on your device may be needing different versions of Node.

Having NVM and Node installed is a likely requirement for software engineers in 2023. This article has steps that make it easy to install Node and NVM on the new Apple Silicon Macs.

Step 1: Installing NVM

Run the following command in a new terminal window that will list all the files including hidden files in your device:

ls -a

If .zshrc is missing from the list, you need to create it by running the following command:

touch .zshrc

Insure you have the .zshrc now available in the list. Use cURL command from this site to install NVM. Copy and run this command in your terminal. It will look similar to this:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.2/install.sh | bash

You will need to refresh the .zshrc file by running the following command:

source .zshrc

You can now confirm that you have NVM installed by running the following command. You should get a figure like 0.39.2.

nvm -v

Step 2: Installing Node

Installing Node is now easy. Run this command in your terminal:

nvm install node

To install a specific version of Node, just add the version number at the end like this:

nvm install 18.12.1

To use Node, you will first have to run the following command in your terminal:

nvm use node

or run a specific version of Node:

nvm use 18.12.1

Remember Node installation includes the Node Package Manager(NPM). You are ready to use all the resources that Node presents to you. Thank you for getting to the end of this article. You are great!

Photo by AltumCode on Unsplash