anydi 0.38.0__py3-none-any.whl → 0.38.2rc0__py3-none-any.whl

anydi/_types.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
+import enum
 import inspect
 from collections.abc import Iterable
+from dataclasses import dataclass
+from functools import cached_property
 from types import ModuleType
-from typing import Annotated, Any, NamedTuple, Union
+from typing import Annotated, Any, Callable, NamedTuple, Union
 
 import wrapt
 from typing_extensions import Literal, Self, TypeAlias
@@ -12,6 +15,8 @@ Scope = Literal["transient", "singleton", "request"]
 
 AnyInterface: TypeAlias = Union[type[Any], Annotated[Any, ...]]
 
+NOT_SET = object()
+
 
 class Marker:
     """A marker class for marking dependencies."""
@@ -53,12 +58,85 @@ class InstanceProxy(wrapt.ObjectProxy):  # type: ignore[misc]
         return object.__getattribute__(self, item)
 
 
+class ProviderKind(enum.IntEnum):
+    CLASS = 1
+    FUNCTION = 2
+    COROUTINE = 3
+    GENERATOR = 4
+    ASYNC_GENERATOR = 5
+
+    @classmethod
+    def from_call(cls, call: Callable[..., Any]) -> ProviderKind:
+        if inspect.isclass(call):
+            return cls.CLASS
+        elif inspect.iscoroutinefunction(call):
+            return cls.COROUTINE
+        elif inspect.isasyncgenfunction(call):
+            return cls.ASYNC_GENERATOR
+        elif inspect.isgeneratorfunction(call):
+            return cls.GENERATOR
+        elif inspect.isfunction(call) or inspect.ismethod(call):
+            return cls.FUNCTION
+        raise TypeError(
+            f"The provider `{call}` is invalid because it is not a callable "
+            "object. Only callable providers are allowed."
+        )
+
+
+@dataclass(kw_only=True, frozen=True)
+class ProviderParameter:
+    pass
+
+
+@dataclass(kw_only=True, frozen=True)
+class Provider:
+    call: Callable[..., Any]
+    scope: Scope
+    interface: Any
+    name: str
+    parameters: list[inspect.Parameter]
+    kind: ProviderKind
+
+    def __str__(self) -> str:
+        return self.name
+
+    @cached_property
+    def is_class(self) -> bool:
+        return self.kind == ProviderKind.CLASS
+
+    @cached_property
+    def is_coroutine(self) -> bool:
+        return self.kind == ProviderKind.COROUTINE
+
+    @cached_property
+    def is_generator(self) -> bool:
+        return self.kind == ProviderKind.GENERATOR
+
+    @cached_property
+    def is_async_generator(self) -> bool:
+        return self.kind == ProviderKind.ASYNC_GENERATOR
+
+    @cached_property
+    def is_async(self) -> bool:
+        return self.is_coroutine or self.is_async_generator
+
+    @cached_property
+    def is_resource(self) -> bool:
+        return self.is_generator or self.is_async_generator
+
+
+class ProviderArgs(NamedTuple):
+    call: Callable[..., Any]
+    scope: Scope
+    interface: Any | None = None
+
+
 class ProviderDecoratorArgs(NamedTuple):
     scope: Scope
     override: bool
 
 
-class Dependency(NamedTuple):
+class ScannedDependency(NamedTuple):
     member: Any
     module: ModuleType
 

anydi/ext/pytest_plugin.py

@@ -35,11 +35,9 @@ CONTAINER_FIXTURE_NAME = "container"
 
 
 @pytest.fixture
-def anydi_setup_container(
-    request: pytest.FixtureRequest,
-) -> Iterator[Container]:
+def anydi_setup_container(request: pytest.FixtureRequest) -> Container:
     try:
-        container = request.getfixturevalue(CONTAINER_FIXTURE_NAME)
+        return cast(Container, request.getfixturevalue(CONTAINER_FIXTURE_NAME))
     except pytest.FixtureLookupError as exc:
         exc.msg = (
             "`container` fixture is not found. Make sure to define it in your test "
@@ -47,8 +45,6 @@ def anydi_setup_container(
         )
         raise exc
 
-    yield container
-
 
 @pytest.fixture
 def _anydi_should_inject(request: pytest.FixtureRequest) -> bool:
@@ -57,27 +53,20 @@ def _anydi_should_inject(request: pytest.FixtureRequest) -> bool:
     return marker is not None or inject_all
 
 
-@pytest.fixture(scope="session")
-def _anydi_unresolved() -> Iterator[list[Any]]:
-    unresolved: list[Any] = []
-    yield unresolved
-    unresolved.clear()
-
-
 @pytest.fixture
 def _anydi_injected_parameter_iterator(
     request: pytest.FixtureRequest,
-    _anydi_unresolved: list[str],
 ) -> Callable[[], Iterator[tuple[str, Any]]]:
-    registered_fixtures = request.session._fixturemanager._arg2fixturedefs  # noqa
+    fixturenames = set(request.node._fixtureinfo.initialnames) - set(
+        request.node._fixtureinfo.name2fixturedefs.keys()
+    )
 
     def _iterator() -> Iterator[tuple[str, inspect.Parameter]]:
         for parameter in get_typed_parameters(request.function):
             interface = parameter.annotation
             if (
                 interface is inspect.Parameter.empty
-                or interface in _anydi_unresolved
-                or parameter.name in registered_fixtures
+                or parameter.name not in fixturenames
             ):
                 continue
             yield parameter.name, interface
@@ -90,7 +79,6 @@ def _anydi_inject(
     request: pytest.FixtureRequest,
     _anydi_should_inject: bool,
     _anydi_injected_parameter_iterator: Callable[[], Iterator[tuple[str, Any]]],
-    _anydi_unresolved: list[str],
 ) -> None:
     """Inject dependencies into the test function."""
 
@@ -111,7 +99,6 @@ def _anydi_inject(
             logger.warning(
                 f"Failed to resolve dependency for argument '{argname}'.", exc_info=exc
             )
-            _anydi_unresolved.append(interface)
 
 
 @pytest.fixture(autouse=True)
@@ -119,7 +106,6 @@ def _anydi_ainject(
     request: pytest.FixtureRequest,
     _anydi_should_inject: bool,
     _anydi_injected_parameter_iterator: Callable[[], Iterator[tuple[str, Any]]],
-    _anydi_unresolved: list[str],
 ) -> None:
     """Inject dependencies into the test function."""
     if (
@@ -149,7 +135,6 @@ def _anydi_ainject(
                     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)

{anydi-0.38.0.dist-info → anydi-0.38.2rc0.dist-info}/METADATA

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

{anydi-0.38.0.dist-info → anydi-0.38.2rc0.dist-info}/RECORD

@@ -1,8 +1,7 @@
-anydi/__init__.py,sha256=OfRg2EfXD65pHTGQKhfkABMwUhw5LvsuTQV_Tv4V4wk,501
-anydi/_container.py,sha256=yH1DsSQFkbfxGaDFs47nr-iXLE_Wwgv6QMTGWrRb8cE,38524
+anydi/__init__.py,sha256=aAq10a1V_zQ3_Me3p_pll5d1O77PIgqotkOm3pshORI,495
+anydi/_container.py,sha256=BqpvUPeYt6OW7TLIDm-OvMGCbcxnvXA6KyOF9XBmi7M,43072
 anydi/_context.py,sha256=7LV_SL4QWkJeiG7_4D9PZ5lmU-MPzhofxC95zCgY9Gc,2651
-anydi/_provider.py,sha256=1IyxHO83NHjsPDHLDIZtW1pJ7i8VpWD3EM4T6duw9zA,7661
-anydi/_types.py,sha256=fdO4xNXtGMxVArmlfDkFYbyR895ixkBTW6V8lMceN7Q,1562
+anydi/_types.py,sha256=oFyx6jxkEsz5FZk6tdRjUmBBQ2tX7eA_bLaa2elq7Mg,3586
 anydi/_utils.py,sha256=INI0jNIXrJ6LS4zqJymMO2yUEobpxmBGASf4G_vR6AU,4378
 anydi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anydi/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -10,7 +9,7 @@ anydi/ext/_utils.py,sha256=U6sRqWzccWUu7eMhbXX1NrwcaxitQF9cO1KxnKF37gw,2566
 anydi/ext/fastapi.py,sha256=AEL3ubu-LxUPHMMt1YIn3En_JZC7nyBKmKxmhka3O3c,2436
 anydi/ext/faststream.py,sha256=qXnNGvAqWWp9kbhbQUE6EF_OPUiYQmtOH211_O7BI_0,1898
 anydi/ext/pydantic_settings.py,sha256=8IXXLuG_OvKbvKlBkBRQUHcXgbTpgQUxeWyoMcRIUQM,1488
-anydi/ext/pytest_plugin.py,sha256=ShGhiZnP1KyMHhnc9Ci1RKAuHVhw628OTS2P2BLEOfc,5001
+anydi/ext/pytest_plugin.py,sha256=yR_vos8qt8uFS9uy_G_HJjNgudzJIXawrtpWnn3Pu_s,4613
 anydi/ext/django/__init__.py,sha256=QI1IABCVgSDTUoh7M9WMECKXwB3xvh04HfQ9TOWw1Mk,223
 anydi/ext/django/_container.py,sha256=cxVoYQG16WP0S_Yv4TnLwuaaT7NVEOhLWO-YdALJUb4,418
 anydi/ext/django/_settings.py,sha256=Z0RlAuXoO73oahWeMkK10w8c-4uCBde-DBpeKTV5USY,853
@@ -22,8 +21,8 @@ anydi/ext/django/ninja/_operation.py,sha256=wSWa7D73XTVlOibmOciv2l6JHPe1ERZcXrqI
 anydi/ext/django/ninja/_signature.py,sha256=2cSzKxBIxXLqtwNuH6GSlmjVJFftoGmleWfyk_NVEWw,2207
 anydi/ext/starlette/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anydi/ext/starlette/middleware.py,sha256=9CQtGg5ZzUz2gFSzJr8U4BWzwNjK8XMctm3n52M77Z0,792
-anydi-0.38.0.dist-info/METADATA,sha256=MdihH1SW8w5R3GwJ1OGnFySPjC2Qkm9uKTwe1FvSICc,4917
-anydi-0.38.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-anydi-0.38.0.dist-info/entry_points.txt,sha256=Nklo9f3Oe4AkNsEgC4g43nCJ-23QDngZSVDNRMdaILI,43
-anydi-0.38.0.dist-info/licenses/LICENSE,sha256=V6rU8a8fv6o2jQ-7ODHs0XfDFimot8Q6Km6CylRIDTo,1069
-anydi-0.38.0.dist-info/RECORD,,
+anydi-0.38.2rc0.dist-info/METADATA,sha256=t8FL1ILCUK37XUFQ_gqgAlwX77UytT5FeP4QueIDX50,4920
+anydi-0.38.2rc0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+anydi-0.38.2rc0.dist-info/entry_points.txt,sha256=Nklo9f3Oe4AkNsEgC4g43nCJ-23QDngZSVDNRMdaILI,43
+anydi-0.38.2rc0.dist-info/licenses/LICENSE,sha256=V6rU8a8fv6o2jQ-7ODHs0XfDFimot8Q6Km6CylRIDTo,1069
+anydi-0.38.2rc0.dist-info/RECORD,,

anydi/_provider.py

@@ -1,232 +0,0 @@
-from __future__ import annotations
-
-import inspect
-import uuid
-from collections.abc import AsyncIterator, Iterator
-from enum import IntEnum
-from typing import Any, Callable
-
-from typing_extensions import get_args, get_origin
-
-try:
-    from types import NoneType
-except ImportError:
-    NoneType = type(None)  # type: ignore[misc]
-
-
-from ._types import Event, Scope
-from ._utils import get_full_qualname, get_typed_annotation
-
-_sentinel = object()
-
-
-class CallableKind(IntEnum):
-    CLASS = 1
-    FUNCTION = 2
-    COROUTINE = 3
-    GENERATOR = 4
-    ASYNC_GENERATOR = 5
-
-
-class Provider:
-    __slots__ = (
-        "_call",
-        "_call_module",
-        "_call_globals",
-        "_scope",
-        "_qualname",
-        "_kind",
-        "_interface",
-        "_parameters",
-        "_is_class",
-        "_is_coroutine",
-        "_is_generator",
-        "_is_async_generator",
-        "_is_async",
-        "_is_resource",
-    )
-
-    def __init__(
-        self, call: Callable[..., Any], *, scope: Scope, interface: Any = _sentinel
-    ) -> None:
-        self._call = call
-        self._call_module = getattr(call, "__module__", None)
-        self._call_globals = getattr(call, "__globals__", {})
-        self._scope = scope
-        self._qualname = get_full_qualname(call)
-
-        # Detect the kind of callable provider
-        self._detect_kind()
-
-        self._is_class = self._kind == CallableKind.CLASS
-        self._is_coroutine = self._kind == CallableKind.COROUTINE
-        self._is_generator = self._kind == CallableKind.GENERATOR
-        self._is_async_generator = self._kind == CallableKind.ASYNC_GENERATOR
-        self._is_async = self._is_coroutine or self._is_async_generator
-        self._is_resource = self._is_generator or self._is_async_generator
-
-        # Validate the scope of the provider
-        self._validate_scope()
-
-        # Get the signature
-        signature = inspect.signature(call)
-
-        # Detect the interface
-        self._detect_interface(interface, signature)
-
-        # Detect the parameters
-        self._detect_parameters(signature)
-
-    def __str__(self) -> str:
-        return self._qualname
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, Provider):
-            return NotImplemented  # pragma: no cover
-        return (
-            self._call == other._call
-            and self._scope == other._scope
-            and self._interface == other._interface
-        )
-
-    @property
-    def call(self) -> Callable[..., Any]:
-        return self._call
-
-    @property
-    def kind(self) -> CallableKind:
-        return self._kind
-
-    @property
-    def scope(self) -> Scope:
-        return self._scope
-
-    @property
-    def interface(self) -> Any:
-        return self._interface
-
-    @property
-    def parameters(self) -> list[inspect.Parameter]:
-        return self._parameters
-
-    @property
-    def is_class(self) -> bool:
-        """Check if the provider is a class."""
-        return self._is_class
-
-    @property
-    def is_coroutine(self) -> bool:
-        """Check if the provider is a coroutine."""
-        return self._is_coroutine
-
-    @property
-    def is_generator(self) -> bool:
-        """Check if the provider is a generator."""
-        return self._is_generator
-
-    @property
-    def is_async_generator(self) -> bool:
-        """Check if the provider is an async generator."""
-        return self._is_async_generator
-
-    @property
-    def is_async(self) -> bool:
-        """Check if the provider is an async callable."""
-        return self._is_async
-
-    @property
-    def is_resource(self) -> bool:
-        """Check if the provider is a resource."""
-        return self._is_resource
-
-    def _validate_scope(self) -> None:
-        """Validate the scope of the provider."""
-        if self.scope not in get_args(Scope):
-            raise ValueError(
-                "The scope provided is invalid. Only the following scopes are "
-                f"supported: {', '.join(get_args(Scope))}. Please use one of the "
-                "supported scopes when registering a provider."
-            )
-        if self.is_resource and self.scope == "transient":
-            raise TypeError(
-                f"The resource provider `{self}` is attempting to register "
-                "with a transient scope, which is not allowed."
-            )
-
-    def _detect_kind(self) -> None:
-        """Detect the kind of callable provider."""
-        if inspect.isclass(self.call):
-            self._kind = CallableKind.CLASS
-        elif inspect.iscoroutinefunction(self.call):
-            self._kind = CallableKind.COROUTINE
-        elif inspect.isasyncgenfunction(self.call):
-            self._kind = CallableKind.ASYNC_GENERATOR
-        elif inspect.isgeneratorfunction(self.call):
-            self._kind = CallableKind.GENERATOR
-        elif inspect.isfunction(self.call) or inspect.ismethod(self.call):
-            self._kind = CallableKind.FUNCTION
-        else:
-            raise TypeError(
-                f"The provider `{self.call}` is invalid because it is not a callable "
-                "object. Only callable providers are allowed."
-            )
-
-    def _detect_interface(self, interface: Any, signature: inspect.Signature) -> None:
-        """Detect the interface of callable provider."""
-        # If the callable is a class, return the class itself
-        if self._kind == CallableKind.CLASS:
-            self._interface = self._call
-            return
-
-        if interface is _sentinel:
-            interface = self._resolve_interface(interface, signature)
-
-        # If the callable is an iterator, return the actual type
-        iterator_types = {Iterator, AsyncIterator}
-        if interface in iterator_types or get_origin(interface) in iterator_types:
-            if args := get_args(interface):
-                interface = args[0]
-                # If the callable is a generator, return the resource type
-                if interface is NoneType or interface is None:
-                    self._interface = type(f"Event_{uuid.uuid4().hex}", (Event,), {})
-                    return
-            else:
-                raise TypeError(
-                    f"Cannot use `{self}` resource type annotation "
-                    "without actual type argument."
-                )
-
-        # None interface is not allowed
-        if interface in {None, NoneType}:
-            raise TypeError(f"Missing `{self}` provider return annotation.")
-
-        # Set the interface
-        self._interface = interface
-
-    def _resolve_interface(self, interface: Any, signature: inspect.Signature) -> Any:
-        """Resolve the interface of the callable provider."""
-        interface = signature.return_annotation
-        if interface is inspect.Signature.empty:
-            return None
-        return get_typed_annotation(
-            interface,
-            self._call_globals,
-            module=self._call_module,
-        )
-
-    def _detect_parameters(self, signature: inspect.Signature) -> None:
-        """Detect the parameters of the callable provider."""
-        parameters = []
-        for parameter in signature.parameters.values():
-            if parameter.kind == inspect.Parameter.POSITIONAL_ONLY:
-                raise TypeError(
-                    f"Positional-only parameter `{parameter.name}` is not allowed "
-                    f"in the provider `{self}`."
-                )
-            annotation = get_typed_annotation(
-                parameter.annotation,
-                self._call_globals,
-                module=self._call_module,
-            )
-            parameters.append(parameter.replace(annotation=annotation))
-        self._parameters = parameters