anydi 0.24.2__tar.gz → 0.25.0__tar.gz

{anydi-0.24.2 → anydi-0.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: anydi
-Version: 0.24.2
+Version: 0.25.0
 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.24.2 → anydi-0.25.0}/README.md

@@ -98,3 +98,59 @@ def say_hello(message: str = Inject()) -> dict[str, str]:
 # Install the container into the FastAPI app
 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.24.2 → anydi-0.25.0}/anydi/_container.py

@@ -43,7 +43,13 @@ 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")
@@ -327,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}` "
@@ -366,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
@@ -711,14 +717,16 @@ 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."
             )
 
-        if get_origin(annotation) in (get_origin(Iterator), get_origin(AsyncIterator)):
+        origin = get_origin(annotation)
+
+        if has_resource_origin(origin):
             args = get_args(annotation)
             if args:
                 return args[0]
@@ -741,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-0.24.2 → anydi-0.25.0}/anydi/_context.py

@@ -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)
@@ -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)

{anydi-0.24.2 → anydi-0.25.0}/anydi/_scanner.py

@@ -20,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
@@ -157,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)

{anydi-0.24.2 → anydi-0.25.0}/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, Mapping, Type, TypeVar, Union
+from typing import Any, Callable, Type, TypeVar, Union
 
 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-0.25.0/anydi/_utils.py

@@ -0,0 +1,122 @@
+"""Shared AnyDI utils module."""
+
+from __future__ import annotations
+
+import builtins
+import functools
+import inspect
+import sys
+from typing import Any, AsyncIterator, Callable, ForwardRef, Iterator, 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()
+    ]
+
+
+_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(
+    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))

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

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

anydi-0.25.0/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.0/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 | 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-0.25.0/anydi/ext/django/_utils.py

@@ -0,0 +1,111 @@
+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",
+        )
+
+
+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 django-ninja views
+        if pattern.lookup_str.startswith("ninja."):
+            continue  # pragma: no cover
+        pattern.callback = container.inject(pattern.callback)
+
+
+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.0/anydi/ext/django/apps.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import logging
+import types
+from typing import Callable, cast
+
+from django.apps import AppConfig
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+from django.utils.module_loading import import_string
+
+import anydi
+
+from ._settings import get_settings
+from ._utils import inject_urlpatterns, register_components, register_settings
+
+logger = logging.getLogger(__name__)
+
+
+class ContainerConfig(AppConfig):  # type: ignore[misc]
+    name = "anydi.ext.django"
+    label = "anydi_django"
+
+    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_factory_path = self.settings["CONTAINER_FACTORY"]
+        if container_factory_path:
+            try:
+                container_factory = cast(
+                    Callable[[], anydi.Container], import_string(container_factory_path)
+                )
+            except ImportError as exc:
+                raise ImproperlyConfigured(
+                    f"Cannot import container factory '{container_factory_path}'."
+                ) from exc
+            self.container = container_factory()
+        else:
+            self.container = anydi.Container(
+                strict=self.settings["STRICT_MODE"],
+            )
+
+    def ready(self) -> None:  # noqa: C901
+        # Register Django settings
+        if self.settings["REGISTER_SETTINGS"]:
+            register_settings(
+                self.container,
+                prefix=getattr(
+                    settings,
+                    "ANYDI_SETTINGS_PREFIX",
+                    "django.conf.settings.",
+                ),
+            )
+
+        # Register Django components
+        if self.settings["REGISTER_COMPONENTS"]:
+            register_components(self.container)
+
+        # Register modules
+        for module_path in self.settings["MODULES"]:
+            try:
+                module_cls = import_string(module_path)
+            except ImportError as exc:
+                raise ImproperlyConfigured(
+                    f"Cannot import module '{module_path}'."
+                ) from exc
+            self.container.register_module(module_cls)
+
+        # Patching the django-ninja framework if it installed
+        if self.settings["PATCH_NINJA"]:
+            from .ninja import patch_ninja
+
+            patch_ninja()
+
+        # Auto-injecting the container into views
+        if urlconf := self.settings["INJECT_URLCONF"]:
+            inject_urlpatterns(self.container, urlconf=urlconf)
+
+        # Scan packages
+        for scan_package in self.settings["SCAN_PACKAGES"]:
+            self.container.scan(scan_package)

anydi-0.25.0/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-0.25.0/anydi/ext/django/ninja/__init__.py

@@ -0,0 +1,16 @@
+try:
+    from ninja import operation
+except ImportError as exc:  # pragma: no cover
+    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_ninja() -> None:
+    operation.ViewSignature = ViewSignature  # type: ignore[attr-defined]
+    operation.Operation = Operation  # type: ignore[misc]
+    operation.AsyncOperation = AsyncOperation  # type: ignore[misc]

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

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+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.0/anydi/ext/django/ninja/_signature.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import inspect
+from collections.abc import Callable
+from typing import Any
+
+from django.http import HttpResponse
+from ninja.signature.details import (
+    FuncParam,  # noqa
+    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.2 → anydi-0.25.0}/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-0.24.2 → anydi-0.25.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "anydi"
-version = "0.24.2"
+version = "0.25.0"
 description = "Dependency Injection library"
 authors = ["Anton Ruhlov <antonruhlov@gmail.com>"]
 license = "MIT"
@@ -50,8 +50,11 @@ 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"
+pytest-django = "^4.8.0"
 
 [tool.poetry.plugins.pytest11]
 anydi = "anydi.ext.pytest_plugin"
@@ -74,6 +77,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",
@@ -81,6 +90,7 @@ addopts = [
 ]
 xfail_strict = true
 junit_family = "xunit2"
+DJANGO_SETTINGS_MODULE = "tests.ext.django.settings"
 
 [tool.coverage.report]
 exclude_also = [
@@ -97,6 +107,12 @@ exclude_also = [
     "if not anyio:",
 ]
 
+[tool.coverage.run]
+omit = [
+    "anydi/ext/django/ninja/_operation.py",
+    "anydi/ext/django/ninja/_signature.py",
+]
+
 [build-system]
 requires = ["poetry-core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"

anydi-0.24.2/anydi/_utils.py

@@ -1,113 +0,0 @@
-"""Shared AnyDI utils module."""
-
-from __future__ import annotations
-
-import builtins
-import functools
-import inspect
-import sys
-from typing import Any, Callable, 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))