anydi 0.46.0__tar.gz → 0.47.0__tar.gz

{anydi-0.46.0 → anydi-0.47.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anydi
-Version: 0.46.0
+Version: 0.47.0
 Summary: Dependency Injection library
 Project-URL: Repository, https://github.com/antonrh/anydi
 Author-email: Anton Ruhlov <antonruhlov@gmail.com>

{anydi-0.46.0 → anydi-0.47.0}/anydi/__init__.py

@@ -5,22 +5,24 @@ from ._decorators import injectable, provided, provider, request, singleton, tra
 from ._module import Module
 from ._provider import ProviderDef as Provider
 from ._scope import Scope
-from ._typing import InjectMarker
+from ._typing import Inject
 
 # Alias for dependency auto marker
-auto = InjectMarker()
+# TODO: deprecate it
+auto = Inject()
 
 
 __all__ = [
     "Container",
+    "Inject",
     "Module",
     "Provider",
     "Scope",
     "auto",
     "injectable",
+    "provided",
     "provider",
     "request",
     "singleton",
     "transient",
-    "provided",
 ]

{anydi-0.46.0 → anydi-0.47.0}/anydi/_container.py

@@ -11,7 +11,7 @@ import uuid
 from collections import defaultdict
 from collections.abc import AsyncIterator, Iterable, Iterator
 from contextvars import ContextVar
-from typing import Any, Callable, TypeVar, cast, overload
+from typing import Annotated, Any, Callable, TypeVar, cast, overload
 
 from typing_extensions import ParamSpec, Self, get_args, get_origin
 
@@ -806,36 +806,68 @@ class Container:
         """Get the injected parameters of a callable object."""
         injected_params: dict[str, Any] = {}
         for parameter in get_typed_parameters(call):
-            interface, should_inject = self._validate_injected_parameter(
+            interface, should_inject = self.validate_injected_parameter(
                 parameter, call=call
             )
             if should_inject:
                 injected_params[parameter.name] = interface
         return injected_params
 
-    def _validate_injected_parameter(
+    @staticmethod
+    def _unwrap_injected_parameter(parameter: inspect.Parameter) -> inspect.Parameter:
+        if get_origin(parameter.annotation) is not Annotated:
+            return parameter
+
+        origin, *metadata = get_args(parameter.annotation)
+
+        if not metadata or not is_inject_marker(metadata[-1]):
+            return parameter
+
+        if is_inject_marker(parameter.default):
+            raise TypeError(
+                "Cannot specify `Inject` in `Annotated` and "
+                f"default value together for '{parameter.name}'"
+            )
+
+        if parameter.default is not inspect.Parameter.empty:
+            return parameter
+
+        marker = metadata[-1]
+        new_metadata = metadata[:-1]
+        if new_metadata:
+            new_annotation = Annotated.__class_getitem__((origin, *new_metadata))  # type: ignore
+        else:
+            new_annotation = origin
+        return parameter.replace(annotation=new_annotation, default=marker)
+
+    def validate_injected_parameter(
         self, parameter: inspect.Parameter, *, call: Callable[..., Any]
     ) -> tuple[Any, bool]:
         """Validate an injected parameter."""
-        interface, should_inject = parameter.annotation, False
-        if is_inject_marker(parameter.default):
-            if parameter.annotation is inspect.Parameter.empty:
-                raise TypeError(
-                    f"Missing `{type_repr(call)}` "
-                    f"parameter `{parameter.name}` annotation."
-                )
-            should_inject = True
+        parameter = self._unwrap_injected_parameter(parameter)
+        interface = parameter.annotation
 
-        return interface, should_inject
+        if not is_inject_marker(parameter.default):
+            return interface, False
 
-        # TODO: temporary disable until strict is enforced
-        if not self.has_provider_for(interface):
+        if interface is inspect.Parameter.empty:
+            raise TypeError(
+                f"Missing `{type_repr(call)}` parameter `{parameter.name}` annotation."
+            )
+
+        # Set inject marker interface
+        parameter.default.interface = interface
+
+        # TODO: temporary disable until strict is enforced (remove False)
+        if False and not self.has_provider_for(interface):
             raise LookupError(
                 f"`{type_repr(call)}` has an unknown dependency parameter "
                 f"`{parameter.name}` with an annotation of "
                 f"`{type_repr(interface)}`."
             )
 
+        return interface, True
+
     ############################
     # Module Methods
     ############################

{anydi-0.46.0 → anydi-0.47.0}/anydi/_typing.py

@@ -7,9 +7,9 @@ import inspect
 import re
 import sys
 from collections.abc import AsyncIterator, Iterator
-from typing import Any, Callable, ForwardRef
+from typing import Any, Callable, ForwardRef, TypeVar
 
-from typing_extensions import Self, get_args, get_origin
+from typing_extensions import get_args, get_origin
 
 try:
     from types import NoneType
@@ -17,6 +17,9 @@ except ImportError:
     NoneType = type(None)
 
 
+T = TypeVar("T")
+
+
 def type_repr(obj: Any) -> str:
     """Get a string representation of a type or object."""
     if isinstance(obj, str):
@@ -93,48 +96,58 @@ def get_typed_parameters(obj: Callable[..., Any]) -> list[inspect.Parameter]:
     ]
 
 
-class _InjectMarker:
-    """A marker object for declaring injectable dependencies."""
+class _Sentinel:
+    __slots__ = ("_name",)
 
-    __slots__ = ()
+    def __init__(self, name: str) -> None:
+        self._name = name
 
-    def __call__(self) -> Self:
-        return self
+    def __repr__(self) -> str:
+        return f"<{self._name}>"
 
+    def __eq__(self, other: object) -> bool:
+        return self is other
 
-def InjectMarker() -> Any:
-    return _InjectMarker()
+    def __hash__(self) -> int:
+        return id(self)
 
 
-def is_inject_marker(obj: Any) -> bool:
-    return isinstance(obj, _InjectMarker)
+NOT_SET = _Sentinel("NOT_SET")
 
 
-class Event:
-    """Represents an event object."""
+class InjectMarker:
+    """A marker object for declaring injectable dependencies."""
 
-    __slots__ = ()
+    __slots__ = ("_interface",)
 
+    def __init__(self, interface: Any = NOT_SET) -> None:
+        self._interface = interface
 
-def is_event_type(obj: Any) -> bool:
-    """Checks if an object is an event type."""
-    return inspect.isclass(obj) and issubclass(obj, Event)
+    @property
+    def interface(self) -> Any:
+        if self._interface is NOT_SET:
+            raise TypeError("Interface is not set.")
+        return self._interface
 
+    @interface.setter
+    def interface(self, interface: Any) -> None:
+        self._interface = interface
 
-class _Sentinel:
-    __slots__ = ("_name",)
 
-    def __init__(self, name: str) -> None:
-        self._name = name
+def is_inject_marker(obj: Any) -> bool:
+    return isinstance(obj, InjectMarker)
 
-    def __repr__(self) -> str:
-        return f"<{self._name}>"
 
-    def __eq__(self, other: object) -> bool:
-        return self is other
+def Inject() -> Any:
+    return InjectMarker()
 
-    def __hash__(self) -> int:
-        return id(self)
 
+class Event:
+    """Represents an event object."""
 
-NOT_SET = _Sentinel("NOT_SET")
+    __slots__ = ()
+
+
+def is_event_type(obj: Any) -> bool:
+    """Checks if an object is an event type."""
+    return inspect.isclass(obj) and issubclass(obj, Event)

{anydi-0.46.0 → anydi-0.47.0}/anydi/ext/django/ninja/_signature.py

@@ -46,11 +46,11 @@ class ViewSignature(BaseViewSignature):
                 self.response_arg = name
                 continue
 
-            interface, should_inject = container._validate_injected_parameter(
+            interface, should_inject = container.validate_injected_parameter(
                 arg, call=self.view_func
             )
             if should_inject:
-                self.dependencies.append((name, arg.annotation))
+                self.dependencies.append((name, interface))
                 continue
 
             func_param = self._get_param_type(name, arg)

{anydi-0.46.0 → anydi-0.47.0}/anydi/ext/fastapi.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from collections.abc import Iterator
-from typing import Any, cast
+from typing import Annotated, Any, cast
 
 from fastapi import Depends, FastAPI, params
 from fastapi.dependencies.models import Dependant
@@ -11,9 +11,8 @@ from fastapi.routing import APIRoute
 from starlette.requests import Request
 
 from anydi._container import Container
-from anydi._typing import get_typed_parameters
+from anydi._typing import InjectMarker, get_typed_parameters
 
-from ._utils import HasInterface, patch_call_parameter
 from .starlette.middleware import RequestScopedMiddleware
 
 __all__ = ["RequestScopedMiddleware", "install", "get_container", "Inject"]
@@ -41,7 +40,7 @@ def install(app: FastAPI, container: Container) -> None:
             if not call:
                 continue  # pragma: no cover
             for parameter in get_typed_parameters(call):
-                patch_call_parameter(container, call, parameter)
+                container.validate_injected_parameter(parameter, call=call)
 
 
 def get_container(request: Request) -> Container:
@@ -49,20 +48,19 @@ def get_container(request: Request) -> Container:
     return cast(Container, request.app.state.container)
 
 
-class Resolver(params.Depends, HasInterface):
-    """Parameter dependency class for injecting dependencies using AnyDI."""
-
+class _Inject(params.Depends, InjectMarker):
     def __init__(self) -> None:
         super().__init__(dependency=self._dependency, use_cache=True)
-        HasInterface.__init__(self)
+        InjectMarker.__init__(self)
 
-    async def _dependency(self, container: Container = Depends(get_container)) -> Any:
+    async def _dependency(
+        self, container: Annotated[Container, Depends(get_container)]
+    ) -> Any:
         return await container.aresolve(self.interface)
 
 
-def Inject() -> Any:  # noqa
-    """Decorator for marking a function parameter as requiring injection."""
-    return Resolver()
+def Inject() -> Any:
+    return _Inject()
 
 
 def _iter_dependencies(dependant: Dependant) -> Iterator[Dependant]:

{anydi-0.46.0 → anydi-0.47.0}/anydi/ext/faststream.py

@@ -9,9 +9,7 @@ from faststream import ContextRepo
 from faststream.broker.core.usecase import BrokerUsecase
 
 from anydi import Container
-from anydi._typing import get_typed_parameters
-
-from ._utils import HasInterface, patch_call_parameter
+from anydi._typing import InjectMarker, get_typed_parameters
 
 
 def install(broker: BrokerUsecase[Any, Any], container: Container) -> None:
@@ -26,7 +24,7 @@ def install(broker: BrokerUsecase[Any, Any], container: Container) -> None:
     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)
+            container.validate_injected_parameter(parameter, call=call)
 
 
 def _get_broken_handlers(broker: BrokerUsecase[Any, Any]) -> list[Any]:
@@ -43,17 +41,17 @@ def get_container(broker: BrokerUsecase[Any, Any]) -> Container:
     return cast(Container, getattr(broker, "_container"))  # noqa
 
 
-class Resolver(Depends, HasInterface):
+class _Inject(Depends, InjectMarker):
     """Parameter dependency class for injecting dependencies using AnyDI."""
 
     def __init__(self) -> None:
         super().__init__(dependency=self._dependency, use_cache=True, cast=True)
-        HasInterface.__init__(self)
+        InjectMarker.__init__(self)
 
     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()
+def Inject() -> Any:
+    return _Inject()

{anydi-0.46.0 → anydi-0.47.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "anydi"
-version = "0.46.0"
+version = "0.47.0"
 description = "Dependency Injection library"
 authors = [{ name = "Anton Ruhlov", email = "antonruhlov@gmail.com" }]
 requires-python = "~=3.9"
@@ -137,7 +137,7 @@ omit = [
 ]
 
 [tool.bumpversion]
-current_version = "0.46.0"
+current_version = "0.47.0"
 parse = """(?x)
     (?P<major>0|[1-9]\\d*)\\.
     (?P<minor>0|[1-9]\\d*)\\.

{anydi-0.46.0 → anydi-0.47.0}/tests/ext/django/api/router.py

@@ -1,9 +1,9 @@
-from typing import Any
+from typing import Annotated, Any
 
 from django.http import HttpRequest
 from ninja import Router
 
-import anydi
+from anydi import Inject
 
 from tests.ext.django.services import HelloService
 
@@ -14,7 +14,7 @@ router = Router()
 def say_hello(
     request: HttpRequest,
     name: str,
-    hello_service: HelloService = anydi.auto,
+    hello_service: Annotated[HelloService, Inject()],
 ) -> Any:
     assert hello_service.started
     return hello_service.say_hello(name)
@@ -24,7 +24,7 @@ def say_hello(
 async def say_hello_async(
     request: HttpRequest,
     name: str,
-    hello_service: HelloService = anydi.auto,
+    hello_service: HelloService = Inject(),
 ) -> Any:
     assert hello_service.started
     return await hello_service.say_hello_async(name)

{anydi-0.46.0 → anydi-0.47.0}/tests/ext/starlette/app.py

@@ -6,7 +6,7 @@ from starlette.requests import Request
 from starlette.responses import JSONResponse
 from starlette.routing import Route
 
-from anydi import auto
+from anydi import Inject
 from anydi.ext.starlette.middleware import RequestScopedMiddleware
 from anydi.testing import TestContainer
 
@@ -28,8 +28,8 @@ def mail_service() -> MailService:
 @container.inject
 async def send_email(
     request: Request,
-    user_service: UserService = auto,
-    mail_service: MailService = auto,
+    user_service: UserService = Inject(),
+    mail_service: MailService = Inject(),
 ) -> JSONResponse:
     data = await request.json()
     message = cast(str, data.get("message"))

{anydi-0.46.0 → anydi-0.47.0}/tests/test_container.py

@@ -9,7 +9,7 @@ from typing import Annotated, Any, Callable, Union
 import pytest
 from typing_extensions import Self
 
-from anydi import Container, Provider, Scope, auto, request, singleton, transient
+from anydi import Container, Inject, Provider, Scope, request, singleton, transient
 from anydi._provider import ProviderKind
 from anydi._typing import Event
 
@@ -1403,25 +1403,53 @@ class TestContainer:
 
 
 class TestContainerInjector:
-    def test_inject(self, container: Container) -> None:
+    def test_inject_using_inject_marker(self, container: Container) -> None:
         @container.provider(scope="singleton")
-        def ident_provider() -> str:
-            return "1000"
+        def message() -> str:
+            return "test"
+
+        @container.inject
+        def func(message: str = Inject()) -> str:
+            return message
 
+        result = func()
+
+        assert result == "test"
+
+    def test_inject_using_inject_annotated_marker(self, container: Container) -> None:
         @container.provider(scope="singleton")
-        def service_provider(ident: str) -> Service:
-            return Service(ident=ident)
+        def message() -> str:
+            return "test"
 
         @container.inject
-        def func(name: str, service: Service = auto) -> str:
-            return f"{name} = {service.ident}"
+        def func(message: Annotated[str, Inject()]) -> str:
+            return message
 
-        result = func(name="service ident")
+        result = func()  # type: ignore
 
-        assert result == "service ident = 1000"
+        assert result == "test"
+
+    def test_inject_using_inject_annotated_with_marker(
+        self, container: Container
+    ) -> None:
+        @container.provider(scope="singleton")
+        def message() -> str:
+            return "test"
+
+        with pytest.raises(
+            TypeError,
+            match=(
+                "Cannot specify `Inject` in `Annotated` and default value "
+                "together for 'message'"
+            ),
+        ):
+
+            @container.inject
+            def func(message: Annotated[str, Inject()] = Inject()) -> str:
+                return message
 
     def test_inject_missing_annotation(self, container: Container) -> None:
-        def handler(name=auto) -> str:  # type: ignore
+        def handler(name=Inject()) -> str:  # type: ignore
             return name  # type: ignore
 
         with pytest.raises(
@@ -1433,7 +1461,7 @@ class TestContainerInjector:
     def test_inject_unknown_dependency(self) -> None:
         container = Container()
 
-        def handler(message: str = auto) -> None:
+        def handler(message: str = Inject()) -> None:
             pass
 
         with pytest.raises(
@@ -1445,32 +1473,6 @@ class TestContainerInjector:
         ):
             container.inject(handler)
 
-    def test_inject_auto_marker(self, container: Container) -> None:
-        @container.provider(scope="singleton")
-        def message() -> str:
-            return "test"
-
-        @container.inject
-        def func(message: str = auto) -> str:
-            return message
-
-        result = func()
-
-        assert result == "test"
-
-    def test_inject_auto_marker_call(self, container: Container) -> None:
-        @container.provider(scope="singleton")
-        def message() -> str:
-            return "test"
-
-        @container.inject
-        def func(message: str = auto()) -> str:
-            return message
-
-        result = func()
-
-        assert result == "test"
-
     def test_inject_class(self, container: Container) -> None:
         @container.provider(scope="singleton")
         def ident_provider() -> str:
@@ -1482,7 +1484,7 @@ class TestContainerInjector:
 
         @container.inject
         class Handler:
-            def __init__(self, name: str, service: Service = auto) -> None:
+            def __init__(self, name: str, service: Service = Inject()) -> None:
                 self.name = name
                 self.service = service
 
@@ -1510,7 +1512,7 @@ class TestContainerInjector:
         await container.astart()
 
         @container.inject
-        async def func(name: str, service: Service = auto) -> str:
+        async def func(name: str, service: Service = Inject()) -> str:
             return f"{name} = {service.ident}"
 
         result = await func(name="service ident")
@@ -1528,8 +1530,8 @@ class TestContainerInjector:
 
         def sum_handler(
             value1: int,
-            value2: Annotated[int, "value1"] = auto,
-            value3: Annotated[int, "value2"] = auto,
+            value2: Annotated[int, "value1"] = Inject(),
+            value3: Annotated[int, "value2"] = Inject(),
         ) -> int:
             return value1 + value2 + value3
 
@@ -1542,7 +1544,7 @@ class TestContainerInjector:
         def message() -> str:
             return "hello"
 
-        def handler(message: str = auto) -> str:
+        def handler(message: str = Inject()) -> str:
             return message
 
         _ = container.run(handler)

{anydi-0.46.0 → anydi-0.47.0}/uv.lock

@@ -13,7 +13,7 @@ wheels = [
 
 [[package]]
 name = "anydi"
-version = "0.46.0"
+version = "0.47.0"
 source = { editable = "." }
 dependencies = [
     { name = "anyio" },

anydi-0.46.0/anydi/ext/_utils.py

@@ -1,77 +0,0 @@
-"""AnyDI FastAPI extension."""
-
-from __future__ import annotations
-
-import inspect
-import logging
-from typing import Annotated, Any, Callable
-
-from typing_extensions import get_args, get_origin
-
-from anydi import Container
-from anydi._typing import _InjectMarker
-
-logger = logging.getLogger(__name__)
-
-
-class HasInterface(_InjectMarker):
-    __slots__ = ("_interface",)
-
-    def __init__(self, interface: Any = None) -> None:
-        self._interface = interface
-
-    @property
-    def interface(self) -> Any:
-        if self._interface is None:
-            raise TypeError("Interface is not set.")
-        return self._interface
-
-    @interface.setter
-    def interface(self, interface: Any) -> None:
-        self._interface = interface
-
-
-def patch_annotated_parameter(parameter: inspect.Parameter) -> inspect.Parameter:
-    """Patch an annotated parameter to resolve the default value."""
-    if not (
-        get_origin(parameter.annotation) is Annotated
-        and parameter.default is inspect.Parameter.empty
-    ):
-        return parameter
-
-    tp_origin, *tp_metadata = get_args(parameter.annotation)
-    default = tp_metadata[-1]
-
-    if not isinstance(default, HasInterface):
-        return parameter
-
-    if (num := len(tp_metadata[:-1])) == 0:
-        interface = tp_origin
-    elif num == 1:
-        interface = Annotated[tp_origin, tp_metadata[0]]
-    elif num == 2:
-        interface = Annotated[tp_origin, tp_metadata[0], tp_metadata[1]]
-    elif num == 3:
-        interface = Annotated[
-            tp_origin,
-            tp_metadata[0],
-            tp_metadata[1],
-            tp_metadata[2],
-        ]
-    else:
-        raise TypeError("Too many annotated arguments.")  # pragma: no cover
-    return parameter.replace(annotation=interface, default=default)
-
-
-def patch_call_parameter(
-    container: Container, call: Callable[..., Any], parameter: inspect.Parameter
-) -> None:
-    """Patch a parameter to inject dependencies using AnyDI."""
-    parameter = patch_annotated_parameter(parameter)
-
-    interface, should_inject = container._validate_injected_parameter(
-        parameter, call=call
-    )  # noqa
-    if should_inject:
-        parameter.default.interface = interface
-    return None