Skip to main content

Dependency injection microframework for Python

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 pattern in formal, pretty, Pythonic way.

Dependency Injector framework key features are:

  • Easy, smart, pythonic style.

  • Obvious, clear structure.

  • Extensibility and flexibility.

  • Memory efficiency.

  • Thread safety.

  • Documentation.

  • Semantic versioning.

Status

PyPi

Latest Version License

Python versions and implementations

Supported Python versions Supported Python implementations

Builds and tests coverage

Build Status Coverage Status

Github

Github watchers Github stargazers Github forks

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

Brief example below demonstrates usage of Dependency Injector for creating several IoC containers for some example application:

"""Example of dependency injection in Python."""

import logging
import sqlite3

import boto.s3.connection

import example.main
import example.services

import dependency_injector.containers as containers
import dependency_injector.providers as providers


class Platform(containers.DeclarativeContainer):
    """IoC container of platform service providers."""

    logger = providers.Singleton(logging.Logger, name='example')

    database = providers.Singleton(sqlite3.connect, ':memory:')

    s3 = providers.Singleton(boto.s3.connection.S3Connection,
                             aws_access_key_id='KEY',
                             aws_secret_access_key='SECRET')


class Services(containers.DeclarativeContainer):
    """IoC container of business service providers."""

    users = providers.Factory(example.services.UsersService,
                              logger=Platform.logger,
                              db=Platform.database)

    auth = providers.Factory(example.services.AuthService,
                             logger=Platform.logger,
                             db=Platform.database,
                             token_ttl=3600)

    photos = providers.Factory(example.services.PhotosService,
                               logger=Platform.logger,
                               db=Platform.database,
                               s3=Platform.s3)


class Application(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)

Next example demonstrates run of example application defined above:

"""Run example application."""

import sys
import logging

from containers import Platform, Application


if __name__ == '__main__':
    # Configure platform logger:
    Platform.logger().addHandler(logging.StreamHandler(sys.stdout))

    # Run application:
    Application.main(uid=sys.argv[1],
                     password=sys.argv[2],
                     photo=sys.argv[3])

    # Previous call is an equivalent of next operations:
    #
    # logger = logging.Logger(name='example')
    # database = sqlite3.connect(':memory:')
    # s3 = boto.s3.connection.S3Connection(aws_access_key_id='KEY',
    #                                      aws_secret_access_key='SECRET')
    #
    # example.main.main(
    #     uid=sys.argv[1],
    #     password=sys.argv[2],
    #     photo=sys.argv[3],
    #     users_service=example.services.UsersService(logger=logger,
    #                                                 db=database),
    #     auth_service=example.services.AuthService(logger=logger,
    #                                               db=database,
    #                                               token_ttl=3600),
    #     photos_service=example.services.PhotosService(logger=logger,
    #                                                   db=database,
    #                                                   s3=s3))

Alternative definition styles of providers

Dependecy Injector supports few other styles of dependency injections definition.

IoC containers from previous example could look like these:

class Platform(containers.DeclarativeContainer):
    """IoC container of platform service providers."""

    logger = providers.Singleton(logging.Logger) \
        .add_kwargs(name='example')

    database = providers.Singleton(sqlite3.connect) \
        .add_args(':memory:')

    s3 = providers.Singleton(boto.s3.connection.S3Connection) \
        .add_kwargs(aws_access_key_id='KEY',
                    aws_secret_access_key='SECRET')

or like this these:

class Platform(containers.DeclarativeContainer):
    """IoC container of platform service providers."""

    logger = providers.Singleton(logging.Logger)
    logger.add_kwargs(name='example')

    database = providers.Singleton(sqlite3.connect)
    database.add_args(':memory:')

    s3 = providers.Singleton(boto.s3.connection.S3Connection)
    s3.add_kwargs(aws_access_key_id='KEY',
                  aws_secret_access_key='SECRET')

You can get more Dependency Injector examples in /examples directory on GitHub:

https://github.com/ets-labs/python-dependency-injector

Installation

Dependency Injector library is available on PyPi:

pip install dependency_injector

Documentation

Dependency Injector documentation is hosted on ReadTheDocs:

Feedback & Support

Feel free to post questions, bugs, feature requests, proposals etc. on Dependency Injector GitHub Issues:

https://github.com/ets-labs/python-dependency-injector/issues

Your feedback is quite important!

Project details


Release history Release notifications | RSS feed

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

dependency-injector-2.2.10.tar.gz (19.3 kB view details)

Uploaded Source

File details

Details for the file dependency-injector-2.2.10.tar.gz.

File metadata

File hashes

Hashes for dependency-injector-2.2.10.tar.gz
Algorithm Hash digest
SHA256 13e2ad074232a6a4f2ee696d04bcbfe1d95adb00ccb014f5ba865ee77bd73a1a
MD5 02f42e5f6a9d6656b48f47e293073960
BLAKE2b-256 c0c58ae0545d89f7992085a19f7b51d3756ecb46860fe0212bec437545d2ec78

See more details on using hashes here.

Supported by

AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Pingdom Monitoring Sentry Error logging StatusPage Status page