So I have written a python script that automatically registers my gym slot every day

Creating and Deploying a python script on Heroku.com

Prerequisites:

• Python
• Selenium
• webdriver (I used Chrome webdriver)

Let's Begin:

Step 1 :

import all necessary modules

from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from time import sleep
from os import environ

Step 2:

Enter the location of Chrome Webdriver and assign it to the browser variable

browser=webdriver.Chrome("/Users/sunilaleti/Documents/chromedriver")

Step 3:

There are few steps to register, i.e opening the portal, authentication(email and password) and slot booking.

we have broswer.get() to open the webpage and for the authentication steps we need to grab the XPath of that element

To grab Xpath of an element: inspect >> copy >> copy Xpath

# to click on sign in button
browser.find_element_by_xpath('//*[@id="divLoginOptions"]/div[2]/div[2]/div/button').click()

# to enter my email for authentication
browser.find_element_by_xpath('//*[@id="i0116"]').send_keys(environ.get["Email"])
browser.find_element_by_xpath('//*[@id="idSIButton9"]').click()

# to enter my password
browser.find_element_by_xpath('//*[@id="i0118"]').send_keys(environ.get["Password"])

# to click on submit
browser.find_element_by_xpath('/html/body/div/form[1]/div/div/div[2]/div/div/div[1]/div[2]/div[2]/div/div[2]/div/div[3]/div[2]/div/div/div/div/input').click()

# to scroll the window
browser.execute_script("window.scrollTo(0,document.body.scrollHeight)")

# to book gym slot
browser.find_element_by_xpath('//*[@id="divBookingSlots"]/div/div[1]/div/button').click()

Source Code:

from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from time import sleep
from os import environ


def Booking():
     browser=webdriver.Chrome("/Users/sunilaleti/Documents/chromedriver") #Enter Location of Chrome driver
    browser.maximize_window()
    try:
        browser.get("https://reclink.uta.edu/booking/5dcc386e-4bd5-4474-80ec-a47472d3963a")
        sleep(2)
        browser.find_element_by_xpath('//*[@id="divLoginOptions"]/div[2]/div[2]/div/button').click()
        browser.find_element_by_xpath('//*[@id="i0116"]').send_keys(environ.get["Email"])
        browser.find_element_by_xpath('//*[@id="idSIButton9"]').click()
        sleep(2)
        browser.find_element_by_xpath('//*[@id="i0118"]').send_keys(environ.get["Password"])
        sleep(2)
        browser.find_element_by_xpath('/html/body/div/form[1]/div/div/div[2]/div/div/div[1]/div[2]/div[2]/div/div[2]/div/div[3]/div[2]/div/div/div/div/input').click()
        browser.execute_script("window.scrollTo(0,document.body.scrollHeight)")
        browser.find_element_by_xpath('//*[@id="divBookingSlots"]/div/div[1]/div/button').click()
        print("Booked Successfully")

    except:
        print("Booking Failed")

    finally:
        browser.quit()

if __name__ == '__main__':
    Booking()

Step 4:

We have written our python script, now we should deploy this on Heroku (which is a container-based cloud Platform as a Service (PaaS)). Developers use Heroku to deploy, manage, and scale modern apps.

For deploying this python script, we also need a Procfile and requirements.txt file. Push these files to GitHub and connect to it Heroku

You can get these files from my GitHub repo

And in order deploy selenium script in heroku, we need to add these in our code

chrome_options = webdriver.ChromeOptions()
chrome_options.binary_location = os.environ.get("GOOGLE_CHROME_BIN")
chrome_options.add_argument("--headless")
chrome_options.add_argument("--disable-dev-shm-usage")
chrome_options.add_argument("--no-sandbox")
browser = webdriver.Chrome(executable_path=environ.get("CHROMEDRIVER_PATH"), options=chrome_options)

Add these values in Config Vars

Step 5:

Add Heroku Scheduler add-on to schedule this python script to execute everyday

That's it

Well, today we will see how to change the Twitter source label

First, we need to have a Twitter developer account, if you don't have.

1) Just navigate to Twitter Developer website

2) Just fill out the form with details about ‘what you want to do with their API’. This process may take like 10 minutes and you will get a verification email instantly once you submitted the form.

After getting approval from Twitter. Now we can create an app

1) Open this link and click on "create app"

2) Give your app a name and this name will be shown on your tweets as a source label. And you can't name an app which is already present.

3) Next, you will be redirected to API keys, tokens and click on "App Settings"

4) Now scroll down to the App permissions section and change the option from “Read” to “Read and Write” and click on Save.

5) Scroll down to Authentication settings and turn on 3rd party authentication. It also asks for your website link, you can use your Instagram profile or your Twitter profile. Then click on Save.

6) Now scroll to the top, and click on the option called ” Keys and Tokens”. Click on it and there you can see your Twitter API keys and Access Tokens by click on the “view keys” button and “generate” button respectively.

7) Now you have access to Twitter APIs, to create a Twitter app, you need to download Python.

8) Now, open the file location of where you have installed python and navigate to "Scripts" folder

C:\Users\"YourUsername"\AppData\Local\Programs\Python\Python37\Scripts

9) Now, Open Command Prompt, and type cd, give space and paste your python file location and click enter

cd C:\Users\"YourUsername"\AppData\Local\Programs\Python\Python37\Scripts

10) Now type the command and hit enter

pip install tweepy

11) Once installed, close the command prompt. Now in the python scripts folder, right-click and click on New > text document to create a new document.

12) Now open that document and paste this code inside

import tweepy
auth = tweepy.OAuthHandler("CONSUMER KEY HERE", "CONSUMER KEY SECRET HERE")
auth.set_access_token("ACCESS TOKEN HERE", "ACCESS TOKEN SECRET HERE")
api = tweepy.API(auth)
tweet = input(" ")
api.update_status(status =(tweet))
print ("Done!")

If you want to tweet with a media file like photo or video, you can use the below code

import tweepy
auth = tweepy.OAuthHandler("CONSUMER KEY HERE", "CONSUMER KEY SECRET HERE")
auth.set_access_token("ACCESS TOKEN HERE", "ACCESS TOKEN SECRET HERE")
api = tweepy.API(auth)
tweet = input("")
#image location
image="C:/Users/facadmin1/Downloads/introdev.PNG"  
api.update_with_media(image, tweet)
print ("Done!")

To reply to tweet with your custom source label then copy the link of the tweet that you want to reply for https://twitter.com/aleti_sunil/status/1356776567154876416 and last "1356776567154876416" is the tweet id

import tweepy
auth = tweepy.OAuthHandler("CONSUMER KEY HERE", "CONSUMER KEY SECRET HERE")
auth.set_access_token("ACCESS TOKEN HERE", "ACCESS TOKEN SECRET HERE")
api = tweepy.API(auth)
tweet = input("")
api.update_status(tweet, in_reply_to_status_id = tweetid)
print ("Done!")

Now replace the placeholders with your twitter APIs. Remember that there are 4 APIs to change – API Key, API Secret Key, Access Token, and Access Token Secret. Once done, it should look like this

13) Now save the file and name it anything, but change the save as type to “All files” and add “.py” at the end of the file name to save it as a python file and click save.

14) Now open that .py file you just made. That’s it, you can type anything in this command line and click enter. It will be tweeted as a new tweet.

That's it. Hola you finally did it

If you still have any queries, check out the video

Hope it's useful

Well, if you still not aware of what AI is? It is the simulation of human intelligence in machines that are programmed to think like humans and mimic their actions.

Here are some boggling sites

Quick Draw

AI Duet

Thing Translator

Article Writer

Icons 8 upscaler

This Person does not exist

Pix2Pix

Even Stranger Things

Krisp

FastPhotoStyle

Semantris

Each time you enter a clue, the model looks at the words in play and selects the one it thinks is most related. The model learned the connections between words after being fed billions of conversational text samples on the internet.

Talk to Books

So I started building a GUI Application which encrypts these files.

Well, I'm using two major modules for this project,

• PyPDF2 - Which helps us to extract information, merging documents and encrypting documents etc... Simply run pip install PyPDF2 to install this module.
• Tkinter - To create GUI application and it's the only framework built into the Python standard library.

Before building a GUI Application, we will see how easy it is to encrypt files using PyPDF2 module

Code to encrypt files

import PyPDF2

#Locate pdf file inside PdfFileReader funtion
pdf_reader = PyPDF2.PdfFileReader(pdf_file)
pdf_writer = PyPDF2.PdfFileWriter()
for page_num in range(pdf_reader.numPages):
    pdf_writer.addPage(pdf_reader.getPage(page_num))
#encrypt method encrypts files with given password
pdf_writer.encrypt("password")

#create a pdf file and make it in wb mode           
result_pdf = open('Lockedfile.pdf','wb')  
pdf_writer.write(result_pdf)
#Close the file
result_pdf.close()

Now we will build a GUI Application using Tkinter (has a bigger community which compared to other GUI frameworks)

Code to build GUI App

import tkinter as tk
from tkinter import messagebox
import PyPDF2
from PIL import Image,ImageTk
from tkinter.filedialog import askopenfile

root = tk.Tk()
root.title("PDF Locker")

canvas =  tk.Canvas(root,width=600,height=300)
canvas.grid(columnspan=3)

#logo
logo = Image.open('/Users/sunilaleti/Desktop/logo.png')
logo = ImageTk.PhotoImage(logo)
logo_label = tk.Label(image=logo)
logo_label.image=logo
logo_label.grid(column=1,row=0)

#instructions
instructions=tk.Label(root,text="Enter a password and select a pdf to encrypt\n")
instructions.grid(columnspan=3,column=0,row=1)

#Creating a input field for password 
password=tk.Entry(root,show="*",width=15)
password.grid(column=1,row=2)

def open_file():
    pdf_file=askopenfile(parent=root,mode="rb",title="choose a file",filetypes=[("PDF Files"," *.pdf")])
    FileName=file.name.split(".")[0]
    if pdf_file is not None:
        pdf_reader = PyPDF2.PdfFileReader(pdf_file)
        pdf_writer = PyPDF2.PdfFileWriter()
        for page_num in range(pdf_reader.numPages):
            pdf_writer.addPage(pdf_reader.getPage(page_num))
        pdf_writer.encrypt(password.get())
        encryptedFile=FileName+"_Encrypted.pdf"
        result_pdf = open(encryptedFile,'wb')  

        pdf_writer.write(result_pdf)
        result_pdf.close()
        #To clear input field 
        password.delete(0, 'end')
        #Message box to show success message
        messagebox.showinfo("Success","File encrypted successfully")
    else:
        messagebox.showerror("Failed","Unable to encrypt file")



#Creating "Browse file" button using tk.Button
browse_btn=tk.Button(root,text="Browse file",command=lambda:open_file(),width="15",height="2")
browse_btn.grid(column=1,row=4)

canvas=tk.Canvas(root,width=600,height=250)
canvas.grid(columnspan=3)

root.mainloop()

The file will be encrypted and you have to enter the password to access it

If you like my content, please consider supporting me

Hope it's useful

A ❤️ would be Awesome 😊

Few algorithms do not perform well when you have huge amounts of data like KNN, Decision trees etc.. So by reducing them it will help the algorithms to perform well. And we cannot visualize data more than 3D so by reducing data to 2D or 3D will allow us to plot and observe patterns more clearly.

This technique also removes multicollinearity by removing redundant features. Let's see we have N variables in the dataset where we reduce it to K variables (K<<N)

There are two components of dimensionality reduction:

• Feature selection: In this, we try to find a subset of the original set of variables, or features, to get a smaller subset which can be used to model the problem. It usually involves three ways:
  1. Filter
  2. Wrapper
  3. Embedded
• Feature extraction: This reduces the data in a high dimensional space to a lower dimension space, i.e. a space with lesser no. of dimensions.

Advantages of Dimensionality Reduction

• It helps in data compression, and hence reduced storage space.
• It reduces computation time.
• Helps to remove noise so that we can improve the performance of models
• It also helps remove redundant features, if any.

Disadvantages of Dimensionality Reduction

• It may lead to some amount of data loss.
• PCA tends to find linear correlations between variables, which is sometimes undesirable.
• PCA fails in cases where mean and covariance are not enough to define datasets.

Different Dimensionality Reduction Techniques

Linear Dimensionality Reduction Methods

• PCA
• Factor Analysis
• LDA

Non Linear Dimensionality Reduction Methods

• MDS
• t-SNE
• HLLE
• Spectral Embedding

Other techniques like

• Auto encoders
• Missing value ratio
• Low variance filter

Image Segmentation

It is the process of partitioning a digital image into multiple segments. The goal of segmentation is to simplify and/or change the representation of an image into something that is more meaningful and easier to analyze. Image segmentation is typically used to locate objects and boundaries (lines, curves, etc.) in images. It has a lot of amazing applications that solve different computer vision problems.

PixelLib is a library created to ensure easy integration of image segmentation in real-life applications. PixelLib now supports a feature known as image tuning.

What is Image tuning?

Nothing but changing the background of an image with a custom background or adding a distinct color to the background or converting a background to grayscale. And we make use of deeplabv3+ model trained on pascalvoc dataset. The model supports 20 common object categories, which means you can change the background of these objects in images.

The model supports the following objects: person, bus, car, aeroplane, bicycle, motorbike, bird, boat, bottle, cat, chair, cow, dinning table, dog, horse, sheep, sofa, train, tv

We should install pixellib and its dependencies

• pip3 install pixellib
• pip3 install tensorflow

For demonstration purposes, let me select one of my pictures and also a custom image

Code to change the background of an image with a picture

Now we changing the background of the 1st image with the 2nd image

import pixellib
from pixellib.tune_bg import alter_bg

change_bg = alter_bg()
change_bg.load_pascalvoc_model("deeplabv3_xception_tf_dim_ordering_tf_kernels.h5")
change_bg.change_bg_img(f_image_path = "me.jpg",b_image_path = "bg.jpg", output_image_name="new_img.jpg")
Image(filename='new_img.jpg',width=300,height=350)

We imported pixellib, and from pixellib, we imported in the class alter_bg

We loaded deeplabv3+ model.

The function takes the following parameters:

f_image_path: This is the foreground image, the image which background would be changed.

b_image_path: This is the image that will be used to change the background of the foreground image.

output_image_name: The new image with a changed background.

And this is the "new_img"

To blur the background of an image

It is also possible to control how blur the background should be.

1. low=True
2. moderate=True
3. extreme=True

change_bg.blur_bg("me.jpg",extreme=True, output_image_name="blur_img.jpg")

To Grayscale the background of an image

Grayscale the background of any image using the same lines of code with PixelLib.

change_bg.gray_bg("me.jpg",output_image_name="gray_img.jpg")

You can also apply these background effects on videos too

Refer to these resources:

https://pixellib.readthedocs.io/en/latest/ https://github.com/ayoolaolafenwa/PixelLib

Hope it's useful

A ❤️ would be Awesome 😊

Step 1: In order to workaround we need some modules, and we can import them using 'import' keyword

• os - allows you to interface with the underlying operating system
• shutil - responsible for copying and moving files respectively
• glob - used to retrieve files/pathnames matching a specified pattern

Step 2: so with the help of glob module, we retrive all files present in that path location

ex: filename=glob.glob("C:/Users/Aleti Sunil/Downloads/*")

Step 3: we will create lists with respect to filetype extensions

documents=['.pdf','.docx','.doc','.txt']
media=['.jpeg','.jpg','.svg','.png','.PNG','.mp4','.mp3']
setupFiles=['.exe','.msi']
compressedFiles=['.zip']
files=['.apk']

And specify the path locations of documents,media and setupfiles respectively

DocumentsLocation='C:/Users/Aleti Sunil/Downloads/documents'
mediaLocation='C:/Users/Aleti Sunil/Downloads/media'
setupFilesLocation='C:/Users/Aleti Sunil/Downloads/setupFiles'
compressedFilesLocation='C:/Users/Aleti Sunil/Downloads/compressedFiles'
FilesLocation='C:/Users/Aleti Sunil/Downloads/Files'

Step 4: And this is the final step, we will extract the filetype extension using 'os.path.splitext' and moves the files with respect to filetype extension to specified location

And this is final code

import os
import glob
import shutil
from os import path
filename=glob.glob("C:/Users/Aleti Sunil/Downloads/*")
documents=['.pdf','.docx','.doc','.txt']
media=['.jpeg','.jpg','.svg','.png','.PNG','.mp4','.mp3']
setupFiles=['.exe','.msi']
compressedFiles=['.zip']
files=['.apk']
DocumentsLocation='C:/Users/Aleti Sunil/Downloads/documents'
mediaLocation='C:/Users/Aleti Sunil/Downloads/media'
setupFilesLocation='C:/Users/Aleti Sunil/Downloads/setupFiles'
compressedFilesLocation='C:/Users/Aleti Sunil/Downloads/compressedFiles'
FilesLocation='C:/Users/Aleti Sunil/Downloads/Files'
for file in filename:
    if os.path.splitext(file)[1] in documents:
        if(path.exists(DocumentsLocation)):
            shutil.move(file,DocumentsLocation)
        else:
            os.mkdir(DocumentsLocation)
            shutil.move(file,DocumentsLocation)
    if os.path.splitext(file)[1] in media:
        if(path.exists(mediaLocation)):
            shutil.move(file,mediaLocation)
        else:
            os.mkdir(mediaLocation)
            shutil.move(file,mediaLocation)
    if os.path.splitext(file)[1] in setupFiles:
        if(path.exists(setupFilesLocation)):
            shutil.move(file,setupFilesLocation)
        else:
            os.mkdir(setupFilesLocation)
            shutil.move(file,setupFilesLocation)
    if os.path.splitext(file)[1] in compressedFiles:
        if(path.exists(compressedFilesLocation)):
            shutil.move(file,compressedFilesLocation)
        else:
            os.mkdir(compressedFilesLocation)
            shutil.move(file,compressedFilesLocation)
    if os.path.splitext(file)[1] in files:
        if(path.exists(FilesLocation)):
            shutil.move(file,FilesLocation)
        else:
            os.mkdir(FilesLocation)
            shutil.move(file,FilesLocation)

Check out the video on how it works

You can also schedule this script for every regular interval

Let me know if any queries

Happy Coding ❤️

Let's dive in..

The tools we're going to use are:

• Request will allow us to send HTTP requests to get HTML files
• BeautifulSoup will help us parse the HTML files
• Pandas will help us assemble the data into a DataFrame to clean and analyze it
• csv(optional)- If you want to share data in csv file format

Let's Begin..

In this tutorial, we're going to scrape IMDB website, which we can get title, year, ratings, genre etc..

First, we'll import the tools to build our scraper

import requests
from bs4 import BeautifulSoup
import pandas as pd
import csv

Getting the contents of webpage into results variable

url = "https://www.imdb.com/search/title/?groups=top_1000"
results = requests.get(url)

In order to make content easy to understand, we are using BeautifulSoup and the content is stored in soup variable

soup = BeautifulSoup(results.text, "html.parser")

And now initializing the lists to store data

titles = []        #Stores the title of movie
years = []         #Stores the launch year of the movie
time = []          #Stores movie duration
imdb_ratings = []  #Stores the rating of the movie
genre = []         #Stores details regarding the genre of the movie
votes = []         #Store the no.of votes for the movie

Now find the right movie container by inspecting it, and hover over the movie div, which looks like below image

And we can see 50 div with class names:lister-item mode-advanced So, find all div's with that classname by

movie_div = soup.find_all("div", class_="lister-item mode-advanced")

find_all attribute extracts all the div's which has class name:"lister-item mode-advanced"

Now get into each lister-item mode-advanced div and get the title, year, ratings, genre, movie duration

So we iterate every div to get title, year, ratings etc..

for movieSection in movie_div:

Extracting the title

From image, we can see that the movie name is placed under div>h3>a

name = movieSection.h3.a.text  #we're iterating those divs using <b>movieSection<b> variable
titles.append(name) #appending the movie names into <b>titles</b> list

Extracting Year

From image, we can see that the movie launch year is placed under div>h3>span(class name="lister-item-year") and we extract it using text keyword

year = movieSection.h3.find("span", class_="lister-item-year").text
years.append(year)   #appending into years list

Similarly, we can get ratings, genre, movieDuration w.r.t classname

ratings = movieSection.strong.text
imdb_ratings.append(ratings)   #appending ratings into list
category = movieSection.find("span", class_="genre").text.strip()
genre.append(category)         #appending category into Genre list
runTime = movieSection.find("span", class_="runtime").text
time.append(runTime)           #appending runTime into time list

Extracting votes

As from the image, we can see that we have two span tags with classname="nv". So, for votings we need to consider nv[0] and for gross collections nv[1]

nv = movieSection.find_all("span", attrs={"name": "nv"})
vote = nv[0].text
votes.append(vote)

Now we will build a DataFrame with pandas To store the data we have to create nicely into a table, so that we can really understand And we can do it..

movies = pd.DataFrame(
    {
        "Movie": titles,
        "Year": years,
        "RunTime": time,
        "imdb": imdb_ratings,
        "Genre": genre,
        "votes": votes,
    }
)

And now let's print the dataframe

As we can see on row 16 and 25, there is some inconsistent of data. So we need to clean

 movies["Year"] = movies["Year"].str.extract("(\\d+)").astype(int) #Extracting only numerical values. so we can commit "I"
 movies["RunTime"] = movies["RunTime"].str.replace("min", "minutes") #replacing <b>min</b> with <b>minutes</b>
 movies["votes"] = movies["votes"].str.replace(",", "").astype(int) #removing "," to make it more clear

And now after cleaning we will see, how it looks

print(movies)

You can also export the data in .csv file format. In order to export, Create a file with .csv file extension

movies.to_csv(r"C:\Users\Aleti Sunil\Downloads\movies.csv", index=False, header=True)

You can get Final code from my Github repo

Hope it's useful

In this tutorial, We are going to build an extension that allows users to get covid19 case details based on the country selected.

Step 1: Create a new directory "dist" and create files under that directory as shown in the picture

Step 2: Create an HTML file

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <meta http-equiv="X-UA-Compatible" content="ie=edge" />
    <title>Covid 19</title>
    <link rel="stylesheet" href="./style.css" />
    <script src="https://unpkg.com/axios/dist/axios.min.js"></script>
    <script type="text/javascript" src="index.js" defer></script>
  </head>
  <body>
    <div class="header">Covid 19</div>
    <div class="container">
    <form class="form-data" autocomplete="on">
      <div class="enter-country">
        <b>Enter a country name:</b>
      </div>
      <div>
        <input type="text" class="country-name" />
      </div><br>
      <button class="search-btn">Search</button>
    </form>
    <div class="result">
      <div class="loading">loading...</div>
      <div class="errors"></div>
      <div class="data"></div>
      <div class="result-container">
        <p><strong>New cases: </strong><span class="todayCases"></span></p>
        <p><strong>New deaths: </strong><span class="todayDeaths"></span></p>
        <p><strong>Total cases: </strong><span class="cases"></span></p>
        <p><strong>Total recovered: </strong> <span class="recovered"></span></p>
        <p><strong>Total deaths: </strong><span class="deaths"></span></p>
        <p><strong>Total tests: </strong><span class="tests"></span></p>
        <center><span class="safe">Stay Safe and Healthy</span></center>
      </div>
    </div>
  </div>
</body>
</html>

Step 3: Create a js file to handle API calls

const api = "https://coronavirus-19-api.herokuapp.com/countries";
const errors = document.querySelector(".errors");
const loading = document.querySelector(".loading");
const cases = document.querySelector(".cases");
const recovered = document.querySelector(".recovered");
const deaths = document.querySelector(".deaths");
const tests=document.querySelector(".tests");
const todayCases=document.querySelector(".todayCases");
const todayDeaths=document.querySelector(".todayDeaths");
const results = document.querySelector(".result-container");
results.style.display = "none";
loading.style.display = "none";
errors.textContent = "";
// grab the form
const form = document.querySelector(".form-data");
// grab the country name
const country = document.querySelector(".country-name");

// declare a method to search by country name
const searchForCountry = async countryName => {
  loading.style.display = "block";
  errors.textContent = "";
  try {
    const response = await axios.get(`${api}/${countryName}`);
    if(response.data ==="Country not found"){ throw error;  }
    loading.style.display = "none";
    todayCases.textContent = response.data.todayCases;
    todayDeaths.textContent = response.data.todayDeaths;
    cases.textContent = response.data.cases;
    recovered.textContent = response.data.recovered;
    deaths.textContent = response.data.deaths;
    tests.textContent =  response.data.totalTests;
    results.style.display = "block";
  } catch (error) {
    loading.style.display = "none";
    results.style.display = "none";
    errors.textContent = "We have no data for the country you have requested.";
  }
};

// declare a function to handle form submission
const handleSubmit = async e => {
  e.preventDefault();
  searchForCountry(country.value);
  console.log(country.value);
};

form.addEventListener("submit", e => handleSubmit(e));

We have an asynchronous function called searchForCountry and within that function, we can use async-await. Async await allows us to stop executing code that is dependent, while we wait for the response from a server. By using the await keyword in front of a piece of code we can get the rest of our code to stop executing while that piece of code executes.

In this example, we await a response from our GET request before setting that response to our articles variable.

Axios is a very popular JavaScript library you can use to perform HTTP requests, that works in both Browser and Node.js platforms. It supports all modern browsers, including support for IE8 and higher. It is promise-based, and this lets us write async/await code to perform XHR requests very easily.

Here are some endpoints to access data via API

• https://coronavirus-19-api.herokuapp.com/countries - To get details about all countries
• https://coronavirus-19-api.herokuapp.com/countries/india - To get covid19 cases details specific to India

Step 4: You can also add css to your HTML file

Step 5: Create manifest.json and add following code. This is the file that contains information on how Chrome should handle the extension.

{
    "manifest_version": 2,
    "name": "Covid19",
    "version": "1.0.0",
    "description": "Provides the cases details regarding Covid19 with respective to any Country",
    "browser_action": {
      "default_popup": "index.html"
    },
    "icons":{
      "16": "./icons/16covid-19.png",
      "64": "./icons/64covid-19.png",
     "128": "./icons/128covid-19.png"
    },

    "content_security_policy": "script-src 'self' https://unpkg.com ; object-src 'self'"
  }

manifest_version, name and version are important and MUST be declared. The extension must have a manifest_version of 2 to work with the latest Chrome browsers, you can give it whatever name/version you wish.

Adding Extension to Chrome:

I recently submitted this extension for review and it's pending for approval.

Hope Google approves it :)

Here is the working video of Covid19 Extension

Hope it's useful

If you like my content, please consider supporting me

Let's start by watching small demo, how its going to look at end 😅

Now lets talk, Prerequisites:

• Python
• Selenium
• webdriver (I used Chrome webdriver)

Step 1 : need to import webdriver, keys and sleep

from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from time import sleep

Step 2 : Enter the location of Chrome Webdriver and assign it to driver variable

driver=webdriver.Chrome("") # Enter Location of Chrome driver

Step 3 : I used whatsapp to send messages and I pinned the person to whom we need to send messages, so that there will not be any hustles.

driver.get("https://web.whatsapp.com/")
sleep(15)
driver.find_element_by_xpath("/html/body/div/div/div/div/div/div/div[1]/div/div/div[1]/div/div/div").click()
sleep(5)

There should be some time where we can scan the QRcode to login, so I gave sleep(15) and that XPath is to open the chat window of that respective person

Step 4 : Now locate the movie script file, assign it to fileLocation variable and open it in reading mode

fileLocation= ""  # Enter location of movie script file

Step 5 : Now use "for loop" to send msg word by word

Xpath for entering a message

driver.find_element_by_xpath("//*/footer/div[1]/div[2]/div/div[2]").send_keys(word)

Source Code

from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from time import sleep


driver=webdriver.Chrome("") # Enter Location of Chrome driver
driver.maximize_window()
driver.get("https://web.whatsapp.com/")
sleep(15)
driver.find_element_by_xpath("/html/body/div/div/div/div/div/div/div[1]/div/div/div[1]/div/div/div").click()
sleep(5)
fileLocation= ""  # Enter location of movie script file
with open(fileLocation,"r") as file:
    for line in file:
        for word in line.split(" "):
            driver.find_element_by_xpath("//*/footer/div[1]/div[2]/div/div[2]").send_keys(word)
            driver.find_element_by_xpath("//*/footer/div[1]/div[2]/div/div[2]").send_keys(Keys.ENTER)

Hope it's useful

If you like my content, please consider supporting me

Overview of DENO JS

Advantages of using Deno JS

• Built in TypeScript Support
• More Secure
• ES6+ Syntax
• No package.json or Node modules

Installation

brew install deno

For Windows, execute this command (Hope chocolatey is already installed)

choco install deno

Building an API

And these are End points

Well, we will start with index.js Normally, in NodeJs we use express for routings and we import it using require keyword but in DENO Js we import from oak (As you can see in below code)

import { Application } from "https://deno.land/x/oak/mod.ts";
import { PORT } from "./config.js";
import router from "./router.js";

const app = new Application();
app.use(router.routes());
app.use(router.allowedMethods());

console.log(`Server is running. Open http://localhost:${PORT}`);

await app.listen({ port: PORT });

Step 2:

Setup configuration file i.e PORT and FilePath required to store JSON data

export const PORT = 5000;
export const FilePath = "./data/todos.json";

Step 3:

Now create get.js, post.js, delete.js, put.js and place it in the controller. For clear code view, you can check my GitHub repository.

Step 4:

Now create a router.js file which handles all the routings that are required for the application

import { Router } from "https://deno.land/x/oak/mod.ts";
import getTodos from "./Controllers/todos/get.js";
import postTodo from "./Controllers/todos/post.js";
import deleteTodo from "./Controllers/todos/delete.js";
import putTodo from "./Controllers/todos/put.js";

const router = new Router();

router.get("/", ({ response }) => {
  response.body = "Todo Application using Deno";
});

router
  .get("/todos", getTodos)
  .post("/todos", postTodo)
  .delete("/todos/:id", deleteTodo)
  .put("/todos/:id", putTodo);

export default router;

Step 5:

The main difference in Deno to NodeJs is the flags which need to be passed while executing the application for read, write permissions And this is one of the reason Deno make more secure.

 deno run --allow-net=:5000 --allow-read=./data/todos.json --allow-write=./data/todos.json ./index.js

Deno loads the modules once from the URL and cache it in your system. To reload the modules again, you need to provide --reload flag before running the program.

deno run --reload --allow-net ./index.js

Step 6:

Now we can test our application in postman

Get

Post

Delete

Put

Conclusion:

Hope it's useful A ❤️ would-be Awesome 😊

This is how it looks - To test more on this implementation, check my profile😉

As there are many ways of achieving this, I chose python

Pre-requisites:

First, we need to have a Twitter developer account, if you don't have.

1) Just navigate to Twitter Developer website 2) Just fill out the form with details about ‘what you want to do with their API’. You will be redirected to four forms, one form after another, complete them and agree to the developer terms and conditions and submit the application. This process may take like 10 minutes and you will get a verification email instantly once you submitted the form.

After getting approval from Twitter. Now we can create an app

1) Open this link and click on "create app"

2) Give your app a name. And you can't name an app which is already present.

3) Next, you will be redirected to API keys, tokens and click on "App Settings"

4) Now scroll down to the App permissions section and change the option from “Read” to “Read and Write” and click on Save.

5) Now scroll to the top, and click on the option called ” Keys and Tokens”. Click on it and there you can see your Twitter API keys and Access Tokens by click on the “view keys” button and “generate” button respectively.

Here comes our logic part...

we should create two files,

1. config.py
2. counter.py

This config.py is responsible for creating an authenticated API using tweepy module and API Keys

config.py

import tweepy
import logging
from os import environ

logger = logging.getLogger()

def create_api():
    consumer_key = environ['CONSUMER_KEY']
    consumer_secret =  environ['CONSUMER_SECRET']
    access_token =  environ["ACCESS_TOKEN"]
    access_token_secret =environ["ACCESS_TOKEN_SECRET"]

    auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
    auth.set_access_token(access_token, access_token_secret)
    api = tweepy.API(auth, wait_on_rate_limit=True,
                     wait_on_rate_limit_notify=True)
    try:
        api.verify_credentials()
    except Exception as e:
        logger.error('Error creating API', exc_info=True)
        raise e
    logger.info('API created')
    return api

Don't forget to add environmental variables when deploying

This counter.py runs every minute and checks the followers count if there is a change then it updates the name and followers count. We can use emoji's as well instead of numbers

counter.py

import tweepy
import logging
from config import create_api
import time

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger()


def validate_follower_count(user):
    # update string split if you don't use this naming format for twitter profile:
    # 'insert_your_name|{emoji_follower_count(user)} Followers'
    current_follower_count = user.name.replace('|', ' ').split()
    return current_follower_count


def emoji_follower_count(user):
    emoji_numbers = {0: "0️⃣", 1: "1️⃣", 2: "2️⃣", 3: "3️⃣",
                     4: "4️⃣", 5: "5️⃣", 6: "6️⃣", 7: "7️⃣", 8: "8️⃣", 9: "9️⃣"}

    follower_count_list = [int(i) for i in str(user.followers_count)]

    emoji_followers = ''.join([emoji_numbers[k]
                               for k in follower_count_list if k in emoji_numbers.keys()])

    return emoji_followers


def main():
    api = create_api()

    while True:
        # change to your own twitter_handle
        user = api.get_user('aleti_sunil')


        if validate_follower_count(user) == emoji_follower_count(user):
            logger.info(
                f'You still have the same amount of followers, no update neccesary: {validate_follower_count(user)} -> {emoji_follower_count(user)}')
        else:
            logger.info(
                f'Your amount of followers has changed, updating twitter profile: {validate_follower_count(user)} -> {emoji_follower_count(user)}')
            # Updating your twitterprofile with your name including the amount of followers in emoji style
            api.update_profile(
                name=f'Sunil Aleti |  {emoji_follower_count(user)}')

        logger.info("Waiting to refresh..")
        time.sleep(60)


if __name__ == "__main__":
    main()

Now push the code to github and you can get files here

You can deploy this in AWS too but it is not my cup of tea. So, As we are deploying it to Heroku we need to add few more files

• requirements.txt - As we are using tweepy module, we need to specify tweepy in requirements.txt
• Procfile - This file specifies heroku to execute counter.py file
• runtime.txt - In our case, we are using python, so mention python-3.6.9

Follow this video for further deployment in Heroku

If you like my content, please consider supporting me

Hope it's useful

A ❤️ would-be Awesome 😊

Hi,

Well, we all know Zoom is a video conferencing app which allows us to attend/conduct meetings. And because of this pandemic situation, the usage of these video conferencing apps also increased drastically and even for school kids this became a new normal and sometimes these continuous online classes becomes cumbersome.

      And today we gonna learn how to automate zoom such that it automatically logs into one's meetings/classes on time.

For this, we need

• python
• pyautogui
• pandas

Behind the scenes:

• An infinite loop keeps checking the current time of the system using "datetime.now" funtion.
• The zoom app is opened using "os.startfile()" funtion as soon as current time matches the time mentioned in "timings.xlsx".
• "pyautogui.locateOnScreen()" function locates the image of join button on the screen and returns the position.
• "pyautogui.locateCenterOnScreen()" function locates the center of the first found instance of the image on the screen.
• "pyautogui.moveTo()" moves the cursor to that location.
• "pyautogui.click()" performs a click operation.
• The meeting Id and Passcode are entered using the "pyautogui.write()" command.

Steps for Automating:

import os              
import pandas as pd    
import pyautogui
import time
from datetime import datetime

os - Provides a way of using operating system dependent functionality.

pandas - Allows us to store and manipulate tabular data in rows and columns of variables.

pyautogui - A module which helps to control the mouse and keyboard, and other GUI automation tasks.

2. Open's zoom application from the specified location

os.startfile(" ")

3. To click join button

#place the pic location inside quotes
joinbtn=pyautogui.locateCenterOnScreen("")
pyautogui.moveTo(joinbtn)
pyautogui.click()

4. Similarly, like join button we have to take screenshot of every button to click or to locate

#To type the meeting id
#place the picture location inside quotes
meetingidbtn=pyautogui.locateCenterOnScreen("")
pyautogui.moveTo(meetingidbtn)
pyautogui.write(meeting_id)

5. To enter passcode

#Enter the passcode to join meeting
passcode=pyautogui.locateCenterOnScreen("")
pyautogui.moveTo(passcode)
pyautogui.write(password)

6. Create an excel file and add all meeting details like "Timings", "Meeting id" and "Password"

7. Now import that excel file using pandas

#place excel file location inside quotes
df = pd.read_excel('',index=False)

8. Now we will write while loop to constantly check for the current time and compare the timings in excel file

while True:
    #To get current time
    now = datetime.now().strftime("%H:%M")
    if now in str(df['Timings']):

        mylist=df["Timings"]
        mylist=[i.strftime("%H:%M") for i in mylist]
        c= [i for i in range(len(mylist)) if mylist[i]==now]
        row = df.loc[c] 
        meeting_id = str(row.iloc[0,1])  
        password= str(row.iloc[0,2])  
        time.sleep(5)
        signIn(meeting_id, password)
        time.sleep(2)
        print('signed in')
        break

Check out my GitHub repo to get code and assets for buttons

Source code for Automation

 import os
 import pandas as pd
 import pyautogui
 import time
 from datetime import datetime


 def signIn(meeting_id,password):

     #Open's Zoom Application from the specified location
     os.startfile("")
     time.sleep(3)

     #Click's join button
     joinbtn=pyautogui.locateCenterOnScreen("")
     pyautogui.moveTo(joinbtn)
     pyautogui.click()
     time.sleep(1)

     #Type the meeting id
     meetingidbtn=pyautogui.locateCenterOnScreen("")
     pyautogui.moveTo(meetingidbtn)
     pyautogui.write(meeting_id)
     time.sleep(2)

     #To turn of video and audio
     mediaBtn=pyautogui.locateAllOnScreen("")
     for btn in mediaBtn:
         pyautogui.moveTo(btn)
         pyautogui.click()
         time.sleep(1)

     #To join
     join=pyautogui.locateCenterOnScreen("")
     pyautogui.moveTo(join)
     pyautogui.click()
     time.sleep(2)

     #Enter's passcode to join meeting
     passcode=pyautogui.locateCenterOnScreen("")
     pyautogui.moveTo(passcode)
     pyautogui.write(password)
     time.sleep(1)

     #Click's on join button
     joinmeeting=pyautogui.locateCenterOnScreen("")
     pyautogui.moveTo(joinmeeting)
     pyautogui.click()
     time.sleep(1)

 df = pd.read_excel('',index=False)

 while True:
     #To get current time
     now = datetime.now().strftime("%H:%M")
     if now in str(df['Timings']):

         mylist=df["Timings"]
         mylist=[i.strftime("%H:%M") for i in mylist]
         c= [i for i in range(len(mylist)) if mylist[i]==now]
         row = df.loc[c] 
         meeting_id = str(row.iloc[0,1])  
         password= str(row.iloc[0,2])  
         time.sleep(5)
         signIn(meeting_id, password)
         time.sleep(2)
         print('signed in')
         break

Demo video:

If you like my content, please consider supporting me

Lemme tell you the real reason to build this ;) I'm a foodie I love Nutella 🤤 but due to this pandemic, I couldn't find Nutella near me in any local stores. So I thought to order it in Amazon but the prices are damn high and prices are fluctuating too... then I started to build a tracker which notifies me whenever the price goes down the tracking price.

Let's get started..

We gonna create a python script which uses request and beautifulSoup module to scrape the data and scheduling the script to run every hour either with Serverless AWS Lambda or WayScript but AWS Lambda is not my cup of tea. So I built using WayScript.

We will discuss this process in 2 phases. Phase I : Scraping the product details Phase II : Scheduling the script to run every hour

Phase I:

Step 1: Create an excel sheet with urls and Tracking Price

Step 2: import necessary packages/module

import requests
import bs4
import pandas as pd

Request - The requests module allows you to send HTTP requests using Python bs4 - Beautiful Soup is a library that makes it easy to scrape information from web pandas - pandas is a fast and powerful used for data analysis. we are faking ourselves as a Firefox user to avoid restrictions.

HEADERS = ({'User-Agent':
            'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36',
            'Accept-Language': 'en-US, en;q=0.5'})

Step 3: Building Python Script Here is the tracker function which takes parameters URL and TrackingPrice and adds the details of the product when it is less or than equal to TrackingPrice

def tracker(url,TrackingPrice):
    res = requests.get(url,headers=HEADERS)
    soup = bs4.BeautifulSoup(res.content, features='lxml')

    # to prevent script from crashing when there isn't a price for the product
    try:
        title = soup.find(id="productTitle").get_text().strip()
        amount = float(soup.find(id='priceblock_ourprice').get_text().replace("₹","").replace("$","").strip())
        if amount<=TrackingPrice:
            offer.append("You got a offer on the {0} for {1}. Check out the product {2}".format(title,amount,url))


    except:
        offer.append("Couldn't get details about product")

Source Code:

import requests
import bs4
import pandas as pd


HEADERS = ({'User-Agent':
            'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36',
            'Accept-Language': 'en-US, en;q=0.5'})
offer=[]
def tracker(url,TrackingPrice):
    res = requests.get(url,headers=HEADERS)
    soup = bs4.BeautifulSoup(res.content, features='lxml')

    # to prevent script from crashing when there isn't a price for the product
    try:
        title = soup.find(id="productTitle").get_text().strip()
        amount = float(soup.find(id='priceblock_ourprice').get_text().replace("₹","").replace("$","").strip())
        if amount<=TrackingPrice:
            offer.append("You got a offer on the {0} for {1}. Check out the product {2}".format(title,amount,url))


    except:
        offer.append("Couldn't get details about product")



df=pd.read_csv("https://docs.google.com/spreadsheets/d/1AzJ93zR6--4vwl81W3v0FHyZ_bFMkFYRxOSjodJu_Qw/export?format=csv")
for i in range(0,len(df["URL"])):
    tracker(df["URL"][i],df["TrackingPrice"][i])
outputs["message"]=offer

Output:

we're done with our python script
Now let's move to Phase II

Phase II:
I already told you can schedule this script either by using AWS Lambda or any other cloud computing services as I'm not familar with AWS. I'm going with WayScript

And this WayScript provide wide range of packages to interact with services Ex:

• Gmail
• Text Message
• Charts
• Figma
• Slack
• Trello
• Twitter

Step 1: Open WayScript
Packages used for this scheduling:

• Time Trigger
• Python
• Loop
• Text Message

Click here to check my configuration in WayScript

On one lucky day..