DEV Community: Sunil Aleti

Automating my gym slot Reservation

Sunil Aleti — Sun, 28 Mar 2021 02:58:00 +0000

🎧 LISTEN TO THIS ARTICLE

I'm a Graduate student at UT Arlington. I always feel that we need to take care of both physical health and mental health to succeed in our life. So, I start my daily routine at Fitness Recreation Center (gym) and registering slots daily is a hassle. Due to covid, gym slots are very limited and I don't want to miss them.

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

aletisunil / AutomateGymSlot

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

Building an Audio generator for DEV.to blogposts

Sunil Aleti — Sat, 06 Mar 2021 04:24:06 +0000

🎧 LISTEN TO THIS ARTICLE

I'm kind of a person who likes to listen rather than reading. And I feel my productivity increases when listening rather than reading. As dev.to don't have such audio feature(which will be helpful if they bring it natively).

So, I built a tool that takes input any dev.to blogpost URL and outputs Audio which you can also download.

Tool: https://audioblogs.herokuapp.com/

You can check the working of tool in the below video

The workflow of this tool is to scrape the article/blogpost and generate audio using gTTS module.

Modules used:

Requests - will allow us to send HTTP requests to get HTML pages
BeautifulSoup - will help us parse the HTML pages
gTTS - converts the text entered, into audio which can be saved as a mp3 file
Streamlit - A Python library that makes it easy to create and share beautiful, custom web apps

Let's begin:

import all necessary modules

import streamlit as st
import requests
from bs4 import BeautifulSoup
from gtts import gTTS

Getting the contents of a webpage into a variable

results = requests.get("https://dev.to/sunilaleti/building-a-pdf-locker-gui-application-4l67")

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")

We use soup.find to get name of the blogpost and you can get class names by inspecting elements

Article=soup.find("div",{"class":"crayons-article__header__meta"}).find('h1').get_text()

To get name of the Author

Author=soup.find("div",{"class":"crayons-article__subheader"}).find('a').get_text()

To get article content

text=soup.find("div", {"id": "article-body"}).find_all(['p','h1','h2','h3','h4','h5','h6','ol','ul'])

With the content we also get HTML tags. So we need to remove all HTML tags.

def remove_html_tags(text):
    for item in text:
        try:
            blog.append(item.get_text())
        except:
            pass

Now after scraping the content and cleaning, we need to create audio with the help of gTTS module.
gTTS module also supports other languages like French, Spanish etc..

from gtts import gTTS 

language = 'en'
myobj = gTTS(text=Text, lang=language, slow=False) 

# Saving the converted audio in an mp3 file name "Audio"
myobj.save("Audio.mp3")

This webapp is built using streamlit and deployed in herokuapp

Source Code:

import streamlit as st
import requests
from bs4 import BeautifulSoup
from gtts import gTTS 
def app():
    st.set_page_config(page_title="Audio Blog",page_icon="🎧")
    st.title("Generate Audio for dev.to blogposts")
    url=st.text_area("Enter any DEV.TO blog url ").strip()
    if st.button("submit"):
        if len(url)!=0:
            with st.spinner('Miracles take time to happen \n Just kidding 😂 \n Generating audio..'):
                results = requests.get(url)
                soup = BeautifulSoup(results.text, "html.parser") 
                blog=[]
                try:
                    Article=soup.find("div",{"class":"crayons-article__header__meta"}).find('h1').get_text()
                    #st.write(Article)
                    Author=soup.find("div",{"class":"crayons-article__subheader"}).find('a').get_text()
                    #st.write(Author)
                    intro="This blogpost {article} is written by {author}".format(article = Article, author = Author)
                    blog.append(intro)
                    text=soup.find("div", {"id": "article-body"}).find_all(['p','h1','h2','h3','h4','h5','h6','ol','ul'])
                    def remove_html_tags(text):
                        for item in text:
                            try:
                                blog.append(item.get_text())
                            except:
                                pass

                    remove_html_tags(text)
                    Text=""
                    for ele in blog:  
                            Text +=ele+" "

                    myobj = gTTS(text=Text, lang='en', slow=False) 

                    myobj.save("Audio.mp3")
                    audio_file = open('Audio.mp3', 'rb')
                    audio_bytes = audio_file.read()
                    st.success("Play or download the audio")
                    st.audio(audio_bytes, format='audio/mp3')
                except:
                    st.error("Enter a valid url")
        else:
            st.error("Enter a valid url")


if __name__ == "__main__":
    app()

lemme know if you have any issues and feel free to send pull request if you had anything to add

aletisunil / AudioBlog

Some AI-based websites

Sunil Aleti — Mon, 08 Feb 2021 09:11:34 +0000

We all know, Artificial Intelligence (AI) is one of the most transformative tech evolutions of our times.

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

This site allows you to draw doodles and site makes a guess about it using AI. This may not be 100% accurate but keeps on improving itself through Machine Learning.

AI Duet

This site has a digital piano that responds to your tune. Helpful for making something creative

Thing Translator

This site allows you to scan an object through the camera and guess it using its AI Mechanism

Article Writer

You just have to type some info about the topic in the given box, select words length and this site generates article

Icons 8 upscaler

This site holds the capacity to enlarge an image up to 8x and change any blurry image to the sharper one. It uses state of the Art AI technology to analyze the image and make it clear

This Person does not exist

This site allows you to generate an image of a person who doesn't actually exist in this world.

Pix2Pix

You can now turn simple line drawings into beautiful works of art. Sketch a simple line drawing and watch the pix2pix AI automatically transform your creation into cats, buildings or shoes.

Even Stranger Things

A fun generator that uses AI image recognition to transform whatever image you upload into a Stranger Things poster.

Krisp

Krisp is an AI-powered noise cancelling app that removes background noise from your calls with one click. With a single button, helps you to have a productive and professional conferencing experience without background noise.

FastPhotoStyle

Earlier this year, NVIDIA released a new AI algorithm called FastPhotoStyle that can transfer the style from any photo to a different image, producing impressive, photo-realistic results.

Semantris

Created by Google, Semantris is a set of online word association games powered by machine learning, natural language understanding (NLP) technology.

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

Google Research has developed multiple activities to teach AI the art of human conversation. In Talk to Books, you can type in any statement or a question, and the model will scan over 100,000 books to find a variety of responses based on your input.

Feel free to add any websites which boggled your brains too :)

Building a PDF Locker GUI Application

Sunil Aleti — Sat, 23 Jan 2021 23:26:06 +0000

I'm a Indian and I recently moved to the USA to pursue my Master's degree at UT Arlington. So I need to carry some essential documents digitally like passport, health reports and other Government id's to be on the safer side and I don't want others to have my sensitive information. So I thought of encrypting these files with a password so that only I can see.

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

Hope it's useful

A ❤️ would be Awesome 😊

Thanks to all readers/viewers who helped me to cross 85K+ views

What is Dimensionality Reduction?

Sunil Aleti — Fri, 04 Dec 2020 07:49:29 +0000

In Machine Learning classification problems, there are often too many factors on the basis of which the final classification is done. These factors are basically variables called features. The higher the number of features, the harder it gets to visualize the training set and then work on it. Sometimes, most of these features are correlated, and hence redundant.

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

How to Change Background of an image using PixelLib

Sunil Aleti — Sat, 14 Nov 2020 20:59:05 +0000

Before talking about "What is Pixellib and what does it do?", let's talk about Image Segmentation

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.

low=True
moderate=True
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 😊

How to Build a Chrome Extension

Sunil Aleti — Sat, 31 Oct 2020 10:16:30 +0000

Chrome extensions are small HTML, CSS and JavaScript apps that we can install in the chrome browser.

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:

Go the Chrome Extensions or you can click on this chrome://extensions to navigate to the extension page.
Once the page is opened, click on load unpacked and locate extension package.

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

A ❤️ would be Awesome 😊

Automating Twitter Followers Count

Sunil Aleti — Fri, 16 Oct 2020 10:39:26 +0000

I've seen many people on Twitter where they append followers count to their name

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,

config.py
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

aletisunil / TwitterFollowerCounter

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

Reference:
https://dev.to/radnerus/twitter-api-is-followers-count-mda

If you like my content, please consider supporting me

Hope it's useful

A ❤️ would-be Awesome 😊

Building a Chrome Extension using DEV API

Sunil Aleti — Thu, 01 Oct 2020 11:04:05 +0000

Chrome extensions are small HTML, CSS and JavaScript apps that we can install in the chrome browser.

In this tutorial, We are going to build an extension that allows users to get articles based on tags from dev.to by simply selecting it.

As we are using get requests method we don't need an API key from dev.to
Check out DEV API docs and get your hands dirty

You can find all the necessary code and files from my GitHub Repository

aletisunil / DEV_Extension

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>Document</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>
    <label><center><b>DEV</b></center></label>
    <p>An Extension which pulls out articles based on tags</p>
    <div class="container">
    <form  id="form-data">
      <label for="tags">Select a tag:</label><br><br>
        <select name="tags" id="tags">
          <option disabled selected value> -- select an option -- </option>
          <option value="python">Python</option>
          <option value="javascript">Javascript</option>
          <option value="tutorial">Tutorial</option>
          <option value="productivity">Productivity</option>
          <option value="discuss">Discuss</option>
          <option value="beginners">Beginners</option>
          <option value="archlinux">archlinux</option>
          <option value="webdev">Webdev</option>
          <option value="android">Android</option>
          <option value="react">React</option>
        </select><br><br>
      <button type="submit" class="seach-btn">Submit</button>
    </form>
    <div class="result">
     </div>
    </div>
  </div>
  </body>
</html>

Step 3: Create a js file to handle API calls

const results = document.querySelector(".result");
const api = "https://dev.to/api/articles?tag=";
const search = document.getElementById("form-data");

const getposts = async (Tag) => {
    try {
      const tag = await document.getElementById("tags").value;
      const response = await axios.get(`${api}${tag}`+"&per_page=5");

      var articles="";
        if(response.data.length!=0){
            for(var i=0;i<response.data.length;i++){
                articles+='<li><a href='+response.data[i].url+'>'+response.data[i].title+'</a></li>';
            }
        link="https://dev.to/t/"+tag
        articles+='<br><center><a href='+link+'>Checkout blog</a><center>';
      }
        results.innerHTML=articles;
    }
      catch (error) {
      console.log("error")
    }
  };
  // declare a function to handle form submission
  const handleSubmit = async e => {
    e.preventDefault();
    getposts(tags);

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

We have an asynchronous function called getposts 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.

Here are some endpoints to access articles, users and other resources via API

https://dev.to/api/articles - To get published articles
https://dev.to/api/articles?username=sunilaleti - To get user specific published articles
https://dev.to/api/articles?tag=tutorial - To get articles based on tutorial tag
https://dev.to/api/articles?tag=python&top=5 - To get most popular posts based on python tag in the last 5 days

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": "DEV",
    "version": "0.1.0",

    "permissions": ["<all_urls>"],

    "browser_action": {
      "default_popup": "index.html"
    },
    "content_security_policy": "script-src 'self' https://unpkg.com ; object-src 'self'"
  }

We set permissions to all_urls so that our extension can run on any page. browser action instructs chrome to show our index.html file as a popup when the icon is clicked.

Adding Extension to Chrome:

Go the Chrome Extensions or you can click on this link to navigate to the extension page.
Once the page is opened, follow the video to add it

If you like my content, please consider supporting me

My level of happiness rose to ecstatic, as I recently crossed 1000 followers and 25000 post views on DEV.
Thanks to DEV Team and Everyone who supported me

Hope it's useful

A ❤️ would be Awesome 😊

Building an Amazon Price Tracker with Python and WayScript

Sunil Aleti — Thu, 17 Sep 2020 09:51:11 +0000

Hi
Well, Today we will discuss How to built Amazon Price Tracker by scraping the price details and scheduling with WayScript

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

Step 2: Explaining everything in blog is not possible and people get cumbersome. So I made video of "How to configure the Python Script in WayScript.
Kindly Follow the video

Click here to check my configuration in WayScript

On one lucky day..

The price got reduced and this script notified me by sending a text message and I ordered it 😁

If you like my content, please consider supporting me

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

Automating Zoom

Sunil Aleti — Mon, 31 Aug 2020 06:13:56 +0000

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:

1. import necessary modules

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 the my GitHub repo to get code and assets for buttons

aletisunil / Automating_Zoom

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:

Lemme know if any queries

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

How to change Twitter Source Label

Sunil Aleti — Thu, 13 Aug 2020 22:32:55 +0000

You might have seen some people using completely different source labels.

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, this name will be shown on your tweets as a source label. And you can't name an app which is already present.
Click on Next

3) Click on App settings

4) Under User authentication settings, click on Setup

5) Enable OAuth 1.0a

6) Select Read and write under App permissions

7) You can enter either your Instagram or Twitter profile link

8) Now click on the option called Keys and Tokens. You can see your Twitter API keys and Access Tokens by clicking on view keys button and generate button respectively.

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

10) 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

11) 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

12) Now type the command and hit enter

pip install tweepy

13) 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.

14) 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="C:/Users/facadmin1/Downloads/introdev.PNG"  #Enter image location
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 twitter.com/aleti_sunil/status/135677656715.. 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

15) 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.

16) 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

A ❤️ would be Awesome 😊