anydi 0.25.0a1__py3-none-any.whl → 0.25.1__py3-none-any.whl

anydi/_container.py

@@ -15,21 +15,16 @@ from typing import (
     Awaitable,
     Callable,
     ContextManager,
-    Dict,
     Iterable,
     Iterator,
-    List,
     Mapping,
-    Optional,
     Sequence,
-    Type,
     TypeVar,
-    Union,
     cast,
     overload,
 )
 
-from typing_extensions import Annotated, ParamSpec, final, get_args, get_origin
+from typing_extensions import ParamSpec, final, get_args, get_origin
 
 try:
     from types import NoneType
@@ -48,12 +43,18 @@ from ._logger import logger
 from ._module import Module, ModuleRegistry
 from ._scanner import Scanner
 from ._types import AnyInterface, Interface, Provider, Scope, is_marker
-from ._utils import get_full_qualname, get_signature, is_builtin_type
+from ._utils import (
+    get_full_qualname,
+    get_typed_parameters,
+    get_typed_return_annotation,
+    has_resource_origin,
+    is_builtin_type,
+)
 
 T = TypeVar("T", bound=Any)
 P = ParamSpec("P")
 
-ALLOWED_SCOPES: Dict[Scope, List[Scope]] = {
+ALLOWED_SCOPES: dict[Scope, list[Scope]] = {
     "singleton": ["singleton"],
     "request": ["request", "singleton"],
     "transient": ["transient", "singleton", "request"],
@@ -71,10 +72,9 @@ class Container:
     def __init__(
         self,
         *,
-        providers: Optional[Mapping[Type[Any], Provider]] = None,
-        modules: Optional[
-            Sequence[Union[Module, Type[Module], Callable[[Container], None]]]
-        ] = None,
+        providers: Mapping[type[Any], Provider] | None = None,
+        modules: Sequence[Module | type[Module] | Callable[[Container], None]]
+        | None = None,
         strict: bool = False,
     ) -> None:
         """Initialize the AnyDI instance.
@@ -84,13 +84,13 @@ class Container:
             modules: Optional sequence of modules to register during initialization.
             strict: Whether to enable strict mode. Defaults to False.
         """
-        self._providers: Dict[Type[Any], Provider] = {}
+        self._providers: dict[type[Any], Provider] = {}
         self._singleton_context = SingletonContext(self)
         self._transient_context = TransientContext(self)
-        self._request_context_var: ContextVar[Optional[RequestContext]] = ContextVar(
+        self._request_context_var: ContextVar[RequestContext | None] = ContextVar(
             "request_context", default=None
         )
-        self._override_instances: Dict[Type[Any], Any] = {}
+        self._override_instances: dict[type[Any], Any] = {}
         self._strict = strict
 
         # Components
@@ -117,7 +117,7 @@ class Container:
         return self._strict
 
     @property
-    def providers(self) -> Dict[Type[Any], Provider]:
+    def providers(self) -> dict[type[Any], Provider]:
         """Get the registered providers.
 
         Returns:
@@ -333,7 +333,7 @@ class Container:
         """
         related_providers = []
 
-        for parameter in provider.parameters.values():
+        for parameter in provider.parameters:
             if parameter.annotation is inspect._empty:  # noqa
                 raise TypeError(
                     f"Missing provider `{provider}` "
@@ -363,7 +363,7 @@ class Container:
                     "registered with matching scopes."
                 )
 
-    def _detect_scope(self, obj: Callable[..., Any]) -> Optional[Scope]:
+    def _detect_scope(self, obj: Callable[..., Any]) -> Scope | None:
         """Detect the scope for a provider.
 
         Args:
@@ -372,7 +372,7 @@ class Container:
             The auto scope, or None if the auto scope cannot be detected.
         """
         has_transient, has_request, has_singleton = False, False, False
-        for parameter in get_signature(obj).parameters.values():
+        for parameter in get_typed_parameters(obj):
             sub_provider = self._get_or_register_provider(parameter.annotation)
             if not has_transient and sub_provider.scope == "transient":
                 has_transient = True
@@ -389,7 +389,7 @@ class Container:
         return None
 
     def register_module(
-        self, module: Union[Module, Type[Module], Callable[[Container], None]]
+        self, module: Module | type[Module] | Callable[[Container], None]
     ) -> None:
         """Register a module as a callable, module type, or module instance.
 
@@ -633,14 +633,11 @@ class Container:
     def inject(self) -> Callable[[Callable[P, T]], Callable[P, T]]: ...
 
     def inject(
-        self, obj: Union[Callable[P, Union[T, Awaitable[T]]], None] = None
-    ) -> Union[
-        Callable[
-            [Callable[P, Union[T, Awaitable[T]]]],
-            Callable[P, Union[T, Awaitable[T]]],
-        ],
-        Callable[P, Union[T, Awaitable[T]]],
-    ]:
+        self, obj: Callable[P, T | Awaitable[T]] | None = None
+    ) -> (
+        Callable[[Callable[P, T | Awaitable[T]]], Callable[P, T | Awaitable[T]]]
+        | Callable[P, T | Awaitable[T]]
+    ):
         """Decorator to inject dependencies into a callable.
 
         Args:
@@ -652,8 +649,8 @@ class Container:
         """
 
         def decorator(
-            obj: Callable[P, Union[T, Awaitable[T]]],
-        ) -> Callable[P, Union[T, Awaitable[T]]]:
+            obj: Callable[P, T | Awaitable[T]],
+        ) -> Callable[P, T | Awaitable[T]]:
             injected_params = self._get_injected_params(obj)
 
             if inspect.iscoroutinefunction(obj):
@@ -694,12 +691,9 @@ class Container:
     def scan(
         self,
         /,
-        packages: Union[
-            Union[types.ModuleType, str],
-            Iterable[Union[types.ModuleType, str]],
-        ],
+        packages: types.ModuleType | str | Iterable[types.ModuleType | str],
         *,
-        tags: Optional[Iterable[str]] = None,
+        tags: Iterable[str] | None = None,
     ) -> None:
         """Scan packages or modules for decorated members and inject dependencies.
 
@@ -723,32 +717,28 @@ class Container:
         Raises:
             TypeError: If the provider return annotation is missing or invalid.
         """
-        annotation = get_signature(obj).return_annotation
+        annotation = get_typed_return_annotation(obj)
 
-        if annotation is inspect._empty:  # noqa
+        if annotation is None:
             raise TypeError(
                 f"Missing `{get_full_qualname(obj)}` provider return annotation."
             )
 
-        origin = get_origin(annotation) or annotation
-        args = get_args(annotation)
+        origin = get_origin(annotation)
 
-        # Supported generic types
-        if origin in (list, dict, tuple, Annotated):
+        if has_resource_origin(origin):
+            args = get_args(annotation)
             if args:
-                return annotation
+                return args[0]
             else:
                 raise TypeError(
-                    f"Cannot use `{get_full_qualname(obj)}` generic type annotation "
+                    f"Cannot use `{get_full_qualname(obj)}` resource type annotation "
                     "without actual type."
                 )
 
-        try:
-            return args[0]
-        except IndexError:
-            return annotation
+        return annotation
 
-    def _get_injected_params(self, obj: Callable[..., Any]) -> Dict[str, Any]:
+    def _get_injected_params(self, obj: Callable[..., Any]) -> dict[str, Any]:
         """Get the injected parameters of a callable object.
 
         Args:
@@ -759,7 +749,7 @@ class Container:
                 of the injected parameters.
         """
         injected_params = {}
-        for parameter in get_signature(obj).parameters.values():
+        for parameter in get_typed_parameters(obj):
             if not is_marker(parameter.default):
                 continue
             try:

anydi/_context.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import abc
 import contextlib
 from types import TracebackType
-from typing import TYPE_CHECKING, Any, Dict, List, Tuple, Type, TypeVar, cast
+from typing import TYPE_CHECKING, Any, TypeVar, cast
 
 from typing_extensions import Self, final
 
@@ -87,7 +87,7 @@ class ScopedContext(abc.ABC):
 
     def _get_provider_arguments(
         self, provider: Provider
-    ) -> Tuple[List[Any], Dict[str, Any]]:
+    ) -> tuple[list[Any], dict[str, Any]]:
         """Retrieve the arguments for a provider.
 
         Args:
@@ -97,7 +97,7 @@ class ScopedContext(abc.ABC):
             The arguments for the provider.
         """
         args, kwargs = [], {}
-        for parameter in provider.parameters.values():
+        for parameter in provider.parameters:
             instance = self.container.resolve(parameter.annotation)
             if parameter.kind == parameter.POSITIONAL_ONLY:
                 args.append(instance)
@@ -107,7 +107,7 @@ class ScopedContext(abc.ABC):
 
     async def _aget_provider_arguments(
         self, provider: Provider
-    ) -> Tuple[List[Any], Dict[str, Any]]:
+    ) -> tuple[list[Any], dict[str, Any]]:
         """Asynchronously retrieve the arguments for a provider.
 
         Args:
@@ -117,7 +117,7 @@ class ScopedContext(abc.ABC):
             The arguments for the provider.
         """
         args, kwargs = [], {}
-        for parameter in provider.parameters.values():
+        for parameter in provider.parameters:
             instance = await self.container.aresolve(parameter.annotation)
             if parameter.kind == parameter.POSITIONAL_ONLY:
                 args.append(instance)
@@ -132,7 +132,7 @@ class ResourceScopedContext(ScopedContext):
     def __init__(self, container: Container) -> None:
         """Initialize the ScopedContext."""
         super().__init__(container)
-        self._instances: Dict[Type[Any], Any] = {}
+        self._instances: dict[type[Any], Any] = {}
         self._stack = contextlib.ExitStack()
         self._async_stack = contextlib.AsyncExitStack()
 
@@ -237,7 +237,7 @@ class ResourceScopedContext(ScopedContext):
 
     def __exit__(
         self,
-        exc_type: Type[BaseException] | None,
+        exc_type: type[BaseException] | None,
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
     ) -> None:
@@ -265,7 +265,7 @@ class ResourceScopedContext(ScopedContext):
 
     async def __aexit__(
         self,
-        exc_type: Type[BaseException] | None,
+        exc_type: type[BaseException] | None,
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
     ) -> None:

anydi/_module.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import inspect
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Tuple, Type, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Callable, TypeVar
 
 from typing_extensions import Concatenate, NamedTuple, ParamSpec
 
@@ -24,7 +24,7 @@ class ModuleMeta(type):
     and stores it in the `providers` attribute.
     """
 
-    def __new__(cls, name: str, bases: Tuple[type, ...], attrs: Dict[str, Any]) -> Any:
+    def __new__(cls, name: str, bases: tuple[type, ...], attrs: dict[str, Any]) -> Any:
         """Create a new instance of the ModuleMeta class.
 
         This method extracts provider information from the class attributes and
@@ -49,7 +49,7 @@ class ModuleMeta(type):
 class Module(metaclass=ModuleMeta):
     """A base class for defining AnyDI modules."""
 
-    providers: List[Tuple[str, ProviderDecoratorArgs]]
+    providers: list[tuple[str, ProviderDecoratorArgs]]
 
     def configure(self, container: Container) -> None:
         """Configure the AnyDI container with providers and their dependencies.
@@ -67,7 +67,7 @@ class ModuleRegistry:
         self.container = container
 
     def register(
-        self, module: Union[Module, Type[Module], Callable[[Container], None]]
+        self, module: Module | type[Module] | Callable[[Container], None]
     ) -> None:
         """Register a module as a callable, module type, or module instance.
 

anydi/_scanner.py

@@ -10,8 +10,6 @@ from typing import (
     Any,
     Callable,
     Iterable,
-    List,
-    Optional,
     TypeVar,
     Union,
     cast,
@@ -22,7 +20,7 @@ from typing import (
 from typing_extensions import NamedTuple, ParamSpec
 
 from ._types import is_marker
-from ._utils import get_signature
+from ._utils import get_typed_parameters
 
 if TYPE_CHECKING:
     from ._container import Container
@@ -56,9 +54,9 @@ class Scanner:
     def scan(
         self,
         /,
-        packages: Union[Union[ModuleType, str], Iterable[Union[ModuleType, str]]],
+        packages: ModuleType | str | Iterable[ModuleType | str],
         *,
-        tags: Optional[Iterable[str]] = None,
+        tags: Iterable[str] | None = None,
     ) -> None:
         """Scan packages or modules for decorated members and inject dependencies.
 
@@ -68,10 +66,10 @@ class Scanner:
             tags: Optional list of tags to filter the scanned members. Only members
                 with at least one matching tag will be scanned. Defaults to None.
         """
-        dependencies: List[Dependency] = []
+        dependencies: list[Dependency] = []
 
         if isinstance(packages, Iterable) and not isinstance(packages, str):
-            scan_packages: Iterable[Union[ModuleType, str]] = packages
+            scan_packages: Iterable[ModuleType | str] = packages
         else:
             scan_packages = cast(Iterable[Union[ModuleType, str]], [packages])
 
@@ -84,10 +82,10 @@ class Scanner:
 
     def _scan_package(
         self,
-        package: Union[ModuleType, str],
+        package: ModuleType | str,
         *,
-        tags: Optional[Iterable[str]] = None,
-    ) -> List[Dependency]:
+        tags: Iterable[str] | None = None,
+    ) -> list[Dependency]:
         """Scan a package or module for decorated members.
 
         Args:
@@ -107,7 +105,7 @@ class Scanner:
         if not package_path:
             return self._scan_module(package, tags=tags)
 
-        dependencies: List[Dependency] = []
+        dependencies: list[Dependency] = []
 
         for module_info in pkgutil.walk_packages(
             path=package_path, prefix=package.__name__ + "."
@@ -119,7 +117,7 @@ class Scanner:
 
     def _scan_module(
         self, module: ModuleType, *, tags: Iterable[str]
-    ) -> List[Dependency]:
+    ) -> list[Dependency]:
         """Scan a module for decorated members.
 
         Args:
@@ -130,7 +128,7 @@ class Scanner:
         Returns:
             A list of scanned dependencies.
         """
-        dependencies: List[Dependency] = []
+        dependencies: list[Dependency] = []
 
         for _, member in inspect.getmembers(module):
             if getattr(member, "__module__", None) != module.__name__ or not callable(
@@ -159,10 +157,10 @@ class Scanner:
 
             # Get by Marker
             if inspect.isclass(member):
-                signature = get_signature(member.__init__)
+                parameters = get_typed_parameters(member.__init__)
             else:
-                signature = get_signature(member)
-            for parameter in signature.parameters.values():
+                parameters = get_typed_parameters(member)
+            for parameter in parameters:
                 if is_marker(parameter.default):
                     dependencies.append(
                         self._create_dependency(member=member, module=module)
@@ -188,7 +186,7 @@ class Scanner:
 
 class InjectDecoratorArgs(NamedTuple):
     wrapped: bool
-    tags: Optional[Iterable[str]]
+    tags: Iterable[str] | None
 
 
 @overload
@@ -197,20 +195,14 @@ def injectable(obj: Callable[P, T]) -> Callable[P, T]: ...
 
 @overload
 def injectable(
-    *, tags: Optional[Iterable[str]] = None
+    *, tags: Iterable[str] | None = None
 ) -> Callable[[Callable[P, T]], Callable[P, T]]: ...
 
 
 def injectable(
-    obj: Optional[Callable[P, T]] = None,
-    tags: Optional[Iterable[str]] = None,
-) -> Union[
-    Callable[
-        [Callable[P, T]],
-        Callable[P, T],
-    ],
-    Callable[P, T],
-]:
+    obj: Callable[P, T] | None = None,
+    tags: Iterable[str] | None = None,
+) -> Callable[[Callable[P, T]], Callable[P, T]] | Callable[P, T]:
     """Decorator for marking a function or method as requiring dependency injection.
 
     Args:

anydi/_types.py

@@ -1,11 +1,13 @@
+from __future__ import annotations
+
 import inspect
 from dataclasses import dataclass
 from functools import cached_property
 from typing import Any, Callable, Type, TypeVar, Union
 
-from typing_extensions import Annotated, Literal, Mapping, Self, TypeAlias
+from typing_extensions import Annotated, Literal, Self, TypeAlias
 
-from ._utils import get_full_qualname, get_signature
+from ._utils import get_full_qualname, get_typed_parameters
 
 Scope = Literal["transient", "singleton", "request"]
 
@@ -58,13 +60,13 @@ class Provider:
         return get_full_qualname(self.obj)
 
     @cached_property
-    def parameters(self) -> Mapping[str, inspect.Parameter]:
+    def parameters(self) -> list[inspect.Parameter]:
         """Returns the parameters of the provider as a mapping.
 
         Returns:
             The parameters of the provider.
         """
-        return get_signature(self.obj).parameters
+        return get_typed_parameters(self.obj)
 
     @cached_property
     def is_class(self) -> bool:

anydi/_utils.py

@@ -1,10 +1,12 @@
 """Shared AnyDI utils module."""
 
+from __future__ import annotations
+
 import builtins
 import functools
 import inspect
 import sys
-from typing import Any, Callable, Dict, Type, TypeVar
+from typing import Any, AsyncIterator, Callable, ForwardRef, Iterator, TypeVar, cast
 
 from typing_extensions import Annotated, ParamSpec, get_origin
 
@@ -14,22 +16,23 @@ except ImportError:
     anyio = None  # type: ignore[assignment]
 
 
-T = TypeVar("T")
-P = ParamSpec("P")
+if sys.version_info < (3, 9):  # pragma: nocover
 
+    def evaluate_forwardref(type_: ForwardRef, globalns: Any, localns: Any) -> Any:
+        return type_._evaluate(globalns, localns)  # noqa
 
-def get_full_qualname(obj: Any) -> str:
-    """Get the fully qualified name of an object.
+else:
+
+    def evaluate_forwardref(type_: ForwardRef, globalns: Any, localns: Any) -> Any:
+        return cast(Any, type_)._evaluate(globalns, localns, set())  # noqa
 
-    This function returns the fully qualified name of the given object,
-    which includes both the module name and the object's qualname.
 
-    Args:
-        obj: The object for which to retrieve the fully qualified name.
+T = TypeVar("T")
+P = ParamSpec("P")
+
 
-    Returns:
-        The fully qualified name of the object.
-    """
+def get_full_qualname(obj: Any) -> str:
+    """Get the fully qualified name of an object."""
     origin = get_origin(obj)
     if origin is Annotated:
         metadata = ", ".join(
@@ -53,35 +56,55 @@ def get_full_qualname(obj: Any) -> str:
     return f"{module_name}.{qualname}"
 
 
-def is_builtin_type(tp: Type[Any]) -> bool:
-    """
-    Check if the given type is a built-in type.
-    Args:
-        tp (type): The type to check.
-    Returns:
-        bool: True if the type is a built-in type, False otherwise.
-    """
+def is_builtin_type(tp: type[Any]) -> bool:
+    """Check if the given type is a built-in type."""
     return tp.__module__ == builtins.__name__
 
 
-@functools.lru_cache(maxsize=None)
-def get_signature(obj: Callable[..., Any]) -> inspect.Signature:
-    """Get the signature of a callable object.
+def make_forwardref(annotation: str, globalns: dict[str, Any]) -> Any:
+    """Create a forward reference from a string annotation."""
+    forward_ref = ForwardRef(annotation)
+    return evaluate_forwardref(forward_ref, globalns, globalns)
+
 
-    This function uses the `inspect.signature` function to retrieve the signature
-    of the given callable object. It applies an LRU cache decorator to improve
-    performance by caching the signatures of previously inspected objects.
+def get_typed_annotation(annotation: Any, globalns: dict[str, Any]) -> Any:
+    """Get the typed annotation of a parameter."""
+    if isinstance(annotation, str):
+        annotation = ForwardRef(annotation)
+        annotation = evaluate_forwardref(annotation, globalns, globalns)
+    return annotation
 
-    Args:
-        obj: The callable object to inspect.
 
-    Returns:
-        The signature of the callable object.
-    """
-    signature_kwargs: Dict[str, Any] = {}
-    if sys.version_info >= (3, 10):
-        signature_kwargs["eval_str"] = True
-    return inspect.signature(obj, **signature_kwargs)
+def get_typed_return_annotation(obj: Callable[..., Any]) -> Any:
+    """Get the typed return annotation of a callable object."""
+    signature = inspect.signature(obj)
+    annotation = signature.return_annotation
+    if annotation is inspect.Signature.empty:
+        return None
+    globalns = getattr(obj, "__globals__", {})
+    return get_typed_annotation(annotation, globalns)
+
+
+def get_typed_parameters(obj: Callable[..., Any]) -> list[inspect.Parameter]:
+    """Get the typed parameters of a callable object."""
+    globalns = getattr(obj, "__globals__", {})
+    return [
+        parameter.replace(
+            annotation=get_typed_annotation(parameter.annotation, globalns)
+        )
+        for name, parameter in inspect.signature(obj).parameters.items()
+    ]
+
+
+_resource_origins = (
+    get_origin(Iterator),
+    get_origin(AsyncIterator),
+)
+
+
+def has_resource_origin(origin: Any) -> bool:
+    """Check if the given origin is a resource origin."""
+    return origin in _resource_origins
 
 
 async def run_async(
@@ -90,19 +113,7 @@ async def run_async(
     *args: P.args,
     **kwargs: P.kwargs,
 ) -> T:
-    """Runs the given function asynchronously using the `anyio` library.
-
-    Args:
-        func: The function to run asynchronously.
-        args: The positional arguments to pass to the function.
-        kwargs: The keyword arguments to pass to the function.
-
-    Returns:
-        The result of the function.
-
-    Raises:
-        ImportError: If the `anyio` library is not installed.
-    """
+    """Runs the given function asynchronously using the `anyio` library."""
     if not anyio:
         raise ImportError(
             "`anyio` library is not currently installed. Please make sure to install "

anydi/ext/django/__init__.py

@@ -1,3 +1,9 @@
 from ._container import container
+from ._utils import inject_urlpatterns, register_components, register_settings
 
-__all__ = ["container"]
+__all__ = [
+    "container",
+    "register_components",
+    "register_settings",
+    "inject_urlpatterns",
+]

anydi/ext/django/_settings.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from typing import Sequence
+
+from django.conf import settings
+from typing_extensions import TypedDict
+
+
+class Settings(TypedDict):
+    CONTAINER_FACTORY: str | None
+    STRICT_MODE: bool
+    REGISTER_SETTINGS: bool
+    REGISTER_COMPONENTS: bool
+    INJECT_URLCONF: str | Sequence[str] | None
+    MODULES: Sequence[str]
+    SCAN_PACKAGES: Sequence[str]
+    PATCH_NINJA: bool
+
+
+DEFAULTS = Settings(
+    CONTAINER_FACTORY=None,
+    STRICT_MODE=False,
+    REGISTER_SETTINGS=False,
+    REGISTER_COMPONENTS=False,
+    MODULES=[],
+    PATCH_NINJA=False,
+    INJECT_URLCONF=None,
+    SCAN_PACKAGES=[],
+)
+
+
+def get_settings() -> Settings:
+    """Get the AnyDI settings from the Django settings."""
+    return Settings(
+        **{
+            **DEFAULTS,
+            **getattr(settings, "ANYDI", {}),
+        }
+    )

anydi/ext/django/_utils.py

@@ -1,6 +1,107 @@
+from __future__ import annotations
+
 from collections.abc import Iterator
+from functools import wraps
+from typing import Any
+
+from django.conf import settings
+from django.core.cache import BaseCache, caches
+from django.db import connections
+from django.db.backends.base.base import BaseDatabaseWrapper
+from django.urls import URLPattern, URLResolver, get_resolver
+from typing_extensions import Annotated, get_origin
+
+import anydi
+
+
+def register_settings(
+    container: anydi.Container, prefix: str = "django.conf.setting."
+) -> None:
+    """Register Django settings into the container."""
+
+    def _get_setting_value(value: Any) -> Any:
+        return lambda: value
+
+    for setting_name in dir(settings):
+        setting_value = getattr(settings, setting_name)
+        if not setting_name.isupper():
+            continue
+
+        container.register(
+            Annotated[Any, f"{prefix}{setting_name}"],
+            _get_setting_value(setting_value),
+            scope="singleton",
+        )
+
+    def _resolve(resolve: Any) -> Any:
+        @wraps(resolve)
+        def wrapper(interface: Any) -> Any:
+            return resolve(_aware_settings(interface, prefix))
+
+        return wrapper
+
+    def _aresolve(resolve: Any) -> Any:
+        @wraps(resolve)
+        async def wrapper(interface: Any) -> Any:
+            return await resolve(_aware_settings(interface, prefix))
+
+        return wrapper
+
+    # Patch resolvers
+    container.resolve = _resolve(container.resolve)  # type: ignore[method-assign]  # noqa
+    container.aresolve = _aresolve(container.aresolve)  # type: ignore[method-assign]  # noqa
+
+
+def _aware_settings(interface: Any, prefix: str) -> Any:
+    origin = get_origin(interface)
+    if origin is not Annotated:
+        return interface  # pragma: no cover
+    named = interface.__metadata__[-1]
+
+    if isinstance(named, str) and named.startswith(prefix):
+        _, setting_name = named.rsplit(prefix, maxsplit=1)
+        return Annotated[Any, f"{prefix}{setting_name}"]
+    return interface
+
+
+def register_components(container: anydi.Container) -> None:
+    """Register Django components into the container."""
+
+    # Register caches
+    def _get_cache(cache_name: str) -> Any:
+        return lambda: caches[cache_name]
+
+    for cache_name in caches:
+        container.register(
+            Annotated[BaseCache, cache_name],
+            _get_cache(cache_name),
+            scope="singleton",
+        )
+
+    # Register database connections
+    def _get_connection(alias: str) -> Any:
+        return lambda: connections[alias]
+
+    for alias in connections:
+        container.register(
+            Annotated[BaseDatabaseWrapper, alias],
+            _get_connection(alias),
+            scope="singleton",
+        )
+
 
-from django.urls import URLPattern, URLResolver
+def inject_urlpatterns(container: anydi.Container, *, urlconf: str) -> None:
+    """Auto-inject the container into views."""
+    resolver = get_resolver(urlconf)
+    for pattern in iter_urlpatterns(resolver.url_patterns):
+        # Skip already injected views
+        if hasattr(pattern.callback, "_injected"):
+            continue
+        # Skip django-ninja views
+        if pattern.lookup_str.startswith("ninja."):
+            continue  # pragma: no cover
+        pattern.callback = container.inject(pattern.callback)
+        pattern.callback._injected = True  # type: ignore[attr-defined]
 
 
 def iter_urlpatterns(

anydi/ext/django/apps.py

@@ -1,22 +1,18 @@
+from __future__ import annotations
+
 import logging
 import types
-from asyncio import get_running_loop
-from functools import wraps
-from typing import Any, Callable, cast
+from typing import Callable, cast
 
 from django.apps import AppConfig
 from django.conf import settings
-from django.core.cache import BaseCache, caches
 from django.core.exceptions import ImproperlyConfigured
-from django.db import connections
-from django.db.backends.base.base import BaseDatabaseWrapper
-from django.urls import get_resolver
 from django.utils.module_loading import import_string
-from typing_extensions import Annotated, get_origin
 
 import anydi
 
-from ._utils import iter_urlpatterns
+from ._settings import get_settings
+from ._utils import inject_urlpatterns, register_components, register_settings
 
 logger = logging.getLogger(__name__)
 
@@ -25,39 +21,44 @@ class ContainerConfig(AppConfig):  # type: ignore[misc]
     name = "anydi.ext.django"
     label = "anydi_django"
 
-    # Prefix for Django settings
-    settings_prefix = "django.conf.settings."
-
     def __init__(self, app_name: str, app_module: types.ModuleType | None) -> None:
         super().__init__(app_name, app_module)
+        self.settings = get_settings()
         # Create a container
-        container_getter_path = getattr(settings, "ANYDI_CONTAINER_GETTER", None)
-        if container_getter_path:
+        container_factory_path = self.settings["CONTAINER_FACTORY"]
+        if container_factory_path:
             try:
-                container_getter = cast(
-                    Callable[[], anydi.Container], import_string(container_getter_path)
+                container_factory = cast(
+                    Callable[[], anydi.Container], import_string(container_factory_path)
                 )
             except ImportError as exc:
                 raise ImproperlyConfigured(
-                    f"Cannot import container getter '{container_getter_path}'."
+                    f"Cannot import container factory '{container_factory_path}'."
                 ) from exc
-            self.container = container_getter()
+            self.container = container_factory()
         else:
             self.container = anydi.Container(
-                strict=getattr(settings, "ANYDI_STRICT_MODE", False),
+                strict=self.settings["STRICT_MODE"],
             )
 
     def ready(self) -> None:  # noqa: C901
         # Register Django settings
-        if getattr(settings, "ANYDI_REGISTER_SETTINGS", False):
-            self.register_settings()
+        if self.settings["REGISTER_SETTINGS"]:
+            register_settings(
+                self.container,
+                prefix=getattr(
+                    settings,
+                    "ANYDI_SETTINGS_PREFIX",
+                    "django.conf.settings.",
+                ),
+            )
 
         # Register Django components
-        if getattr(settings, "ANYDI_REGISTER_COMPONENTS", False):
-            self.register_components()
+        if self.settings["REGISTER_COMPONENTS"]:
+            register_components(self.container)
 
         # Register modules
-        for module_path in getattr(settings, "ANYDI_MODULES", []):
+        for module_path in self.settings["MODULES"]:
             try:
                 module_cls = import_string(module_path)
             except ImportError as exc:
@@ -67,111 +68,18 @@ class ContainerConfig(AppConfig):  # type: ignore[misc]
             self.container.register_module(module_cls)
 
         # Patching the django-ninja framework if it installed
-        if getattr(settings, "ANYDI_PATCH_NINJA", False):
-            self.patch_ninja()
+        if self.settings["PATCH_NINJA"]:
+            from .ninja import patch_ninja
+
+            patch_ninja()
 
         # Auto-injecting the container into views
-        if urlconf := getattr(settings, "ANYDI_AUTO_INJECT_URLCONF", None):
-            self.auto_inject_urlconf(urlconf)
+        if urlconf := self.settings["INJECT_URLCONF"]:
+            if isinstance(urlconf, str):
+                urlconf = [urlconf]
+            for u in urlconf:
+                inject_urlpatterns(self.container, urlconf=u)
 
         # Scan packages
-        for scan_package in getattr(settings, "ANYDI_SCAN_PACKAGES", []):
+        for scan_package in self.settings["SCAN_PACKAGES"]:
             self.container.scan(scan_package)
-
-        # Start the container
-        if getattr(settings, "ANYDI_START_CONTAINER", False):
-            try:
-                get_running_loop()
-            except RuntimeError:
-                logger.warning(
-                    "Starting the container is only supported in an async context."
-                )
-            else:
-                self.container.start()
-
-    def register_settings(self) -> None:  # noqa: C901
-        """Register Django settings into the container."""
-
-        def _get_setting_value(value: Any) -> Any:
-            return lambda: value
-
-        for setting_name in dir(settings):
-            setting_value = getattr(settings, setting_name)
-            if not setting_name.isupper():
-                continue
-
-            self.container.register(
-                Annotated[Any, f"{self.settings_prefix}{setting_name}"],
-                _get_setting_value(setting_value),
-                scope="singleton",
-            )
-
-        def _aware_settings(interface: Any) -> Any:
-            origin = get_origin(interface)
-            if origin is not Annotated:
-                return interface  # pragma: no cover
-            named = interface.__metadata__[-1]
-
-            if isinstance(named, str) and named.startswith(self.settings_prefix):
-                _, setting_name = named.rsplit(self.settings_prefix, maxsplit=1)
-                return Annotated[Any, f"{self.settings_prefix}{setting_name}"]
-            return interface
-
-        def _resolve(resolve: Any) -> Any:
-            @wraps(resolve)
-            def wrapper(interface: Any) -> Any:
-                return resolve(_aware_settings(interface))
-
-            return wrapper
-
-        def _aresolve(resolve: Any) -> Any:
-            @wraps(resolve)
-            async def wrapper(interface: Any) -> Any:
-                return await resolve(_aware_settings(interface))
-
-            return wrapper
-
-        # Patch resolvers
-        self.container.resolve = _resolve(self.container.resolve)  # type: ignore[method-assign]  # noqa
-        self.container.aresolve = _aresolve(self.container.aresolve)  # type: ignore[method-assign]  # noqa
-
-    def register_components(self) -> None:
-        """Register Django components into the container."""
-
-        # Register caches
-        def _get_cache(cache_name: str) -> Any:
-            return lambda: caches[cache_name]
-
-        for cache_name in caches:
-            self.container.register(
-                Annotated[BaseCache, cache_name],
-                _get_cache(cache_name),
-                scope="singleton",
-            )
-
-        # Register database connections
-        def _get_connection(alias: str) -> Any:
-            return lambda: connections[alias]
-
-        for alias in connections:
-            self.container.register(
-                Annotated[BaseDatabaseWrapper, alias],
-                _get_connection(alias),
-                scope="singleton",
-            )
-
-    def auto_inject_urlconf(self, urlconf: str) -> None:
-        """Auto-inject the container into views."""
-        resolver = get_resolver(urlconf)
-        for pattern in iter_urlpatterns(resolver.url_patterns):
-            # Skip django-ninja views
-            if pattern.lookup_str.startswith("ninja."):
-                continue  # pragma: no cover
-            pattern.callback = self.container.inject(pattern.callback)
-
-    @staticmethod
-    def patch_ninja() -> None:
-        """Patch the django-ninja framework."""
-        from .ninja import patch
-
-        patch()

anydi/ext/django/middleware.py

@@ -0,0 +1,26 @@
+from typing import Callable
+
+from asgiref.sync import iscoroutinefunction
+from django.http import HttpRequest, HttpResponse
+from django.utils.decorators import sync_and_async_middleware
+
+from ._container import container
+
+
+@sync_and_async_middleware  # type: ignore[misc]
+def request_scoped_middleware(
+    get_response: Callable[[HttpRequest], HttpResponse],
+) -> Callable[[HttpRequest], HttpResponse]:
+    if iscoroutinefunction(get_response):
+
+        async def async_middleware(request: HttpRequest) -> HttpResponse:
+            async with container.arequest_context():
+                return await get_response(request)
+
+        return async_middleware
+
+    def middleware(request: HttpRequest) -> HttpResponse:
+        with container.request_context():
+            return get_response(request)
+
+    return middleware

anydi/ext/django/ninja/__init__.py

@@ -10,7 +10,7 @@ from ._operation import AsyncOperation, Operation
 from ._signature import ViewSignature
 
 
-def patch() -> None:
+def patch_ninja() -> None:
     operation.ViewSignature = ViewSignature  # type: ignore[attr-defined]
     operation.Operation = Operation  # type: ignore[misc]
     operation.AsyncOperation = AsyncOperation  # type: ignore[misc]

anydi/ext/django/ninja/_operation.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from typing import Any
 
 from django.http import HttpRequest, HttpResponseBase

anydi/ext/django/ninja/_signature.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import inspect
 from collections.abc import Callable
 from typing import Any
@@ -9,7 +11,7 @@ from ninja.signature.details import (
 )
 from ninja.signature.utils import get_path_param_names, get_typed_signature
 
-from anydi._types import Marker  # noqa
+from anydi._types import is_marker  # noqa
 
 
 class ViewSignature(BaseViewSignature):
@@ -44,7 +46,7 @@ class ViewSignature(BaseViewSignature):
                 continue
 
             # Skip default values that are anydi dependency markers
-            if isinstance(arg.default, Marker):
+            if is_marker(arg.default):
                 self.dependencies.append((name, arg.annotation))
                 continue
 

anydi/ext/fastapi.py

@@ -13,7 +13,7 @@ from starlette.requests import Request
 from typing_extensions import Annotated, get_args, get_origin
 
 from anydi import Container
-from anydi._utils import get_full_qualname, get_signature
+from anydi._utils import get_full_qualname, get_typed_parameters
 
 from .starlette.middleware import RequestScopedMiddleware
 
@@ -47,7 +47,7 @@ def install(app: FastAPI, container: Container) -> None:
             call, *params = dependant.cache_key
             if not call:
                 continue  # pragma: no cover
-            for parameter in get_signature(call).parameters.values():
+            for parameter in get_typed_parameters(call):
                 _patch_route_parameter(call, parameter, container)
 
 

anydi/ext/pytest_plugin.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 import inspect
-from typing import Any, Callable, Iterator, List, Tuple, cast
+from typing import Any, Callable, Iterator, cast
 
 import pytest
 
@@ -49,8 +51,8 @@ def _anydi_should_inject(request: pytest.FixtureRequest) -> bool:
 
 
 @pytest.fixture(scope="session")
-def _anydi_unresolved() -> Iterator[List[Any]]:
-    unresolved: List[Any] = []
+def _anydi_unresolved() -> Iterator[list[Any]]:
+    unresolved: list[Any] = []
     yield unresolved
     unresolved.clear()
 
@@ -58,9 +60,9 @@ def _anydi_unresolved() -> Iterator[List[Any]]:
 @pytest.fixture
 def _anydi_injected_parameter_iterator(
     request: pytest.FixtureRequest,
-    _anydi_unresolved: List[str],
-) -> Callable[[], Iterator[Tuple[str, Any]]]:
-    def _iterator() -> Iterator[Tuple[str, inspect.Parameter]]:
+    _anydi_unresolved: list[str],
+) -> Callable[[], Iterator[tuple[str, Any]]]:
+    def _iterator() -> Iterator[tuple[str, inspect.Parameter]]:
         for name, parameter in inspect.signature(request.function).parameters.items():
             if (
                 ((interface := parameter.annotation) is parameter.empty)
@@ -77,8 +79,8 @@ def _anydi_injected_parameter_iterator(
 def _anydi_inject(
     request: pytest.FixtureRequest,
     _anydi_should_inject: bool,
-    _anydi_injected_parameter_iterator: Callable[[], Iterator[Tuple[str, Any]]],
-    _anydi_unresolved: List[str],
+    _anydi_injected_parameter_iterator: Callable[[], Iterator[tuple[str, Any]]],
+    _anydi_unresolved: list[str],
 ) -> None:
     """Inject dependencies into the test function."""
 
@@ -107,8 +109,8 @@ def _anydi_inject(
 async def _anydi_ainject(
     request: pytest.FixtureRequest,
     _anydi_should_inject: bool,
-    _anydi_injected_parameter_iterator: Callable[[], Iterator[Tuple[str, Any]]],
-    _anydi_unresolved: List[str],
+    _anydi_injected_parameter_iterator: Callable[[], Iterator[tuple[str, Any]]],
+    _anydi_unresolved: list[str],
 ) -> None:
     """Inject dependencies into the test function."""
     if not inspect.iscoroutinefunction(request.function) or not _anydi_should_inject:

{anydi-0.25.0a1.dist-info → anydi-0.25.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: anydi
-Version: 0.25.0a1
+Version: 0.25.1
 Summary: Dependency Injection library
 Home-page: https://github.com/antonrh/anydi
 License: MIT
@@ -139,3 +139,59 @@ def say_hello(message: str = Inject()) -> dict[str, str]:
 anydi.ext.fastapi.install(app, container)
 ```
 
+
+
+## Django Ninja Example
+
+*container.py*
+
+```python
+from anydi import Container
+
+
+def get_container() -> Container:
+    container = Container()
+
+    @container.provider(scope="singleton")
+    def message() -> str:
+        return "Hello, World!"
+
+    return container
+```
+
+*settings.py*
+
+```python
+INSTALLED_APPS = [
+    ...
+    "anydi.ext.django",
+]
+
+ANYDI = {
+    "CONTAINER_FACTORY": "myapp.container.get_container",
+    "PATCH_NINJA": True,
+}
+```
+
+*urls.py*
+
+```python
+from django.http import HttpRequest
+from django.urls import path
+from ninja import NinjaAPI
+
+from anydi import auto
+
+api = NinjaAPI()
+
+
+@api.get("/hello")
+def say_hello(request: HttpRequest, message: str = auto) -> dict[str, str]:
+    return {"message": message}
+
+
+urlpatterns = [
+    path("api/", api.urls),
+]
+```
+

anydi-0.25.1.dist-info/RECORD

@@ -0,0 +1,28 @@
+anydi/__init__.py,sha256=aeaBp5vq09sG-e9sqqs9qpUtUIDNfOdFPrlAfE5Ku9E,584
+anydi/_container.py,sha256=rZ0HgWFC7jJuZo7iLjMYnTm4utWBMOeiaPThz8a5sbY,27996
+anydi/_context.py,sha256=k956mFE_pfPdU0fxOJ8YRHBZx7sU_ln8fheYNofbmSs,10215
+anydi/_logger.py,sha256=UpubJUnW83kffFxkhUlObm2DmZX1Pjqoz9YFKS-JOPg,52
+anydi/_module.py,sha256=E1TfLud_Af-MPB83PxIzHVA1jlDW2FGaRP_il1a6y3Y,3675
+anydi/_scanner.py,sha256=cyEk-K2Q8ssZStq8GrxMeEcCuAZMw-RXrjlgWEevKCs,6667
+anydi/_types.py,sha256=vQTrFjsYhlMxfo1nOFem05x2QUJMQkVh4ZaC7W0XZJY,3434
+anydi/_utils.py,sha256=XHVNkd-__SKlWlyeGE2e1Yi-DBr4DPWzZOIVbTrQyMI,3692
+anydi/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anydi/ext/django/__init__.py,sha256=QI1IABCVgSDTUoh7M9WMECKXwB3xvh04HfQ9TOWw1Mk,223
+anydi/ext/django/_container.py,sha256=cxVoYQG16WP0S_Yv4TnLwuaaT7NVEOhLWO-YdALJUb4,418
+anydi/ext/django/_settings.py,sha256=cKzFBGtPCsexZ2ZcInubBukIebhxzNfa3F0KuwoZYaA,844
+anydi/ext/django/_utils.py,sha256=76_T-gxP67qddlRyevAF2oe-FTv9NBJSBgOWxxs0qZQ,3673
+anydi/ext/django/apps.py,sha256=-gj_tqb6goeYMNItr6nwWHYXZwDOdiH8anby0YwnUmw,2866
+anydi/ext/django/middleware.py,sha256=iVHWtE829khMY-BXbNNt0g2FrIApKprna7dCG9ObEis,823
+anydi/ext/django/ninja/__init__.py,sha256=kW3grUgWp_nkWSG_-39ADHMrZLGNcj9TsJ9OW8iWWrk,546
+anydi/ext/django/ninja/_operation.py,sha256=wSWa7D73XTVlOibmOciv2l6JHPe1ERZcXrqI8W-oO2w,2696
+anydi/ext/django/ninja/_signature.py,sha256=2cSzKxBIxXLqtwNuH6GSlmjVJFftoGmleWfyk_NVEWw,2207
+anydi/ext/fastapi.py,sha256=kVUKVKtqCx1Nfnm1oh2BMyB0G7qQKPw6OGfxFlqUqtc,5305
+anydi/ext/pytest_plugin.py,sha256=vtjQCwQ0_saG8qhYAYn2wQzXVrXfwXOEhJlTjGqtXA8,3999
+anydi/ext/starlette/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anydi/ext/starlette/middleware.py,sha256=Ni0BQaPjs_Ha6zcLZYYJ3-XkslTCnL9aCSa06rnRDMI,1139
+anydi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anydi-0.25.1.dist-info/LICENSE,sha256=V6rU8a8fv6o2jQ-7ODHs0XfDFimot8Q6Km6CylRIDTo,1069
+anydi-0.25.1.dist-info/METADATA,sha256=fB_AJZKJ6uqYM9Sd4O5ULmFJWuyJq1i1Vi1zV5AyBJE,5160
+anydi-0.25.1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+anydi-0.25.1.dist-info/entry_points.txt,sha256=GmQblwzxFg42zva1HyBYJJ7TvrTIcSAGBHmyi3bvsi4,42
+anydi-0.25.1.dist-info/RECORD,,

anydi-0.25.0a1.dist-info/RECORD

@@ -1,26 +0,0 @@
-anydi/__init__.py,sha256=aeaBp5vq09sG-e9sqqs9qpUtUIDNfOdFPrlAfE5Ku9E,584
-anydi/_container.py,sha256=LeGrujx8zMzBuR8PD7qNqVJmmLB-frAG74gihX0lxNc,28341
-anydi/_context.py,sha256=btGJzvTMkj5v95rAw6kjOclISKcSugC4wzrHlWlCk_I,10258
-anydi/_logger.py,sha256=UpubJUnW83kffFxkhUlObm2DmZX1Pjqoz9YFKS-JOPg,52
-anydi/_module.py,sha256=1fBo9-RWxo7TeyP0Y2uJokT-NXP2pjik6CXNoeo3l-8,3712
-anydi/_scanner.py,sha256=9S3XbNVFAnHClT3FBo2CWeDBzCLG58i93a1ZJgaMNIo,6775
-anydi/_types.py,sha256=TfqJ7TfudOzGMG4_OliAMMJplu42mXZcZmgmtK2oz14,3412
-anydi/_utils.py,sha256=haRwC6YTTFf6CNTfwsRQ4NZsNByoUkEmE4-rh1-VYLs,3152
-anydi/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-anydi/ext/django/__init__.py,sha256=wsFBQP2j76Ui_0SJlN_8LKhZvEEdxA-w_yoyRAcaM58,59
-anydi/ext/django/_container.py,sha256=cxVoYQG16WP0S_Yv4TnLwuaaT7NVEOhLWO-YdALJUb4,418
-anydi/ext/django/_utils.py,sha256=C-1UabpwgCHUryAT-Pv8vU5QFfBahQlqhjecvihjtgY,430
-anydi/ext/django/apps.py,sha256=qjzKqYIB00qjsSv2RQNVnFMi0lCljmaGtMIy3JMAE0U,6326
-anydi/ext/django/ninja/__init__.py,sha256=FckjVqzXTzlBllFg2PZ62wi432-ydZFyWq6ZkF2LJ9I,540
-anydi/ext/django/ninja/_operation.py,sha256=A_RbMbJyVaafoeBhZpmPQ96l1RQFLA1FchkJC_uRKnM,2660
-anydi/ext/django/ninja/_signature.py,sha256=kdPU0QL3_oloWi43ehi2QJVn_WaRm1klZ6D7sA-SQYo,2177
-anydi/ext/fastapi.py,sha256=zKuo7nNpcMXppUsime5LLKTkAiNrlEtcLRFK4FRur0c,5311
-anydi/ext/pytest_plugin.py,sha256=tmncz2IbIR7FGlgmAtcf00yDKg9SQP9lCFnJBmtHx3A,3976
-anydi/ext/starlette/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-anydi/ext/starlette/middleware.py,sha256=Ni0BQaPjs_Ha6zcLZYYJ3-XkslTCnL9aCSa06rnRDMI,1139
-anydi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-anydi-0.25.0a1.dist-info/LICENSE,sha256=V6rU8a8fv6o2jQ-7ODHs0XfDFimot8Q6Km6CylRIDTo,1069
-anydi-0.25.0a1.dist-info/METADATA,sha256=WvjurCb1o4pBgxTvNh-7KY3-6qocjK0euML7cVagy2E,4373
-anydi-0.25.0a1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-anydi-0.25.0a1.dist-info/entry_points.txt,sha256=GmQblwzxFg42zva1HyBYJJ7TvrTIcSAGBHmyi3bvsi4,42
-anydi-0.25.0a1.dist-info/RECORD,,