DEV Community: Siddhartha Chowdhury

Introduction to Dependency Injection in Python

Siddhartha Chowdhury — Sat, 20 Mar 2021 07:17:59 +0000

Motivation: After mindlessly creating projects and writing code that implements somethings but never made any sense from a bird's eye view for almost 11 years, it was time to learn something that would help me understand design patterns and write code that actually made sense and looked aesthetic (bringing in Instagram vibes to DEV.to 😁). Recently came across Dependency Injection in Python at work and thought of giving it a try.

What is Dependency Injection (DI) in Python?

DI is a common design pattern used in most modern (and not so modern) programming languages. Yet it remains an underutilized functionality in Python. A lot of people speak for and against the use of DI in Python which is a topic for another day.

How to use Dependency Injection (DI) in Python?

dependency-injector (docs) is python library that provides a framework which enables you to implement DI and IoC in Python.

GETTING STARTED

Two key components of dependency-injector are

containers
providers

providers create object and inject the dependencies. Resource, Factory, Configuration, Singleton, Callable, etc. are some of the provider types and this is not an exhaustive list but we'll keep our discussion limited around these types to justify the scope of the article.

container is merely a collection of providers.

Keep the below point in mind as it will be the only mantra to live by while implementing DI:

Each provider is callable. Whenever you need an object of particular type, just call the corresponding provider as you would call a function.

Enough with the theory and now,

Let's get our hands dirty:

We'll start by importing containers and providers from dependency_injector package.

from dependency_injector import containers, providers

We'll create two classes School and Student. A Student goes to a particular School, so Student has a dependency on School.

Let's look at the attributes of these classes:

`School`:

schoolname: str - Every school has a name, obviously!
city: str - Where do you study? A school named <schoolname> in <city>
board: str - What education board does your school follow? C.B.S.E.? I.C.S.E. or State Board?

`Student`:

name: str - Again, every student has a name, obviously!
age: int - How old are you? I am <age> years old.
school: School - In which school do you study? I study at <schoolname>
grade: int - What grade you are in? I am in <grade>

class School:

    def __init__(self, name: str, city: str, board: str):
        self.schoolname = name
        self.city = city
        self.board = board

    def get_schoolname(self):
        print(f"school name is {self.schoolname}")


class Student:

    def __init__(self, name: str, age: int, grade: int, school: School):
        self.name = name
        self.age = age
        self.grade = grade
        self.school = school
        #super().__init__(school, city, board)

    def get_students(self):
        student_detail = f"""
            Student Name: {self.name}
            Student Age: {self.age}
            Student Grade: {self.grade}
            School: {self.school.schoolname}
            Exam Board: {self.school.board}
            City: {self.school.city}
        """

        print(student_detail)

To create dependencies we'll create a class called Container

class Container(containers.DeclarativeContainer):

    school = providers.Singleton(
        School,
        "Kendriya Vidhyala",
        "C.B.S.E.",
        "Bina"
    )

    student = providers.Factory(
        Student,
        "Siddhartha",
        28, 12,
        school
    )

Here we have created 2 providers, school and student. To initialize a factory provider, we use providers.Factory and provide a class as the first argument and other arguments are the class attributes required to initialize the class. Singleton provider works in the same way as a factory provider with an added restriction that it will only create a single object which will be memorized in the entire application lifetime.

Since many student go to a single school, we have established that relationship by making Student a Factory and School a Singleton.

Since, we have established this fact above that Student has a dependency on School, we'll now establish this dependency. If you watch carefully, after creating the school dependency will have injected it into student. Look close and observe the last argument of student provider:

school = providers.Singleton(
    School,
    "Kendriya Vidhyala",
    "C.B.S.E.",
    "Bina"
)

student = providers.Factory(
    Student,
    "Siddhartha",
    28, 12,
    school
)

This is how we create and inject dependencies. Now all we need to do is create a single container object and wire the modules together and it will take care of all the underlying object creation and their injections at suitable positions. This is how we do it:

container = Container()
container.wire(modules=[sys.modules[__name__]])

Now whenever we need to see the Student, we call the get_student() function using the student provider.

student = Container.student()
student.get_students()

Here is what the code looks in it's entirity:

import sys
from dependency_injector import containers, providers
from dependency_injector.wiring import inject, Provide

class School:

    def __init__(self, name: str, city: str, board: str):
        self.schoolname = name
        self.city = city
        self.board = board

    def get_schoolname(self):
        print(f"school name is {self.schoolname}")

class Student():

    def __init__(self, name: str, age: int, grade: int, school: School):
        self.name = name
        self.age = age
        self.grade = grade
        self.school = school
        #super().__init__(school, city, board)

    def get_students(self):
        student_detail = f"""
            Student Name: {self.name}
            Student Age: {self.age}
            Student Grade: {self.grade}
            School: {self.school.schoolname}
            Exam Board: {self.school.board}
            City: {self.school.city}
        """

        print(student_detail)


class Container(containers.DeclarativeContainer):

    school = providers.Factory(
        School,
        "Kendriya Vidhyala",
        "C.B.S.E.",
        "Bina"
    )

    student = providers.Factory(
        Student,
        "Siddhartha",
        28, 12,
        school
    )


def main():

    student = Container.student()
    student.get_students()


if __name__ == "__main__":

    container = Container()
    container.wire(modules=[sys.modules[__name__]])
    main()

When you run the code this will be your expected output:

Student Name: Siddhartha
Student Age: 28
Student Grade: 12
School: Kendriya Vidhyala
Exam Board: C.B.S.E.

To be honest, this example can easily be implemented using inheritence. But when your code bigger and bigger with tens and hundreds of classes, keeping a track of all the objects and the their position in inheritence tree is extremely difficult. This is where DI comes handly.

It looks a bit overwhelming at the start but once you understand it, it makes your code extremly flexible to change and test.

I'll be writing a detailed article with advanced use of DI in a real-world use-case somewhere in near future. So if you found this article helpful, your feedback would be genuinely appreciated so that I can avoid similar pitfalls in upcoming articles

Practical Way to Get Started With Python

Siddhartha Chowdhury — Sat, 13 Mar 2021 10:51:36 +0000

No matter the what the use case is, Python can always be utilized to solve the problem statement. Maybe, not in the most efficient way but it does solve your problem. And the best part is, it's one of the easiest Programming language to learn in today's date. And here's how you can get started with it in the most practical way possible.

One can skim through the internet trying to find ways to learn Python and most of the articles/tutorial/courses you find will tell you how to use Python's constructs, conditional statements, iterations, OOP concepts, a few libraries like NumPy, Pandas etc. and that's a really good starting point. But the question always lies, WHAT NEXT?

This article talks about what to do next to implement the basics of Python and getting comfortable with the language.

Start with a small project to read a file from filesystem and log all the events happening inside the code.

All those who want to explore on their own may now close this tab and move ahead with googling "How to read a file in Python?" or "How to log events in Python?". Others who would like a guiding hand, may follow along this article.

Reading files in Python.

We'll start by reading a simple text file.
For starters create a text file manually and paste loren ipsum statement into it.

Now to read this file, we need 2 objects:

Path to this file
IO object to perform read operation.

From a bunch of filesystem libraries, I find pathlib the most intuitive. You might like to explore more on similar libraries as well.

from pathlib import Path

file_path = Path.cwd() / 'loren_ipsum.txt'

with open(file_path, 'r') as text_file:
    file_data = text_file.read()

print(file_data)

Let's see what's happening here.

We import Path module from pathlib package. Path.cwd()'s __str__() implementation returns the string representation of pathlib object for current working directory. / 'loren_ipsum.txt' uses the operator overloading concept to append the text file name in the path.

Using the context manager with we then open() the text file as text_file object in reading ('r') mode. And then we print the data. Pretty easy stuff, right?

Obtaining resources using with is generally a good idea because then you won't have to worry about releasing those resources.

Now we move to the logging part.

Logging in Python

It's quite easy to implement basic logging functionality in Python. All you need to do is import logging package, set logging configurations using logging.basicConfig() method and start logging events using logging.info('Event Here')/logging.warning('Warning Here') etc. methods.

Here's how it looks like:

import logging

logging.basicConfig(filename="applog.log", datefmt="%d-%m-%Y %H:%M:%S", level=logging.DEBUG, format="%(asctime)s - %(levelname)s %(message)s")

logging.debug("This is a DEBUG MESSAGE")
logging.info("This is a INFO MESSAGE")
logging.warning("This is a WARNING MESSAGE")
logging.critical("This is a CRITICAL MESSAGE")

We'll take a advanced step and configure logging in detail to understand underlying concepts.

We'll start with importing logging package as usual

import logging

Logging package basically requires 4 objects to work.

Logger Object: Logger is never instantiated directly but through a module-level function called getLogger(logger_name). It exposes interfaces which application code can directly consume. If no logger is defined, the default logger, Root Logger, will be used.

logger = logging.getLogger("newLogger")

Handlers: Handlers is also never instantiated directly. There are mostly 2 kinds of handlers used, one being the StreamHandler which outputs logs directly into the console window and the other being FileHandler which outputs the logs in a file

console_handler = logger.StreamHandler()

Log Level: Logging in general, concerns with 5 kinds of message namely, DEBUG, INFO, ERROR, WARNING and CRITICAL.

Both Logger and Handler requires log level to be specified to them.
Level for Logger determines the type of logs to be collected by the logger. Level for Handler determines the type of logs to be displayed by the handler.

Example:
If I set logger level to ERROR, then logger will only collect ERROR, WARNING and CRITICAL logs but not DEBUG and INFO logs. And then if I set handler level to WARNING then handler will be display WARNING and CRITICAL logs and ERROR logs will be ignored.

logger.setLevel(logging.DEBUG)
console_handler.setLevel(logging.DEBUG)

Formatter: Formatter object takes in, what will be format of logs being displayed on console or written into the log file, as an argument.

One of the most generic format of a log would be:

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

Now all we need to attach this formatter to the handler and then attach the handler to the logger

console_handler.setFormatter(formatter)
logger.addHandler(console_handler)

Here we are done with setting up the logging in our application.

Now we can put all the code together which would look something like this:

from pathlib import Path
import pretty_errors
import logging

app_name = "Logging APP"

logger = logging.getLogger(app_name)
logger.setLevel(logging.DEBUG)

console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

console_handler.setFormatter(formatter)
logger.addHandler(console_handler)

try:
    logger.info("Locating File...")
    file_path = Path.cwd() / 'loren_ipsum.txt'
except FileNotFoundError as e:
    logger.error(f"Locating File Unsuccessful: Error:: {e}")
    raise e

logger.info("File Located!")
logger.info("Opening File")
with open(file_path, 'r') as text_file:
    logger.info("Reading File")
    file_data = text_file.read()
    logger.info("Content of the File is read")
logger.info("File Closed!")
logger.info("Execution Complete")

print(file_data)

Once you run the program, you'll get this output on your screen:

2021-03-13 16:01:04,442 - Logging APP - INFO - This is a info message
2021-03-13 16:01:04,443 - Logging APP - INFO - Locating File...
2021-03-13 16:01:04,443 - Logging APP - INFO - File Located!
2021-03-13 16:01:04,443 - Logging APP - INFO - Opening File
2021-03-13 16:01:04,444 - Logging APP - INFO - Reading File
2021-03-13 16:01:04,444 - Logging APP - INFO - Content of the File is read
2021-03-13 16:01:04,444 - Logging APP - INFO - File Closed!
2021-03-13 16:01:04,445 - Logging APP - INFO - Execution Complete
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

Once you have understood how to write this code, you can go ahead and read more about the objects of logging library in depth.

Reading configuration files and logging events are two major components of every application you develop. This mechanism is omnipresent. Once you are comfortable with reading files and logging, consider yourself a notch better than yesterday at any enterprise.