cdi

cdi is a powerful Python dependency injection library designed for simplicity and ease of use. It streamlines the process of dependency management, allowing developers to focus on building features without the hassle of complex dependency configuration.

Key Features

• Forward Reference Resolver: Easily handle types that reference each other.
• Union Support: Simplifies the injection of varying types.
• Lazy Type for Circular Dependencies: Allows for the injection of types that depend on each other.
• ContextVar Support: Facilitates thread-local storage for scoped dependencies.
• Transient Instances: Support for non-singleton instances to be used when needed.
• Generics and TypeVar Support: Compatibility with Python's type hinting system for better type safety.
• Scope Inheritance: Easily manage the lifecycle and access of instances across different scopes.
• Limited Instances: Control over the number of instances created for each type.

Design Philosophy

The library embodies the principle that explicit is better than implicit. It encourages clear type definitions without sacrificing readability or usability, making it easier for developers to define and manage dependencies.

Example Usages

Here's how to define a simple injectable class:

import cdi

# Create a container for dependency registration
ctr = cdi.Container()

# Register a factory function for integers
@cdi.Injectable(ctr)
def get_int() -> int:
    return 100

# Register a class Foo that will use the integer
@cdi.Injectable(ctr)
class Foo:
    def __init__(self, number: int) -> None:
        self.number = number

# Create a scope to resolve dependencies
scope = cdi.Scope(cdi)
instance = scope.get_instance(Foo)
assert instance.number == 100

Advanced usage, including generics and complex object relationships, can also be managed with ease:

from typing import Generic, TypeVar

T = TypeVar('T')
ctr = cdi.Container()

class MyBase(Generic[T]):
    def __init__(self, field: T) -> None:
        self.field = field

@cdi.Injectable(ctr)
class MyType(MyBase[str]): pass

@cdi.Injectable(ctr)
def name_generator() -> str:
    return "foo"

scope = cdi.Scope(__name__, container=ctr)
instance = scope.get_instance(MyType)
assert instance.field == "foo"

Async Support

While cdi does not have an explicit async interface, it supports async code seamlessly. It does not yield control back but ensures it works efficiently with multiple asyncio executors, thanks to a thread-safe design using internal locks.

Conclusion

cdi provides a robust and user-friendly framework for dependency injection in Python applications. It simplifies dependency management, enhances code clarity, and facilitates scalable architecture without the common pitfalls of overly complex setups. This library is ideal for developers looking for an efficient solution to manage dependencies cleanly and effectively.