ets-labs/python-dependency-injector

Features

• Dependency Injection - Provides a comprehensive framework for managing object lifecycles and decoupling components through dependency injection.
• Automated Dependency Wiring - Installs a module loader hook to automatically resolve and wire dependencies when modules are imported into the application.
• Declarative Registries - Organizes dependency providers as class attributes to decouple object creation from business logic.
• Asynchronous Dependencies - Resolves dependencies using awaitables to support non-blocking initialization and shutdown of shared resources.
• Dependency Wiring Hooks - Installs a module loader hook to automatically resolve and inject dependencies when modules are imported.
• Automated Component Wiring - Injects dependencies into functions and classes across modules without manually passing objects through every layer.
• Dependency Injection Containers - Defines the assembly of services and their dependencies in a central container to decouple object creation from usage.
• Callable Wiring - Binds container providers to functions or methods across different modules and packages using decorators.
• Component Wiring - Aggregates multiple package containers into a single application container to resolve dependencies and connect decoupled modules.
• Structured Provider Containers - Organizes providers as class attributes to create a structured, reusable assembly of dependencies.
• Dependency Injection Frameworks - Implements inversion of control to manage component dependencies and object lifecycles in Python.
• Automatic Constructor Injection - Supplies required objects to functions or classes at runtime using markers to eliminate manual instantiation.
• Dynamic Dependency Overriding - Replaces a provider with another implementation at runtime to facilitate testing with stubs.
• Factory-Based Instantiation - Creates new object instances by injecting defined dependencies or assigning attributes during initialization.
• Object Assembly Management - Manages the assembly and linking of objects using diverse provider types to handle complex dependency graphs.
• Object Lifecycle Management - Manages object instantiation through specific provider types like singletons, factories, and asynchronous coroutines.
• External Resource Initialization - Manages the setup and teardown of shared external resources, such as connection pools, and injects them into dependent services.
• Asynchronous Providers - Resolves dependencies asynchronously using await expressions to handle non-blocking object initialization.
• Inversion-of-Control Containers - Provides a central registry for defining object instantiation and linkage to manage complex dependency graphs.
• Object Lifetime Management - Controls whether a dependency is created as a new instance every time or as a single shared instance.
• Resource Lifecycle Managers - Handles the initialization and shutdown of shared components using functions, context managers, or asynchronous initializers.
• Shared Resource Lifecycles - Coordinates the initialization and shutdown sequences of shared external resources and singletons.
• Service Instance Managers - Implements singleton management to ensure a single instance of a dependency is returned on all requests.
• Dependency Mocking - Replaces production dependencies with mocks or alternative implementations during test execution to isolate the system.
• Execution Scope Resource Management - Initializes and configures shared resources like logging, event loops, or thread pools for specific execution scopes.
• Scope-Based Resource Cleanup - Provides automated initialization and shutdown of resources when functions are called via function wiring.
• Dynamic Provider Switching - Selects between different provider implementations at runtime based on a specific configuration value.
• Configuration Merging - Combines settings from multiple external sources like YAML, JSON, and environment variables into a unified registry.
• Multi-Container Organization - Allows distributing object assembly across multiple declarative containers to manage complexity in large applications.
• Package Dependency Decoupling - Defines external dependencies within a package container using placeholders to maintain implementation agnosticism.
• Provider Lifecycle Management - Manages the reset of singleton instances and copying of container states to control object instantiation.
• String-Based Class Import - Resolves and instantiates objects using absolute or relative module path strings instead of direct class references.
• Dependency Argument Injection - Binds a specific function or callable object to a dependency to pass it into other services.
• Dependency Injection Hooks - Implements import hooks to automatically wire containers to modules as they are dynamically imported.
• Dependency Placeholders - Uses abstract placeholders to define required dependencies that must be concrete implementations before application assembly.
• Application Configuration - Loads and injects settings from environment variables, YAML, JSON, or INI files into application components.
• Callable-Based Resolution - Resolves and provides objects by calling a function or class with specified positional and keyword arguments.
• Module-Level Injection - Wires specific modules to a container to inject dependencies directly into functions or endpoints.
• Resolution Verification - Checks if all dependencies in a container are defined or have defaults and raises an error if unresolved.
• Schema-Based Container Initialization - Builds dependency providers automatically using definitions provided in JSON or YAML schema files.
• Abstract Dependency Definitions - Creates placeholder factories for base classes that must be overridden with concrete implementations.
• Dependency Placeholders - Creates placeholders for required objects to ensure provided instances match a specified type.
• Provider Definition Inheritance - Enables extending existing containers to inherit and reuse dependency definitions while specializing new providers.
• Provider Delegation - Enables injecting a provider instead of the created object, allowing components to produce new instances on demand.
• Provider Grouping - Groups several factories under a single provider and selects the active one based on a runtime key.
• Static Object Injection - Provides mechanisms to inject pre-defined objects or constant values exactly as they are into the dependency graph.
• Dynamic Assembly Configurations - Provides the ability to determine application structure at runtime via configuration files or external data.
• Runtime Configuration Overrides - Replaces registered provider implementations at execution time to facilitate mocking and environment-specific configuration.
• Test Isolation - Allows replacing production service implementations with mocks or stubs during testing to isolate components.
• Request Context Management - Creates singletons scoped to specific execution contexts to ensure separate instances for each request.
• Web Framework Integrations - Passes request-scoped resources into handlers, views, and endpoints of web frameworks to simplify dependency management.
• General Utilities - Framework for managing dependency injection in Python.

Star history