Forem: Osahenru

Using dj-rest-auth to integrate GitHub authentication in your Django project

Osahenru — Wed, 20 Nov 2024 08:33:34 +0000

This article is a simple guide on how to implement GitHub OAuth for a secure user authentication.

In this guide we will be able to

seamlessly create or login a user using their GitHub credentials
save users credentials for later use

Prerequisite

To get the best out of this article users should have a fair understanding on

We are going to implement this in 3 simple steps

1. setup GitHub
2. setup Django
3. test authentication endpoint

1. Setup GitHub

Create your GitHub OAuth credentials by going to to settings on your GitHub account, scroll down to where you see Developer settings, click on OAuth Apps as shown below.
If you have an existing app you can edit it else you can create a new one by clicking on New OAuth App and create a new one, give a clear and descriptive name for the app, add to your Homepage URL http://localhost:8000/ you might want to substitute localhost: for 127.0.0.1: if that's how you've configured your Django app to run point been that whatever configuration you setup on GitHub should match with what you have on your app to avoid server errors been thrown, add to Authorization callback URL this callback url http://localhost:8000/api/auth/github/login/callback/ your setup should reflect what you see in the image below.
Copy and save your Client ID and Client Secrets as shown below for later use on your Django project

2. Setup Django

Run pip install django-allauth dj-rest-auth requests in other to install these packages. In the settings.py file of your app add the following code block to your

SOCIALACCOUNT_PROVIDERS = {
    'github': {
        'APP': {
            'client_id': '<github_client_id>',
            'secret': '<github_secret_keys>',
            'key': ''
        }
    }
}

SITE_ID = 1

if you wish to capture the email of an authenticated users in the admin you can include this line of code to your projects settings.py file

ACCOUNT_EMAIL_REQUIRED = True

We continue to modify our settings.py file by adding the following code block

'rest_framework',
'rest_framework.authtoken',
'dj_rest_auth',

'django.contrib.sites',

'allauth',
'allauth.account',
'allauth.socialaccount',
'allauth.socialaccount.providers.github'

in the middlesware of your settings.py file include this line of code

'allauth.account.middleware.AccountMiddleware',

Lastly we modify the projects urls.py file by adding the following code block

from allauth.socialaccount.providers.github import views as github_views

path('api/auth/github/login/', github_views.oauth2_login, name='github_login'),
path('api/auth/github/login/callback/', github_views.oauth2_callback, name='github_callback'),

NB: The modification should be done in the project's urls.py file and not the app's urls.py file

3. Test authentication endpoint

All done ? visit the endpoint http://localhost:8000/api/auth/github/login/ you should be redirected to a page like this and when you click on the Continue button you should be redirected to GitHub's authorization page

Additional consideration

You notice after a successful authentication you're been redirected to http://localhost:8000/accounts/profile/ which displays a 404 error page.

To fix this we can create an endpoint /accounts/profile to your apps urls.py file and then create a relative views for that endpoint. If your endpoint and views are setup correctly then you should now see this instead of 404 error page

Difference between dj-auth-rest and social-auth-app-django

dj-auth-rest and social-auth-app-django are both libraries used to facilitate authentication in Django projects, but they cater to different needs and operate differently

dj-auth-rest is used for an API based project while social-auth-app-django is used for a web based project and both can be used on the same project

Conclusion

Integrating GitHub OAuth into your Django application provides a secure and user-friendly way for individuals to log in using their GitHub credentials.

Using this guide, you can enhance your application's security, streamline the login process, and improve the overall user experience while accessing relevant user data.

Using Canonical URLs for your next Django project

Osahenru — Sat, 17 Aug 2024 03:34:10 +0000

What is a canonical URL?

A canonical URL is the preferred version of a web page when there are multiple URLs that could lead to the same content. A canonical URL helps search engines understand which version of a web page should be considered the primary one for indexing.

The concept of canonical URLs is important for search engine optimization (SEO) which helps prevent issues with duplicate content.

When multiple URLs point to the same content, search engines might get confused and may not know which URL to prioritize in search results.

Ensuring that each page has a canonical URL improves the clarity of your website structure to search engines. It consolidates link signals for duplicate or similar content, thus enhancing the overall ranking of your website.

Example, we could have two URLs like this http://127.0.0.1:8000/note/2024/7/18/how-to-become-more-self-disciplined/ and this http://127.0.0.1:8000/note/life-style/2024/7/18/how-to-become-more-self-disciplined/ both pointing to the same content, to avoid duplicate content issues we can choose to canonicalize the former without a life-style filter tags.

Now, you might be wondering why a page will be rendering similar or nearly similar contents. Below are some highlighted reasons why a website might have duplicate contents

Language: same content(duplicate), but different languages.
URL Parameters: different URL parameters might lead to the same or similar content e.g., /products/?category=shoes&sort=price vs. /products/?sort=price&category=shoes.
Paginated Content: Content split across multiple pages e.g., /articles/page/2, which might appear as duplicate content.

Canonical tag

Canonical tag guides search engines in managing and prioritizing content this helps you define your primary page in search engines which in turn affects how performance metrics are tracked and analyzed.

A canonical tag is found in the head section of an HTML page

<head>
<link rel="canonical" href="..." />
</head>

Now let’s see how we can use a canonical URL in a Django project

Writing canonical URLs in Django

Django allows you to implement the get_absolute_url() on a model class to return a canonical URL for that object

You can use the get_absolute_url() method on Django models to generate a canonical URL for objects. This method typically returns the absolute URL for a model instance, which can be used as the canonical URL. In the models.py file we can implement the get_absolute_url() method there

class Article(models.Model):
    title = models.CharField(max_length=100)
    slug = models.SlugField()
    …
    publish = models.DateTimeField(default=datetime.now)

    def get_absolute_url(self):
        return reverse('note:detailed_note',
                       args=[self.publish.year,
                             self.publish.month,
                             self.publish.day,
                             self.slug ])

and then implement this in the views by passing in the necessary arguments.

def single_note(request, year, month, day, slug):
    note = get_object_or_404(Note,
                             publish__year=year,
                             publish__month=month,
                             publish__day=day,
                             slug=slug)

and lastly represent a canonical url in the template as shown

{% block head %} <link rel="canonical" href="{{ note.get_absolute_url }}"> {% endblock %}

Summary

In summary, canonical URLs in Django are a best practice for managing how your content is indexed by search engines, preventing duplicate content issues, and ensuring that your website is optimized by search engines.

Enhancing your Python code with decorators

Osahenru — Mon, 03 Jun 2024 14:40:08 +0000

Introduction

In this article, you'll learn about decorators in Python: how they work, why they are useful, and when to use them. We'll also explore some common decorators and their use cases.

While I aim to explain concepts from a beginner's perspective, this article is not tailored for absolute beginners. A fundamental understanding of OOP in Python is required to fully benefit from this article. With that in mind, let's dive in.

In Python and most programming languages, a decorator is a tool that allows you to modify the behavior of a function or method without changing it’s main behavior.

They help add more functionality before a function is called or after it has been called. Decorators give you the ability to modify the behavior of functions without altering their main implementation.

Creating Decorators

A decorator in Python is a function that:

Accepts another function as an argument,
Defines a new function inside itself,
Returns that new function. This is the basic template for creating decorators in Python.

For example, if we want to create a simple decorator function that multiplies the return value of any function by 10, we can do it like this:

def mul_by_ten_decorator(func):

    def wrapper_function():
        return func() * 10

    return wrapper_function


# target function
def demo():
    return 2


result =  mul_by_ten_decorator(demo)
print(result())

john@doe:~/Desktop$ python3 main.py
output: 20

Notes📝

We have the mul_by_ten_decorator that takes a function as an argument. Inside, the wrapper_function calls func() (i.e., the passed function) and multiplies the result by 10.

Moving to the demo function, which we use to test our decorator, it simply returns 2. The mul_by_ten_decorator wraps the demo function, so when demo is passed as an argument, the decorator multiplies its return value by 10. Calling result() is equivalent to calling wrapper_function(), which returns 20. This value is then printed to the screen when we run the code from the terminal.

We can further simplify our code by introducing the @ symbol

Introducing `@` symbol in decorators

def mul_by_ten_decorator(func):

    def wrapper_function():
        return func() * 10

    return wrapper_function

# target function
@mul_by_ten_decorator
def demo():
    return 2


result = demo()
print(result)

john@doe:~/Desktop$ python3 main.py
output: 20

Notes📝

When we introduce the decorator symbol @, we can wrap our target function with our decorator function, making our code more encapsulated. By simply calling the demo() function, it is similar to calling the wrapper_function(), which internally calls func() (the demo function). The demo function returns 2, which is then multiplied by 10. The wrapper_function returns 20, which is assigned to result and printed out.

Passing Arguments to Wrapper Functions

Sometimes, functions can take multiple arguments. If we modify our demo function to take two arguments, a and b, and return their product multiplied by 2, it would look like this:

def mul_by_ten_decorator(func):

    def wrapper_function():
        return func() * 10

    return wrapper_function


@mul_by_ten_decorator
def demo(a, b):
    return 2 * (a * b)


result = demo(4, 5)
print(result)

When we run our code, we encounter a type error.

john@doe:~/Desktop$ python3 demo.py
TypeError: mul_by_ten.<locals>.wrapper() takes 0 positional arguments but 2 were given

The error message implies that the wrapper_function is also expecting a number of arguments. We can modify our wrapper_function as follows:

def wrapper_function(a, b):
   return func(a, b) * 10

so the entire code block can further be modified like this

def mul_by_ten_decorator(func):

    def wrapper_function(a, b):
        return func(a, b) * 10

    return wrapper_function


# target function
@mul_by_ten_decorator
def demo(a, b):
    return 2 * (a * b)


result = demo(4, 5)
print(result)

john@doe:~/Desktop$ python3 main.py
output: 400

Notes📝

Calling demo() is the same as calling the wrapper_function(), which in turn calls func(). Therefore, we must ensure these functions accept the same number of arguments.

What if we want to add 20 numbers using this same decorator? Do we need to pass 20 arguments to both the target function and the wrapper function? We cannot always define the number of arguments for both functions explicitly. Instead, we can use Python's *args and **kwargs keywords.

The *args keyword allows us to pass a variable number of positional arguments to the function, while **kwargs allows us to pass a variable number of keyword arguments.

We can make our code block more Pythonic by introducing these keywords.

def mul_by_ten_decorator(func):

    def wrapper_function(*args, **kwargs):
        return func(*args, **kwargs) * 10

    return wrapper_function


# target function
@mul_by_ten_decorator
def demo(a, b):
    return 2 * (a * b)


result = demo(4, 5)
print(result)

Notes📝

Now, our target function takes in two arguments, while our wrapper function accepts an arbitrary number of arguments.

With a good understanding of how to use decorator functions, we can proceed to explore some use cases and the importance of using decorator functions.

Use Case of Decorators in Python

Let's examine some real-world examples where using a decorator comes in handy.

Logging

It is often helpful to have logs of which functions are executed, along with relevant information. A logger is useful when you're trying to debug your code.

Here is a simple example of how to create a logger using Python's built-in logging package. The information about the script is saved to a file named test.log:

import logging

def function_logger(func):
    logging.basicConfig(level=logging.INFO, filename='test.log')
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        logging.info(f'{func.__name__} ran with positional arguments: {args} and keyword arguments: {kwargs}. Return value: {result}')

        return result
    return wrapper


# target function
@function_logger
def addition(a, b):
    return (a + b)


print(addition(2, 5))

john@doe:~/Desktop$ python3 demo.py
output: 7

When you first run this code, a test.log file is created, which looks like this.

INFO:root:addition ran with positional arguments: (2, 5) and keyword arguments: {}. Return value: 7

To see different log messages, we can change the values of the arguments passed, for example, (11, 12)*.

INFO:root:addition ran with positional arguments: (2, 5) and keyword arguments: {}. Return value: 7
INFO:root:addition ran with positional arguments: (11, 12) and keyword arguments: {}. Return value: 23

Notes📝

You can see our repeated template for creating a decorator:

The decorator takes a function as an argument. ✅

The wrapper function calls and returns a function. ✅

We import Python’s logging module with import logging, which includes a BasicConfig method that sets up the logging configuration. We pass the logging level, which can be logging.INFO, logging.DEBUG, or logging.ERROR.

Once we wrap this logger decorator around a function, we can get information about the function, including the arguments passed and the returned value. This can be a very useful tool for debugging and error tracking.

For more about logging in Python, checkout the official documentation https://docs.python.org/3/howto/logging.html

Caching

Caching is another use case where the knowledge of decorators comes in very handy. Caching is a technique used to store the results of expensive functions that take the same arguments and return the same value each time they are called. Instead of always recalculating the results, we can cache the process. This approach ensures that too many resources aren’t used up on such expensive functions.

To implement a caching function in Python, we use the @lru_cache decorator from functools.

Notes📝

LRU stands for Least Recently Used. The LRU function has a default maximum size of 128, which is the maximum number of calls to cache. Once this limit is reached, older results are discarded to make space for new ones.

The Fibonacci sequence is a great example to illustrate the concept of caching because it depicts a recursive function, where calculating a Fibonacci sequence recalculates the same values multiple times.

from functools import lru_cache

@lru_cache(maxsize=120)
def fibonacci(n):
  if n < 2:
     return n
  return fibonacci(n-1) + fibonacci(n-2)


result = fibonacci(10)
print(result)

john@doe:~/Desktop$ python3 demo.py
output: 55

Notes📝

We use the lru_cache decorator from functools. When we call fibonacci(10), it recursively calls fibonacci(9), fibonacci(8), fibonacci(7), and so on until it reaches 1 or 0, ultimately outputting 55 to the screen. If n is less than 1, it returns n; otherwise, it returns the sum of the function called with n-1 and n-2.

When we call fibonacci(30) for the first time, it stops calling the Fibonacci function when it reaches 10, since we’ve previously run fibonacci(10). Similarly, when we run fibonacci(60) for the first time, it stops calling the Fibonacci function at 30 since we’ve previously run fibonacci(30).

Therefore, a cached fibonacci() function will execute faster compared to one that isn’t cached. We can write a script to demonstrate the time difference between a cached function and one that isn't cached.

import time
from functools import lru_cache

# Fibonacci function without caching
def fibonacci_no_cache(n):
   if n < 2:
       return n
   return fibonacci_no_cache(n-1) + fibonacci_no_cache(n-2)

# Fibonacci function with caching
@lru_cache(maxsize=None)  # Use LRU cache with unlimited size
def fibonacci_with_cache(n):
   if n < 2:
       return n
   return fibonacci_with_cache(n-1) + fibonacci_with_cache(n-2)

# Calculate Fibonacci(30) without caching and measure the time
start_time = time.time()
fibonacci_no_cache(10)
no_cache_time = time.time() - start_time

# Calculate Fibonacci(30) with caching and measure the time
start_time = time.time()
fibonacci_with_cache(10)
with_cache_time = time.time() - start_time

print(f"Time without cache: {no_cache_time}")
print(f"Time with cache: {with_cache_time}")

john@doe:~/Desktop$ python3 main.py
Time without cache: 3.886222839355469e-05
Time with cache: 2.2172927856445312e-05

Notes📝

We see the differences in time it takes to run a cached function and one that isn't: cached 0.0000221729, not cached 0.0000388622. You can see we reduce the time by almost half.

Caching is particularly effective for recursive functions like Fibonacci, where the same inputs are used repeatedly. It saves time by avoiding redundant calculations, especially for large or frequently accessed values.

Now that we've explored some use cases where knowledge of decorators in Python can be very handy, let's further look at some of the built-in decorators that come with Python.

Python Decorators

Properties

Properties are built-in Python functions for managing methods of a class. They allow you to define methods that get and set the values of attributes, providing a way to enforce rules and validation when accessing or modifying these attributes. Properties are typically used to encapsulate private attributes and control access to them.

Let's see an example of how properties work in a class method:

class Circle:
    def __init__(self, radius):
        self.radius = radius

    @property
    def diameter(self):

        return 2 * self.radius

circle = Circle(4)
print(circle.diameter)

john@doe:~/Desktop$ python3 main.py
Output: 8

We can access the diameter method as an attribute, instead of calling the function with circle.diameter(), thanks to the @property decorator.

The beauty of having property decorators is how they make our code more concise. We can choose to make our diameter method stricter by ensuring the radius doesn’t take numbers less than or equal to zero, like this:

class Circle:
    def __init__(self, radius):
        self.radius = radius

    @property
    def diameter(self):
        if self. radius <= 0:
            raise ValueError('Only positive numbers')
        return 2 * self.radius

circle = Circle(-3)
print(circle.diameter)

when we run the code, a value error is raised as shown below

john@doe:~/Desktop$ python3 main.py
    raise ValueError('Only positive numbers')
ValueError: Only positive numbers

Setters and Getters

A getter method is responsible for retrieving the current value of a property, decorated with the @property decorator, while a setter method is responsible for setting the value of a property. The setter method is called when the property is assigned a new value.

One major flaw in how we've implemented validation above is that if we have other methods that rely on the radius being positive, this current approach might not handle invalid values properly. This can lead to subtle bugs or crashes. For example, consider a circumference method:

@property
def circumference(self):
    return 2 * 3.14159 * self.radius

The circumference property does not currently validate whether the radius is a positive number or not. It would be redundant to validate the radius within the circumference method. Instead, we can introduce setter and getter properties for our radius.

class Circle:
    def __init__(self, radius):
        self.radius = radius

    @property
    def radius(self):
        return self._radius


    @radius.setter
    def radius(self, value):
        if value <= 0:
            raise ValueError('Positive numbers only')
        self._radius = value


    @property
    def diameter(self):
        return 2 * self.radius


    @property
    def circumference(self):
        return 2 * 3.14159 * self.radius


circle = Circle(10)
print(f'Diameter: {circle.diameter}')
print(f'Circumference: {circle.circumference}')

john@doe:~/Desktop$ python3 main.py
Diameter: 20
Circumference: 62.8318

Notes📝

Our getter method retrieves the current value of the radius and returns it, while our setter method decorator checks the validity of the value. If the value is valid, it is assigned to the radius self._radius.

Notice that in our getter and setter methods, we use _radius to avoid the function calling itself repeatedly.

Deleters

The deleter function in a Python property decorator is used to define the behavior when an attribute is deleted using the del statement. Like the getter and setter functions, it allows you to control access to an attribute, but specifically handles what happens when you delete the attribute.

Returning to our circle class, let’s include a deleter property that defines how the class should behave when a radius in a circle object is deleted.

class Circle:
    def __init__(self, radius):
        self.radius = radius

    @property
    def radius(self):
        return self._radius


    @radius.setter
    def radius(self, value):
        if value <= 0:
            raise ValueError('Positive numbers only')
        self._radius = value


    @radius.deleter
    def radius(self):
        print('Radius deleted')
        del self._radius


    @property
    def diameter(self):
        return 2 * self.radius


    @property
    def circumference(self):
        return 2 * 3.14159 * self.radius


circle = Circle(10)
print(f'Diameter: {circle.diameter}')
print(f'Circumference: {circle.circumference}')
del circle.radius

john@doe:~/Desktop$ python3 main.py
Diameter: 20
Circumference: 62.8318
Radius deleted

Class method (@classmethod)

A class method is a method that is bound to the class rather than the instance of the class. It takes the class itself as its first argument (cls) instead of the instance (self). This allows the method to access and modify class state that applies across all instances of the class. A class method can be called by both the class and its instances.

Let's see how to use a class method in a class by modeling a Person:

from datetime import datetime

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def birth_year(cls, name, year):
        return cls(name, datetime.today().year - year)

    def __str__(self):
        return f'Name: {self.name}, Year: {self.age}'

person = Person.birth_year('Doe', 34)
print(person)

john@doe:~/Desktop$ python3 main.py
Name: Doe, Year: 1990

Notes📝

Notice that we can call the birth_year() method directly on the class without creating a Person instance, e.g., person = Person('Doe', 34).

Let's take a look at another example that explains the use of @classmethod in a code block.

Assuming we have an employee record, we can use a class method to retrieve individual employee records based on the PRIMARY KEY passed.

import sqlite3

class Employee:
    def __init__(self, id, name, salary):
        self.id = id
        self.name = name
        self.salary = salary

    @classmethod
    def from_database(cls, id):

        conn = sqlite3.connect('employees.db')
        cursor = conn.cursor()
        cursor.execute('SELECT name, salary FROM employees WHERE id=?', (id,))
        row = cursor.fetchone()
        conn.close()

        if row:
            name, salary = row
            return cls(id, name, salary)
        else:
            raise ValueError('Employees not found')

    def __str__(self):
        return f'{self.id} {self.name} {self.salary}'

employee_1 = Employee.from_database(3)
print(employee_1)

But before we run this code, let's create a database.py file that will set up our database of employees.

import sqlite3

conn = sqlite3.connect('employees.db')

cursor = conn.cursor()

cursor.execute('''CREATE TABLE IF NOT EXISTS employees
               (id INTEGER PRIMARY KEY, name TEXT, salary REAL)''')

cursor.execute("INSERT INTO employees (id, name, salary) VALUES (1, 'Ohemaa', 10000)")
cursor.execute("INSERT INTO employees (id, name, salary) VALUES (2, 'Nana', 3000)")
cursor.execute("INSERT INTO employees (id, name, salary) VALUES (3, 'Kofi', 15000)")

conn.commit()

cursor.execute("SELECT * FROM employees")
rows = cursor.fetchall()
for row in rows:
    print(row)

cursor.close()
conn.close()

When we run database.py for the first time it creates an employee.db file as shown below

john@doe:~/Desktop$ python3 database.py
(1, 'Ohemaa', 10000.0)
(2, 'Nana', 3000.0)
(3, 'Kofi', 15000.0)

Now, when we run our main.py file we can get the individual associated to the PRIMARY_KEY passed

john@doe:~/Desktop$ python3 database.py
3 Kofi 15000.0

Notes📝

In the classmethod in our main.py file,

   conn = sqlite3.connect("employees.db")
       cursor = conn.cursor()
       cursor.execute("SELECT name, salary FROM employees WHERE id=?", (id,))
       row = cursor.fetchone()
       conn.close()

We establish and close the connection with our employees.db and then unpack the values of the row into name and salary. This allows us to use a classmethod without creating an employee instance to access an employee record. If we were to implement this using an instance method, it would require us to create an empty employee object first, like employee = Employee(0, '', ''), before fetching the record, which might seem a bit too complex.

Static method (@staticmethod)

In a static method, you don’t need to pass an explicit first argument like cls in a classmethod or self in an instance method. A static method is also bound to a class and somewhat behaves like a class method. The major differences are:

A static method doesn’t take an instance of the class as its first argument, unlike a classmethod or instance method.
A static method cannot modify the state of the class.
It is primarily used as a utility function that does not depend on the state of the class or its instances.
A static method is defined using the @staticmethod decorator.

A staticmethod is most suitable in scenarios where you need to perform a function on a class without keeping a record of the instances of the class, as shown below:

class Calculator:
    @staticmethod
    def add(a,b):
        return a + b

    @staticmethod
    def multiply(a, b):
        return a * b

print(f'Addition: {Calculator.add(11, 15)}')
print(f'Multiply: {Calculator.multiply(18, 15)}')
print()
# you can also create a calculator instance
results = Calculator()
print(f'Addition: {results.add(21, 13)}')
print(f'Multiply: {results.multiply(20, 10)}')

john@doe:~/Desktop$ python3 main.py
Addition: 26
Multiply: 270

Addition: 34
Multiply: 200

You notice we do not need to rely on a class instance to use a static method.

Let's take a look at another example that calculates the average salary of employees in a company.

class Company:

    @staticmethod
    def average_salary(employees):
        result = sum(employees.values())/ len(employees)
        return int(result)

data = {
    "Alice": 50000,
    "Bob": 60000,
    "Charlie": 70000
    }

print(f'Average salary: {Company.average_salary(data)}')

john@doe:~/Desktop$ python3 main.py
Average salary: 60000

You see that the staticmethod doesn’t need to know or modify anything in the class other than having access to the class name.

In summary, static methods are within a class and do not need access to the class (no self or cls keyword). They cannot change or look at any object attributes or call other methods within the class. Static methods are mostly suitable as helper or utility functions that are relevant to the class but do not need to access or modify class or instance data.

Abstract method (@abstractmethod)

Lastly, let’s take a look at abstractmethod in Python.

An abstract class acts as an interface for other subclasses, serving as a blueprint and forcing all subclasses to implement all of its abstract methods. An abstract base class cannot be instantiated directly.

Python does not provide abstract classes natively, but rather comes with a module that provides the base for defining Abstract Base Classes (ABC).

You use an @abstractmethod when all children of a subclass are required to have the same method as the inherited abstract class. Like the example below

from abc import ABC, abstractmethod

class Employee(ABC):
    @abstractmethod
    def calculate_salary(self):
        pass

class FullTimeEmployee(Employee):
    def calculate_salary(self):
        return "Calculating salary for full-time employee"

class PartTimeEmployee(Employee):
    def calculate_salary(self):
        return "Calculating salary for part-time employee"

class ContractEmployee(Employee):
    def calculate_salary(self):
        return "Calculating salary for contract employee"

Notes📝

Employee(ABC) defines an abstract class, which cannot be instantiated. If a class inherits from an abstract class, it must implement all the abstract methods defined in the parent abstract class. Otherwise, it will also be considered an abstract class and cannot be instantiated.

Abstract property

Just like with abstractmethod, an abstract property must also be implemented in any subclass. This allows you to specify that a subclass must include a property with a getter (and optionally a setter) method.

from abc import ABC, abstractmethod

class Employee(ABC):
    @property
    @abstractmethod
    def salary(self):
        """The salary property must be implemented by all subclasses"""
        pass

class FullTimeEmployee(Employee):
    def __init__(self, base_salary):
        self.base_salary = base_salary

    @property
    def salary(self):
        return self.base_salary

class PartTimeEmployee(Employee):
    def __init__(self, hourly_rate, hours_worked):
        self.hourly_rate = hourly_rate
        self.hours_worked = hours_worked

    @property
    def salary(self):
        return self.hourly_rate * self.hours_worked

# Example usage
full_time = FullTimeEmployee(50000)
part_time = PartTimeEmployee(20, 1000)

print(f'Full_time Salary: {full_time.salary}') 
print(f'Part_time Salary: {part_time.salary}')

Notes📝

Every child class (FullTimeEmployee and PartTimeEmployee) has the salary property, although with different implementations. One takes in one argument and the other takes two. When we run the code, we get the following output:

john@doe:~/Desktop$ python3 main.py
Full_time Salary: 50000
Part_time Salary: 20000

FullTimeEmployee and PartTimeEmployee are concrete subclasses that provide specific implementations for the salary property. The salary methods in both subclasses are concrete methods. Concrete methods are methods that have a complete implementation within a class. They contain actual code that defines what the method does, as opposed to abstract methods, which only declare the method's signature without providing an implementation.

Conclusion

An understanding of decorators can help you write cleaner, more maintainable, and reusable code. Decorators are a flexible and readable way to modify the behavior of functions and methods. They are useful for a variety of tasks such as logging, authorization, and caching.

Regex pattern in Python: A beginners guide

Osahenru — Fri, 26 Apr 2024 13:26:34 +0000

Regular expression (regex) is a sequence of characters that define a search pattern, usually used for text search, text manipulation, and input validation

In this tutorial we are going to see how to validate, clean and extract users data, using code examples to explain the concepts of regular expressions in Python.

At the end of this tutorial, I hope you'll be more confident in using regex in your next project or have a better understanding when you encounter it in a codebase.

^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$

Insight💡: The regex pattern above is used to validate an email address. I know it looks really cryptic, but as we look at examples, you will begin to have a more in-depth understanding.

Let's start by updating our vocabulary with some common metacharacters used in regex.

.   any character except a new line
*   0 or more repetitions
+   1 or more repetitions
?   0 or 1 repetition
{m} m repetitions
{m,n} m-n repetitions
^   matches the start of the string
$   matches the end of the string or just before the newline at the end of the string
\ Used to drop the special meaning of character following it
| Means OR (A|B) A or B
(...)   a group
(?:...) non-capturing version
[]    set of characters
[^]   complementing the set

Now, let's write some code to better understand the regex syntax above, as we will be revisiting this code block frequently.

VALIDATING USERS DATA

Example 1: IP address validator:

Ideally, an IP address should consist of four sets of numbers separated by periods, with each set ranging from 0 to 255 and typically represented with at most three digits (e.g., 192.168.1.1). Each set is called an octet, represented in decimal form. That said, let's see how we can pattern a user's IPv4 address.

import re

def main():
    print(validate(input("IPv4 Address: ")))


def validate(ip):
    matches = re.search(r"^(\d{1,3}\.){3}\d{1,3}$", ip)

    if not matches:
        return False
    return True

if __name__ == "__main__":
    main()

Now, let’s break down this pattern to understand what each syntax does

^ -matches the beginning of the string
\d -numbers only, i.e a letter will return False
{1, 3} -do something either once or 3 times i.e the number can be one - three digits, i.e 0 - 999
\. -a literal dot(.), if we do not use the backslash the re.search function will interpret . as any character except a new line
(\d{1,3}\.) -a group of pattern
{3} -do something 3 times, so we want to do whatever is in the group parenthesis (\d{1,3}\.) 3 times which will match something like this 192.168.1.
\d -digits
{1, 3} -do something either once or 3 times
$ -matches the end of the string or just before the newline

Our code above checks if a user's IP address has four sets of octet numbers. However, it does not check if each octet number is between 0 and 255. Therefore, an IP address like 1.300.600.5 will return True instead of False. To fix this, we can include some extra logic. Modify the code as follows

Example 2: IP address validator:

import re

def main():
    print(validate(input("IPv4 Address: ")))

def validate(ip):
    matches = re.search(r"^(\d{1,3}\.){3}\d{1,3}$", ip)

    if not matches:
        return False

    ip_list = list(map(int, matches.group(0).split(".")))

    for number in ip_list:
        if 0 <= number <= 255:
            return True
        return False


if __name__ == "__main__":
    main()

Let’s update our regex vocabulary to see how we can improve our existing code base

\d    decimal digit
\D    not a decimal digit
\s    whitespace characters
\S    not a whitespace character
\w    word character, as well as numbers and the underscore
\W    not a word character
\b word bound, matches if a word matches the beginning and end of a word

Now, let's see how we might be able to use regex to extract data from a user's input

EXTRACTING DATA

Assuming we have a Facebook URL https://www.facebook.com/johndoe and we want to extract just the username, how might we go about this using our bank of rich regex vocabulary? We can think of various ways to implement this. One straightforward approach is to introduce the use of the re.sub() function.

The re.sub() function in Python is used for replacing substrings that match a specified pattern with a replacement string. It takes three main arguments: re.sub(pattern, replacement, string).

Example 3: Username extractor:

import re


text = 'https://www.facebook.com/johndoe'
matches = re.sub('https://www.facebook.com/', '', text)
print(matches)

Note: This code assumes that every Facebook URL begins with https://www., but you can take it up as a challenge to pattern URLs that begin with http://www. or just www.

I hope at this point it's all beginning to make sense. If not, let's cover some more examples.

CLEANING DATA

Sometimes, phone books append special characters and whitespaces to a phone number. How about we write a pattern to clean the data of a user’s phone number? Let's revisit our rich metacharacter vocabulary.

Assuming we want to get rid of the (+233) and replace it with a 0, how might we go about it? Well, let's take a look at the example below

Example 4: Phone number book:

import re


phone_number = '(+233) 546 07890'
matches = re.sub(r'\(\+233\)', '0', phone_number)

print(matches)

Output: 0 546 07890

We can further improve this code by removing the whitespaces, again, by using the re.sub() function

Example 5: Phone number book

import re

phone_number = '(+233) 546 07890'
matches = re.sub(r'\(\+233\)', '0', phone_number)

rematched_pattern = re.sub(' ', '', matches)
print(rematched_pattern)

Output: 054607890

MORE REGEX FUNCTION

The re.fullmatch() function in regex checks whether the entire string satisfies the pattern. It returns a match object if there is a match and None otherwise. This means that you have to pattern the entire string for the re.fullmatch() function to return a match object; otherwise, it returns None. This is unlike the re.search() function, which looks for the pattern anywhere in the string. Consider the example below:

Example 6 with fullmatch:

import re
text = '123abcd' 
matches = re.fullmatch(r'\d+', text)

print(matches)

When you run this program, you'll notice that the re.fullmatch() function returns None because we only tried to match the digits part of the string with r'\d+'. Now, let's write the same pattern, but using the re.search() function.

Example 7 with search():

import re

text = '123abcd' 
matches = re.search(r'\d+', text)

print(matches)

Output: <re.Match object; span=(0, 3), match='123'>

While the re.fullmatch() function returns None, the re.search() function returns a match object. This illustrates that using the re.fullmatch() function would have been a simpler approach for our IP address example above, as we are mapping an entire string of data.

re.fullmatch() vs. re.match()

The main difference is that re.fullmatch() searches the entire string (from beginning to end) for a pattern, whereas re.match() only searches the beginning for a match. It returns a match object if a match is found, otherwise None.

When to Use fullmatch(), match(), or search()

re.fullmatch(): Use when you want to ensure the entire string matches a pattern. For example, to validate a string against a specific format, such as checking if a string is a valid date or a sequence of digits.
re.match(): Use when you want to find a match only at the beginning of a string. For example, to validate user input, such as checking if a string starts with a specific prefix.
re.search(): Use when you want to find a match anywhere in a string. For example, to check if a string contains a specific pattern, such as a certain word or sequence of characters.

In general, if you are unsure which function to use, re.search() is often a good choice because it is more flexible and can be used to find patterns anywhere in the string. On a surface level, one could argue that re.match() and re.fullmatch() are just shortcuts, as re.search() can perform the functions of both re.match() and re.fullmatch().

COMMON FLAGS

To optimize the functionality of a regex function, you can include flags. We will discuss three common flags used in regex.

re.IGNORECASE(re.I)

This flag ignores case sensitivity in a pattern, allowing uppercase and lowercase letters to be matched interchangeably.

Example 8: without the re.IGNORECASE flag:

import re

text = '123ABCDabcd'
matches = re.search(r'[A-Z]+', text)

print(matches)

The above code prints out a match object <re.Match object; span=(3, 7), match='ABCD'>, omitting lowercase characters. Let's consider another version of the same code where we use the re.IGNORECASE flag and observe the output.

Example 9: with the re.IGNORECASE flag:

import re

text = '123ABCDabcd'

matches = re.search(r'[A-Z]+', text, re.IGNORECASE)
print(matches)

Notice that with the re.IGNORECASE flag, we have a different printout <re.Match object; span=(3, 11), match='ABCDabcd'>, which includes all characters (due to case-insensitivity).

re.MULTILINE (re.M)

This flag allows ^ (caret) and $ (dollar) to match the pattern at the beginning of the string and at the beginning of each newline (\n). It also allows them to match the pattern at the end of the string and at the end of each newline (\n).

Example 10 without the re.MULTILINE flag:

import re

target_str = "Joy lucky number is 75\nTom lucky number is 25"

result = re.findall(r"^\w{3}", target_str)
print(result)

Output: ['Joy']

The code above ignores every third word after a newline (\n). With a modified version like this...

Example 11 with the re.MULTILINE flag:

import re

target_str = "Joy lucky number is 75\nTom lucky number is 25"

result = re.findall(r"^\w{3}", target_str, re.MULTILINE)
print(result)
Output: ['Joy', 'Tom']

we can ignore the new line character and print out every 3 word.

re.DOTALL (re.S)

By default, the . inside a regular expression pattern represents any character (a letter, digit, symbol, or punctuation mark), except the newline character (\n). However, this behavior can be altered using the re.DOTALL flag.

Example 12 without the re.DOTALL flags:

import re

target_str = """ML 
and AI"""
result = re.search(r".+", target_str)
print(result)

Output: <re.Match object; span=(0, 3), match='ML '>

Example 13 with the re.DOTALL flag:

import re

target_str = """ML 
and AI"""

result = re.search(r".+", target_str, re.DOTALL)
print(result)
<re.Match object; span=(0, 10), match='ML \nand AI'>

you can see it included the nextline character to the match object

CONCLUSION

The key to writing a good regex pattern is to visually model the pattern based on the data given and tweak it as you progress, rather than relying solely on memory. Remember to test your pattern against a variety of inputs to ensure it behaves as expected. Please leave a comment below if any questions or for further clarifications. Happy coding!

Getting Started with Python's map() Function: A Beginner's Guide

Osahenru — Tue, 26 Mar 2024 00:31:26 +0000

In Python, a map() refers to the process of applying a function to each item in an iterable (like a list, tuple, or dictionary) and returning a new iterable with the results. map() function takes two arguments: a function and an iterable. The function is applied to each item in the iterable, and the results are returned as a new iterable. These terminologies might sound a bit unfamiliar so let’s explain with some examples

syntax:

map(function, iterables)

Assuming we have a string “1/2" from a user’s input and we want to perform an arithmetic operation on this string, how might we go about that, well lets list out the steps

Traditional approach
Step 1
Split the fraction, using the split() method and “/” as it’s delimiter

“1/2".split(“/”)

Step 2
The split function returns a list of two values(strings) which we can assign to an unpacked variable a and b

a, b = “1/2".split(“/”)

Step 3
Convert a and b to an int

a = int(a)
b = int(b)

Step 4
Finally we perform our arithmetic operation with

answer = a / b
print(answer)

Putting everything together we have 5 lines of code

a, b = "1/2".split("/")
a = int(a)
b = int(b)
fraction = a / b
print(fraction)

Output: 0.5

Using map() function
Now, lets see how we can use the map function to achieve same result but with fewer lines of code
Step 1
Split the fraction, using the split() method “/” as it’s delimiter

“1/2".split(“/”)

Step 2
The split function returns a list of two values(strings) which we can assign to an unpack value

a, b = “1/2".split(“/”)

Step 3
Use the map() function to convert the return values of the split() to an int

a, b = map(int, “1/2".split(“/”))

Step 4
Finally we perform our arithmetic operation with

answer = a / b

Putting all together we have 3 lines of code as to 5 lines of code from the traditional method

a, b = map(int, "1/2".split("/"))
answer = a / b
print(answer)

Output:0.5

Note that the split() function returns a list of strings [“1”, “2”] and key word int is a python function which is applied to each item in the list and these values are unpacked and assigned to the variable a and b

Map() and Lambda, What is a Lambda function ?
A lambda function is an anonymous function defined using the lambda keyword. It is a small, inline function that can have any number of arguments but can only have one expression.

Syntax:

lambda arguments: expression

Example
Assuming we need a function that adds two numbers together, let us see how we can achieve this using both the traditional way and the lambda function
Traditional way

def add(a,b):
    result = a + b
    return result

and to call this function in the main function will be like this

print(add(4,3))

Output:7
Using a lambda function

add = lambda a,b: a + b

and we call the function in the main function, same way

print(add(6,9)

Output: 15

As seen from the example above a lambda function can take any number of arguments

Now lets see an example as to how we can use both a map() and lambda function

assuming we want a function that returns a list but the first character of each word of this list is being capitalized, say we want to convert a list like this [“serah”, “hakim”, “adam”, “kwame”] to this [“Serah”, “Hakim”, “Adam”, “Kwame”]

Traditional approach

def title_each_word(word_list):
   new_word = []
   for word in word_list:
       new_word.append(word.title())

   return new_word

print(title_each_word(["serah", "simi", "nana"]))

Output: [“Serah”, “Hakim”, “Adam”, “Kwame”]

Using lambda and map() function

word = ["serah", "hakim", "adam", "kwame"]
new_word = map(lambda word: word.title(), word)

print(list(new_word))

Output: [“Serah”, “Hakim”, “Adam”, “Kwame”]
You can see how concise the map and lambda function have made our code look like, now when does one use a lambda function or a map function

`map()`	`lambda`
It is used when you want to apply a single transformation function to all the iterable elements and return an iterator	A quick function you can just use and throw away without a name or sort

Conclusion
Just like any concepts, with regular practice these Python features will become second nature if you keep at it as familiarizing yourself with them will ensure you adhere strictly to the DRY principles

Devin: A Tool, Not a Substitute for Your Job

Osahenru — Mon, 18 Mar 2024 11:28:58 +0000

In the past couple of weeks, there's been a lot of talk about AI replacing software engineers as speculated from known figures. While I find these statements laughable, it's also important to address these concerns here just as I did via email to a thriving community of aspiring Python developers who are worried about the future. Since this platform remains a haven for aspiring tech enthusiasts, I believe it's also important to drop my 2 cents here.

While a lot of work and resources are being put into programs that ensure the tech industry is more inclusive in offering more accessible pathways to becoming a software engineers, I find it distasteful that the marketing campaign strategy of an emerging company is in the dismissal of an entire industry, goes to tell a lot about the company. Well, in plain and simple text AI is in no way replacing software engineers anytime, AI tools like Devin are nothing but tools, the choice to use it or not to rely solely on several decisions.

AI is still arguably a decade away from having anything revolutionary, folks like Jensen Huang who hasn’t written a single line of code in recent years sometimes use these buzzwords to either attract more investments or maybe truly some actually do lack the understanding of how these tools operate, anyone who has built anything substantial knows that feeding an AI tool like Devin with vital information about your application is a call for disaster.

While I think Devin is a fantastic tool and if built correctly will impact the way software engineers work, I find their marketing mantra quite sh!tty, Devin like every other software tool is to optimize the performance of developers just like Xcode or Pycharm, Copilot...; I can choose to build an app using notepad ++ (a dumb idea tho 😂 ) instead of VS code, the emphasis is that these are just merely tools which developers can familiarize with when you have solidified an understanding on the fundamentals of your desired tech stack.

A simple search about Devin reveals two important things: One, Devin is built on GPT4, If you frequently use these tools you would have noticed that even the best of them hallucinate, these companies just show the working demos when in reality it’s a war dealing with these hallucinations from these tools. Two, Isn’t it quite ironic that Devin is in their recruitment for the positions of software engineer which is laughable, I mean if you’ve built a tool to replace software engineers why are there still openings for those job roles?

Lastly, while I think AI tools are the new cool and here to stay and not to replace the job of a software engineer, if there’s going to be any replacement it'll be the boring and mundane things of being a software engineer and not your job, again learn the very fundamental and basics of your tech stack and then proceed to learning these tools, block out all the noise and focus on building your career.

SO to everyone building something worthwhile making humanity better through inclusivity. And to every aspiring tech enthusiast, keep learning and building! ❤️

Photo credit: rawpixel on freepik

Building a basic Python todo app and pushing on GitHub

Osahenru — Sun, 21 May 2023 21:54:35 +0000

Hello guys,
to conclude what we have been on for a couple of days now, here is a blog post I have prepared for you that you can always reflect back on, you can check out the whole code on github [here].

In this article we will:

Complete the todo app we started by adding a users class to it and then push to GitHub
Go through basic git commands

here is a snippet of the previous code

class Task():
    def __init__(self, title):
        self.name = title
        self.description = ""
        self.is_completed = False

to extend the code to accommodate a user, we will create a User class and initialize with a name for each instance of the User object

class User():
    def __init__(self, name):
        self.name = name
        self.tasks = []

we want to also add more functionality to the app by allowing a user to be able to add tasks, delete tasks and view task
so an updated main.py file will look like this

class User():
    def __init__(self, name):
        self.name = name
        self.tasks = []


    def add_task(self, task):
        self.tasks.append(task)


    def delete_task(self, task):
        if task in self.tasks:
            self.tasks.remove(task)


    def display_tasks(self):
        print("Username: ", self.name)
        for task in self.tasks:
            print("Title", task.title)
            print("Description", task.description)
            print("Completed", task.is_completed)
            print()



class Task():
    def __init__(self, title):
        self.name = title
        self.description = ""
        self.is_completed = False

PUSHING TO GITHUB

It is expected the project has been cloned with git clone and is resting on your local machine, here is a link to repo to clone from

after copying the contents of main.py with git status you can see the current status of your repo

Next, we add out implementation to git with the command git add main.py and to commit the changes you have made run the command
git commit -m “created a user model for each task object”

run git status again to be sure you changes were added and committed

and to finally push to github we run the command
git push

viola an updated project should be sitting on the repo from which you cloned from.

for questions and comments you can contact me via mail timosahenru@gmail.com

Building globally with Django internalization

Osahenru — Fri, 03 Mar 2023 17:24:29 +0000

The world as a global village is comprising of different languages, ethnicity and gender. In this article I will introduce to you the concept of internalization with Django.

You will understand how an application can be built to reach a global audience using Django’s internalization by either.

Manually changing the language code of your application
Or using an extension to change language sessions.

Prerequisites:

For getting the best out of this article, a basic understanding of Django is needed;
- How to setup a Django project and run an application
Have gettext running on your machine, for linux run this command sudo apt-get install gettext
Install language switch, a firefox extension language switcher. If you have checked these prerequisites then lets proceed.

So I have successfully created a project config and an application app as shown in this file tree.

to run and compile your message create a folder called locale inside your app directory with mkdir app/locale the locale/ directory we just created is where the magic happens, where our messages will be compiled.

If you have gettext installed on your machine then import it with the following line of code from django.utils.translation import gettext as _

We can translate text either from the backend view (views.py) or from the frontend templating engine.

Translating from views

Translating from your template

We proceed further to generate a translated text file with django-admin makemessages -l es if you open the locale folder, you'll see a django.po file where the translation process takes place.

Make the following changes by changing your default language code in your settings.py file from English to Spanish LANGUAGE_CODE = 'es'

and when you're done run application with the compile command
django-admin compilemessages load your tags from the template with {% load i18n %} as shown above.

To manually change the language from your `settings.py` file

all you need to do is just change the language code from English to Spanish as previously shown above.

To change the language using an extension

If you have installed the language switcher extension, then include this line of code to your middleware in your settings.py django.middleware.locale.LocalMiddleware

Please ensure to include this file after the sesion middleware precisely after
the common middleware as shown above.

If that is done, then toggle between language on your browser

I hope this was helpful, please give a follow if you found this helpful.

Beginner to hired in 12 months (a step-by-step approach on getting hired as a Dev)

Osahenru — Thu, 26 Jan 2023 22:20:55 +0000

In the late quarter of 2022, I received a mail asking for my application for an internship position(paid in dollars), I wasn’t surprised because I expected it, I felt it even took too long 😄 😄, this sense of confidence came because I knew I had put in the work needed, so why some might interpret my fate as mere luck, although it is true, luck did contribute to my success, but also, I was prepared and in search of her(luck) by being deliberate about what I wanted and also by taken some actionable steps.

These deliberate steps to getting you your first job are what I will be sharing in this guide, I’m not promising you a similar outcome as mine, cos I believe yours might even be a better position as to how I started, but what I am assuring you of is, if you put in these steps to good use, you’ll see the results within a year, and this brings me to my first tip;

NB: Although the Python language and the Django framework are used as a case study for this article, the lessons learned and tips shared here can also be used across any other language, framework or technology concepts as a beginner.

NB: Although the Python language and the Django framework is used as a case study for this article, the lessons learnt and tips shared here can also be used across any other language, framework or technology concepts as a beginner

Tip1: Being intentional:

Intentional living is the art of making your own choices before other choices make you.

I had to be intentional about what part of tech I wanted to start building a career in and for me it was as a backend engineer, a backend engineer is usually bothered about the flow of logic of an application.

I had researched some of the best languages to learn as of 2021 as a backend engineer and Python was top on that list, it still is as of 2023 according to hostinger, it takes about 6 months or more to understand the concepts of Python.

When I was sure I understood what it’ll cost me to be proficient in Python as a backend engineer, I committed myself to it, which brings me to our next tip.

Tip2: Commit yourself:

Unless commitment is made, there are only promises and hopes; but no plans. ― Peter F. Drucker.

Commitment is the decision to show up every day regardless of the amount of work put in, commitment is in the little steps you take each day towards your plan or goal, commitment is in knowing that consistency beats intensity any day or time, not focusing too much on the result of perfection but on the process of the journey.

So, on November 8, 2022, I decided to be committed to my intention about becoming a software engineer.

You know, when the universe knows about your plan it finds a way it guides you unto completion, especially if you’re determined to see it through, the old book of wisdom says

...Write the vision And make it plain on tablets, That he may run who reads it.

This was what I did by making that tweet, making a tweet wasn’t the last bus stop, I had to also put in the work needed.

I signed up for a beginners course in computer science I learned programming with scratch for a couple of weeks (say about 4 weeks) on their platform

While many are meant to believe that tech is hard, the lack of a proper road map can even make it harder.

I proceeded to c++ still under the same curriculum(cs50), not sure how long this took but to follow a plan let's say two months because by February of the following year(2022) I had already narrowed my learning to just Python.

Once I understood the fundamentals of computer programming I narrowed my skill to learning Python with Mosh Hamedani, as my first encounter with the programming language called Python, Mosh’s teaching style is top-notch and very beginners friendly.

After understanding the core concepts of Python; variables, functions, classes, OOP, etc, I was still in search of a beginners guide to learning Python, which brings me to my next tips.

Tip4: Document your journey

Accomplishments will prove to be a journey, not a destination - Dwight D. Eisenhower

Documentation is the love language that you write to your future self, it is very important to document your journey as a software engineer, you will always be impressed by how much you have improved when you go back to visit your documentation.

Documenting your tech journey helps you better understand the concepts you are learning and also gives you room to improve on your skill sets as it exposes you to a community of both expert engineers and learners who will benefit from your experience, I’m still shocked at the number of engagement I get on my dev.to interesting to see that people benefit from my sharing of my little wealth of knowledge.

I use my GitHub account not just as a version control system but also to document my projects, which is why I always take out time to write out a proper README file for all my projects(public or private), my dev.to account and hashnode accounts are used to write on whatever concepts I'm learning.

You don’t need to pay for a blog domain as a beginner; these resources are freely available for use.

Tip5: Effectively belong to a community

Alone, we can do so little; together, we can do so much – Helen Keller

In May 2022, I searched for some Python handles to follow on Twitter and I stumbled on PyGhana, coincidentally they made a retweet about the PyConGhana 22, so I gave a follow on Twitter to find out more about them when I was convinced about understanding the concept of a Py conference PyConGhana, I promised myself to give a talk at the conference, submitted my first ever CFP and thankfully it was approved.

I understand not everyone enjoys socializing, scary but, somehow being a software developer will force you to socialize in ways that might not suit your personality, just see it as the prize you need to pay.

The decision to give my first talk at a tech conference was very crucial to my journey in landing a job, I met recruiters foreign and local, and had a couple of sincere interactions with developers who were present at the event I could see the gap in knowledge from my end and it challenged me that I can be better and also in the same light I could also see how far I had come as a self-taught developer seeing how much people also benefited from my little knowledge shared.

Well, if you’re reading this I sincerely urge you to become a member of a community regardless of your level of competence.

When you pick a language, search out for the community close to you, the Python community, for example, is very broad and diverse, having branches in almost every continent, most countries and major cities and if there are none this is a call to create one.

Being an active person in your community means you are contributing to the community from; financial contributions to resources and material, to contributing with your skills and expertise, no matter how small let your presence and impact be felt, and engage their social media handles by commenting and retweeting whenever a post is made.

In the long run, when there’s a job opening, it is most times first circulated within the community before it is made public and sometimes it is easier for people to recommend you for a position when you’re an active member of a mutual community.

Tip6: Market yourself:

The price you will offer yourself to the world is how much they will buy you. ― Lailah Gifty Akita

What makes a story compelling, is how it is being told, to be hired for a position you want to be able to tell a story with your journey on your Twitter, Github or Linkedin profile in a way that is captivating and shows an amazing personality.

How you tell your story on these platforms is more important than your story itself, especially as one with no work experience, you should learn how to constantly share what you’re currently doing/learning, the challenges you faced and how you have overcome those challenges but, be careful not to make another boring writeup, add some personality while you market yourself.

From your display picture to your bio, be very intentional about what you post from now on, see social media as a podium and Twitter(or any other platform) as the mic, what you say and HOW you say it will determine if people should listen to you.

A story gives room for engagement, for example, two developers sharing their story on how they got a job can differ based on how they share their stories.

Why this tip might not seem as portraying the importance of selling yourself as a software engineer, the message I want you to pick is to be very deliberate on how you market yourself by telling your story.

Tip7: Contribute to an open-source project

Your engagement with open is the surest referral to getting your first job.

An open source project is a project in which its source code has been made public and can be modified, the Django framework is a good example of an open source project, my first open source project in 2022 exposed me to what a large code base looks like, as a developer it is one thing to read through your code and debug, and yet another to read and try to understand the code of others.

Contributing to an open source project will strengthen your skill in whatever language you're learning as you will be able to see thinking pieces of what makes up the code base to which you are contributing.

Also, another benefit of contributing to open source as a beginner is how it exposes you to the working wonders of a version control system.

For how to get started with open source as a beginner, I prepared this detailed guide, please check it out.

Tip 8: Start applying

The best time to plant a tree was 20 years ago. The second best time is now.

The biggest injustice you can do to yourself is to sit on the sidelines and wait for the perfect time to arrive, the right time for you to start doing what it is you want to do and create what it is you want to create is NOW!

You don't have to be great to start, but you have to start to be great; you don’t need to become a great “developer” before you start applying, ironically you need to start applying to become a great developer in the long run.

Polish your Linkedin profile, and prepare your resume and a cover letter.

You can start applying on Linkedin jobs or any job portals, two of the surest positions for a beginner are an internship position or a junior position, and you can get these offers on Linkedin jobs depending on how you have tweaked your Linkedin page.

Besides Linkedin, another platform where you can get jobs is the websites of the companies who are sponsoring some of these tech events, especially those who sponsor the language or framework you’re working with.

So, as a Python/Django developer search for companies sponsoring any PyCon or DjangoCon event close to you or where you would love to work, visit the company's career pages on their website and apply to them, this process is way easier as you’re sure of some of the requirements for working for the company as they are sponsors of your choice language/framework.

Tip 9: Believe

To accomplish great things, we must not only act, but also dream; not only plan, but also believe. - Anatole France

Belief is a practical instrument you need to shape reality, now you have done all the tips earlier highlighted, you must believe it can happen for you and watch it happen.

Move without fear or doubt believing it will work for you, provided you are willing to put in the work as highlighted in this article then believe it will most certainly work for you.

What the mind of man can conceive and believe, the mind of man can achieve - Napoleon Hill.

Thankfully November 2022 I got my offer that birthed this article

I will end with a very beautiful quote from four-time grand slam singles champion, Naomi Osaka

I don't think there's a perfectly correct path to take in life but I always felt that if you move forward with good intentions you'll find your way eventually.

I know it might seem draining on some days but please don’t be discouraged, it worked for me and also it can work for you.

May the odds forever be in your favor.

How to deploy a sphinx styled documentation

Osahenru — Wed, 21 Dec 2022 12:48:28 +0000

In this tutorial guide I will show you how to create a documentation for your project using the Sphinx style.

Sphinx is a documentation generator written and used by the Python community and environments.

Sphinx uses the reStrcuturedText markup language by default and can also be tweaked to using markdown.md as a third party package

In this tutorial guide I’ll show you how to

Install sphinx on your project
Setup Sphinx on your project
Run Sphinx with some basic commands
Install a different theme
Deploy your documentation on reathedocs

First create a project on GitHub and clone it on your local machine or alternatively clone this blank project

cd into the directory of the repo you just cloned with
cd demo-sphinx-tutorial

Create a virtual environment with
python3 -m venv venv if you’re on a linux server like I am or python -m venv venv on a windows

Activate your virtual environment with
source venv/bin/activate on a linux server venv\Scripts\activate on a windows and open your project in your choice editor.

Install Sphinx
pip install sphinx

Setup Sphinx
sphinx-quickstart docs

Now what this is going to do is to run you through a bunch of questions, whenever you want to accept the default value just go ahead and press enter

Separate source and build directories (y/n) [n]: 
press y

The project name will occur in several places in the built documentation.
> Project name: demo-sphinx-tutorial
> Author name(s): Tim Osahenru
> Project release []: 1.0

> Project language [en]: 
press enter

Run Sphinx
cd into source folder and make a directory called images with mkdir images where our images will be stored
your file tree should look like this

open the index.rst file this is where the magic takes place, you want to leave this section.

the toctree tells sphinx the hierarchical order of your file, you can either push to the bottom of the page of leave it ontop DO NOT DELETE THIS

next I’m going to copy and paste some dummy data into the index.rst file

now we build our documentation with this commands sphinx-build -b html docs/source/ docs/build/html

To view your built work open the build folder and load index.html on your browser

NB:
whenever you make a change inside the index.rst
file always make sure you build with 
sphinx-build -b html docs/source/ docs/build/html

Install theme
To pick a theme visit for this tutorial this theme was used

install the theme with
pip install sphinx-rtd-theme

locate this session in your conf.py file and change html_theme = 'alabaster' to html_theme = 'sphinx_rtd_theme' and build again with sphinx-build -b html docs/source/ docs/build/html

PART II

Deploying to readthedocs
cd into you docs folder and create a requirements file with pip freeze > requirements.txt for readthedocs to know the dependencies used on this project

Perform these git commands to push to GitHub where we will be deploying our project from

git status
git add .
Git commit -m ‘first commit’
git push

Create an account on readthedocs navigate to your profile image button and click the drop down menu
click on My Projects > Import a Project select the project you wish to deploy and click on Build Project

Once the build is successful you should get an indication and have a project like this.
Congratulations!

Getting started with your first open source project

Osahenru — Wed, 26 Oct 2022 18:56:21 +0000

Prerequisite

I expect the reader of this article to have an existing GitHub account and is fairly familiar with GitHub and a few command like git status, git commit, git add .

However if you're not familiar with GitHub checkout this beginners guide

What is open source

I can relate to how the term ‘open source’ sounds like a term used only by those who are perceived as the top dog by other developers well, I fairly understand, open source just merely means project which are open for contributions and this is intentionally done by the creators of these projects.

As a contributor you can contribute to an existing issue or create one yourself (although as a beginner I recommend you stick with the former of contributing to an existing issue), for the purpose of this article an issue can be said to be a list of improvements required for the project to function optimally either as fixing a bug or requesting additional functions to the project

A good issue is one which has a tag, has a simple title, has been opened for at least a year (as a beginner you don’t want to contribute to an issue that has been left unattended to with zero to few interactions).

So, now, you have spotted an issue you feel comfortable contributing to, you need to notify the maintainer of that project by sending a comment to assign the issue to you.

Please give time before you get feedback from the maintainer as most times the feedback might not be instance as most have other project they are maintaining or have a busy work life.

If you’re not sure of where to find open source project easily, sign up to hacktoberfest and browse through their list of sites where you can find good open source projects, alternatively below are some sites you can easily check out too
Ups for grabs
Good first issues
Good first issues dotdev

While you’re waiting for a response from the maintainer you can familiarize yourself with the project's code base for this sole reason is why I strongly encourage beginners to contribute to open source projects because you’ll be exposed to the code base of the project where you can familiarize yourself on the industry way of writing clean and maintainable codes and the exposure to collaboration too is very rewarding when you’re in search of a job.

Forking a project

Once an issue has been assigned to you, next, you need to FORK the repository of that project to your GitHub repository

To fork a repo according to Thanoshan MV means

When we love someone’s repository and would like to have it in our GitHub account, we fork it so that we can work with it separately. When we fork a repository, we get an instance of that entire repository with its whole history. After forking, we can do whatever we want to do without affecting the original version

unrelated but I find this definition really hilarious more so that the pronunciation of the word has other meanings, makes me wonder what the engineers at GitHub were thinking about while coming up with their naming conventions… 😂😂😂

You might fork a project to propose changes to the
upstream(original repository).

Select an owner(which in most case is you) scroll down and CLICK create fork

Cloning a forked repo

So you have successfully forked the project you want to work on but you need to clone it to make it available on your local machine so you can work on it, to do this navigate to your newly forked project which usually has this naming convention [YourName/Name-of-forked-project]

Above the list of files CLICK code copy the URL using HTTPS

Now to clone this project to your machine open your terminal, change directory to where you want your project cloned and type git clone followed by the URL you just copied and press ENTER

Syncing your forked project with the original repo

In an open source project you’ll always have different contributors working on different issues so to keep with the latest commit or changes we need to sync our forked project with the upstream.

On your GitHub account navigate to the repo of the original project where you forked from.

Above the list of files CLICK codejust close to the Add file icon, copy the URL using HTTPS.

cd into the directory of the earlier forked clone type git remote -v press ENTER to see the remote name of the repo you just forked.

your output should look something like this

origin  https://github.com/YourName/OriginalNameofYourFork.git (fetch)
origin  https://github.com/YourName/OriginalNameofYourFork.git (push)

Type git remote add upstream and then paste the URL you last copied followed by ENTER

your command should look something like this

git remote add upstream https://github.com/YourName/OriginalOwner/OriginalNameofProject.git

to be sure of the upstream of your fork, type git remote -v again, you should see the URL for your fork as origin and the URL for the original repo as upstream

your output should look something like this

origin  https://github.com/YourName/NameofYourFork.git (fetch)
origin  https://github.com/YourName/NameofYourFork.git (push)
upstream  https://github.com/YourName/RepoNameOriginalofOriginalOwner.git (fetch)
upstream  https://github.com/YourName/RepoNameofOriginalOwner.git (push)

Now, your forked project will be synced with the upstream repo, it is good practice to always sync your fork with the upstream repository after cloning to your local machine.

So, you have successfully spotted an issue in an open source project, the issue has been assigned to you, you’ve forked and cloned it to your local machine also, but before you start working on it, it is very important to create a branch.

Create a branch

Few git branch commands and their functions to have at your finger tips.

git branch
current branch you’re working on
git branch -r
all remote branches
git branch -a
all remote branches local and remote
git checkout
shows a record of all the commit in your current branch.

Now, we create a new branch using the git checkout command.
git checkout -b [branch name]

Making changes

After you’ve successfully resolved the issue, git takes a record of every change made in that repo to see the changes that has been made we use the git statuscommand on a windows environment these changes will be highlighted in red.

Commit changes

Once you're sure that the changes made solve the issues raised, next, you need to add these changes to the repo with git add . and commit these changes with
git commit -m ‘a commit message summarizing what you did’

Pushing changes

Now we need to make our changes visible remotely by pushing these changes using git push but before we do that we need to be sure of the name of the remote, some repo use main others master or origin

by using the command git remote you’ll see the remote name used for the project

once you’ve successfully identified the remote name, you can now successfully push with git push [repo name] [branch name] for the case of this article, the remote name used in demoing this article is origin and the branch name is register-models so your git command will be something like
git push origin register-models

Making a pull request

Once you’ve successfully pushed your code, the next and final step will be to make a pull request, that is alerting the maintainer of the project that a change has been made and a merge is needed

*CLICK * on the compare & request icon

Fill up the fields with the necessary information and click create pull request, Congratulations you have successfully made your first contribution to an open source project, if your PR is accepted you’ll receive a mail.

Conclusion

It is okay to google the solutions to an issue no one will penalize you for doing that, what is important to contributing to an open source project is solving the issue, and also very important to note is that your PR might not be merge do not take it personal or feel less skilled to keep contributing to more projects, it might be that your approach to tackling the issue isn’t a maintainable or clean approach, you can always seek help from contributors on how best to contribute if your PR isn’t merged.

Using Django's hitcount for unregistered users in your application

Osahenru — Mon, 12 Sep 2022 15:17:18 +0000

Django hitcount is a python library that allows you track the number of hits/views on a particular objects by detecting the IP address of each click to prevent unreal views this ensures views aren't counted twice.

This library was built using the Django’s class based views which provides a wrapper for Django’s generic DetailView and allows you to process the Hit as the view is loaded.

To begin with this library you must have Python and Django running on your system, next we install the django-hitcount using pip install django-hitcount, after installation we add the hitcount library to our installed applications in settings.py

Next, we modify our models.py file by importing the following line of code

from hitcount.models import HitCountMixin, HitCount
from django.contrib.contenttypes.fields import GenericRelation

this library was built using Django's class based views so for beginners who might have already began using function based view in their application should have no worry as you can use both function based views and a class based view in one application view.

So, now lets move to our views.py and tweak it a little, but before we do that, we need to import our hitcount into our views.py file

from hitcount.views import HitCountDetailView

The HitCountDetailView can be used to do the business-logic of counting the hits by setting count_hit=True.

Almost there, now we move to our HTML template and load our hitcount tags, just right above your html DOCTYPE load the hitcount tags

{% load hitcount_tags %}

Finally, we add styling to our application with this line of code

<span class="ion-ios-eye"></span> {% get_hit_count for project %} views

VOILA!!! You've successfully integrated Django's hitcount to your application

Forem: Osahenru

Using dj-rest-auth to integrate GitHub authentication in your Django project

Prerequisite

1. Setup GitHub

2. Setup Django

3. Test authentication endpoint

Additional consideration

Difference between dj-auth-rest and social-auth-app-django

Conclusion

Using Canonical URLs for your next Django project

What is a canonical URL?

Canonical tag

Writing canonical URLs in Django

Summary

Enhancing your Python code with decorators

Introduction

Creating Decorators

Notes📝

Introducing @ symbol in decorators

Notes📝

Passing Arguments to Wrapper Functions

Notes📝

Notes📝

Use Case of Decorators in Python

Logging

Notes📝

Caching

Notes📝

Notes📝

Notes📝

Python Decorators

Properties

Setters and Getters

Notes📝

Deleters

Class method (@classmethod)

Notes📝

Notes📝

Static method (@staticmethod)

Abstract method (@abstractmethod)

Notes📝

Abstract property

Notes📝

Conclusion

Regex pattern in Python: A beginners guide

VALIDATING USERS DATA

Example 1: IP address validator:

Example 2: IP address validator:

EXTRACTING DATA

Example 3: Username extractor:

CLEANING DATA

Example 4: Phone number book:

Example 5: Phone number book

MORE REGEX FUNCTION

Example 6 with fullmatch:

Example 7 with search():

re.fullmatch() vs. re.match()

When to Use fullmatch(), match(), or search()

COMMON FLAGS

re.IGNORECASE(re.I)

Example 8: without the re.IGNORECASE flag:

Example 9: with the re.IGNORECASE flag:

re.MULTILINE (re.M)

Example 10 without the re.MULTILINE flag:

Example 11 with the re.MULTILINE flag:

re.DOTALL (re.S)

Example 12 without the re.DOTALL flags:

Example 13 with the re.DOTALL flag:

CONCLUSION

Getting Started with Python's map() Function: A Beginner's Guide

Devin: A Tool, Not a Substitute for Your Job

Building a basic Python todo app and pushing on GitHub

PUSHING TO GITHUB

Building globally with Django internalization

Translating from views

Translating from your template

To manually change the language from your settings.py file

To change the language using an extension

Beginner to hired in 12 months (a step-by-step approach on getting hired as a Dev)

How to deploy a sphinx styled documentation

Introducing `@` symbol in decorators

To manually change the language from your `settings.py` file