anydi 0.22.0__py3-none-any.whl → 0.37.4__py3-none-any.whl

anydi/ext/django/apps.py

@@ -0,0 +1,85 @@
+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):
+    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"]:
+            if isinstance(urlconf, str):
+                urlconf = [urlconf]
+            for u in urlconf:
+                inject_urlpatterns(self.container, urlconf=u)
+
+        # Scan packages
+        for scan_package in self.settings["SCAN_PACKAGES"]:
+            self.container.scan(scan_package)

anydi/ext/django/middleware.py

@@ -0,0 +1,28 @@
+from typing import Any, Callable
+
+from asgiref.sync import iscoroutinefunction
+from django.http import HttpRequest
+from django.utils.decorators import sync_and_async_middleware
+
+from ._container import container
+
+
+@sync_and_async_middleware
+def request_scoped_middleware(
+    get_response: Callable[..., Any],
+) -> Callable[..., Any]:
+    if iscoroutinefunction(get_response):
+
+        async def async_middleware(request: HttpRequest) -> Any:
+            async with container.arequest_context() as context:
+                context.set(HttpRequest, request)
+                return await get_response(request)
+
+        return async_middleware
+
+    def middleware(request: HttpRequest) -> Any:
+        with container.request_context() as context:
+            context.set(HttpRequest, request)
+            return get_response(request)
+
+    return middleware

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/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/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 is_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 is_marker(arg.default):
+                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/ext/fastapi.py

@@ -1,6 +1,9 @@
 """AnyDI FastAPI extension."""
 
-from typing import Any, Iterator, cast
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Any, cast
 
 from fastapi import Depends, FastAPI, params
 from fastapi.dependencies.models import Dependant
@@ -8,9 +11,9 @@ from fastapi.routing import APIRoute
 from starlette.requests import Request
 
 from anydi import Container
-from anydi._utils import get_signature
+from anydi._utils import get_typed_parameters
 
-from ._utils import HasInterface, patch_parameter_interface
+from ._utils import HasInterface, patch_call_parameter
 from .starlette.middleware import RequestScopedMiddleware
 
 __all__ = ["RequestScopedMiddleware", "install", "get_container", "Inject"]
@@ -19,10 +22,6 @@ __all__ = ["RequestScopedMiddleware", "install", "get_container", "Inject"]
 def install(app: FastAPI, container: Container) -> None:
     """Install AnyDI into a FastAPI application.
 
-    Args:
-        app: The FastAPI application instance.
-        container: The container.
-
     This function installs the AnyDI container into a FastAPI application by attaching
     it to the application state. It also patches the route dependencies to inject the
     required dependencies using AnyDI.
@@ -41,42 +40,27 @@ 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():
-                patch_parameter_interface(call, parameter, container)
+            for parameter in get_typed_parameters(call):
+                patch_call_parameter(container, call, parameter)
 
 
 def get_container(request: Request) -> Container:
-    """Get the AnyDI container from a FastAPI request.
-
-    Args:
-        request: The FastAPI request.
-
-    Returns:
-        The AnyDI container associated with the request.
-    """
+    """Get the AnyDI container from a FastAPI request."""
     return cast(Container, request.app.state.container)
 
 
-class Resolver(params.Depends, HasInterface):
+class Resolver(HasInterface, params.Depends):
     """Parameter dependency class for injecting dependencies using AnyDI."""
 
     def __init__(self) -> None:
         super().__init__(dependency=self._dependency, use_cache=True)
-        HasInterface.__init__(self)
 
     async def _dependency(self, container: Container = Depends(get_container)) -> Any:
         return await container.aresolve(self.interface)
 
 
 def Inject() -> Any:  # noqa
-    """Decorator for marking a function parameter as requiring injection.
-
-    The `Inject` decorator is used to mark a function parameter as requiring injection
-    of a dependency resolved by AnyDI.
-
-    Returns:
-        The `Resolver` instance representing the parameter dependency.
-    """
+    """Decorator for marking a function parameter as requiring injection."""
     return Resolver()
 
 

anydi/ext/faststream.py

@@ -0,0 +1,58 @@
+"""AnyDI FastStream extension."""
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+from fast_depends.dependencies import Depends
+from faststream import ContextRepo
+from faststream.broker.core.usecase import BrokerUsecase
+
+from anydi import Container
+from anydi._utils import get_typed_parameters
+
+from ._utils import HasInterface, patch_call_parameter
+
+
+def install(broker: BrokerUsecase[Any, Any], container: Container) -> None:
+    """Install AnyDI into a FastStream broker.
+
+    This function installs the AnyDI container into a FastStream broker by attaching
+    it to the broker. It also patches the broker handlers to inject the required
+    dependencies using AnyDI.
+    """
+    broker._container = container  # type: ignore[attr-defined]
+
+    for handler in _get_broken_handlers(broker):
+        call = handler._original_call  # noqa
+        for parameter in get_typed_parameters(call):
+            patch_call_parameter(container, call, parameter)
+
+
+def _get_broken_handlers(broker: BrokerUsecase[Any, Any]) -> list[Any]:
+    if hasattr(broker, "handlers"):
+        return [handler.calls[0][0] for handler in broker.handlers.values()]
+    # faststream > 0.5.0
+    return [
+        subscriber.calls[0].handler
+        for subscriber in broker._subscribers.values()  # noqa
+    ]
+
+
+def get_container(broker: BrokerUsecase[Any, Any]) -> Container:
+    return cast(Container, getattr(broker, "_container"))  # noqa
+
+
+class Resolver(HasInterface, Depends):
+    """Parameter dependency class for injecting dependencies using AnyDI."""
+
+    def __init__(self) -> None:
+        super().__init__(dependency=self._dependency, use_cache=True, cast=True)
+
+    async def _dependency(self, context: ContextRepo) -> Any:
+        container = get_container(context.get("broker"))
+        return await container.aresolve(self.interface)
+
+
+def Inject() -> Any:  # noqa
+    return Resolver()

anydi/ext/pydantic_settings.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Annotated, Any, Callable
+
+from pydantic.fields import ComputedFieldInfo, FieldInfo  # noqa
+from pydantic_settings import BaseSettings
+
+from anydi import Container
+
+
+def install(
+    settings: BaseSettings | Iterable[BaseSettings],
+    container: Container,
+    *,
+    prefix: str = "settings.",
+) -> None:
+    """Install Pydantic settings into an AnyDI container."""
+
+    # Ensure prefix ends with a dot
+    if prefix[-1] != ".":
+        prefix += "."
+
+    def _register_settings(_settings: BaseSettings) -> None:
+        all_fields = {**_settings.model_fields, **_settings.model_computed_fields}
+        for setting_name, field_info in all_fields.items():
+            if isinstance(field_info, ComputedFieldInfo):
+                interface = field_info.return_type
+            elif isinstance(field_info, FieldInfo):
+                interface = field_info.annotation
+            else:
+                continue
+
+            container.register(
+                Annotated[interface, f"{prefix}{setting_name}"],
+                _get_setting_value(getattr(_settings, setting_name)),
+                scope="singleton",
+            )
+
+    if isinstance(settings, BaseSettings):
+        _register_settings(settings)
+    else:
+        for _settings in settings:
+            _register_settings(_settings)
+
+
+def _get_setting_value(setting_value: Any) -> Callable[[], Any]:
+    return lambda: setting_value

anydi/ext/pytest_plugin.py

@@ -1,9 +1,18 @@
+from __future__ import annotations
+
 import inspect
-from typing import Any, Callable, Iterator, List, Tuple, cast
+import logging
+from collections.abc import Iterator
+from typing import Any, Callable, cast
 
 import pytest
+from _pytest.python import async_warn_and_skip
+from anyio.pytest_plugin import extract_backend_and_options, get_runner
 
 from anydi import Container
+from anydi._utils import get_typed_parameters
+
+logger = logging.getLogger(__name__)
 
 
 def pytest_configure(config: pytest.Config) -> None:
@@ -49,8 +58,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,17 +67,20 @@ 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]]:
-        for name, parameter in inspect.signature(request.function).parameters.items():
+    _anydi_unresolved: list[str],
+) -> Callable[[], Iterator[tuple[str, Any]]]:
+    registered_fixtures = request.session._fixturemanager._arg2fixturedefs  # noqa
+
+    def _iterator() -> Iterator[tuple[str, inspect.Parameter]]:
+        for parameter in get_typed_parameters(request.function):
+            interface = parameter.annotation
             if (
-                ((interface := parameter.annotation) is parameter.empty)
+                interface is inspect.Parameter.empty
                 or interface in _anydi_unresolved
-                or name in request.node.funcargs
+                or parameter.name in registered_fixtures
             ):
                 continue
-            yield name, interface
+            yield parameter.name, interface
 
     return _iterator
 
@@ -77,8 +89,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."""
 
@@ -89,44 +101,58 @@ def _anydi_inject(
     container = cast(Container, request.getfixturevalue("anydi_setup_container"))
 
     for argname, interface in _anydi_injected_parameter_iterator():
+        # Skip if the interface is not registered
+        if container.strict and not container.is_registered(interface):
+            continue
+
         try:
-            # Release the instance if it was already resolved
-            container.release(interface)
-        except (LookupError, TypeError):
-            pass
-        try:
-            # Resolve the instance
-            instance = container.resolve(interface)
-        except (LookupError, TypeError):
+            request.node.funcargs[argname] = container.resolve(interface)
+        except Exception as exc:
+            logger.warning(
+                f"Failed to resolve dependency for argument '{argname}'.", exc_info=exc
+            )
             _anydi_unresolved.append(interface)
-            continue
-        request.node.funcargs[argname] = instance
 
 
 @pytest.fixture(autouse=True)
-async def _anydi_ainject(
+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:
+    if (
+        not inspect.iscoroutinefunction(request.function)
+        and not inspect.isasyncgenfunction(request.function)
+        or not _anydi_should_inject
+    ):
         return
 
-    # Setup the container
-    container = cast(Container, request.getfixturevalue("anydi_setup_container"))
+    # Skip if the anyio backend is not available
+    if "anyio_backend" not in request.fixturenames:
+        async_warn_and_skip(request.node.nodeid)
 
-    for argname, interface in _anydi_injected_parameter_iterator():
-        try:
-            # Release the instance if it was already resolved
-            container.release(interface)
-        except (LookupError, TypeError):
-            pass
-        try:
-            # Resolve the instance
-            instance = await container.aresolve(interface)
-        except (LookupError, TypeError):
-            _anydi_unresolved.append(interface)
-            continue
-        request.node.funcargs[argname] = instance
+    async def _awrapper() -> None:
+        # Setup the container
+        container = cast(Container, request.getfixturevalue("anydi_setup_container"))
+
+        for argname, interface in _anydi_injected_parameter_iterator():
+            # Skip if the interface is not registered
+            if container.strict and not container.is_registered(interface):
+                continue
+
+            try:
+                request.node.funcargs[argname] = await container.aresolve(interface)
+            except Exception as exc:
+                logger.warning(
+                    f"Failed to resolve dependency for argument '{argname}'.",
+                    exc_info=exc,
+                )
+                _anydi_unresolved.append(interface)
+
+    anyio_backend = request.getfixturevalue("anyio_backend")
+    backend_name, backend_options = extract_backend_and_options(anyio_backend)
+
+    with get_runner(backend_name, backend_options) as runner:
+        runner.run_fixture(_awrapper, {})

anydi/ext/starlette/middleware.py

@@ -12,26 +12,12 @@ class RequestScopedMiddleware(BaseHTTPMiddleware):
     """Starlette middleware for managing request-scoped AnyDI context."""
 
     def __init__(self, app: ASGIApp, container: Container) -> None:
-        """Initialize the RequestScopedMiddleware.
-
-        Args:
-            app: The ASGI application.
-            container: The container.
-        """
         super().__init__(app)
         self.container = container
 
     async def dispatch(
         self, request: Request, call_next: RequestResponseEndpoint
     ) -> Response:
-        """Dispatch the request and handle the response.
-
-        Args:
-            request: The incoming request.
-            call_next: The next request-response endpoint.
-
-        Returns:
-            The response to the request.
-        """
-        async with self.container.arequest_context():
+        async with self.container.arequest_context() as context:
+            context.set(Request, request)
             return await call_next(request)