anydi 0.24.3__tar.gz → 0.25.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: anydi
-Version: 0.24.3
+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.3 → 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.3 → anydi-0.25.0}/anydi/_container.py

@@ -47,6 +47,7 @@ from ._utils import (
     get_full_qualname,
     get_typed_parameters,
     get_typed_return_annotation,
+    has_resource_origin,
     is_builtin_type,
 )
 
@@ -723,7 +724,9 @@ class Container:
                 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]

{anydi-0.24.3 → anydi-0.25.0}/anydi/_utils.py

@@ -6,7 +6,7 @@ import builtins
 import functools
 import inspect
 import sys
-from typing import Any, Callable, ForwardRef, TypeVar, cast
+from typing import Any, AsyncIterator, Callable, ForwardRef, Iterator, TypeVar, cast
 
 from typing_extensions import Annotated, ParamSpec, get_origin
 
@@ -96,6 +96,17 @@ def get_typed_parameters(obj: Callable[..., Any]) -> list[inspect.Parameter]:
     ]
 
 
+_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],
     /,

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.3 → anydi-0.25.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "anydi"
-version = "0.24.3"
+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"