Inject, Factory and Injects

Ravyn dependency injection system is actually pretty simple and can be checked in the official dependency injection section for more details.

from ravyn import Inject, Injects, Factory

ravyn.Inject

Inject(dependency, use_cache=False, **kwargs)

Bases: ArbitraryHashableBaseModel

Ravyn's dependency injector built on Lilya's dependency system internally. Keeps full backward compatibility with the old behavior and interface.

Source code in ravyn/injector.py

def __init__(self, dependency: "AnyCallable", use_cache: bool = False, **kwargs: Any):
    super().__init__(**kwargs)
    self.dependency = dependency
    self.use_cache = use_cache
    self.signature_model: Optional[Type["SignatureModel"]] = None
    self._depends = _Depends(dependency, use_cache=use_cache)
    self.value: Any = Void

model_config class-attribute instance-attribute

model_config = ConfigDict(
    extra="allow", arbitrary_types_allowed=True
)

dependency instance-attribute

dependency = dependency

use_cache instance-attribute

use_cache = use_cache

signature_model instance-attribute

signature_model = None

_depends instance-attribute

_depends = Depends(dependency, use_cache=use_cache)

value instance-attribute

value = Void

__call__ async

__call__(**kwargs)

Source code in ravyn/injector.py

async def __call__(self, **kwargs: dict[str, Any]) -> Any:
    if self.use_cache and self.value is not Void:
        return self.value

    try:
        if is_async_callable(self.dependency):
            value = await self.dependency(**kwargs)
        else:
            value = self.dependency(**kwargs)
    except TypeError as e:
        raise ImproperlyConfigured(str(e)) from e

    if self.use_cache:
        self.value = value

    return value

__eq__

__eq__(other)

Source code in ravyn/injector.py

def __eq__(self, other: Any) -> bool:
    return other is self or (
        isinstance(other, self.__class__)
        and other.dependency == self.dependency
        and other.use_cache == self.use_cache
        and getattr(other, "value", Void) == getattr(self, "value", Void)
    )

__hash__

__hash__()

Source code in ravyn/injector.py

def __hash__(self) -> int:
    values: dict[str, Any] = {}
    for key, value in self.__dict__.items():
        values[key] = None
        if isinstance(value, (list, set)):
            values[key] = tuple(value)
        else:
            values[key] = value
    return hash((type(self),) + tuple(values))

    - "!^model_config"
    - "!^__hash__"
    - "!^__call__"
    - "!^__eq__"

ravyn.Injects

Injects(
    default=Undefined,
    skip_validation=False,
    allow_none=True,
)

Bases: FieldInfo

Creates a FieldInfo class with extra parameters. This is used for dependencies and to inject them.

Example

@get(dependencies={"value": Inject(lambda: 13)})
def myview(value: Injects()):
    return {"value": value}

Source code in ravyn/injector.py

def __init__(
    self,
    default: Any = Undefined,
    skip_validation: bool = False,
    allow_none: bool = True,
) -> None:
    self.allow_none = allow_none
    self.extra: dict[str, Any] = {
        IS_DEPENDENCY: True,
        SKIP_VALIDATION: skip_validation,
        "allow_none": self.allow_none,
    }
    super().__init__(default=default, json_schema_extra=self.extra)

allow_none instance-attribute

allow_none = allow_none

extra instance-attribute

extra = {
    IS_DEPENDENCY: True,
    SKIP_VALIDATION: skip_validation,
    "allow_none": allow_none,
}

    - "!^model_config"
    - "!^__hash__"
    - "!^__call__"
    - "!^__eq__"

ravyn.Factory

Factory(provides, *args, **kwargs)

A dependency injection factory that supports both positional and keyword arguments.

The provider can be passed as either: - A direct callable - A string reference to be dynamically imported

Example Usage

dependencies = { "user": Factory(UserDAO, db_session=session, cache=cache) }

Source code in ravyn/injector.py

def __init__(self, provides: Union["AnyCallable", str], *args: Any, **kwargs: Any) -> None:
    """
    A dependency injection factory that supports both positional and keyword arguments.

    The provider can be passed as either:
    - A direct callable
    - A string reference to be dynamically imported

    Example Usage:
        dependencies = {
            "user": Factory(UserDAO, db_session=session, cache=cache)
        }
    """
    self.__args: tuple[Any, ...] = args
    self.__kwargs: dict[str, Any] = kwargs
    self.is_nested: bool = False

    if isinstance(provides, str):
        self.provides, self.is_nested = load_provider(provides)
    else:
        self.provides = provides

__args instance-attribute

__args = args

__kwargs instance-attribute

__kwargs = kwargs

is_nested instance-attribute

is_nested = False

provides instance-attribute

provides = provides

cls property

cls

Return the provided class or function.

set_args

set_args(*args, **kwargs)

Set or update arguments dynamically.

Source code in ravyn/injector.py

def set_args(self, *args: Any, **kwargs: Any) -> None:
    """Set or update arguments dynamically."""
    self.__args = args
    self.__kwargs = kwargs

__call__ async

__call__()

Instantiates the provided class/function, handling both sync and async cases.

Supports

• Nested imports (e.g., MyClass.func, MyClass.SubClass.func)
• Both sync and async callables
• Positional and keyword arguments

Example

Factory(UserDAO, db_session=session)

Source code in ravyn/injector.py

async def __call__(self) -> Any:
    """
    Instantiates the provided class/function, handling both sync and async cases.

    Supports:
        - Nested imports (e.g., MyClass.func, MyClass.SubClass.func)
        - Both sync and async callables
        - Positional and keyword arguments

    Example:
        Factory(UserDAO, db_session=session)
    """
    if self.is_nested:
        self.provides = self.provides()

    if is_async_callable(self.provides):
        return await self.provides(*self.__args, **self.__kwargs)
    return self.provides(*self.__args, **self.__kwargs)

    - "!^model_config"
    - "!^__hash__"
    - "!^__call__"
    - "!^__eq__"