CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/pypi-dependency-injector

Dependency injection framework for Python

—

Pending
Overview
Eval results
Files

providers.mddocs/

Provider System

The provider system is the core of the dependency injection framework, offering various provider types for creating, managing, and configuring dependencies. Providers are factory objects that know how to create instances with proper dependency injection.

Capabilities

Base Provider Classes

Foundation classes that define the provider interface and common functionality.

class Provider:
    """Base provider class with overriding and lifecycle management."""
    def __call__(self, *args, **kwargs): ...
    def async_(self, *args, **kwargs): ...
    def override(self, provider): ...
    def reset_override(self): ...
    def delegate(self): ...
    @property
    def provided(self): ...
    def traverse(self, types=None): ...
    def enable_async_mode(self): ...
    def disable_async_mode(self): ...
    @property
    def is_async_mode_enabled(self): ...
    @property
    def overridden(self): ...
    @property
    def last_overriding(self): ...

class Object(Provider):
    """Provider for static objects and instances."""
    def __init__(self, provides=None): ...
    def set_provides(self, provides): ...

class Self(Provider):
    """Provider for container self-reference."""
    def __init__(self, container=None): ...
    def set_container(self, container): ...

class Delegate(Provider):
    """Provider delegation wrapper."""
    def __init__(self, provides=None): ...

Factory Providers

Providers that create new instances on each call, supporting constructor injection and attribute setting.

class Factory(Provider):
    """Creates new instances on each call."""
    def __init__(self, provides, *args, **kwargs): ...
    @property
    def provides(self): ...
    def set_provides(self, provides): ...
    def add_args(self, *args): ...
    def set_args(self, *args): ...
    def add_kwargs(self, **kwargs): ...
    def set_kwargs(self, **kwargs): ...
    def add_attributes(self, **kwargs): ...
    def set_attributes(self, **kwargs): ...

class DelegatedFactory(Factory):
    """Delegated factory variant."""

class AbstractFactory(Factory):
    """Abstract factory for overriding."""

Usage example:

class Database:
    def __init__(self, host, port, username, password):
        self.host = host
        self.port = port
        self.username = username
        self.password = password

# Factory with constructor arguments
database_factory = providers.Factory(
    Database,
    host="localhost",
    port=5432,
    username="admin",
    password="secret"
)

# Create instances
db1 = database_factory()
db2 = database_factory()  # Creates a new instance

Singleton Providers

Providers that create a single instance and return the same instance on subsequent calls.

class BaseSingleton(Provider):
    """Base singleton with lifecycle management."""
    def __init__(self, provides, *args, **kwargs): ...
    @property
    def provides(self): ...
    def add_args(self, *args): ...
    def set_args(self, *args): ...
    def add_kwargs(self, **kwargs): ...
    def set_kwargs(self, **kwargs): ...
    def add_attributes(self, **kwargs): ...
    def set_attributes(self, **kwargs): ...
    def reset(self): ...
    def full_reset(self): ...

class Singleton(BaseSingleton):
    """Standard singleton implementation."""

class ThreadSafeSingleton(Singleton):
    """Thread-safe singleton."""

class ThreadLocalSingleton(BaseSingleton):
    """Thread-local singleton."""

class ContextLocalSingleton(BaseSingleton):
    """Context-local singleton."""

class DelegatedSingleton(Singleton):
    """Delegated singleton variant."""

class DelegatedThreadSafeSingleton(ThreadSafeSingleton):
    """Delegated thread-safe singleton variant."""

class DelegatedThreadLocalSingleton(ThreadLocalSingleton):
    """Delegated thread-local singleton variant."""

class AbstractSingleton(BaseSingleton):
    """Abstract singleton for overriding."""

Usage example:

# Singleton database connection
database = providers.Singleton(
    Database,
    host="localhost",
    port=5432
)

# Always returns the same instance
db1 = database()
db2 = database()  # Same instance as db1
assert db1 is db2

Callable Providers

Providers that call functions or methods with dependency injection.

class Callable(Provider):
    """Calls functions/methods with injected arguments."""
    def __init__(self, provides, *args, **kwargs): ...
    @property
    def provides(self): ...
    def set_provides(self, provides): ...
    def add_args(self, *args): ...
    def set_args(self, *args): ...
    def add_kwargs(self, **kwargs): ...
    def set_kwargs(self, **kwargs): ...

class Coroutine(Callable):
    """Async coroutine provider."""

class DelegatedCallable(Callable):
    """Delegated callable variant."""

Usage example:

def create_connection(host, port):
    return f"Connected to {host}:{port}"

# Callable provider
connection_provider = providers.Callable(
    create_connection,
    host="localhost",
    port=5432
)

connection = connection_provider()  # Calls the function

Configuration Providers

Providers for managing application configuration from multiple sources.

class Configuration(Provider):
    """Configuration management with multiple source support."""
    def __init__(self, name="config", default=None, strict=False): ...
    def __getattr__(self, item): ...
    def __getitem__(self, item): ...
    def from_yaml(self, filepath, required=False): ...
    def from_json(self, filepath, required=False): ...
    def from_ini(self, filepath, required=False): ...
    def from_env(self, name, default=None, required=False): ...
    def from_dict(self, options, required=False): ...
    def from_pydantic(self, settings, required=False): ...
    def update(self, value): ...
    def get(self, selector): ...
    def set(self, selector, value): ...

class ConfigurationOption(Provider):
    """Individual configuration option with type conversion."""
    def as_int(self): ...
    def as_float(self): ...
    def as_(self, callback, *args, **kwargs): ...
    def required(self): ...
    def update(self, value): ...

Usage example:

# Configuration provider
config = providers.Configuration()

# Load from multiple sources
config.from_yaml("config.yaml")
config.from_env("DATABASE_URL", default="sqlite:///app.db")

# Access configuration values
database_url = config.database.url()
debug_mode = config.debug.as_(bool)()
port = config.server.port.as_int()

Collection Providers

Providers for creating collections with injected dependencies.

class List(Provider):
    """Provides list of injected values."""
    def __init__(self, *args): ...
    def add_args(self, *args): ...
    def set_args(self, *args): ...

class Dict(Provider):
    """Provides dictionary of injected values."""
    def __init__(self, dict_=None, **kwargs): ...
    def add_kwargs(self, dict_=None, **kwargs): ...
    def set_kwargs(self, dict_=None, **kwargs): ...

Usage example:

# List provider
services = providers.List(
    user_service,
    email_service,
    notification_service
)

# Dict provider
endpoints = providers.Dict(
    users="/api/users",
    posts="/api/posts",
    comments="/api/comments"
)

Resource Providers

Providers for managing resource lifecycles with initialization and cleanup.

class Resource(Provider):
    """Resource lifecycle management provider."""
    def __init__(self, provides, *args, **kwargs): ...
    @property
    def provides(self): ...
    def add_args(self, *args): ...
    def set_args(self, *args): ...
    def add_kwargs(self, **kwargs): ...
    def set_kwargs(self, **kwargs): ...
    @property
    def initialized(self): ...
    def init(self): ...
    def shutdown(self): ...

Usage example:

from dependency_injector.resources import Resource

class DatabaseResource(Resource):
    def init(self, connection_string):
        # Initialize database connection
        connection = create_connection(connection_string)
        return connection
    
    def shutdown(self, connection):
        # Close database connection
        connection.close()

# Resource provider
database = providers.Resource(
    DatabaseResource,
    connection_string="postgresql://localhost/mydb"
)

Dependency Providers

Providers for defining abstract dependencies that can be overridden.

class Dependency(Provider):
    """Abstract dependency placeholder."""
    def __init__(self, instance_of=object, default=None): ...
    @property
    def instance_of(self): ...
    def set_instance_of(self, instance_of): ...
    @property
    def default(self): ...
    def set_default(self, default): ...
    def provided_by(self, provider): ...

class ExternalDependency(Dependency):
    """External dependency variant."""

class DependenciesContainer(Provider):
    """Container for dependency providers."""
    def __init__(self, **dependencies): ...

Aggregate and Selection Providers

Providers for grouping multiple providers and conditional selection.

class Aggregate(Provider):
    """Aggregate of multiple providers."""
    def __init__(self, provider_dict=None, **provider_kwargs): ...
    @property
    def providers(self): ...
    def set_providers(self, provider_dict=None, **provider_kwargs): ...

class Selector(Provider):
    """Conditional provider selection."""
    def __init__(self, selector=None, **providers): ...
    @property
    def selector(self): ...
    def set_selector(self, selector): ...
    @property
    def providers(self): ...
    def set_providers(self, **providers): ...

Provider Interface Utilities

Fluent interface for accessing provider results and performing operations.

class ProvidedInstance:
    """Fluent interface for provider.provided access."""
    def __getattr__(self, item): ...
    def __getitem__(self, item): ...
    def call(self, *args, **kwargs): ...

class AttributeGetter(Provider):
    """Attribute access provider."""
    def __init__(self, provides=None, name=None): ...

class ItemGetter(Provider):
    """Item access provider."""
    def __init__(self, provides=None, name=None): ...

class MethodCaller(Provider):
    """Method call provider."""
    def __init__(self, provides=None, *args, **kwargs): ...

Utility Functions

Helper functions for working with providers.

def is_provider(instance) -> bool:
    """Check if object is a provider."""

def ensure_is_provider(instance) -> Provider:
    """Ensure object is a provider."""

def is_delegated(instance) -> bool:
    """Check if provider is delegated."""

def deepcopy(instance, memo=None):
    """Deep copy providers with memoization."""

def traverse(*providers, types=None):
    """Traverse provider graph."""

def represent_provider(provider, indent=0) -> str:
    """Return string representation of provider structure."""

Context Managers

Context managers for managing provider overrides and singleton lifecycle.

class OverridingContext:
    """Context manager for temporary provider overriding."""
    def __init__(self, overridden, overriding): ...
    def __enter__(self): ...
    def __exit__(self, *exc_info): ...

class SingletonResetContext:
    """Context manager for singleton reset."""
    def __init__(self, provider): ...
    def __enter__(self): ...
    def __exit__(self, *exc_info): ...

class SingletonFullResetContext:
    """Context manager for full singleton reset."""
    def __init__(self, provider): ...
    def __enter__(self): ...
    def __exit__(self, *exc_info): ...

Install with Tessl CLI

npx tessl i tessl/pypi-dependency-injector

docs

containers.md

index.md

providers.md

resources.md

schema.md

wiring.md

tile.json