DEV Community: Favour George

Python’s Assert Statement: A Not-So Comprehensive Guide

Favour George — Sun, 03 Sep 2023 02:05:34 +0000

What are Assertions?

Assertions are statements used to prove that a certain condition is true or has stayed true. If the condition proves to be false then the program will generally raise an AssertionError.

When to use Assertions

As powerful as assertions can be, they shouldn't be used haphazardly in your code as this could result in quite a mess especially when they are in a production environment, Ill explain this later. For now, the key point is that assertions are mainly used as a debugging aid to test conditions.

Assertion Syntax

The Python assert statement mainly consists of the assert keyword, the condition to test for and an optional assertion message to be returned if the condition proves to be false. This syntax is shown below:

odds = 4
assert odds < 3, 'odds less than 3 is required'

If the condition evaluates to be true, then the program continues its execution as usual, otherwise, if it evaluates to be false, then it returns an AssertionError. The assert_message parameter though optional, is quite handy in providing a good description of the problem.

Common Assertion Types

Lets look at some of the commonly used assertion types in this section. There are various assertion types but for this article, well focus on three of the most common types:

Integrity/Identity Assertion: This type of assertion is used to test for an entity's identity thus proving its integrity. It checks for the data type of the entity in the assertion

a = 1
  b = 2
  assert a is a

Association Assertion: This type of assertion is used to check if an entity is associated in any way with a given collection such as a list, set, tuple etc. It checks if the item is a member of that collection

def checker(fruit, fruits):
      assert fruit in fruits
      return True

  checker('apple', ['apple', 'banana', 'cherry'])

Comparison: This type of assertion is used to compare two or more values

    assert 5 > 3

Limitations of Assertions

As I mentioned earlier, assertions are quite powerful but when used randomly can lead one into a pitfall. To avoid this, it is quite necessary to know the limitations of assertions and under what conditions not to use them.

Data Validation: Assertions shouldn't be used to validate data or user input because assertions can be disabled globally thus resulting in unexpected results as well see in the code below:
Exception Handling: Assertions shouldn't be used as substitutes to proper exception handling in your code for the same reasons they shouldn't be used for data validation because they can be disabled.

Summarily, assertions are powerful debugging tools or aids. However, their usage should be done meticulously to avoid falling into one of its pitfalls

That's it for this article, Thanks for reading and don't break production with your assertion.

Python's Prototype Design Pattern: Crafting Objects for Performance

Favour George — Wed, 09 Aug 2023 21:44:12 +0000

In a previous article, we discussed the singleton design pattern and saw how it could be applied in practice. In this article, well be discussing the prototype design pattern, when to use it and how to use it.

The prototype design pattern lets you as a developer copy existing objects without making your code dependent on the classes in which they were instantiated from. So what does this mean? Say you had an object in your code and for some reason you wanted to create an exact copy of that object with its attributes, normally you would first create an object of the same class and then go through all the properties of the original object and copy over their values to the new object. However, it is important to note that not all objects can be copied that way because some of the objects properties (i.e. attributes and methods) may be private. Furthermore, you would have to know the objects class to create a duplicate and in a long codebase, this could become very tedious and this is where the prototype design pattern comes in.

Fundamentally, the prototype pattern is just a clone() function that accepts an object as an argument and returns a clone of the object.

Building a Prototype Design

Let us implement the prototype design in code as follows::

from abc import ABCMeta, abstractmethod
from copy import deepcopy

# prototype interface
class Prototype(metaclass=ABCMeta):
    @abstractmethod
    def clone(self):
        pass

# concrete prototype
class Car(Prototype):
    def __init__ (self, make, model, year) -> None:
        self.make = make
        self.model = model
        self.year = year

    def clone(self):
        return deepcopy(self)

# client
car_1 = Car('Dodge', 'Challenger SRT', 2021)
cloned_car = car_1.clone()

print(car_1)
print(cloned_car)
print(car_1 == cloned_car)

In the code above, we first import the necessary tools well need. We imported the ABCMeta class and abstractmethod decorator from the abc module. The ABCMeta class is used to define an abstract base class and the abstractmethod decorator is used to declare abstract methods that must be implemented by subclasses. We also imported the deepcopy function from the copy module. This function creates a deep copy of an object

Abstract Class

This is a class that cannot be instantiated directly and is meant to be subclassed by other classes.

Abstract Method

This is a method declared in abstract base classes but does not contain any implementation in the base class itself.

We then created a class Prototype , that serves as the interface for creating prototype objects. The metaclass=ABCMeta argument specifies that this class is an abstract class (i.e. a class that cannot be instantiated directly and is meant to be subclassed by other classes) and should be treated as such.

The @abstractmethod decorator marks the clone method as an abstract method. Abstract methods are declared in abstract base classes but do not contain any implementation in the base class itself. Subclasses inheriting from this base class are required to provide an implementation for this method

We then created another class, Car , which implements our Prototype base class. We created a constructor method that is to be initialized when objects are created from the class. We then defined the implementation of our abstract method clone , derived from the Prototype class implemented in our car class. The clone function takes the object as an argument and returns a deep copy of the object.

To test our code, we created a car object from the Car class, specifying all the needed attributes (make, model, year) and we named this object car_1. We then created another object, cloned_car , which is a clone of our first car, thanks to applying the clone method to our car_1 object.

Using our print statements, we can see they are not stored in the same memory address and they are not the same although one is a clone of the other as seen in the output below:

< __main__.Car object at 0x000000FF942AE2E0>
< __main__.Car object at 0x000000FF94327040>
False

Applications of the Prototype Design

The prototype design is useful for:

Reducing Object Creation Overload: If object creation is a computationally expensive task, using the prototype design pattern can be more efficient than creating objects from scratch.
Creating Stateful Objects: Prototypes can be used to capture the state of an object at a certain point in time, making it useful for tasks such as creating snapshots and the redo/undo functionality.
Dynamically Creating Objects: In cases where the exact class of an object isnt known until runtime, the prototype pattern can be helpful to achieve runtime object creation without knowing the specific classes in advance

With all that said, the keypoint is to understand that the prototype design pattern basically creates a clone of an existing object.

Thats it for this article folks, dont just read it but also try to understand and perhaps even use it. So till next time, as usual, dont break production.

Singleton Design Pattern: Mastering the Art of Single Instance Classes

Favour George — Mon, 07 Aug 2023 20:57:11 +0000

What are Design Patterns?

A design pattern is a reusable solution to a general obstacle faced by developers while designing and building software. They are models or blueprints for solving recurring problems in software development

Why are Design Patterns necessary?

Design patterns when used properly for the right problems can accelerate the speed of software development by helping developers to avoid reinventing the solution to an already solved problem. With that said, it is important to understand that design patterns are not an alternative to sound logic and problem-solving skills and as such, they shouldnt be used randomly and the developer should know under what circumstances a certain design pattern(s) should be used

In the next few weeks, Ill be uploading articles on various design patterns. For today, lets get started with the singleton design pattern.

Singleton Design Pattern

The singleton design pattern is a software design pattern that aims at making sure theres just one instance of a class in a program regardless of how many times an object is instantiated from said class.

To show the singleton design pattern in practice, well use it to build a logger for logging errors into a log file. In a previous article here, we built a logger but had an issue where we always had to specify the name of the log file as an argument in our logger function as shown below:

import datetime

def logger(level, msg, logger):
    date = datetime.datetime.now()
    with open(f'./{logger}.log', 'a') as logger:
        logger.write(f'\n [{level}] {msg} ---- {date}'.format())

This could result in quite a messy file structure as we could end up logging into multiple log files which wont be clean. So using the singleton design pattern, well create one and only one instance of our logger, logging all the messages to one log file that wont need to be provided as an argument when creating an object from our class. Lets get started.

In the previous article where we built our logger here, we created a logger.py file where we stored the code for our logger. Now we are going to modify that file by creating a class that logs to just one file. To implement the singleton design pattern, well create a dunder method or special method ( these are Python methods that are identified by two trailing underscores before and after their names ). This method is responsible for creating a new instance of a class if none exists as shown below

import datetime

class Logger():
    instance = None

    def __new__ (cls):
        if cls.instance == None:
            cls.instance = super(). __new__ (cls)
        return cls.instance

In the code above, we import the datetime module to keep track of the time a message is being logged to our log file. We then created a class- Logger, we created a variable, instance, which shows if an instance of the class exists, for now, we set it to None. We then set up the dunder method, new , which is responsible for creating a new instance of a class if none exists. This method takes a default argument, cls , which is a reference to the class itself (i.e. Logger ) and not an instance of the class as most would think. In the method, we then write an if statement to check if theres no instance of the class and if theres none, it creates one and then returns that instance. Likewise, if theres already an instance, it returns that instance.

With that out of the way, let's create a method in the class for writing messages to our log file as shown:

def __init__ (self) -> None:
        self.filename = "pyLogger.log"

    def log(self, level, msg):
        date = datetime.datetime.now()
        with open(self.filename, 'a') as logger:
            logger.write(f"[{level}] ---- {msg} ---- {date}\n")

In the code above, we create a constructor method for our class which will automatically be called when an object is instantiated from the class and explicitly set a filename for our logger; this is where our logged messages will be written. Its important to note that we didnt pass the filename as an argument.

We then wrote a method for writing logged messages into our log file, taking the level of the message (e.g. ERROR, CRITICAL, DEBUG etc ) and the message itself as arguments. We then set up the date, and write to our log file the level and message.

To test if our singleton has been successfully implemented, well use the Logger class in a new file - main.py as shown below:

from logger import Logger

logger_1 = Logger()
logger_2 = Logger()

print(logger_1 == logger_2)
print(logger_1)
print(logger_2)

In the code above, we import the Logger class from our logger.py file into our main.py file. We then created two objects from the class, and heres the tricky part, normally these would be two different instances of the class and these two instances would be stored in different memory addresses but since we had implemented the singleton design pattern, these two instances are just one and are stored in the same memory address as shown below from the output of the code above.

True
<logger.Logger object at 0x00000071F1397940>
<logger.Logger object at 0x00000071F1397940>

Now to use it in our logger, in our main.py well keep the import of the Logger class and create an instance of it. Then well write a basic script, the same as we did in the previous article on creating a logger, in the script well try to divide a number by zero and catch the Zero Division error that occurs and then log it to our logger as shown:

from logger import Logger

logger_1 = Logger()

try:
    calc = 5 / 0
except ZeroDivisionError as err:
    logger_1.log("ERROR", err)
finally:
    print('done')

If the code above runs successfully, our logger object would have created a logger file with the name we set it to in the class in our logger.py file and in the file you should see something like this:

[ERROR] ---- division by zero ---- 2023-08-07 08:49:07.513796

Alright folks, thats it for this article, weve learnt about the singleton design pattern and showed it in practice by building a logger. So to recap, the singleton design pattern is useful when we want to create just one instance of a class regardless of how many objects are instantiated from the class.

So till next time nerds, dont break production.

Your employer wont be happy 😀

Harness the Potential of Logging: Create a Python Logger from Scratch

Favour George — Sun, 06 Aug 2023 21:30:54 +0000

Imagine building an application for a client and it worked successfully on your computer and also worked successfully for the client initially. Then on a fateful morning, you get a message from the client saying the application is bugging out. To debug the error on the application, you have to replicate the error and that wont be an easy job if you dont know the steps the client had taken that led to this error occurring. This is where logging and loggers come in.

What is Logging?

Logging is the process of keeping track of events occurring in your software to keep an eye out for possible bugs that survived the development phase and snuck themselves into production. Not just bugs can be tracked using logging but also how a user is using the program.

What is a Logger?

A logger is a program that creates a logging file (.log) that enables developers to write to the file errors caught during development and production. Not only error messages could be written to the file, but warnings and information could also be written to the file to help developers keep track of how their programs are being used.

Why Loggers?

Loggers are quite useful when code has been pushed into production and you cant keep track of the events occurring by simply printing to the console as you would do during development. In such a case, loggers are useful for keeping track of events occurring in the application and you can easily access the log file and see whats going on. Summarily, instead of littering your code with loads of print statements, you can simply write the message to the log file. This achieves two things: first, it keeps your codebase clean and second, it provides persistency ( i.e unlike the console that gets cleared every time the program is run, the log file is persistent. It's like the difference between storing things in a list and a database )

Now Python has a default logger module, but for this article, well build a rudimentary version of the logger. If you would like a complete tutorial on the Python Logger module, indicate in the comments. Alright, lets get started.

Building a Logger

Our logger is going to be able to log messages of 5 levels - Error, Warning, Critical, Info and Debug.

import datetime

def error(msg):
    date = datetime.datetime.now()
    with open('./logger.log', 'a') as logger:
        logger.write(f'\n [ERROR] {msg} ---- {date}'.format())

In the code above, we create a logger.py file where well be writing the code for our logger. In our logger.py file, we first import the datetime module to help us keep track of the time in which each log is made to our log file. We then create a function error, that takes the message we wish to log to our log file as an argument. In the function, we set up the date, which is the time the user calls the function and then we open a logger.log file in append mode, meaning we write to the end of the file without altering its previous contents. We then write to the file the message, which was passed in as an argument as well as the date which was created earlier.

We then copy the function and paste it four times, changing its name to the different levels we specified at the beginning of this section as shown


def critical(msg):
    date = datetime.datetime.now()
    with open('./logger.log', 'a') as logger:
        logger.write(f'\n [CRITICAL] {msg} ---- {date}'.format())

def warning(msg):
    date = datetime.datetime.now()
    with open('./logger.log', 'a') as logger:
        logger.write(f'\n [WARNING] {msg} ---- {date}'.format())

def info(msg):
    date = datetime.datetime.now()
    with open('./logger.log', 'a') as logger:
        logger.write(f'\n [INFO] {msg} ---- {date}'.format())

def debug(msg):
    date = datetime.datetime.now()
    with open('./logger.log', 'a') as logger:
        logger.write(f'\n [DEBUG] {msg} ---- {date}'.format())

Now to use our logger, we create a new Python file - main.py and import our logger file into it. Now for testing purposes, well write a basic script to divide a number by zero and try catching the error (ZeroDivisionError) that comes up and then log it to our logger as shown below.:

import logger

try:
    calc = 5 / 0
except ZeroDivisionError as err:
    logger.error(err)
finally:
    print('done')

Now to see our logged message, we open the logger.log file and you should see this


 [ERROR] division by zero ---- 2023-08-06 08:45:42.013959

You can try the other functions we defined in the logger.py file such as critical at your leisure.

Simplifying Our Code

In programming, theres a principle known as DRY ( Dont Repeat Yourself ) and its pretty... DRY.

If you are a geek for code efficiency and minimalism, youd notice that our logger.py file is quite repetitive. We can create one function that takes the level, message and logger as arguments as shown below:

import datetime

def logger(level, msg, log_file):
    date = datetime.datetime.now()
    with open(f'./{log_file}.log', 'a') as logger:
        logger.write(f'\n [{level}] {msg} ---- {date}'.format())

The problem with this design is that every time we call the function, we have to explicitly provide the name of the log file we intend to use and it could become quite messy as we could be logging into multiple log files.

To make this project even better we could implement the singleton design pattern to our logger, now thats for another article.

So for now, weve built and used a basic Python logger, all praise to Mad Max.

Thats it for now, Ill be uploading a new tutorial on how to implement the singleton design pattern to our logger later on. Till then, dont break production.

Python Itertools: Mastering Efficient Iteration for Enhanced Productivity

Favour George — Tue, 25 Jul 2023 06:39:26 +0000

What is Itertools?

Itertools is a Python module used for iterating over iterable data structures using a for loop. It is a collection of tools for handling iterators and iterations in a fast and memory-efficient way.

Now, before we get started exploring the itertools module, lets understand a few important terms used in iteration.

Iterables

An iterable is any data structure that can be iterated or looped over to access its individual items. Examples of iterables in Python include Lists, Tuples, Sets, Strings, Dictionaries etc.

Iterator

An iterator is an object that allows you to traverse or move through elements of an iterable one at a time. Iterators are stateful, meaning that they maintain an internal state to keep track of their current position during iteration.

Now with that out of the way, lets explore the various tools available to us through Itertools

Types of Iterators in Itertools

There are mainly three types of iterators available to us in Itertools:

Infinite Iterators
Finite Iterators
Combinatoric iterators

Infinite Iterators

Infinite iterators are a type of iterator that can produce an infinite sequence of values which results from an endless loop. To stop this, you have to specify a condition for breaking out of the loop.

Itertools provides us with a few of these types of iterators which include

Count(start, step)

The count iterator will return evenly spaced numbers starting from the number passed into its start parameter. It also provides steps, which can be quite useful. Lets see how it works in practice

from itertools import count

for i in count(start=2, step=2):
    if i < 10:
        print(i)
    else:
        break

In the code above, we first imported the count iterator from the itertools module. We then set up a for loop with the count iterator starting from 2 with a step size of 2. Later on, we set up a condition to break out of the loop if the iterator is greater than 10. The output of this code would be even numbers from 2 to 10, excluding 10 as shown below

Cycle(iterable)

The cycle() iterator takes an iterable as an argument and iterates through each item of the iterable in perpetuity unless a condition is provided to break out of the loop as shown below:

from itertools import cycle

tracker = 0
numbers = [1, 2]
for i in cycle(numbers):
    if tracker < 5:
        print(i)
    else:
        break
    tracker += 1

In the code above, we import the cycle iterator, define a tracker variable to keep track of the number of iterations and set up an iterable in the form of a list containing two numbers. We then construct a for loop with the cycle iterator and pass in the list of numbers as an argument. Finally, we set up a condition to break out of the loop if the number of iterations(i.e. the tracker variable) is greater than five. The output of this code is shown below:

Repeat(object, times=None)

The repeat iterator takes an object such as an iterable as an argument and returns the object infinitely unless its times parameter is provided with an argument as shown below

from itertools import repeat

numbers = [1, 2, 3, 4, 5]
for i in repeat(numbers, 5):
    print(i)

In the code above, we imported the repeat iterator, then we defined an iterable in the form of a list of numbers. We then set up a for loop with the repeat iterator, passing in our list of numbers as an argument along with the number of times we want to repeat, in this case, 5. The output of the code is seen below:

Finite Iterators

Finite iterators are a type of iterator that have a finite or limited sequence of values to iterate over. They are usually associated with finite iterables. Itertools has quite a bunch of finite iterators for us to use.

Accumulate(iterable)

The accumulate iterator takes in an iterable as an argument and returns its accumulated sums. The default of the accumulate iterator is addition, but for this article, well be using the multiplication operator as shown below:

from itertools import accumulate
from operator import mul

numbers = [1, 2, 3, 4, 5]
for i in accumulate(numbers, mul):
    print(i)

In the code above, we imported the accumulate iterator and also imported the multiplication operator from the operator module. We then defined an iterable in the form of a list of numbers. Finally, we set up a for loop with the accumulate iterator, passing in our list of numbers along with the operator we wish to use, in this case, the multiplication operator from the operator module as arguments. This code should return the accumulated product of the numbers in our list as shown:

Compress(data, selectors)

The compress iterator is quite handy for filtering the first iterable(data) with the second iterable(selectors). For this to work, we set the second iterable as a list of booleans which will be assigned to the selectors parameter. Lets show this in code:

from itertools import compress
numbers = [1, 2, 3, 4, 5]
bool_list = [True, False, True, False, True]

for i in compress(numbers, bool_list):
    print(i)

In the code above, we import the compress iterator, define a list of numbers which will be used as our data and define another list of booleans which will be used as our selectors.

We then set up a for loop with the compress iterator, passing in our various lists as data and selectors. This code will return items in our first list (data) which match True in our second list (selectors) as shown below:

Dropwhile(predicate, iterable)

The dropwhile iterator takes in a predicate which can be a function as an argument as well as an iterable. The dropwhile iterator will drop elements as long as the filter criteria is True but once it hits upon an element which when checked with the filter criteria is False, it keeps that element along with every other element that comes after. Fundamentally, this iterator drops every item in the iterable while it has not reached an item that evaluates to False. Lets show this with the code:


from itertools import dropwhile

def greater_than_three(x):
    return x > 3

num = [6, 4, 5, 6, 2, 6, 7, 9]
for i in dropwhile(greater_than_three, num):
    print(i)

In the code above, we imported the dropwhile iterator, created a function that returns True if the number provided as argument is greater than three and finally defined an iterable in the form of a list of numbers. We then set up a for loop with the dropwhile iterator, passing in our predicate( the function) and iterable( list of numbers) as arguments. The output of this code will be every item in the list after the predicate hits upon an item in the list that returns False as shown:

Filterfalse(predicate, iterable)

The filter false iterator takes in a predicate which can be a function as well as an iterable as arguments. It returns values of the iterable that evaluate to False when checked with the predicate and drops values that evaluate to True. Lets show this with the code:

from itertools import filterfalse

def less_than_four(x):
    return x < 4

num = [6, 7, 8, 9 , 1, 6, 3, 0 , 9, 2]
for i in filterfalse(less_than_four, num):
    print(i)

In the code above, we imported the filterfalse iterator, defined a function that returns True if the number passed into it is less than four and we also created an iterable in the form of a list of numbers. We then as usual, set up a for loop with the filterfalse iterator, passing in our function and iterable as arguments. This code will return items in our iterable that evaluate to False (i.e are greater than four) as shown:

Takewhile(predicate, iterable)

The takewhile iterator takes a predicate and an iterable as arguments. It is the polar opposite of the dropwhile iterator. The takewhile iterator will return values of the iterable that evaluate to True from the predicate, but once it stumbles upon an item which evaluates to False it stops and drops the rest of the values in the iterable. Essentially, this iterator takes every item in the iterable while it has not reached an item that evaluates to False. Lets show this with the code:


from itertools import takewhile

def greater_than_three(x):
     return x > 3

num = [6, 4, 5, 6, 2, 6, 7, 9]
for i in takewhile(greater_than_three, num):
    print(i)

In the code above, we imported the takewhile iterator, defined a function that returns True if the value passed to it is greater than three and we created our iterable as a list of numbers as usual. We then set up a for loop with the takewhile iterator, passing in our function and iterable as arguments. The output of this code will be every item in the list before the predicate hits upon an item in the list that returns False as shown:

Zip_longest(*iterables, fillvalue=None)

The zip_longest iterator can be used to iterate over two iterables together. If the two iterables are not of the same length, you can provide a fill value to fill up the blank spots of the lesser or shorter iterable as shown below:

from itertools import zip_longest

for i in zip_longest('abcd', '12', fillvalue='None'):
    print(i)

In the code above, we import the zip_longest iterator and set up a for loop with it passing in two iterables and a fill value as arguments. The second iterable(12) is two characters short, so we provide a fill value of None to it. The output is shown below:

Combinatoric Iterators

Combinatoric iterators are a type of iterator that focuses on generating various combinations and permutations from an iterable. They are particularly useful for solving combinatorial problems. Itertools provides us with a handful of these combinatorial generators.

Combinations(iterable, r)

The combinations iterator takes an iterable as an argument along with an r-length tuple which is the length of each combination. Lets see this in the code:

from itertools import combinations

for i in combinations('ABCD', 2):
    print(''.join(i))

In the code above, we imported the combinations iterator and then set up a for loop with it, providing a String as an iterable and 2 as the length of each combination. This code would normally return a tuple of each combination, but after using the join method weve joined the two values that would have been in a tuple to a single String as shown below:

It is important to note that the combination is done in a lexicographic manner (i.e. alphabetically, A-Z). Also, the combinations will not produce repeat values(e.g. AA, BB) if all the input elements are unique.

Combinations_with_replacement(iterable, r)

The combinations_with_replacement iterator is quite similar to the combinations iterator, except in this case, it creates combinations where elements do repeat (e.g. AA, BB). Lets see this in the code:

from itertools import combinations_with_replacement

for i in combinations_with_replacement('ABCD', 2):
    print(''.join(i))

Permutations(iterable, r)

The permutations iterator returns a progression of r-length permutations of elements of the iterable you give to it. Lets see this in code:

from itertools import permutations

for i in permutations('ABCD', 2):
    print(''.join(i))

Thats it for this article, as you can see, the itertools module provides us with a collection of very handy functions that we can use for efficient iteration without coding them from scratch by ourselves. For a more comprehensive outlook on more of these tools be sure to visit the docs.

Building A Mail Client With Python

Favour George — Tue, 18 Jul 2023 19:03:38 +0000

What is a Mail Client?

A mail client is a program used to manage and compose emails that can be sent as well as received. A mail client is only ever active when it is being run by a user.

In this project, well be creating a rudimentary version of a mail client to send emails with attachments such as images in the Python programming language.

PROJECT REQUIREMENTS: To build this project, youll need a Gmail account. In addition, in your project folder youll need:

A message text file containing the email's message
An image file of your choice

Lets get started building our highly ineffective but usable mail client:

Defining Import Statements

In this section, well be importing the necessary libraries we need to build this project into our main.py file in our project directory

import smtplib
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
from email.mime.multipart import MIMEMultipart
from email import encoders

Lets understand what each import statement above does:

smtplib: This is the Python library well be using to send emails
MIMEText: This class will be used to wrap our emails message to provide better formatting.
MIMEBase: The MIMEBase class adds a content-type header to the email.
MIMEMultipart: This class is used to create an object that will contain information that will be in the emails header such as the from address, to address and email subject.
encoders: This will be used to encode our payload, in our case, the image, to a base64 format.

Setting Up Our Credentials

In this section, well set up the login details for our Gmail account; email address and app password as shown below:

credentials = __import__ ("credentials")
email_address = credentials.email
password = credentials.app_password
to_addr = credentials.to_address

In the code above, I had already created a file named credentials.py, and in it, I stored my email address and app password as well as the email address I'm sending the email. So all I did was import them into my main.py file and assign them to variables as shown above. If the code you are writing won't be shared anywhere, feel free to include the email address and password directly into the code.

Now, you may have heard me say the app password above twice and thats because its important to understand that this is different from your Gmail accounts password. Now, the app password is a safer way to access your Gmail account outside Gmail itself through our code. To set up an app password follow the steps below:

Login to your Google account
Go to the security tab
Enable 2-factor authentication
After enabling 2-factor authentication, in the 2-factor authentication section scroll down, and youll find a section on creating an app password. Create one.
Copy the password which will be 16 characters long and paste it where you are assigning the password in your code

This YouTube video provides a clearer explanation of how to set up an app password.

Setting up the Email Header

In this section well be setting the contents of our email header which will include things such as the from address, to address and email subject

msg = MIMEMultipart()
msg['From'] = "Mad Max"
msg["To"] = to_addr
msg["Subject"] = "Hello nerd, its Mad Max"

In the code above, we created an instance of the MIMEMultipart class. Think of the object instantiated as a dictionary, to which we can assign values to its keys. In this case, we've assigned the "from email address", "to email address" and "subject" to their respective keys.

Reading our Message File

Now we'll read the message text file we created and stored in our project folder

with open("message.txt", 'r') as message:
    subject = message.read()
    msg.attach(MIMEText(subject, "plain"))

In the code above, we opened our message.txt file in read mode, 'r'. We then read the file and attached it to the message as a plain text document through the MIMEText class.

Attaching a File

We'll now be attaching a file to our message body

attached_file = "mad_max.png"
with open(attached_file, "rb") as attachment:
    payload = MIMEBase("application", "octet-stream")
    payload.set_payload(attachment.read())

    encoders.encode_base64(payload)
    payload.add_header("Content-Disposition", f"attachment; filename={attached_file}")
    msg.attach(payload)

First of all, we read our file in read binary mode, 'rb' because we are dealing with an image file and not an ordinary text file. Next, we instantiate the MIMEBase class and set a payload of our read image file. We then encode the payload to base64 as good practice and then add a header and finally attach the payload to the email message body.

Sending our Email

To send our email, we'll be using the SMTP library of Python as shown below

text = msg.as_string()
with smtplib.SMTP("smtp.gmail.com", 587) as server:
    server.starttls()
    server.login(email_address, password)
    server.sendmail(email_address, to_addr, text)

Before sending our email, we convert the entire message body to string just for good measure. Then we create a connection with the SMTP service of our email service provider, in this case, Gmail, on their specified port, 587. The starttls() method enables us to establish a secure connection to our email service provider. We then log in using the credentials we provided above(email address and password) and finally send the mail specifying the email address we are sending from, the address we are sending to and the contents of the email.

If everything was successful and the code ran without errors, the email should be in the inbox of the email address it was sent to as shown below

From the image above, you can confirm that I've successfully received the email sent from our crappy mail client and that our code ran without any errors, thus far.

Here's the complete code and a link to the project on GitHub.

import smtplib
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
from email.mime.multipart import MIMEMultipart
from email import encoders

credentials = __import__ ("credentials")
email_address = credentials.email
password = credentials.app_password
to_addr = credentials.to_address

msg = MIMEMultipart()
msg['From'] = "Mad Max"
msg["To"] = to_addr
msg["Subject"] = "Hello nerd, its Mad Max"

with open("message.txt", 'r') as message:
    subject = message.read()
    msg.attach(MIMEText(subject, "plain"))

attached_file = "mad_max.png"
with open(attached_file, "rb") as attachment:
    payload = MIMEBase("application", "octet-stream")
    payload.set_payload(attachment.read())

    encoders.encode_base64(payload)
    payload.add_header("Content-Disposition", f"attachment; filename={attached_file}")
    msg.attach(payload)

text = msg.as_string()
with smtplib.SMTP("smtp.gmail.com", 587) as server:
    server.starttls()
    server.login(email_address, password)
    server.sendmail(email_address, to_addr, text)

That's it for this article, thanks for reading and hopefully building along. Let me know in the comments about any issues you might have gotten into while building.

A Step by Step Guide to Code Profiling in Python

Favour George — Sun, 16 Jul 2023 13:13:28 +0000

As programmers and software developers writing code is not enough, just because the code works doesnt mean it is effective. Optimizing our code for improved performance should be one of the tenets of software development. Code profiling helps us to achieve this by helping developers to find bottlenecks and redundancies in their software and fix them.

Prerequisites : Knowledge of the Python programming language is crucial

Definition of Code Profiling

What is Code Profiling:

In software engineering, profiling ("program profiling", "software profiling") is a form of dynamic program analysis that measures, for example, the space (memory) or time complexity of a program, the usage of particular instructions, or the frequency and duration of function calls. Most commonly, profiling information serves to aid program optimization, and more specifically, performance engineering. - Wikipedia

Code profiling refers to the proper appraisal and examination of a software's source code to find the slowest parts of the code as well as parts that are consuming a lot of resources and optimize these parts of the code to improve the performance of the software.

The Purpose of Code Profiling

Why is Code Profiling Necessary

Code profiling is necessary to help software developers and engineers find bottlenecks in the source code of their software. These bottlenecks could result in performance issues such as poor user experience and overconsumption of resources. Code Profiling helps developers find parts of their code containing such bottlenecks and fix them.

What is Code Optimization

Code optimization is a set of procedures taken to improve code by making it consume lesser resources while also providing high performance.

Code profiling can be said to be a form of code optimization as it aids software developers reach their software performance goals by providing an interface to help them find bottlenecks preventing them from achieving these goals in their code.

Profiling Tools

These are software or libraries that aid software developers in the code profiling process. For this article, we'll be looking at a few code profiling libraries from the Python programming language.

timeit

This Python module allows developers to be able to time small bits of their Python code. timeit docs.

Let's try to time a simple Python code with timeit

In the code above we first import the timeit module.

We then use the timeit.timeit() method to time a piece of code which is declared as a statement in the method's " stmt" keyword argument. The "number" keyword argument refers to the number of times the statement provided is going to be executed by the method. In the end, this method returns a floating point number of the time it took for the statement provided to be executed in seconds which we stored in the variable, "value" and printed out as shown below:

cProfile

This Python module is used to measure the time it takes for a function to be executed as well as the number of times a function is executed. cProfile docs.

Now let's try using cProfile to time a simple function

In the code above, we first import cProfile as profile. We then create a function named loop which takes an argument "text" and prints it out when being called. Lastly, we called the run() method of the cProfile module and provided the function call as an argument. After the code ran, it provided the statistics shown below

Interpreting Profiling Results

Profiling code is just one piece of the puzzle, understanding the output or metrics used by profilers to profile the code is another part of the puzzle.

Understanding the Metrics

When using the timeit module to time a piece of code the output was relatively easy to comprehend but for more complex outputs such as the one given by cProfile, understanding the multiple metrics used to profile the code becomes essential.

For this example, we'll be interpreting the results of the cProfile profiler we saw above.

The cProfile output is divided into five distinct parts:

ncalls : This is the number of times the function is called.
tottime : This refers to the total time spent in the function without taking into consideration other function calls.
percall : This refers to the time spent for a single call of the function.
cumtime : This refers to the time spent in the function including other function calls.
filename:lineno : This refers to the filename and its corresponding line numbers.

Profiling Best Practices

These are a few procedures to take to make the code profiling process smoother

Write Concise Code: it is important to make sure your code is clear and concise. Chunk your code into smaller pieces. Also, make sure that each function handles only one operation.
Be Patient: profiling code can be a long and tedious process as some of the bottlenecks don't come off easily. Equally, profiling a long codebase will also require patience.

Profiling Case Study

This will show a simple practical use case of code profiling.

Case Study

In the code above, we created two functions, one of the functions has a little time delay of three seconds while the other has no time delay.

Assuming this time delay is a bottleneck, let's see if the cProfile profiler will detect this slight delay once we run the code

Output

From the output above, we can say that cProfile successfully detected the delay in the first function as seen in the time it took to execute the function.

In conclusion, code profiling is a great way of optimizing our code for improved performance by finding the bottlenecks preventing it from running at its peak performance.

Charting Your Path to Web Development Mastery: A Roadmap for Success

Favour George — Sun, 16 Jul 2023 12:45:39 +0000

So you've finally decided to take that bold step of learning to code, perhaps for fun or to get a new job and settle into the IT industry. You decide to take on Web Development and search on Google how to go about it, but you get carried away by the vast amount of information and opinions you get.

Should you become a Front-end developer? Back-end developer? Full-stack or Senior Developer? Should you learn React or Angular? Is No-SQL better than SQL databases? What is the MERN stack?

Technically there's an information overload out there and it's easy to get lost in all of it. I won't say this article is any different from the others you've read on getting started in Web Development, 'cos it's not, I just intend to make it more definitive.

STEP 1: KNOW THE BASICS

Yeah, before you get on to building the Instagram clone or any fantasy project of yours, you've got to appease the basics which are:

HTML - HyperText Markup Language

HTML allows you to lay the basic foundation for your website or web app. Though it's an ugly thing both when typing it and when it's visualized on a browser, it's a necessary evil. While learning HTML you need to get familiar with the Semantic Tags. It's also important to know that HTML is not a programming language but just a markup language

CSS - Cascading Style Sheets

Now CSS allows you to style your ugly-looking HTML code into something visually appealing and somewhat lovable. While learning CSS you will need to get acquainted with basic CSS syntax, Positioning, Selectors, Layout(Flex & Grid), Transitions and Animations as well as Responsive Design.

JavaScript

JavaScript is a real programming language and I mean as real as it gets. You can use JavaScript to create websites, games, mobile apps etc. But for this article, you can use JavaScript to add functionality to your website like clicking a button to give the site a dark theme. Equally, while learning JavaScript you need to get quite comfy with basic JavaScript syntax, data types, DOM & styling, JSON, HTTP Requests etc.

Other technologies worth learning at this stage include:

Version Control System (e.g Git)
Browser Developer Tools
Deployment (e.g Netlify)

Now you know the basics of Web Development, where should you go from here? You are literally at a crossroads, if you've enjoyed building the UI or visual part of websites as you've done so far you should continue with step 2, but if you are more drawn to logic than visuals then feel free to skip to step 3.

STEP 2: BECOME A FRONTEND GURU

It's time to get into the hamburger of Web Development, making your user interface (UI) better and a lot easier to create. Just kidding, it will be better looking but not easy to create, on the first try. Now you need to learn some more annoyingly awesome technologies.

SASS - Syntactically Awesome Style Sheets

SASS is a CSS preprocessor/pre-compiler/library or whatever you want to call it. SASS extends some of the features of CSS and makes it feel more like a programming language by providing features such as variables, nesting, partials and functions. It is used for styling websites and is a must-know for front-end developers, at least in my opinion.

BOOTSTRAP

Well, well, well, let's talk about something that can make your life a lot easier, Bootstrap. Bootstrap is CSS already created for your comfort, meaning you don't have to style your buttons, headings, padding etc from scratch. Just add the bootstrap class to your markup and problem solved. It's something worth learning as it can make your life a whole lot easier and your development work faster.

A FRONTEND FRAMEWORK

Frontend frameworks allow you to create complicated user interfaces(UI) that you could build with vanilla JavaScript but would be too time-consuming. They do this by providing the developer with reusable code modules. There are a lot of frameworks out there you could choose from, but these are some of the more popular and established ones: React, Vue, Angular and Svelte.

Now you might just be wondering, which one of these nerds should I choose? Well, that depends on the requirements needed for the job you are applying for or the project you're working on.

Generally, Svelte is the easiest to learn but not the most stable as it's relatively new, React is intermediate and Angular is the most difficult to learn not for the most terrible reason though. Vue, while having a relatively easy learning curve, also provides high productivity and stability that Svelte currently doesn't have.

Now you know the basics to become a frontend guru, some other technologies worth researching but not necessary at this stage include:

TypeScript
Server Side Rendering
Static Site Generators
The JAM Stack

With your knowledge till this point, you can now create your jolly Instagram clone, Twitter clone and other cloneable that never asked to be cloned but are worth cloning because we just enjoy cloning them.

STEP 3: BACKEND

Now let's get into the brains of web development. I call it the brains not because the front-end does not involve brains but because... whatever let's just get into it shall we?

SERVER-SIDE TECHNOLOGY AND FRAMEWORK

This can range from Python to Java. Here you've got to know a programming language and a framework for manipulating the backend of your web app. So I'm gonna leave you with a merry list of programming languages and their preferred frameworks for backend web development.

Node.JS - Express
Python - Django & Flask
Java - Spring MVC
Ruby - Ruby on Rails
PHP - Laravel
C# - ASP.NET
Kotlin - Javalin, kTor

You could pick one of these languages, learn its basics and get on with a backend framework of its own. None is better than the other. Dear, just pick a language you are comfortable with and get on with its dummy framework.

DATABASES:

Well, well, your web app can't possibly be complete without being able to store data, manipulate data, present data and eat data too. This is where databases come in as they can make organizing, storing, updating and deleting data a whole lot easier than trying to understand the logic behind Spongebob SquarePants, I mean how can there be a Fire Department under the sea? Sorry, I digress. Anyway, there are majorly two kinds of databases you've got to worry about now:

SQL DATABASES

SQL(Structured Query Language) databases allow you as a developer, coder, and software engineer, man there are so many names for us these days, to store data in tables and create relationships between them. SQL databases are used in the Finance industry as well as other industries such as Music and Social Media. Examples of SQL databases include PostgreSQL, MySQL, Oracle Database etc.

NO-SQL DATABASES

Like the name implies, No-SQL databases

are Non-SQL. Unlike SQL databases, they store data in a JSON (JavaScript Object Notation) format which looks like objects in JavaScript and dictionaries in Python. No-SQL databases provide more flexibility than SQL databases. No-SQL databases are great for gaming, social media, the Internet of Things (IoT) etc. An example of a No-SQL database and the most popular of them all is MongoDB.

Now that you've gotten your head around databases you might just be wondering which is better. The answer is actually up to you, depending on what you want to build you have to find the suitable database type for your project.

Before wrapping up this lengthy section, there are some technologies that I think are worth looking into to become a better developer and you should look them up, but again it's totally up to you:

REST API
GraphQL
Docker
Jenkins
Kubernetes
Vector Databases
Artificial Intelligence

So there you have it, a complete web-developer roadmap that is easy to read and yet completely difficult to stick to, even for myself, because every new technology out there is super exciting and tempting to dabble with. I'll be leaving you with the words of an ancient wise developer on YouTube who said "You don't have to learn every new technology out there".

I'm not saying be stagnant and not learn new stuff, 'cos that's what we signed up to do as developers, but if you find yourself having a "knowledge overload" and the whole development process becoming a burden then stop and breathe and try to find the balance, I know you will.

How to Work with Python Lists

Favour George — Sat, 15 Jul 2023 20:31:05 +0000

Lists are one of the basic data types in programming that allow programmers to represent a finite number of items. In this article, we'll discuss their importance and how to use them effectively in the Python programming language.

Table Of Content:

What are lists?
Uses of Lists
Basic Operations on Lists

Prerequisites : Knowledge of the Python programming language is crucial.

What are Lists?

In computer science, a list or sequence is an abstract data type that represents a finite number of ordered values, where the same value may occur more than once. -Wikipedia

Lists aid programmers to represent a finite number of items of the same data type together.

Uses of Lists

Storing and Organizing Data: Lists are used to store data of the same data type together as a collection. With the aid of lists, one can store items of the same type together such as strings, integers and objects.
Storing Temporary Data: Lists are useful for storing data that isn't going to be needed for future use but is essential for calculations at the moment.
Iteration over items: If the need comes to iterate over items, a list is a great way to store such items as lists are iterable.

Basic Operations on Lists

These are some of the basic operations done on lists in Python

Creating a List

Creating a list isn't as hard as one would expect.

The code below creates a list of fruits

Accessing Items in a List

To access items on a list, one has to specify the index of the item in the list. Indexes work as numbers to show the position of an item in a list, exactly as it works with lists in real life. Take the list below for example:

Apple
Banana
Cherry

The item at index 1 or number 1 is Apple. It works almost the same way in programming except that we start counting from 0 instead of 1. So referring to the same list above programmatically, the item at index 1 or number 1 is Banana while Apple is the item at index 0. Let's show that with code as seen below

Changing Items of a List

To change an item in a list, we simply access the index of the particular item we wish to change and assign it a different value as shown below:

In the code above we changed the value of the fruit at index 1 from banana to orange and this is reflected in the output below

Removing Items from a List

To remove an item from a list we use the remove() method and specify within the method the particular item we wish to remove from the list as shown below:

Adding Items to a List

To add a new item to a list, we simply use the append() method that lists have in Python and inside the method we provide the item we wish to add to the list as shown below:

It's important to note that the append method adds an item to the end of the list.

Sorting a List

We can sort lists by using the sort() method on the list we intend to sort. This method will sort the list in ascending order by default, but if we set the reverse keyword argument to True, we can sort a list in descending order as well. Let's see the code for this below:

Clearing a List

To clear a list means to wipe it of all its contents. To do this we'll use the clear() method on the list we want to clear as shown below

These are but a few operations that can be performed on Python lists. For a more comprehensive guide visit the W3School's website.