===========================================================
Dependency Injector - Python dependency injection framework
===========================================================

*Dependency Injector* is a Python dependency injection framework. It was 
designed to be unified, developer-friendly tool for managing any kind
of Python objects and their dependencies in formal, pretty 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*                                | .. image:: https://img.shields.io/pypi/v/dependency_injector.svg                |
|                                       |    :target: https://pypi.python.org/pypi/dependency_injector/                   |
|                                       |    :alt: Latest Version                                                         |
|                                       | .. image:: https://img.shields.io/pypi/dm/dependency_injector.svg               |
|                                       |    :target: https://pypi.python.org/pypi/dependency_injector/                   |
|                                       |    :alt: Downloads                                                              |
|                                       | .. image:: https://img.shields.io/pypi/l/dependency_injector.svg                |
|                                       |    :target: https://pypi.python.org/pypi/dependency_injector/                   |
|                                       |    :alt: License                                                                |
+---------------------------------------+---------------------------------------------------------------------------------+
| *Python versions and implementations* | .. image:: https://img.shields.io/pypi/pyversions/dependency_injector.svg       |
|                                       |    :target: https://pypi.python.org/pypi/dependency_injector/                   |
|                                       |    :alt: Supported Python versions                                              |
|                                       | .. image:: https://img.shields.io/pypi/implementation/dependency_injector.svg   |
|                                       |    :target: https://pypi.python.org/pypi/dependency_injector/                   |
|                                       |    :alt: Supported Python implementations                                       |
+---------------------------------------+---------------------------------------------------------------------------------+
| *Builds and tests coverage*           | .. image:: https://travis-ci.org/ets-labs/dependency_injector.svg?branch=master |
|                                       |    :target: https://travis-ci.org/ets-labs/dependency_injector                  |
|                                       |    :alt: Build Status                                                           |
|                                       | .. image:: https://coveralls.io/repos/ets-labs/dependency_injector/badge.svg    |
|                                       |    :target: https://coveralls.io/r/ets-labs/dependency_injector                 |
|                                       |    :alt: Coverage Status                                                        |
+---------------------------------------+---------------------------------------------------------------------------------+

Installation
------------

*Dependency Injector* library is available on PyPi_::

    pip install dependency_injector

Documentation
-------------

*Dependency Injector* documentation is hosted on ReadTheDocs:

- `User's guide`_ 
- `API docs`_

Examples
--------

API client example:

.. code-block:: python

    """Pythonic way for Dependency Injection - API Client."""

    from dependency_injector import providers

    from mock import Mock


    class ApiClient(object):
        """Some API client."""

        def __init__(self, host, api_key):
            """Initializer."""
            self.host = host
            self.api_key = api_key

        def call(self, operation, data):
            """Make some network operations."""
            print 'API call [{0}:{1}], method - {2}, data - {3}'.format(
                self.host, self.api_key, operation, repr(data))


    class User(object):
        """User model."""

        def __init__(self, id, api_client):
            """Initializer."""
            self.id = id
            self.api_client = api_client

        def register(self):
            """Register user."""
            self.api_client.call('register', {'id': self.id})


    # Creating ApiClient and User providers:
    api_client = providers.Singleton(ApiClient,
                                     host='production.com',
                                     api_key='PROD_API_KEY')
    user_factory = providers.Factory(User,
                                     api_client=api_client)

    # Creating several users and register them:
    user1 = user_factory(1)
    user1.register()
    # API call [production.com:PROD_API_KEY], method - register, data - {'id': 1}

    user2 = user_factory(2)
    user2.register()
    # API call [production.com:PROD_API_KEY], method - register, data - {'id': 2}

    # Mock ApiClient for testing:
    with api_client.override(Mock(ApiClient)) as api_client_mock:
        user = user_factory('test')
        user.register()
        api_client_mock().call.assert_called_with('register', {'id': 'test'})


    # Overriding of ApiClient on dev environment:
    api_client.override(providers.Singleton(ApiClient,
                                            host='localhost',
                                            api_key='DEV_API_KEY'))

    user3 = user_factory(3)
    user3.register()
    # API call [localhost:DEV_API_KEY], method - register, data - {'id': 3}

Auth system example:

.. code-block:: python

    """Pythonic way for Dependency Injection - Auth System."""

    from dependency_injector import providers
    from dependency_injector import injections


    @providers.DelegatedCallable
    def get_user_info(user_id):
        """Return user info."""
        raise NotImplementedError()


    @providers.Factory
    @injections.inject(get_user_info=get_user_info)
    class AuthComponent(object):
        """Some authentication component."""

        def __init__(self, get_user_info):
            """Initializer."""
            self.get_user_info = get_user_info

        def authenticate_user(self, token):
            """Authenticate user by token."""
            user_info = self.get_user_info(user_id=token + '1')
            return user_info


    print AuthComponent
    print get_user_info


    @providers.override(get_user_info)
    @providers.DelegatedCallable
    def get_user_info(user_id):
        """Return user info."""
        return {'user_id': user_id}


    print AuthComponent().authenticate_user(token='abc')
    # {'user_id': 'abc1'}

Service providers catalog example:

.. code-block:: python

    """Pythonic way for Dependency Injection - Service Providers Catalog."""

    import sqlite3

    from dependency_injector import catalogs
    from dependency_injector import providers
    from dependency_injector import injections


    class UsersService(object):
        """Users service, that has dependency on database."""

        def __init__(self, db):
            """Initializer."""
            self.db = db


    class AuthService(object):
        """Auth service, that has dependencies on users service and database."""

        def __init__(self, db, users_service):
            """Initializer."""
            self.db = db
            self.users_service = users_service


    class Services(catalogs.DeclarativeCatalog):
        """Catalog of service providers."""

        database = providers.Singleton(sqlite3.connect, ':memory:')
        """:type: providers.Provider -> sqlite3.Connection"""

        users = providers.Factory(UsersService,
                                  db=database)
        """:type: providers.Provider -> UsersService"""

        auth = providers.Factory(AuthService,
                                 db=database,
                                 users_service=users)
        """:type: providers.Provider -> AuthService"""


    # Retrieving catalog providers:
    users_service = Services.users()
    auth_service = Services.auth()

    # Making some asserts:
    assert users_service.db is auth_service.db is Services.database()
    assert isinstance(auth_service.users_service, UsersService)
    assert users_service is not Services.users()
    assert auth_service is not Services.auth()


    # Making some "inline" injections:
    @injections.inject(users_service=Services.users)
    @injections.inject(auth_service=Services.auth)
    @injections.inject(database=Services.database)
    def example(users_service, auth_service, database):
        """Example callback."""
        assert users_service.db is auth_service.db
        assert auth_service.db is database
        assert database is Services.database()


    # Making a call of decorated callback:
    example()

Providing callbacks catalog example:

.. code-block:: python

    """Pythonic way for Dependency Injection - Providing Callbacks Catalog."""

    import sqlite3

    from dependency_injector import catalogs
    from dependency_injector import providers
    from dependency_injector import injections


    class UsersService(object):
        """Users service, that has dependency on database."""

        def __init__(self, db):
            """Initializer."""
            self.db = db


    class AuthService(object):
        """Auth service, that has dependencies on users service and database."""

        def __init__(self, db, users_service):
            """Initializer."""
            self.db = db
            self.users_service = users_service


    class Services(catalogs.DeclarativeCatalog):
        """Catalog of service providers."""

        @providers.Singleton
        def database():
            """Provide database connection.

            :rtype: providers.Provider -> sqlite3.Connection
            """
            return sqlite3.connect(':memory:')

        @providers.Factory
        @injections.inject(db=database)
        def users(**kwargs):
            """Provide users service.

            :rtype: providers.Provider -> UsersService
            """
            return UsersService(**kwargs)

        @providers.Factory
        @injections.inject(db=database)
        @injections.inject(users_service=users)
        def auth(**kwargs):
            """Provide users service.

            :rtype: providers.Provider -> AuthService
            """
            return AuthService(**kwargs)


    # Retrieving catalog providers:
    users_service = Services.users()
    auth_service = Services.auth()

    # Making some asserts:
    assert users_service.db is auth_service.db is Services.database()
    assert isinstance(auth_service.users_service, UsersService)
    assert users_service is not Services.users()
    assert auth_service is not Services.auth()

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

    https://github.com/ets-labs/dependency_injector


Feedback
--------

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

    https://github.com/ets-labs/dependency_injector/issues

Your feedback is quite important!


.. _PyPi: https://pypi.python.org/pypi/dependency_injector
.. _User's guide: http://dependency_injector.readthedocs.org/en/stable/
.. _API docs: http://dependency-injector.readthedocs.org/en/stable/api/
.. _SLOC: http://en.wikipedia.org/wiki/Source_lines_of_code
.. _SOLID: http://en.wikipedia.org/wiki/SOLID_%28object-oriented_design%29
.. _IoC: http://en.wikipedia.org/wiki/Inversion_of_control
.. _dependency injection: http://en.wikipedia.org/wiki/Dependency_injection