dependency-injector

The Flask tutorial demonstrates several core dependency-injector patterns:

• Containers and Providers: Used to assemble services and integrate 3rd-party libraries.
• Configuration Provider: Used to handle reading configuration from YAML files and environment variables.
• Wiring: Used to inject dependencies directly into Flask views (e.g., the index() view).
• Provider Overriding: Used during testing to replace real providers with mocks via the .override() method.

Containers are collections of providers used to organize your dependency injection logic. You can use them in several ways:

• Centralized Management: Keeping all providers in a single container (the most common pattern).
• Architectural Layering: Grouping providers by layer, such as creating separate Services, Models, or Forms containers.
• Functional Grouping: Grouping providers by domain or package, such as a Users container that holds all functional parts of a users package.

The Asyncio Daemon tutorial demonstrates several core patterns of the python-dependency-injector library:

• Containers and Providers: Used to define how application components (like monitors and dispatchers) are assembled.
• List Provider: Used to inject a collection of monitors into a single dispatcher component.
• Configuration Provider: Used to manage application settings loaded from external files (e.g., YAML).
• Wiring: Used to inject dependencies into functions (like main()) that are outside the container's direct control.
• Provider Overriding: Used during testing to swap real implementations with mocks (e.g., container.http_client.override() or container.override_providers()).

Providers are the core building blocks used to assemble object graphs. They are callables that, when invoked, create objects and automatically inject their required dependencies. This creates a cascade effect where calling one provider can trigger the instantiation and injection of multiple underlying dependencies.

Key capabilities include:

• Object Assembly: Automatically retrieving and injecting dependencies into new objects.
• Overriding: Any provider can be overridden by another provider. This is a critical feature for testing (replacing real services with mocks/stubs) or switching between environments (e.g., replacing production API clients with stubs for development).

The Selector provider allows you to select a specific provider at runtime based on a configuration value or the result of a callable. This is useful for implementing polymorphism or switching between different implementations (e.g., different database drivers or API clients) based on environment variables or configuration settings.

How it works:

1. Selector: The first argument is the selector. This can be an option from a Configuration provider or any callable that returns a string.
2. Providers: All other arguments are passed as keyword arguments. The argument names serve as the keys used for selection.
3. Execution: When the Selector provider is called, it evaluates the selector, retrieves the corresponding string, and delegates the call to the provider matching that name.

To follow the tutorial, create a project directory and set up a Python virtual environment:

mkdir movie-lister-tutorial
cd movie-lister-tutorial

python3 -m venv venv
. venv/bin/activate

Once your application factory is defined, you can run the Flask development server by setting the FLASK_APP environment variable to the module containing your create_app function.

Run the following commands in your terminal:

export FLASK_APP=githubnavigator.application
export FLASK_ENV=development
flask run