anydi 0.46.0__py3-none-any.whl → 0.47.0__py3-none-any.whl

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/_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/_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/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/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/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.dist-info → anydi-0.47.0.dist-info}/METADATA

@@ -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.dist-info → anydi-0.47.0.dist-info}/RECORD

@@ -1,19 +1,18 @@
-anydi/__init__.py,sha256=GNKdoiDe1XNdMIGvI8UP43QSLOBbMQYyFpiicLlgZxI,544
+anydi/__init__.py,sha256=KjjYm-1yAFxiPYaMs1WRJMtxE0q_vdX7ZRLQR1fFGs8,567
 anydi/_async.py,sha256=KhRd3RmZFcwNDzrMm8ctA1gwrg-6m_7laECTYsZdF5k,1445
-anydi/_container.py,sha256=EC06Uur6GOahFF5mhluGYX95woOnKv2Hcr7j1rs9xu8,31262
+anydi/_container.py,sha256=Ug0TVOuNQ1cpwUQiHSNtAiZB-qJHv8ECd89WcK6ZwWg,32350
 anydi/_context.py,sha256=_Xy8cTpRskb4cxTd-Fe-5NnIZyBe1DnovkofhdeUfmw,3020
 anydi/_decorators.py,sha256=F3yBeGQSz1EsulZaEvYn3cd6FEjJRMoyA6u1QCbEwcs,2813
 anydi/_module.py,sha256=QPvP27JndZkwl-FYUZWscJm6yfkNzjwoFGURyDhb6Pc,2582
 anydi/_provider.py,sha256=ig2ecn-STmFGcpkLE5A5OM35XHtU2NsxFVrGp2CvuvM,2123
 anydi/_scan.py,sha256=nOpspmceVucdwf8nUv1QVFsz2sRVWCVUb0QTH9EbWr4,3653
 anydi/_scope.py,sha256=PFHjPb2-n0vhRo9mvD_craTFfoJBzR3y-N3_0apL5Q0,258
-anydi/_typing.py,sha256=zSyE4JAnaBsJLZ3Zb3o9o02LgKePwBWzMwczdhmyG3U,3711
+anydi/_typing.py,sha256=7Nhg4ezPgvFmdGOd2SI_9y5iQv8j-QkNOohXRGNAaIE,4057
 anydi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anydi/testing.py,sha256=ex9grqKpQmmJWwhIVnzq6aHaUAGLu2-7fwLyYTUuKHE,5678
 anydi/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-anydi/ext/_utils.py,sha256=EjOhBtze0tqWMjpTiBCSzaOyecHCRWygMDZbj4ZyAEA,2213
-anydi/ext/fastapi.py,sha256=QIC45I3sfE_cNVL27cilw7lwLEZhHPhxj0mtFdtKlIc,2484
-anydi/ext/faststream.py,sha256=Ewfj9hXbCSr5x7QWoLEORmc3uPcbr7PEcCcG1wM-6XM,1946
+anydi/ext/fastapi.py,sha256=L9VGPHGy23se1sflmJqTE7LNfQuElVdYEogoT1f5-4A,2324
+anydi/ext/faststream.py,sha256=Dy81Vf34CP6pEIbZ-41vh_-Dn6Qc-rcf14U5poebjxI,1905
 anydi/ext/pydantic_settings.py,sha256=8IXXLuG_OvKbvKlBkBRQUHcXgbTpgQUxeWyoMcRIUQM,1488
 anydi/ext/pytest_plugin.py,sha256=IoP6XKuGLGLd2Xlpfttc3mI4pxCm2WQLE7x_a7asbv4,4732
 anydi/ext/django/__init__.py,sha256=QI1IABCVgSDTUoh7M9WMECKXwB3xvh04HfQ9TOWw1Mk,223
@@ -24,11 +23,11 @@ anydi/ext/django/apps.py,sha256=YLL1uU6dSQ3uf3GB0VHzPW_eLuB1j9h6pv8EdAutMqo,2725
 anydi/ext/django/middleware.py,sha256=5OUdp0OWRozyW338Sq04BDhacaFlyUTTOduS_7EwCTA,854
 anydi/ext/django/ninja/__init__.py,sha256=4J0zoHPK9itbTVrjjvLX6Ftrsb2ND8bITqNDIJzEhks,520
 anydi/ext/django/ninja/_operation.py,sha256=wk5EOjLY3KVIHk9jMCGsFsja9-dQmMOpLpHXciqxQdk,2680
-anydi/ext/django/ninja/_signature.py,sha256=mseRTLZZdwdXCG-jdTe1l4WRacbKoa3kfEGWQ1aq3QY,2364
+anydi/ext/django/ninja/_signature.py,sha256=p7JtyMdFhX4fWQOvAhvZNss6iURNERcdsTsQADTHkMY,2358
 anydi/ext/starlette/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anydi/ext/starlette/middleware.py,sha256=MxnzshAs-CMvjJp0r457k52MzBL8O4KAuClnF6exBdU,803
-anydi-0.46.0.dist-info/METADATA,sha256=4C-I83UUd7PWkcDhIUm7Z1KfWqEDWyhoecoLgf6GlB4,4957
-anydi-0.46.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-anydi-0.46.0.dist-info/entry_points.txt,sha256=Nklo9f3Oe4AkNsEgC4g43nCJ-23QDngZSVDNRMdaILI,43
-anydi-0.46.0.dist-info/licenses/LICENSE,sha256=V6rU8a8fv6o2jQ-7ODHs0XfDFimot8Q6Km6CylRIDTo,1069
-anydi-0.46.0.dist-info/RECORD,,
+anydi-0.47.0.dist-info/METADATA,sha256=PBlr12YCEaTNpURekET6v25gNR9mixOyyYqtVW3y75E,4957
+anydi-0.47.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+anydi-0.47.0.dist-info/entry_points.txt,sha256=Nklo9f3Oe4AkNsEgC4g43nCJ-23QDngZSVDNRMdaILI,43
+anydi-0.47.0.dist-info/licenses/LICENSE,sha256=V6rU8a8fv6o2jQ-7ODHs0XfDFimot8Q6Km6CylRIDTo,1069
+anydi-0.47.0.dist-info/RECORD,,

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