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

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

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,
}

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