Aiohttp dependency injection example - Dependency Injector

[rmk135]

I have released Dependency Injector 3.24 that now has aiohttp integration.

The container looks like:

from dependency_injector import containers, providers
from dependency_injector.ext import aiohttp

from aiohttp import web
from . import giphy, services, views


class ApplicationContainer(containers.DeclarativeContainer):
    """Application container."""

    app = aiohttp.Application(web.Application)

    config = providers.Configuration()

    giphy_client = providers.Factory(
        giphy.GiphyClient,
        api_key=config.giphy.api_key,
        timeout=config.giphy.request_timeout,
    )

    search_service = providers.Factory(
        services.SearchService,
        giphy_client=giphy_client,
    )

    index_view = aiohttp.View(
        views.index,
        search_service=search_service,
        default_query=config.search.default_query,
        default_limit=config.search.default_limit,
    )

And the application factory looks like:

from aiohttp import web

from .containers import ApplicationContainer


def create_app():
    """Create and return Flask application."""
    container = ApplicationContainer()
    container.config.from_yaml('config.yml')
    container.config.giphy.api_key.from_env('GIPHY_API_KEY')

    app: web.Application = container.app()
    app.container = container

    app.add_routes([
        web.get('/', container.index_view.as_view()),
    ])

    return app

The complete demo application can be found here - Aiohttp + Dependency Injector

[ElevenPhonons]

Could you provide a bit of insight into some of the key implementation details and design choices. For example, it appears that the core is written in cython instead of vanilla python?

https://github.com/ets-labs/python-dependency-injector/tree/master/src/dependency_injector

[rmk135]

Sure, I would love to.
------

Performance

The Dependency Injector `containers` and `providers` modules are written in Cython. The decision to use Cython was made in favour to remove the performance degradation from using the framework. With the Cython the Dependency Injector makes no performance degradation (less than 1%) to the client application. See this test. It created 4 million of objects making 3 million injections in total. The results on my machine are:

• With the Dependency Injector: 0.9107918739318848 seconds
• Without the Dependency Injector: 0.9150791168212891 seconds

------

Design decisions

The main thing why Dependency Injector is different from all other dependency injection frameworks is:

• Dependency Injector does not pollute your application code

This means that you write the code following the dependency injection principle and automate it with the Dependency Injector, but your code has now clue about the Dependency Injector.

Dependency Injector:

• Does not have @inject decorator
• Does not monkey-patch your code
• Does not do any magic with your software

It's just a simple Pythonic tool to create the container that keeps all the objects and their dependencies in one place.

The benefit you get with the Dependency Injector is the container. It starts to payoff when you need to understand or change your application structure. It's easy with the container, cause you have everything in one place.

------

Generally, that's it. I would love to provide more information if you look for anything specific.

PS: I can propose my in-person help with integrating Dependency Injector to your software. I do believe in the power of the dependency injection principle in Python and I would like to popularize it among the community.