anydi 0.24.3__tar.gz → 0.25.0a0__tar.gz

{anydi-0.24.3 → anydi-0.25.0a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: anydi
-Version: 0.24.3
+Version: 0.25.0a0
 Summary: Dependency Injection library
 Home-page: https://github.com/antonrh/anydi
 License: MIT
@@ -89,7 +89,7 @@ pip install anydi
 *app.py*
 
 ```python
-from anydi import auto, Container
+from anydi import Container, dep
 
 container = Container()
 
@@ -100,7 +100,7 @@ def message() -> str:
 
 
 @container.inject
-def say_hello(message: str = auto) -> None:
+def say_hello(message: str = dep()) -> None:
     print(message)
 
 

{anydi-0.24.3 → anydi-0.25.0a0}/README.md

@@ -49,7 +49,7 @@ pip install anydi
 *app.py*
 
 ```python
-from anydi import auto, Container
+from anydi import Container, dep
 
 container = Container()
 
@@ -60,7 +60,7 @@ def message() -> str:
 
 
 @container.inject
-def say_hello(message: str = auto) -> None:
+def say_hello(message: str = dep()) -> None:
     print(message)
 
 

{anydi-0.24.3 → anydi-0.25.0a0}/anydi/__init__.py

@@ -1,6 +1,6 @@
 """AnyDI public objects and functions."""
 
-from typing import Any, cast
+from typing import Any
 
 from ._container import Container, request, singleton, transient
 from ._module import Module, provider
@@ -14,7 +14,7 @@ def dep() -> Any:
 
 
 # Alias for dependency auto marker
-auto = cast(Any, Marker())
+auto = dep
 
 
 __all__ = [

{anydi-0.24.3 → anydi-0.25.0a0}/anydi/_container.py

@@ -15,16 +15,21 @@ from typing import (
     Awaitable,
     Callable,
     ContextManager,
+    Dict,
     Iterable,
     Iterator,
+    List,
     Mapping,
+    Optional,
     Sequence,
+    Type,
     TypeVar,
+    Union,
     cast,
     overload,
 )
 
-from typing_extensions import ParamSpec, final, get_args, get_origin
+from typing_extensions import Annotated, ParamSpec, final, get_args, get_origin
 
 try:
     from types import NoneType
@@ -42,18 +47,13 @@ from ._context import (
 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_typed_parameters,
-    get_typed_return_annotation,
-    is_builtin_type,
-)
+from ._types import AnyInterface, Interface, Marker, Provider, Scope
+from ._utils import get_full_qualname, get_signature, 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,9 +71,10 @@ class Container:
     def __init__(
         self,
         *,
-        providers: Mapping[type[Any], Provider] | None = None,
-        modules: Sequence[Module | type[Module] | Callable[[Container], None]]
-        | None = None,
+        providers: Optional[Mapping[Type[Any], Provider]] = None,
+        modules: Optional[
+            Sequence[Union[Module, Type[Module], Callable[[Container], None]]]
+        ] = None,
         strict: bool = False,
     ) -> None:
         """Initialize the AnyDI instance.
@@ -83,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[RequestContext | None] = ContextVar(
+        self._request_context_var: ContextVar[Optional[RequestContext]] = ContextVar(
             "request_context", default=None
         )
-        self._override_instances: dict[type[Any], Any] = {}
+        self._override_instances: Dict[Type[Any], Any] = {}
         self._strict = strict
 
         # Components
@@ -116,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:
@@ -332,7 +333,7 @@ class Container:
         """
         related_providers = []
 
-        for parameter in provider.parameters:
+        for parameter in provider.parameters.values():
             if parameter.annotation is inspect._empty:  # noqa
                 raise TypeError(
                     f"Missing provider `{provider}` "
@@ -362,7 +363,7 @@ class Container:
                     "registered with matching scopes."
                 )
 
-    def _detect_scope(self, obj: Callable[..., Any]) -> Scope | None:
+    def _detect_scope(self, obj: Callable[..., Any]) -> Optional[Scope]:
         """Detect the scope for a provider.
 
         Args:
@@ -371,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_typed_parameters(obj):
+        for parameter in get_signature(obj).parameters.values():
             sub_provider = self._get_or_register_provider(parameter.annotation)
             if not has_transient and sub_provider.scope == "transient":
                 has_transient = True
@@ -388,7 +389,7 @@ class Container:
         return None
 
     def register_module(
-        self, module: Module | type[Module] | Callable[[Container], None]
+        self, module: Union[Module, Type[Module], Callable[[Container], None]]
     ) -> None:
         """Register a module as a callable, module type, or module instance.
 
@@ -632,11 +633,14 @@ class Container:
     def inject(self) -> Callable[[Callable[P, T]], Callable[P, T]]: ...
 
     def inject(
-        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]]
-    ):
+        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]]],
+    ]:
         """Decorator to inject dependencies into a callable.
 
         Args:
@@ -648,8 +652,8 @@ class Container:
         """
 
         def decorator(
-            obj: Callable[P, T | Awaitable[T]],
-        ) -> Callable[P, T | Awaitable[T]]:
+            obj: Callable[P, Union[T, Awaitable[T]]],
+        ) -> Callable[P, Union[T, Awaitable[T]]]:
             injected_params = self._get_injected_params(obj)
 
             if inspect.iscoroutinefunction(obj):
@@ -690,9 +694,12 @@ class Container:
     def scan(
         self,
         /,
-        packages: types.ModuleType | str | Iterable[types.ModuleType | str],
+        packages: Union[
+            Union[types.ModuleType, str],
+            Iterable[Union[types.ModuleType, str]],
+        ],
         *,
-        tags: Iterable[str] | None = None,
+        tags: Optional[Iterable[str]] = None,
     ) -> None:
         """Scan packages or modules for decorated members and inject dependencies.
 
@@ -716,26 +723,32 @@ class Container:
         Raises:
             TypeError: If the provider return annotation is missing or invalid.
         """
-        annotation = get_typed_return_annotation(obj)
+        annotation = get_signature(obj).return_annotation
 
-        if annotation is None:
+        if annotation is inspect._empty:  # noqa
             raise TypeError(
                 f"Missing `{get_full_qualname(obj)}` provider return annotation."
             )
 
-        if get_origin(annotation) in (get_origin(Iterator), get_origin(AsyncIterator)):
-            args = get_args(annotation)
+        origin = get_origin(annotation) or annotation
+        args = get_args(annotation)
+
+        # Supported generic types
+        if origin in (list, dict, tuple, Annotated):
             if args:
-                return args[0]
+                return annotation
             else:
                 raise TypeError(
-                    f"Cannot use `{get_full_qualname(obj)}` resource type annotation "
+                    f"Cannot use `{get_full_qualname(obj)}` generic type annotation "
                     "without actual type."
                 )
 
-        return annotation
+        try:
+            return args[0]
+        except IndexError:
+            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:
@@ -746,8 +759,8 @@ class Container:
                 of the injected parameters.
         """
         injected_params = {}
-        for parameter in get_typed_parameters(obj):
-            if not is_marker(parameter.default):
+        for parameter in get_signature(obj).parameters.values():
+            if not isinstance(parameter.default, Marker):
                 continue
             try:
                 self._validate_injected_parameter(obj, parameter)

{anydi-0.24.3 → anydi-0.25.0a0}/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, TypeVar, cast
+from typing import TYPE_CHECKING, Any, Dict, List, Tuple, Type, 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:
+        for parameter in provider.parameters.values():
             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:
+        for parameter in provider.parameters.values():
             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-0.24.3 → anydi-0.25.0a0}/anydi/_module.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import inspect
-from typing import TYPE_CHECKING, Any, Callable, TypeVar
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Tuple, Type, TypeVar, Union
 
 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: Module | type[Module] | Callable[[Container], None]
+        self, module: Union[Module, Type[Module], Callable[[Container], None]]
     ) -> None:
         """Register a module as a callable, module type, or module instance.
 

{anydi-0.24.3 → anydi-0.25.0a0}/anydi/_scanner.py

@@ -10,6 +10,8 @@ from typing import (
     Any,
     Callable,
     Iterable,
+    List,
+    Optional,
     TypeVar,
     Union,
     cast,
@@ -19,8 +21,8 @@ from typing import (
 
 from typing_extensions import NamedTuple, ParamSpec
 
-from ._types import is_marker
-from ._utils import get_typed_parameters
+from ._types import Marker
+from ._utils import get_signature
 
 if TYPE_CHECKING:
     from ._container import Container
@@ -54,9 +56,9 @@ class Scanner:
     def scan(
         self,
         /,
-        packages: ModuleType | str | Iterable[ModuleType | str],
+        packages: Union[Union[ModuleType, str], Iterable[Union[ModuleType, str]]],
         *,
-        tags: Iterable[str] | None = None,
+        tags: Optional[Iterable[str]] = None,
     ) -> None:
         """Scan packages or modules for decorated members and inject dependencies.
 
@@ -66,10 +68,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[ModuleType | str] = packages
+            scan_packages: Iterable[Union[ModuleType, str]] = packages
         else:
             scan_packages = cast(Iterable[Union[ModuleType, str]], [packages])
 
@@ -82,10 +84,10 @@ class Scanner:
 
     def _scan_package(
         self,
-        package: ModuleType | str,
+        package: Union[ModuleType, str],
         *,
-        tags: Iterable[str] | None = None,
-    ) -> list[Dependency]:
+        tags: Optional[Iterable[str]] = None,
+    ) -> List[Dependency]:
         """Scan a package or module for decorated members.
 
         Args:
@@ -105,7 +107,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__ + "."
@@ -117,7 +119,7 @@ class Scanner:
 
     def _scan_module(
         self, module: ModuleType, *, tags: Iterable[str]
-    ) -> list[Dependency]:
+    ) -> List[Dependency]:
         """Scan a module for decorated members.
 
         Args:
@@ -128,7 +130,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(
@@ -157,11 +159,11 @@ class Scanner:
 
             # Get by Marker
             if inspect.isclass(member):
-                parameters = get_typed_parameters(member.__init__)
+                signature = get_signature(member.__init__)
             else:
-                parameters = get_typed_parameters(member)
-            for parameter in parameters:
-                if is_marker(parameter.default):
+                signature = get_signature(member)
+            for parameter in signature.parameters.values():
+                if isinstance(parameter.default, Marker):
                     dependencies.append(
                         self._create_dependency(member=member, module=module)
                     )
@@ -186,7 +188,7 @@ class Scanner:
 
 class InjectDecoratorArgs(NamedTuple):
     wrapped: bool
-    tags: Iterable[str] | None
+    tags: Optional[Iterable[str]]
 
 
 @overload
@@ -195,14 +197,20 @@ def injectable(obj: Callable[P, T]) -> Callable[P, T]: ...
 
 @overload
 def injectable(
-    *, tags: Iterable[str] | None = None
+    *, tags: Optional[Iterable[str]] = None
 ) -> Callable[[Callable[P, T]], Callable[P, T]]: ...
 
 
 def injectable(
-    obj: Callable[P, T] | None = None,
-    tags: Iterable[str] | None = None,
-) -> Callable[[Callable[P, T]], Callable[P, T]] | Callable[P, T]:
+    obj: Optional[Callable[P, T]] = None,
+    tags: Optional[Iterable[str]] = None,
+) -> Union[
+    Callable[
+        [Callable[P, T]],
+        Callable[P, T],
+    ],
+    Callable[P, T],
+]:
     """Decorator for marking a function or method as requiring dependency injection.
 
     Args:

{anydi-0.24.3 → anydi-0.25.0a0}/anydi/_types.py

@@ -1,13 +1,11 @@
-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, Self, TypeAlias
+from typing_extensions import Annotated, Literal, Mapping, TypeAlias
 
-from ._utils import get_full_qualname, get_typed_parameters
+from ._utils import get_full_qualname, get_signature
 
 Scope = Literal["transient", "singleton", "request"]
 
@@ -21,14 +19,6 @@ class Marker:
 
     __slots__ = ()
 
-    def __call__(self) -> Self:
-        return self
-
-
-def is_marker(obj: Any) -> bool:
-    """Checks if an object is a marker."""
-    return isinstance(obj, Marker)
-
 
 @dataclass(frozen=True)
 class Provider:
@@ -60,13 +50,13 @@ class Provider:
         return get_full_qualname(self.obj)
 
     @cached_property
-    def parameters(self) -> list[inspect.Parameter]:
+    def parameters(self) -> Mapping[str, inspect.Parameter]:
         """Returns the parameters of the provider as a mapping.
 
         Returns:
             The parameters of the provider.
         """
-        return get_typed_parameters(self.obj)
+        return get_signature(self.obj).parameters
 
     @cached_property
     def is_class(self) -> bool:

anydi-0.25.0a0/anydi/_utils.py

@@ -0,0 +1,111 @@
+"""Shared AnyDI utils module."""
+
+import builtins
+import functools
+import inspect
+import sys
+from typing import Any, Callable, Dict, Type, TypeVar
+
+from typing_extensions import Annotated, ParamSpec, get_origin
+
+try:
+    import anyio  # noqa
+except ImportError:
+    anyio = None  # type: ignore[assignment]
+
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+
+def get_full_qualname(obj: Any) -> str:
+    """Get the fully qualified name of an object.
+
+    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.
+
+    Returns:
+        The fully qualified name of the object.
+    """
+    origin = get_origin(obj)
+    if origin is Annotated:
+        metadata = ", ".join(
+            [
+                f'"{arg}"' if isinstance(arg, str) else str(arg)
+                for arg in obj.__metadata__
+            ]
+        )
+        return f"Annotated[{get_full_qualname(obj.__args__[0])}, {metadata}]]"
+
+    qualname = getattr(obj, "__qualname__", None)
+    module_name = getattr(obj, "__module__", None)
+    if qualname is None:
+        qualname = type(obj).__qualname__
+
+    if module_name is None:
+        module_name = type(obj).__module__
+
+    if module_name == builtins.__name__:
+        return qualname
+    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.
+    """
+    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.
+
+    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.
+
+    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)
+
+
+async def run_async(
+    func: Callable[P, T],
+    /,
+    *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.
+    """
+    if not anyio:
+        raise ImportError(
+            "`anyio` library is not currently installed. Please make sure to install "
+            "it first, or consider using `anydi[full]` instead."
+        )
+    return await anyio.to_thread.run_sync(functools.partial(func, *args, **kwargs))

anydi-0.25.0a0/anydi/ext/django/__init__.py

@@ -0,0 +1,3 @@
+from ._container import container
+
+__all__ = ["container"]

anydi-0.25.0a0/anydi/ext/django/_container.py

@@ -0,0 +1,18 @@
+from typing import cast
+
+from django.apps.registry import apps
+from django.utils.functional import SimpleLazyObject
+
+import anydi
+
+from .apps import ContainerConfig
+
+__all__ = ["container"]
+
+
+def _get_container() -> anydi.Container:
+    app_config = cast(ContainerConfig, apps.get_app_config(ContainerConfig.label))
+    return app_config.container
+
+
+container = cast(anydi.Container, SimpleLazyObject(_get_container))

anydi-0.25.0a0/anydi/ext/django/_utils.py

@@ -0,0 +1,14 @@
+from collections.abc import Iterator
+
+from django.urls import URLPattern, URLResolver
+
+
+def iter_urlpatterns(
+    urlpatterns: list[URLPattern | URLResolver],
+) -> Iterator[URLPattern]:
+    """Iterate over all views in urlpatterns."""
+    for url_pattern in urlpatterns:
+        if isinstance(url_pattern, URLResolver):
+            yield from iter_urlpatterns(url_pattern.url_patterns)
+        else:
+            yield url_pattern

anydi-0.25.0a0/anydi/ext/django/apps.py

@@ -0,0 +1,138 @@
+import types
+from functools import wraps
+from typing import Annotated, Any, get_origin
+
+from django.apps import AppConfig
+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 get_resolver
+from django.utils.module_loading import import_string
+
+import anydi
+
+from ._utils import iter_urlpatterns
+
+
+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)
+        # Create a container
+        self.container = anydi.Container(
+            strict=getattr(settings, "ANYDI_STRICT_MODE", False),
+        )
+
+    def ready(self) -> None:
+        # Register Django settings
+        if getattr(settings, "ANYDI_REGISTER_SETTINGS", False):
+            self.register_settings()
+
+        # Register Django components
+        if getattr(settings, "ANYDI_REGISTER_COMPONENTS", False):
+            self.register_components()
+
+        # Register modules
+        for module_path in getattr(settings, "ANYDI_MODULES", []):
+            module_cls = import_string(module_path)
+            self.container.register_module(module_cls)
+
+        # Patching the django-ninja framework if it installed
+        if getattr(settings, "ANYDI_PATCH_NINJA", False):
+            self.patch_ninja()
+
+        # Auto-injecting the container into views
+        if urlconf := getattr(settings, "ANYDI_AUTO_INJECT_URLCONF", None):
+            self.auto_inject_urlconf(urlconf)
+
+    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, value in settings.__dict__.items():
+            if not setting_name.isupper():
+                continue
+            self.container.register(
+                Annotated[Any, f"{self.settings_prefix}.{setting_name}"],
+                _get_setting_value(value),
+                scope="singleton",
+            )
+
+        def _aware_settings(interface: Any) -> Any:
+            origin = get_origin(interface)
+            if origin is not Annotated:
+                return interface
+            named = interface.__metadata__[-1]
+
+            if isinstance(named, str):
+                _, 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
+            pattern.callback = self.container.inject(pattern.callback)
+
+    @staticmethod
+    def patch_ninja() -> None:
+        """Patch the django-ninja framework."""
+        from .ninja import patch
+
+        patch()

anydi-0.25.0a0/anydi/ext/django/ninja/__init__.py

@@ -0,0 +1,16 @@
+try:
+    from ninja import operation
+except ImportError as exc:
+    raise ImportError(
+        "'django-ninja' is not installed. "
+        "Please install it using 'pip install django-ninja'."
+    ) from exc
+
+from ._operation import AsyncOperation, Operation
+from ._signature import ViewSignature
+
+
+def patch() -> None:
+    operation.ViewSignature = ViewSignature  # type: ignore[attr-defined]
+    operation.Operation = Operation  # type: ignore[misc]
+    operation.AsyncOperation = AsyncOperation  # type: ignore[misc]

anydi-0.25.0a0/anydi/ext/django/ninja/_operation.py

@@ -0,0 +1,73 @@
+from typing import Any
+
+from django.http import HttpRequest, HttpResponseBase
+from ninja.operation import (
+    AsyncOperation as BaseAsyncOperation,  # noqa
+    Operation as BaseOperation,
+)
+
+from anydi.ext.django import container
+
+from ._signature import ViewSignature
+
+
+def _update_exc_args(exc: Exception) -> None:
+    if isinstance(exc, TypeError) and "required positional argument" in str(exc):
+        msg = "Did you fail to use functools.wraps() in a decorator?"
+        msg = f"{exc.args[0]}: {msg}" if exc.args else msg
+        exc.args = (msg,) + exc.args[1:]
+
+
+class Operation(BaseOperation):
+    signature: ViewSignature
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.dependencies = self.signature.dependencies
+
+    def run(self, request: HttpRequest, **kw: Any) -> HttpResponseBase:
+        error = self._run_checks(request)
+        if error:
+            return error
+        try:
+            temporal_response = self.api.create_temporal_response(request)
+            values = self._get_values(request, kw, temporal_response)
+            values.update(self._get_dependencies())
+            result = self.view_func(request, **values)
+            return self._result_to_response(request, result, temporal_response)
+        except Exception as e:
+            _update_exc_args(e)
+            return self.api.on_exception(request, e)
+
+    def _get_dependencies(self) -> dict[str, Any]:
+        return {
+            name: container.resolve(interface) for name, interface in self.dependencies
+        }
+
+
+class AsyncOperation(BaseAsyncOperation):
+    signature: ViewSignature
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.dependencies = self.signature.dependencies
+
+    async def run(self, request: HttpRequest, **kw: Any) -> HttpResponseBase:  # type: ignore
+        error = await self._run_checks(request)
+        if error:
+            return error
+        try:
+            temporal_response = self.api.create_temporal_response(request)
+            values = self._get_values(request, kw, temporal_response)
+            values.update(await self._get_dependencies())
+            result = await self.view_func(request, **values)
+            return self._result_to_response(request, result, temporal_response)
+        except Exception as e:
+            _update_exc_args(e)
+            return self.api.on_exception(request, e)
+
+    async def _get_dependencies(self) -> dict[str, Any]:
+        return {
+            name: await container.aresolve(interface)
+            for name, interface in self.dependencies
+        }

anydi-0.25.0a0/anydi/ext/django/ninja/_signature.py

@@ -0,0 +1,62 @@
+import inspect
+from collections.abc import Callable
+from typing import Any
+
+from django.http import HttpResponse
+from ninja.signature.details import (  # noqa
+    FuncParam,
+    ViewSignature as BaseViewSignature,
+)
+from ninja.signature.utils import get_path_param_names, get_typed_signature
+
+from anydi._types import Marker  # noqa
+
+
+class ViewSignature(BaseViewSignature):
+    def __init__(self, path: str, view_func: Callable[..., Any]) -> None:
+        self.view_func = view_func
+        self.signature = get_typed_signature(self.view_func)
+        self.path = path
+        self.path_params_names = get_path_param_names(path)
+        self.docstring = inspect.cleandoc(view_func.__doc__ or "")
+        self.has_kwargs = False
+        self.dependencies = []
+
+        self.params = []
+        for name, arg in self.signature.parameters.items():
+            if name == "request":
+                # TODO: maybe better assert that 1st param is request or check by type?
+                # maybe even have attribute like `has_request`
+                # so that users can ignore passing request if not needed
+                continue
+
+            if arg.kind == arg.VAR_KEYWORD:
+                # Skipping **kwargs
+                self.has_kwargs = True
+                continue
+
+            if arg.kind == arg.VAR_POSITIONAL:
+                # Skipping *args
+                continue
+
+            if arg.annotation is HttpResponse:
+                self.response_arg = name
+                continue
+
+            # Skip default values that are anydi dependency markers
+            if isinstance(arg.default, Marker):
+                self.dependencies.append((name, arg.annotation))
+                continue
+
+            func_param = self._get_param_type(name, arg)
+            self.params.append(func_param)
+
+        if hasattr(view_func, "_ninja_contribute_args"):
+            for p_name, p_type, p_source in view_func._ninja_contribute_args:  # noqa
+                self.params.append(
+                    FuncParam(p_name, p_source.alias or p_name, p_source, p_type, False)
+                )
+
+        self.models = self._create_models()
+
+        self._validate_view_path_params()

{anydi-0.24.3 → anydi-0.25.0a0}/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_typed_parameters
+from anydi._utils import get_full_qualname, get_signature
 
 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_typed_parameters(call):
+            for parameter in get_signature(call).parameters.values():
                 _patch_route_parameter(call, parameter, container)
 
 

{anydi-0.24.3 → anydi-0.25.0a0}/anydi/ext/pytest_plugin.py

@@ -1,7 +1,5 @@
-from __future__ import annotations
-
 import inspect
-from typing import Any, Callable, Iterator, cast
+from typing import Any, Callable, Iterator, List, Tuple, cast
 
 import pytest
 
@@ -51,8 +49,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()
 
@@ -60,9 +58,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)
@@ -79,8 +77,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."""
 
@@ -109,8 +107,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.24.3 → anydi-0.25.0a0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "anydi"
-version = "0.24.3"
+version = "0.25.0a0"
 description = "Dependency Injection library"
 authors = ["Anton Ruhlov <antonruhlov@gmail.com>"]
 license = "MIT"
@@ -50,8 +50,10 @@ mypy = "^1.10.0"
 ruff = "^0.4.3"
 pytest = "^8.1.0"
 pytest-cov = "^5.0.0"
-fastapi = "^0.95.1"
+fastapi = "^0.100.0"
 httpx = "^0.26.0"
+django = "^4.2"
+django-ninja = "^1.1.0"
 
 [tool.poetry.plugins.pytest11]
 anydi = "anydi.ext.pytest_plugin"
@@ -60,7 +62,7 @@ anydi = "anydi.ext.pytest_plugin"
 line-length = 88
 
 [tool.ruff.lint]
-select = ["A", "B", "C", "E", "F", "I", "W", "TID252", "T20", "UP"]
+select = ["A", "B", "C", "E", "F", "I", "W", "TID252", "T20"]
 ignore = ["A003", "B008", "B009", "B010", "D104", "D107"]
 
 [tool.ruff.lint.isort]
@@ -74,6 +76,12 @@ convention = "google"
 python_version = "3.10"
 strict = true
 
+[[tool.mypy.overrides]]
+module = [
+    "django.*",
+]
+ignore_missing_imports = true
+
 [tool.pytest.ini_options]
 addopts = [
     "--strict-config",

anydi-0.24.3/anydi/_utils.py

@@ -1,111 +0,0 @@
-"""Shared AnyDI utils module."""
-
-from __future__ import annotations
-
-import builtins
-import functools
-import inspect
-import sys
-from typing import Any, Callable, ForwardRef, TypeVar, cast
-
-from typing_extensions import Annotated, ParamSpec, get_origin
-
-try:
-    import anyio  # noqa
-except ImportError:
-    anyio = None  # type: ignore[assignment]
-
-
-if sys.version_info < (3, 9):  # pragma: nocover
-
-    def evaluate_forwardref(type_: ForwardRef, globalns: Any, localns: Any) -> Any:
-        return type_._evaluate(globalns, localns)  # noqa
-
-else:
-
-    def evaluate_forwardref(type_: ForwardRef, globalns: Any, localns: Any) -> Any:
-        return cast(Any, type_)._evaluate(globalns, localns, set())  # noqa
-
-
-T = TypeVar("T")
-P = ParamSpec("P")
-
-
-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(
-            [
-                f'"{arg}"' if isinstance(arg, str) else str(arg)
-                for arg in obj.__metadata__
-            ]
-        )
-        return f"Annotated[{get_full_qualname(obj.__args__[0])}, {metadata}]]"
-
-    qualname = getattr(obj, "__qualname__", None)
-    module_name = getattr(obj, "__module__", None)
-    if qualname is None:
-        qualname = type(obj).__qualname__
-
-    if module_name is None:
-        module_name = type(obj).__module__
-
-    if module_name == builtins.__name__:
-        return qualname
-    return f"{module_name}.{qualname}"
-
-
-def is_builtin_type(tp: type[Any]) -> bool:
-    """Check if the given type is a built-in type."""
-    return tp.__module__ == builtins.__name__
-
-
-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)
-
-
-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
-
-
-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()
-    ]
-
-
-async def run_async(
-    func: Callable[P, T],
-    /,
-    *args: P.args,
-    **kwargs: P.kwargs,
-) -> T:
-    """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 "
-            "it first, or consider using `anydi[full]` instead."
-        )
-    return await anyio.to_thread.run_sync(functools.partial(func, *args, **kwargs))