Using PyAutoGUI to Automate Your Python Scripts

Dennis Farley — Sat, 20 May 2023 02:42:00 +0000

Project Day

Hello! Today I completed phase 3 of 5 of my full-stack software engineering course here at Flatiron School. As with every phase, we were tasked with submitting and presenting a final project. This phase, we were tasked with building a CLI application using python and SQLAlchemy ORM. Excited to put our skills to work, my partner and I brainstormed project ideas. Ultimately, we settled on creating a application that mimics the functionality of a Command Line Interface.

Getting Started

With python's built-in os module, allowing the user to input commands to navigate and interact with the files within our SQLite database was simple enough.

For example, this is was our code to cd (change directory) based on user input:

import os 

#instantiating terminal while program is active 
terminal_active = True

while terminal_active == True: 
#check if user input is valid 
if x.split(" ")[0] == "cd":

#cd into user's specified directory 
    os.chdir(x.split(" ")[1])

Easy enough.

The Problem: Opening and Playing a Youtube Video

While implementing the "open" command (i.e. open file), I decided to add an Easter egg: if the inputed file does not exist, a youtube video (Rick Roll - Never Gonna Give You Up) is opened and played in the browser. By use of another python module webbrowser, opening a video in the browser was simple enough:

import webbrowser

webbrowser.open("https://www.youtube.com/watch?v=dQw4w9WgXcQ")
## This will open the file in the user's default browser

However, the tricky part was getting the video to then play after being opened. Sifting through dozens of outdated stackoverflow posts yielded no promising results. Many proposed solutions were outdated, and others proved too cumbersome to implement.

The Solution: Automate

At last, I stumbled upon PyAutoGUI and a solution was in sight. PyAutoGUI is an installable package which allows you to use Python scripts to directly control the mouse and keyboard. Thus, use of PyAutoGUI makes for seamless automation of application-to-application interactions.

PyAutoGUI Functions

For my particular problem, three of PyAutoGUI's functions came in handy:

size()
moveTo()
click()

The size function returns a named tuple with the resolution (width and height) of your screen:

width_height = pyautogui.size() 

>>> width_height

#return value
Size(width=1920, height=1080)

With the size function, I was able to determine the x,y coordinates center-screen. Next, it was only a matter of using moveTo() and click() to move the cursor to the center of the screen and click "play":

import webbrowser
import pyautogui
import time

webbrowser.open("https://www.youtube.com/watch?v=dQw4w9WgXcQ")

#wait five seconds before moving cursor
time.sleep(5)

# moves cursor to center of (my) screen
pyautogui.moveTo(700, 450, 2)      

# clicks cursor after .05 seconds
time.sleep(.05)
pyautogui.click()

Success!

Et voilà! With this code, my program successfully opened and played the youtube video. While my use of PyAutoGUI's automation was quite simple, it nonetheless serves as an example of the enormous potential automation has in the world of software engineering.

Thanks for Reading!

Using 'Faker' to Generate Fake Data

Dennis Farley — Tue, 11 Apr 2023 22:53:51 +0000

About Me

Hello, my name is Dennis and this is my first blog post as a student at Flatiron School. Having just completed the first of five phases here, I am excited to share something new I have learned along the way. Namely, how to use 'Faker' (and other similar gems), a library for generating fake data.

While working on my phase 1 project (a variation of the snake game), I came across the need for data, and a lot of it. I had a leaderboard that would keep track and display the user's score, but the board was empty-it needed players!

I knew it would be too cumbersome to hard code data for each player object in my db.json file, and too time-consuming to play the game enough times to fill out the leaderboard.

The solution: Faker!

What is Faker?

Faker is a library used to generate fake data which can then be used by a developer in their project.

For instance, here is a code snippet of the faker data I used in my db.json file:

{
  "players": [
    {
      "id": 1,
      "userName": "Tiffany.Koss",
      "score": 2029
    },
    {
      "id": 2,
      "userName": "Zoie63",
      "score": 625
    },
    {
      "id": 3,
      "userName": "Brandon_Beahan52",
      "score": 2013
    },

No, "Tiffany Koss" is not a real person and no privacy violations are being committed here.

While the data is fictitious, the developer can choose to make each value unique and eliminate the need to worry about instances of repeat-data. In order to do so, you can prefix your method call like so:

Faker::Name.unique.name

How to Use

While I am going to walk through some of the steps necessary to use Faker, you can navigate to https://github.com/faker-ruby/faker and peruse the README.md for more in-depth information on installation and usage.

Step 1. After first making sure you are in your projects local directory, use a package manager (npm, yarn, pnpm) to install Faker as a Dev Dependency:

npm install @faker-js/faker --save-dev

and then:

npm run dev

Note: This post is for the implementation of Fakerjs. The set-up process for Ruby, Java, and Python is slightly different.

Step 2. Create a generateData.js file within your project directory:

dennis@Dennis's-MacBook-Pro my-project % touch generateData.js

Step 3. Within your generateData.js, retrieve the Faker data by providing the program with a route to '@faker-js/faker':

import { faker } from '@faker-js/faker'

Step 4. Create a function that generates your data. Here is what my function looked like:

const { faker } = require('@faker-js/faker');

function generateData() {
    const players = [] //create an empty array for player data

    for (let i = 1; i < 201; i++) { // iterate through array
        const player = { // structure data within array
            id: i,
            userName: faker.internet.userName(),
            score: faker.datatype.number({ min: 10, max: 3000 })
        }
        players.push(player) 
          // fills empty players array with data
    }

    return {
        players // returns populated array 
    };
}

module.exports = generateData; // exports data to be used in your project (in this case it is exported from the module that houses my leaderboard)

As you can see, the function generateData creates an empty array for player data, iterates through the array, structures the data within the array, and then exports it from the module.

Step 5. Now that you have retrieved your data and wrote a function to structure and export it, you are ready to implement the data within your program. Doing so is simply a matter of writing a function(s) to render the data according to your needs.

For instance, here is how I was able to get my data (player names and scores) to display on my leaderboard:

function getPlayers(){
    fetch(baseUrl)
    .then(res => res.json())
    .then(players => players.sort((playerA, playerB) => {
        const playerAScore = Number(playerA.score)
        const playerBScore = Number(playerB.score)
        return playerBScore - playerAScore
    }))
    .then(renderRankings)
}


function renderRankings(players){
    for(let i = 0; i < players.length; i++){
        let ranking = i + 1
        renderUserRanking(ranking, players[i])
    }
}

This code snippet (used to display player data retrieved from Faker) provides a simple demonstration of how one can make use of their fake data.

Hopefully this blog post was helpful and you now have the knowledge necessary to make use of Faker in your own applications and projects.

For more information on implementing Faker and it's different data types (animals, names, vehicles, etc.) refer to https://fakerjs.dev/api/.

Forem: Dennis Farley