DEV Community: Khumbo Klein Chilamwa

The Ultimate Guide to Object-Oriented Programming in Python

Khumbo Klein Chilamwa — Tue, 11 Jul 2023 12:53:50 +0000

Object-Oriented Programming, also known as OOP, is one of those important topics that any programmer needs to have full knowledge of. Before diving any deeper into this topic, let us define what OOP is in general and why it is a must-have skill for any programmer. OOP in Python is a method of structuring a program by bundling related properties and behaviors into individual objects.

Why OOP?

Object Oriented Programming comes with so many benefits for the programmer, some of these benefits are listed below:

Makes your code reusable
Makes your code clean and gives it a clear structure
Makes your code easy to maintain

The structure of OOP

Classes -These are user-defined data types that act as a blueprint for objects, methods, and attributes or they are containers of objects, methods, and attributes
Objects -These are instances of a class created with specifically defined data
Methods -These are functions defined inside a class describing the behavior of objects
Attributes -These represent the state of objects in a class

Creating our first class

We can create a class using the class keyword followed by the class name and a colon at the end.
Syntax:

class ClassName:
    statement1
        .
        .
    statementN

Example1: Creating a Car class

class Car:
    pass

If you do print(type(Car)) you will get the below output:

Class objects

An object is an instance of a class and it must be known that we can have as many objects as possible from a class. The process of creating a class object is also called object instantiating, you can only create an object for a class that exists.
Syntax:

object_name = ClassName()

Example2: Creating a class object

audi = Car()

audi is an object for the class Car

Creating a class and its objects

# creating a class Car
class Car:
    pass
# instantiating the Car class
car1 = Car()
car2 = Car()
# creating attributes for instances car1 and car2
car1.name = "Audi A7"
car2.name = "Nissan Demio"
car1.year_made = "2000"
car2.year_made = "1994"
# printing the output
print(car1.name, "was built in", car1.year_made)
print(car2.name, "was built in", car2.year_made)

Output:

Methods

These are functions defined inside a class describing the behavior of objects tied to that class. Methods inside a class will always take self as the first parameter.
Example3: Creating methods inside a class

# creating a class Car
class Car:
    # initializing method(one of the special methods)
    # called everytime an instance is created
    # takes self always
    def __init__(self, name, year_made):
        self.name = name
        self.year_made = year_made
    # normal method to return the car info   
    def carInformation(self):
        return self.name + " was built in " + self.year_made

#instantiating class objects 
car1 = Car("Audi A7", "2000")
car2 = Car("Nissan Demio", "1994")
# calling the carInformation() method
print(car1.carInformation())
print(car2.carInformation())

Output:

Note:
Any object has access to everything contained in the class, for example, object car1 has access to method carInformation().

Let us now talk about the __init__ or dunder init method also known as the constructor, this method is used to initialize an instance, and the name is fixed (cannot be renamed to anything). It is inside the __init__ method that we define or instantiate the class attributes, apart from attributes self is another parameter that __init__ method takes.

def __init__(self, name, year_made):
    self.name = name
    self.year_made = year_made

Other special methods used in classes

●__str__ is used for displaying data in a beautiful way
Example:

# creating a class Car
class Car:
    def __init__(self, name, year_made):
        self.name = name
        self.year_made = year_made
    #the __str__ function for display pretty output 
    def __str__(self):
        return self.name
# instantiating an object
car1 = Car("Range Rover", "2019")
# calling the whole object
print(car1)

Output:

●__repr__ is used for logging and debugging
Example:

# creating a class Car
class Car:
    def __init__(self, name, year_made):
        self.name = name
        self.year_made = year_made
    #the __repr__ function for display pretty output 
    def __repr__(self):
        return self.name
# instantiating an object
car1 = Car("Range Rover", "2019")
# calling the whole object
print(car1)

Output:

Note:
The __str__ and __repr__ do not differ much in nature

Class and instance variables

As you are creating your classes you might want to work with class variables or instance variables or work with both, so how do these two differ then? The below table explains everything:

Example4: Class variables

# creating a class Car
class Car:
    # creating the class variable after class definition
    maximum_speed = "210 km/hr"
    # initializing method(one of the special methods)
    # called everytime an instance is created
    # takes self always
    def __init__(self, name, year_made):
        self.name = name
        self.year_made = year_made
    # normal method to return the car info   
    def carInformation(self):
        return self.name + " was built in " + self.year_made

#instantiating class objects 
car1 = Car("Audi A7", "2000")
# calling the carInformation() method
print(car1.carInformation())
# accessing class and instance variable using the object
print(car1.name, "has maximum speed of", car1.maximum_speed)

Output:

Example5: Instance variables

# creating the class
class Car:
    # initializing method
    def __init__(self, name, year_made):
        # 2 instance variables name and year_made
        self.name = name
        self.year_made = year_made
#instantiating the class object   
car1 = Car("Audi A7", "2000")
# car1.name and car1.year_made accesses instance variables
print("Car name:", car1.name)
print("Year made:", car1.year_made)

Output:

Inheritance

Inheritance in Object Oriented Programming is a concept where a new class is created using an already existing class. As you are inheriting from a class, it means you are getting the methods, and attributes of that class, in short, you are getting everything contained in that class.

Why inheritance?

Inheritance allows the reusability of code, this means that we do not have to write the same code over and over again, and we can easily reuse a method with the same or modified data.

Types of inheritance

Single inheritance - a child class inherits from only one parent class Syntax:

class ParentClass:
    statement(s)

class ChildClass(ParentClass):
    statement(s)

Multiple inheritance - a child class inherits from multiple parent classes Syntax:

class ParentClass:
    statement(s)

class AnotherParentClass:
    statement(s)

class ChildClass(ParentClass, AnotherParentClass):
    statement(s)

Example1: Using inheritance

class Car:
    # creating class variables
    maximum_speed = "210 km/hr"
    number_of_tyres = 4
    # the dunder init method/initializer
    def __init__(self, name, year_made):
        self.name = name
        self.year_made = year_made

# class Minibus inheriting from class Car
class Minibus(Car):
    # __init__ method of class Minibus
    def __init__(self, name, year_made, price):
        self.name = name
        self.year_made = year_made
        self.price = price
    # method to return price
    def carPrice(self):
        return self.price
# instantiating the object for class Minibus
minbus1 = Minibus("Vanetti", "2013", "MWK4500000")
# printing data
print("Name:", minbus1.name)#name for Minibus class
print("Year made:", minbus1.year_made)#year for Minibus class
print("Maximum speeed:", minbus1.maximum_speed)#max_speed inherited from Car
print("Number of tyres:", minbus1.number_of_tyres)#number_of_tyres inherited from Car
print("Price:", minbus1.carPrice())#calling the carPrice() method in Minibus

Output:

Encapsulation

As you are writing your programs in an Object Oriented Programming way, situations arise where you want your class data not to be modified in any way, to solve this encapsulation comes into play. Encapsulation is defined as a way of restricting access to methods and variables available in a class. Using encapsulation, you can make your class attributes private or protected.

Private - These attributes are invisible and inaccessible from outside the class itself

Syntax:

def __init__(self, name, year_made):
    self.__year_made = year_made#this attribute is private

We use double underscores __ to denote a private attribute

Example2: Creating a private attribute

# creating our class Car
class Car:
    # initializing attribute name via __init__
    def __init__(self, name):
        self.__name = name#this is a private attribute

#instantiating an object   
car1 = Car("BMW")
# printing the private attribute
print(car1.name)

Output:

We are getting an error because the private attribute is invisible and inaccessible outside the class

Protected - This attribute can only be accessed via a subclass but it’s possible to access them outside the class

Syntax:

def __init__(self, name, year_made):
    self._name = name#this attribute is protected

We use a single underscore _ to denote a protected attribute
Example3: creating a protected attribute

# creating our class Car
class Car:
    # initializing attribute name via __init__
    def __init__(self, name):
        self._name = name#this is a protected attribute

#instantiating an object   
car1 = Car("BMW")
# printing the protected attribute
print(car1._name)

Output:

To access the protected attribute outside the class, we use a single underscore before the attribute name e.g. car1._name

Note:
Attributes without any underscores are said to be public, this means they are visible and accessible even from outside the class itself using an object.

Polymorphism

Poly means many and morphism means forms, so polymorphism means having many forms. In Python, polymorphism means the same function name is used in different ways.
Example4: Using polymorphism

# creating class Square
class Square:
    # initializer
    def __init__(self, side):
        self.side = side 
    # common method
    def calculate_area(self):
        return self.side * self.side
# creating class Triangle
class Triangle:
    # initializer
    def __init__(self, base, height):
        self.base = base
        self.height = height
    # common method
    def calculate_area(self):
        return 0.5 * self.base * self.height
# instantiating class objects
sq = Square(6)
tri = Triangle(2, 7)
# printing results
print("Area of square: ", sq.calculate_area())
print("Area of triangle: ", tri.calculate_area())

Output:

In our two classes, we have created a common method calculate_area() that is being used in different ways, that is calculating the area of a square and a triangle.

Conclusion

In summary, mastering object-oriented concepts is a must-have skill for any developer. Following an object-oriented paradigm when writing your code makes it cleaner, maintainable, and reusable.

A Python Script for Downloading YouTube Videos

Khumbo Klein Chilamwa — Fri, 10 Mar 2023 11:26:53 +0000

It is no surprise that YouTube has become a great platform where you could find lots of video resources like courses, music videos, movies, etc. For a self-taught programmer like me, it has become a daily go-to resource whenever am stuck on my coding projects. On YouTube, there are a lot of exciting videos and you might want to have some of these videos on your local machine, this means that you will need a video downloader app to download them. What if I tell you that you can build your video downloader using Python? In this article, I will be showing you how you can build a Python script that will download for you YouTube videos from the ground up using a lightweight and simple-to-use library called pytube.

Here is what we will cover:

Installing pytube
Creating the script
Testing the script
Conclusion

Installing pytube

First things first, let’s install the pytube library, in your terminal enter this command:
$ pip install pytube
Make sure you have an internet connection as you are installing the library.

Creating the script

After successfully installing the library, create a new Python file and call it video_downloader_script.py, you can name it whatever you what as long as the name is meaningful. Do the following imports:

from pytube.cli import on_progress # this displays download progress in the console
from pytube import YouTube

Now that the imports are taken care of, let’s create the video download handler, this is the function that will handle the video download task. Below the imports, paste this code:

# this is the handler/function for downloading the video
# the function takes the video url as an argument
def video_downloader(video_url):
    # passing the video url and progress_callback to the YouTube object
    my_video = YouTube(video_url, on_progress_callback=on_progress)
    # downloading the video in high resolution
    my_video.streams.get_highest_resolution().download()
    # return the video title
    return my_video.title

To be on the same page, let’s break down the video_downloader() function. We, first of all, pass a video URL to the function and inside it, we create a YouTube object. This object has a lot of methods like streams, get_highest_resolution, download, etc. streams will get all the available streams for the video, get_highest_resolution will return the highest resolution for the video and download is for downloading the video. And the last line of the function returns the video title.

Below the function add these lines of code:

"""
    Running the code inside the try/except block
"""
try:
    # getting the url from the user
    youtube_link = input('Enter the YouTube link:')
    print(f'Downloading your Video, please wait.......')
    # passing the url to the function
    video = video_downloader(youtube_link)
    # printing the video title
    print(f'"{video}" downloaded successfully!!')

except:
    print(f'Failed to download video')

Here is the breakdown of the code snippet, we have a try/except block, inside the try we are getting the link from the user via the input() function. We are then printing a message to the console using the print() function, after that, we are making a function call and passing the video link to this function. Finally, we are printing a successful message to the console.

The except will run if there are errors while downloading the video.

Testing the script

It is now time we test the script, go on YouTube and copy any video link of your choice. Run the script using this command:
$ python video_downloader_script.py

You will be prompted to enter the video link, and if you enter the link this is the output:

After the download is complete this is the output you will get:

And if you check your current working directory, you will see a video file:

Suppose we had no internet connection, the except statement will execute and the output would be this:

Something worth mentioning here is not every video that is downloadable on YouTube with this script, some videos require a subscription, some are restricted to a certain region, some are live streams, etc.

Conclusion

That’s it, geeks!!!! I hope you have learned so much from this article. There is so much that you can do with this library, for more information do read its documentation. Thanks for reading.

Building Command Line Applications using the click-shell Library

Khumbo Klein Chilamwa — Wed, 01 Mar 2023 13:00:57 +0000

The click-shell is a Python library that’s built on top of the standard cmd library. It is an extension of the click library that’s used for building command-line applications. These command-line applications are programs that use a command-line interface(CLI) for receiving commands from users. These commands are in the form of text, and they are for instructing the computer to do a specific task. One thing that’s notable about command-line applications is that they do not have a graphical user interface(GUI), it’s just the console with some background and the user is prompted to enter commands. Have you ever wondered how a popular command line application like Git works? if you are curious and want to know how it works and you fancy the idea of building your own command line application then this tutorial is for you.

These is what we will cover:

Installing the click-shell Library
Creating the Shell
Adding a Command to the Shell
Getting Advanced
Conclusion

Installing the click-shell Library

To use the click-shell library you need to install it on your machine, enter this command in your terminal:
$ pip install click-shell

Creating the Shell

Now that we have installed click-shell, let us create a new Python file and call it automation_shell.py. Make it look like this:

from click_shell import shell

message = """
Welcome to Ninja Shell!!!Please enter a command below.
"""
# creating the shell
@shell(prompt='ninjashell/>', intro=message)
def my_shell():
    pass

# executing the shell 
if __name__ == '__main__':
    my_shell()

In the code, we are importing the shell from click_shell, then we are creating a string that will be the shell’s welcoming message.

To create the shell, use the @shell() decorator which takes prompt and intro as arguments, both these arguments are strings.

After the shell’s definition, create its function with a pass statement inside, and finally, we are executing the function inside the if block.

Adding a Command to the Shell

Let’s add the first command to the shell, this command will just print a hello word text. To do that, below the shell paste this code:

# adding a command to print hello world message
@my_shell.command() # adds a shell’s command
def hello_world():
    print("Hello World!")

To add a command to the shell, use the command() method. Create the command which is a Python function, then inside this function define what you want the command to do when executed. Note, the command that we will enter is the hello-world.

To run the program, use:
$ python automation_shell.py

Make sure you get this output:

Enter the hello-world command and the output will be this:

The click-shell library handles so much under the hood, like exception handling and keeping the shell running even when an error occurs and it has some inbuilt commands like the exit command.

Try to enter a command that does not exist, you will get this:

And to break out of the shell, just enter the exit command.

Getting Advanced

We will now modify the shell to do meaningful tasks like listing the available shell commands, printing the current date and time, and creating a file. Open the file and replace the current code with this code:

from click_shell import shell
from datetime import datetime

message = """
Welcome to Ninja Shell!!!Please enter a command below. If you want to
see a list of all the available commands, enter "help".
"""

# creating the shell
@shell(prompt='ninjashell/>', intro=message)
def my_shell():
    pass

# adding command to the shell to list available commands
@my_shell.command()
def help(): # the command will be help
    print(
        """Here is a list of all commands:
*******************************
help: List all the available commands
date-time: Prints current date and time
create-file: Creates a new file and write to it
exit: Exits the shell
        """
        )

@my_shell.command()
def date_time(): # the command will be date-time
    now = datetime.now().strftime("%d/%m/%Y %H:%M:%S") # getting the formatted current date and time
    print(f"The current date&time is: {now}")

@my_shell.command()
def create_file(): # the command will be create-file
    filename = input("Enter the file name and extension:") # getting the filename from user
    content = input("Enter the file content:") # getting the file contents from user
    # creating the new file, opening it in write mode
    with open(filename, "w") as f:
        f.write(content) # writing content to the file

# executing the shell 
if __name__ == '__main__':
    my_shell()

To be on the same page, let’s do some code breakdown. This code is not different from the previous code, here we have a few additions.

We have imported the datetime library, extended the message string, and added 3 commands, help, date-time, and create-file.

The help command will list all the available commands for the shell, the date-time command will print the current date and time and lastly, the create-file command will assist the user in creating a basic file.

Run the program and enter the help command to get this output:

If you enter the date-time command, you get this:

To create a file, enter the create-file command:

You will find the file in your current working directory:

With this content:

Conclusion

That’s it, geeks!!! I hope you have learned so much from this piece. Remember there is so much that you could do with click-shell. I have only shown you a few things you could do with the library in this piece. But you can go the extra mile by building advanced commandline applications. Thanks for reading!!!! and do let me know in the comment section how you have benefitted from this piece.

Top 11 Advanced Tkinter Projects You Should Try This Year

Khumbo Klein Chilamwa — Mon, 20 Feb 2023 11:54:49 +0000

Programming is cool and more rewarding at the same time when you have what clients are looking for. These days it is not all about talking alone but rather acting on the ground, that’s why clients are opting for developers with hands-on experience. So the best way to catch a client’s attention is to work on some cool projects using a particular tool and include those projects on your resume. Know this, there will never be the best way of convincing clients than having some advanced projects that you can show off on your resume. When I first started using Tkinter I was just creating some basic GUIs, like displaying text when a button is clicked, something that would not catch a client’s attention right? So I had to change the gears If I was ever to impress a client, so I found projects and started working on them one at a time. I have to admit that I did not finish all these projects in a single year but yeah I finished them. In this article, I will be sharing the 11 advanced Tkinter projects that I have successfully worked on in the past years, with these projects I strongly believe that you will master the framework and be able to build your own GUI applications that you can show on your resume.

Something worth mentioning here, I have just listed the projects randomly, the order in which they are listed does not in any way mean the project’s relevance and difficulty.

1. Age Calculator

The Age Calculator is simply an app that calculates your age, it takes your date of birth(day, month, year) as input and calculates your age. To build this app I used the ttkbootstrap and datetime libraries. The ttkbootstrap library helps you style your widgets in an advanced way using bootstrap styles and the datetime library is for working with dates.

2. Real-Time Currency Converter

A Real-Time Currency Converter is an app that converts currencies from a source rate to a destination rate. To successfully build this app you will need any free currency converter API(Fixer API, Exchange Rate API, Yahoo Finance API, etc), the tkinter, requests, and json libraries. The requests library is for sending a response to the API and the json library is for converting the response to JSON data.

3. Gender Predictor

The Gender Predictor app simply predicts the gender of a given name, it uses the genderize API and these 3 libraries tkinter, requests, and json.

4. Audio Dictionary

If you have ever fancied the idea to build a dictionary app with an audio feature, then this one is for you. With this project, you will use the PyDictionary library for finding the words meaning and the pyttsx3 library for converting text to speech. How this app works, the user will enter a word and search for its meaning then pronounce the found word.

5. Real-Time Spelling Checker

Don’t you want to build a real-time spelling checker, whereas you are typing your sentences in the scrollable text field the app will check in real-time for spelling errors. If this sounds cool, then this project is worth your attention this year. The libraries that you will need for this project are the tkinter, re, and nltk.

6. QR Code Generator and Detector

We all know that QR code technology is booming and that it is being incorporated with a lot of technologies like WIFIs, online payment systems, etc. Building your app that generates and detects QR codes would be a feat on its own. For this project, you will need these libraries, tkinter, cv2 for detecting QR codes, and qrcode for generating QR codes.

7. Voice Recorder

Another cool project to prove your skill is a Voice Recorder, this app records your voice for a specified amount of seconds, and after successfully recording the voice it is saved to a file for later use. The libraries required for this project are the sounddevice, scipy.io.wavfile, threading, datetime, time, and os.

8. PDF Viewer

Ever wondered how apps like Foxit reader or adobe reader work, in this project you will build your own PDF file viewer, and through this project, you will learn things like extracting data from a PDF document. The libraries you will need for this project are the fitz from PyMuPDF, tkinter, and os.

9. Language Translator

If you want to build your own language translator then try this project, by building this project you will learn a lot of programming concepts. You will get to design the snazzy GUI, and implement all the advanced features like voice, copy to clipboard, notifications, etc. The libraries used in this project are the ttkbootstrap, googletrans, pyttsx3, and pyperclip.

10. MP3 YouTube Downloader

MP3 downloader is an app that downloads for you MP3 files from YouTube videos and the required libraries for this project are tkinter, pytube, threading, and os.

11. YouTube Video Downloader

Building your video downloader like IDM would be worth it, and it’s a project that every developer would be proud of. In this project you get to build a YouTube video downloader, you will get to implement features like search resolution, display download progress on the progress bar, etc. The libraries needed are the tkinter, pytube, and threading.

Conclusion

I have only listed a few projects that I think will be of great use when it comes to mastering the Tkinter GUI framework, there are lots of cool projects that other developers have done, please check them out as well. A reminder, these are projects that I have worked on as an individual, and am not claiming they are the best, I only wrote this article to share what I have built using Tkinter. Thanks for reading!!

How to Build a YouTube Video Search Voice Assistant

Khumbo Klein Chilamwa — Sat, 18 Feb 2023 15:16:08 +0000

Voice assistants are software programs that can understand and respond to voice commands. With the release of Amazon’s Echo and Google Home, voice assistants are becoming more popular than ever. Searching for a video on YouTube can be a hassle, especially if you don’t know what you’re looking for. But what if you could have a voice assistant that could search through YouTube videos for you? That would be pretty cool, right? In this article, I will show you how to build a YouTube video search voice assistant using SpeechRecognition and the pyttsx3 Python packages. So if you’re ready to get started, let’s dive right in!

Here is the Table of Contents:

Creating a Virtual Environment
Installing the Required Packages
Building the YouTube Video Voice Assistant
- Creating the speak() Function
- Creating the voice_assistant() Function
- Creating the search() Function
Testing the YouTube Video Search Voice Assistant
Conclusion

Creating a Virtual Environment

First things first, let us create the virtual environment for the project, in your terminal run this command:
$ python -m venv project
You can call your virtual environment any name, but just make sure the name is meaningful, not cryptic.

Installing the Required Packages

Now that the virtual environment is taken care of, it is time we install all the required packages for this project, so activate the virtual environment by running this command on Windows:
$ .\project\Scripts\activate

And on Linux or macOS use:
$ source project/bin/activate

Having activated the virtual environment, we are ready to install the packages, run this command:
$ pip install pyttsx3 SpeechRecognition pyaudio

Installing packages inside a virtual environment means that they are not global, but rather local for that one special project they are installed for. And these virtual environments come in handy because they help in managing packages very easily.

Building the Voice Assistant

In this section we will build the actual YouTube Video Search Voice Assistant, we will build it from the ground up, so roll up your sleeves for we are about to go coding.

The first task that we have to do is to create a new Python file, let us call it video_search_assistant.py, as usual just be extra careful when naming your Python files, make sure the names are meaningful and that they do not conflict with the packages being used in your project. Open the file and do the following imports:

# this package is a web browser controller
import webbrowser
# this package is for speach recognition
import speech_recognition
# this package converts text to speech
import pyttsx3
# this package will be used to get the PC username
import os

Let us break down the above code, our first import is the webbrowser package, this package is the web browser controller, and we will use it for launching the web browser. The speech_recognition package is simply for recognizing speech, it works hand in hand with the pyaudio package to capture voice from the microphone and process it accordingly.

The other package that we are importing is the pyttsx3, this package will convert a given text to speech and the final package being imported is the os package, which we will use for getting the computer’s username.

After taking care of the imports, our next task will be creating the speak() function, this function will help turn text data into audio data, now just below the imports paste the following code:

# function to turn textual data into audio data
def speak(command):
    # initializing the pyttsx3 object
    engine = pyttsx3.init()
    # gets the speaking rate
    rate = engine.getProperty('rate')
    # setting the speaking rate
    engine.setProperty('rate', 125)
    # getting the available voices
    voices = engine.getProperty('voices')
    # setting the second voice, the female voice
    engine.setProperty('voice', voices[1].id)
    # this function takes the word to be spoken
    engine.say(command)
    # this function processes the voice commands
    engine.runAndWait()

In the code above, we are creating a function speak() that is taking command as an argument, inside this function we are initializing the pyttsx3 object, then using this object we are getting and setting the speaking rate. We are also able to get a voice from the available voices and set it, in our case we are using the second voice which happens to be the female voice.

After this, we are passing the command to the say() function, and the runAndWait() function processes the voice commands.

Our next task is to create the voice_assistant() function, so in the file just below the speak() function paste the following code:

# creating a Recognizer object
recognizer = speech_recognition.Recognizer()
# prints the message to let the user know to start speaking
print(f'Say something, am listening')
# the function for recognizing speech and processing it accordingly
def voice_assistant():
    # the try statement will execute the speech recognizing code
    try:
        # here we are creating a context for the speech_recognition.Microphone() function
        # this enables us to use the microphone
        with speech_recognition.Microphone() as mic:
            # this listens to the ambient noise for the specified duration
            recognizer.adjust_for_ambient_noise(mic, duration=0.5)
            # capturing speech from the default microphone
            audio = recognizer.listen(mic)
            # recognizing speech using google speech recognition API 
            text = recognizer.recognize_google(audio)
            # this converts the text to lowercase text
            text = str(text.lower())
            # calling the speak function, it takes text as an argument
            speak(f'Be patient while i search for you all {text} videos')
            # this will print the captured word
            print(f'Searching {text}')

    # this except statement catches an error when the assistant fails to recognize the said word   
    except speech_recognition.UnknownValueError:
        # calling the speak function, it takes text as an argument
        speak(f'Sorry i did not hear you!!!')
        print(f'Sorry i did not hear you!!!')

    # this except statement catches an error when the assistant fails to recognize the said word 
    except speech_recognition.RequestError:
        # calling the speak function, it takes text as an argument
        speak(f'Make sure you have a stable internet connection!!!')
        print(f'Make sure you have a stable internet connection!!!')

# this is a function call 
voice_assistant()

Before we move any further, let us break this code down so that we are on the same page. We are creating a speech recognition object via speech_recognition.Recognizer() function, below it we have a print() function. Then we are creating a function called voice_assistant(), inside this function we have a try/exceptblock, the first except statement catches UnknownValueError which occurs when the voice assistant fails to recognize the speech and the second except statement catches a RequestError caused by unstable or no internet connection.

If you notice, inside these two except statements we are calling the speak() function and we are passing a string as an argument and we are also printing the same string via the print() function. Having the speak() function and the print statement inside the two except statements at once seems repetitive, but this is for testing purposes only.

Inside the try statement, we are declaring the microphone as the source of input and this code:
recognizer.adjust_for_ambient_noise(mic, duration=0.5)
helps let the recognizer waits for a duration of 0.5 seconds to adjust the energy threshold based on the surrounding noise levels. According to SpeechRecognition documentation, the best duration for accurate results is 0.5 seconds.

After adjusting the ambient noise, we are letting the **recognizer **capture audio from the microphone using the code:
audio = recognizer.listen(mic)

This audio data is then converted to text using this line of code:
text = recognizer.recognize_google(audio)

Finally, we are calling the speak() function as well and we are passing the argument text and we are printing the text.

We will now test the program, make sure your computer’s microphone is working and that your environment is quiet. Such an environment is helpful because it will enable the voice assistant to recognize the speech without any problems, but if the environment is the noise the voice assistant will have difficulties distinguishing the speech from noise.

In your terminal run this command:
$ python video_search_assistant.py

Say a word when you are prompted to, the first output will be an audible voice and the second will be this:

Say something, am listening
Searching programming

It seems the program can capture the speech and process it accordingly.

We will now move on to creating the search() function, this function will enable the voice assistant to search for YouTube videos, so above the speak() function or just below the imports, paste this code:

# function for searching youtube videos
def search(query):
    # creating the search url
    url = f'https://www.youtube.com/results?search_query={query}'
    # opening the webbrowser
    webbrowser.get().open(url)

Here we are creating a function that takes query as an argument, the function is called search(), then we are creating a URL, this is just a youtube video search URL. After everything, the webbrowser.get().open(url) will open the URL in the web browser. Remember, we will not type the URL manually but we will get it from the microphone.

Now to do a YouTube video search we need to call the search() function, we will call it in the try statement of the voice_assistant() function since we want it to search the data captured from the microphone. Below this line of code:
text = str(text.lower())
Paste this line of code:
search(text)

And below the voice_assistant() function, add this code:

# this gets the username of the computer 
username = os.getlogin()
# calling the speak function to welcome the user by the username
speak(f'Welcome {username}')
# asking the user what to search for
speak(f'What do you want to search for?')

Testing the YouTube Video Search Voice Assistant

In this section, we will test the program, and let us search for programming videos. You can run it again using:
$ python video_search_assistant.py

If the program runs successfully, it will welcome you and ask you what videos you want to search for, and if you provide valid input you will get this out:

And in the terminal you will get this output:

Say something, am listening
Searching programming

If you run the program and speak a cryptic word, the program will give you this output:

Say something, am listening
Sorry i did not hear you!!!

And at the same time, the speak() function will echo the same message.

And if you have an unstable or no internet connection, the output will be as follows:

Say something, am listening
Make sure you have a stable internet connection!!!

This message will again be echoed by the speak() function.

Congratulations on creating your voice assistant, and to make the code a little cleaner you can remove all the print statements. If you observe well there are four print statements.

Conclusion

This article has shown you how to build a YouTube Video Search Voice Assistant. I hope there is so much that you have learned and that you can use this knowledge to create your own amazing projects. If you want to further this project feel free to do so, you can add as many cool features as you want. Thanks for reading.

How to Verify Email Addresses Using Python

Khumbo Klein Chilamwa — Fri, 17 Feb 2023 19:59:25 +0000

Email verification is a process that involves the confirmation of the authenticity or legitimacy of an email address. Nowadays businesses are integrating email verification into their day-to-day operations and this has proved to be more effective as it helps them keep only customers' email addresses that are valid and reachable. The email verifying tools that are available out there are cool and sophisticated but they come with a price tag, for a developer that should never be a huddle because you can build your own tool to verify a single email or bulk email. In this article, I will show you how you can build your own email verification tool using the Python library called verify-email.

Here is the Table of Contents:

Installing the Required Package
Verifying a Single Email Address
Verifying Bulk Email Addresses
Final Thoughts

Installing the Required Package

First things first, you need to have the verify-email package installed. Ensure that pip is working on your computer, in your terminal run the below command to install the package:
$ pip install verify-email
The verify-email package verifies email addresses by checking the domain name and pinging the handler or username for its existence.

Verifying a Single Email Address

Firstly, open a new Python file, call it email-verifier-script.py, and on top of the file do the following import:
from verify_email import verify_email
After doing the import, you need to create an email verifying handler, this is a function that will handle the email verification process. Call the function email_verifier() and make it look like this:

def email_verifier(email):
    # verifying email using verify_email function
    verify = verify_email(email)
    # checking if the verify value is True
    if verify == True:
        print(f'{email} is a valid email address')
    # checking if the verify value is False
    elif verify == False:
        print(f'{email} is not a valid email address')

The email_verifier() function is taking an argument email, this will be provided by the user, so do the following:

# getting email from user
my_email = input('Enter email address:')

After the user has provided the email address, it needs to be verified, to do that do a function call as below:

# calling the email_verifier function
email_verifier(my_email)

Now you are set to verify your first email address, open the terminal and navigate to the directory where the script is located. Run this script using this command:
python email-verifier-script.py

You will be prompted to enter an email address, if the email address is valid, the output will look like this:

If you enter an invalid email address, this is what you get:

Verifying Bulk Email Addresses

In this section, you will get to verify a list of email addresses, so tweak the email-verifier-script.py file so that it looks like this:

from verify_email import verify_email

# a list of email addresses to be verified
email_addresses = ['khumboklein@gmail.com', 'muo@gmail.com', 
                   'admin@gmail.com', 'kchilamwa@hackbits.tech',
                   'trainings@updates.internshala.com', 'noreply@medium.com',
                   'maryellen.m@valnetinc.com']

for email in email_addresses:
    # verify individual email address
    verify = verify_email(email)

    # checking if verify is True
    if verify == True:
        print(f'{email} is a valid email address')

    # checking if verify is False
    elif verify == False:
        print(f'{email} is not a valid email address')

In the code snippet, there is a list of email addresses. The for loop is looping through all the email addresses in the list. Inside the for loop, an email is being verified individually.

Running the script, the output will be:

Final Thoughts

With Python’s versatility, you can build your free email address verifier with a few lines of code, this comes in handy and it’s cheaper than using a premium email verifying service.

Getting to know the .NET framework

Khumbo Klein Chilamwa — Fri, 29 Apr 2022 11:30:22 +0000

In this article, you will get to know the .NET framework, why it is an investment-worthy of your time, and what you can build using this technology.

What is the .NET framework?

Before we dive deeper into this article, let us get to understand what a framework is. A framework is a collection of already written code that helps the programmer solve some complex tasks that are part of the software development process. For example, writing code to authenticate users is more tedious and time-consuming, so time being one of the crucial factors in the software development business, developers came up with a solution to this by introducing frameworks that come with all necessary features out of the box.
According to Microsoft, the founder and creator of the framework, .NET also pronounced as dot net is said to be a software development framework for building and running applications on windows. The framework is C# based meaning it was built using the C# programming language, and my advice to those willing to learn this popular framework would be, to learn some C# basics, this will help you to get familiar with the syntax the framework uses, since it is C# like.

Why the .NET framework?

Probably by now, you might be asking yourself questions like why should I learn this framework for my career development and is it really worth my time, and who is still using it out there, maybe I might be just one of those geeks using obsolete technology. All these questions are understandable and they all make sense; it has been the norm for everyone new to any technology to ask lots of these kinds of questions. So why should you learn the .NET framework? Listed below are some of the reasons why you should learn this popular framework as an addition to your stack.

It offers better in-built user interface(UI) controls and supports other UI controls such as Telerik which is drag and drop.
it takes security seriously, for example, it offers cryptography for securing data, and its environment is highly secure.
It can be easily integrated with other Microsoft applications e.g. MS office applications, and emails.
It uses the MVC (Model View Controller) architecture just like the other popular web development frameworks e.g. Django, Laravel, and Ruby on rails.
It helps you to quickly deploy your applications

Listed above are just some of the reasons you should learn the .NET framework, I have not exhausted everything.

Still doubting the .NET framework?

Just like the other popular frameworks available, the .NET framework has been around for some time and because it is mature and feature-rich, famous and big companies are embracing it as their primary framework for building their business solutions. Listed below are some of the companies that use the .NET framework.

Microsoft (founder and creator)
Dell
Stack Overflow
Accenture
Trustpilot

What you can build using the .NET framework

.NET being a versatile framework, a lot of businesses are relying on it when it comes to building their quality and reliable business solutions. Businesses that have embraced this technology are now using it for building.

Web-based applications
Web services
Form-based applications

Conclusion

In this article, you have learned what a .NET framework is, why you should learn it and what you can build after adding it to your stack.