Project description

Dependency Injector is a dependency injection microframework for Python.
It was designed to be unified, developer-friendly tool that helps to implement
dependency injection design pattern in formal, pretty, Pythonic way.

Dependency Injector framework key features are:

Easy, smart, pythonic style.

Obvious, clear structure.

Extensibility and flexibility.

High performance.

Memory efficiency.

Thread safety.

Documentation.

Semantic versioning.

Dependency Injector containers and providers are implemented as C extension
types using Cython.

Status

PyPi

Python versions and implementations

Builds and tests coverage

Github

Dependency injection

Dependency injection is a software design pattern that implements
Inversion of control for resolving dependencies. Formally, if object A
depends on object B, object A must not create or import object B
directly. Instead of this object A must provide a way for injecting
object B. The responsibilities of objects creation and dependencies
injection are delegated to external code - the dependency injector.

Popular terminology of dependency injection pattern:

Object A, that is dependant on object B, is often called -
the client.

Object B, that is a dependency, is often called - the service.

External code that is responsible for creation of objects and injection
of dependencies is often called - the dependency injector.

There are several ways of how service can be injected into the client:

by passing it as __init__ argument (constructor / initializer injection)

by setting it as attribute’s value (attribute injection)

by passing it as method’s argument (method injection)

Dependency injection pattern has few strict rules that should be followed:

The client delegates to the dependency injector the responsibility
of injecting its dependencies - the service(s).

The client doesn’t know how to create the service, it knows only
interface of the service. The service doesn’t know that it is used by
the client.

The dependency injector knows how to create the client and
the service, it also knows that the client depends on the service,
and knows how to inject the service into the client.

The client and the service know nothing about the dependency injector.

Dependency injection pattern provides the following advantages:

Control on application structure.

Decreased coupling between application components.

Increased code reusability.

Increased testability.

Increased maintainability.

Reconfiguration of system without rebuilding.

Example of dependency injection

Let’s go through next example:

Listing of example.engines module:

"""Dependency injection example, engines module."""classEngine(object):"""Example engine base class.
Engine is a heart of every car. Engine is a very common term and could be
implemented in very different ways.
"""classGasolineEngine(Engine):"""Gasoline engine."""classDieselEngine(Engine):"""Diesel engine."""classElectroEngine(Engine):"""Electro engine."""

While previous example demonstrates advantages of dependency injection, there
is a disadvantage demonstration as well - creation of car requires additional
code for specification of dependencies. Nevertheless, this disadvantage could
be easily avoided by using a dependency injection framework for creation of
inversion of control container (IoC container).

Example of creation of several inversion of control containers (IoC containers)
using Dependency Injector:

Factory - provider that creates new instance of specified class on every
call. Supports positional & keyword argument injections, as well as
attribute injections.

Singleton - provider that creates new instance of specified class on first
call and returns same instance on every next call. Supports positional &
keyword argument injections, as well as attribute injections.

Object - provider that returns provided instance “as is”.

ExternalDependency - provider that can be useful for development of
self-sufficient libraries / modules / applications that has required
external dependencies.

Containers

Containers are collections of providers. Main purpose of containers is to
group providers.

DeclarativeContainer - is inversion of control container that could be
defined in declarative manner. It should cover most of the cases when list
of providers that would be included in container is deterministic
(container will not change its structure in runtime).

DynamicContainer - is an inversion of control container with dynamic
structure. It should cover most of the cases when list of providers that
would be included in container is non-deterministic and depends on
application’s flow or its configuration (container’s structure could be
determined just after application will be started and will do some initial
work, like parsing list of container providers from the configuration).

Dependency Injector in action

Brief example below is a simplified version of inversion of control
containters from one of the real-life applications. This example demonstrates
usage of Dependency Injector inversion of control containers & providers
for specifying all application components and their dependencies beetween
each other in one module. Besides other listed above advantages, it gives a
great opportunity to control & manage application’s structure in one place.

"""Example of dependency injection in Python."""importloggingimportsqlite3importboto3importexample.mainimportexample.servicesimportdependency_injector.containersascontainersimportdependency_injector.providersasprovidersclassCore(containers.DeclarativeContainer):"""IoC container of core component providers."""config=providers.Configuration('config')logger=providers.Singleton(logging.Logger,name='example')classGateways(containers.DeclarativeContainer):"""IoC container of gateway (API clients to remote services) providers."""database=providers.Singleton(sqlite3.connect,Core.config.database.dsn)s3=providers.Singleton(boto3.client,'s3',aws_access_key_id=Core.config.aws.access_key_id,aws_secret_access_key=Core.config.aws.secret_access_key)classServices(containers.DeclarativeContainer):"""IoC container of business service providers."""users=providers.Factory(example.services.UsersService,db=Gateways.database,logger=Core.logger)auth=providers.Factory(example.services.AuthService,db=Gateways.database,logger=Core.logger,token_ttl=Core.config.auth.token_ttl)photos=providers.Factory(example.services.PhotosService,db=Gateways.database,s3=Gateways.s3,logger=Core.logger)classApplication(containers.DeclarativeContainer):"""IoC container of application component providers."""main=providers.Callable(example.main.main,users_service=Services.users,auth_service=Services.auth,photos_service=Services.photos)