anydi 0.53.0__tar.gz → 0.54.0__tar.gz

{anydi-0.53.0 → anydi-0.54.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anydi
-Version: 0.53.0
+Version: 0.54.0
 Summary: Dependency Injection library
 Keywords: dependency injection,dependencies,di,async,asyncio,application
 Author: Anton Ruhlov

{anydi-0.53.0 → anydi-0.54.0}/anydi/_container.py

@@ -19,7 +19,7 @@ from ._async import run_sync
 from ._context import InstanceContext
 from ._decorators import is_provided
 from ._module import ModuleDef, ModuleRegistrar
-from ._provider import Provider, ProviderDef, ProviderKind
+from ._provider import Provider, ProviderDef, ProviderKind, ProviderParameter
 from ._scan import PackageOrIterable, Scanner
 from ._scope import ALLOWED_SCOPES, Scope
 from ._typing import (
@@ -298,7 +298,7 @@ class Container:
 
         unresolved_parameter = None
         unresolved_exc: LookupError | None = None
-        parameters: list[inspect.Parameter] = []
+        parameters: list[ProviderParameter] = []
         scopes: dict[Scope, Provider] = {}
 
         for parameter in signature.parameters.values():
@@ -326,7 +326,21 @@ class Container:
             if sub_provider.scope not in scopes:
                 scopes[sub_provider.scope] = sub_provider
 
-            parameters.append(parameter)
+            default = (
+                parameter.default
+                if parameter.default is not inspect.Parameter.empty
+                else NOT_SET
+            )
+            parameters.append(
+                ProviderParameter(
+                    name=parameter.name,
+                    annotation=parameter.annotation,
+                    default=default,
+                    has_default=default is not NOT_SET,
+                    provider=sub_provider,
+                    shared_scope=sub_provider.scope == scope and scope != "transient",
+                )
+            )
 
         # Check for unresolved parameters
         if unresolved_parameter:
@@ -356,7 +370,7 @@ class Container:
             interface=interface,
             name=name,
             kind=kind,
-            parameters=parameters,
+            parameters=tuple(parameters),
         )
 
         self._set_provider(provider)
@@ -495,9 +509,36 @@ class Container:
     ) -> Any:
         """Internal method to handle instance resolution and creation."""
         provider = self._get_or_register_provider(interface, **defaults)
+        return self._resolve_with_provider(provider, create, **defaults)
+
+    async def _aresolve_or_create(
+        self, interface: Any, create: bool, /, **defaults: Any
+    ) -> Any:
+        """Internal method to handle instance resolution and creation asynchronously."""
+        provider = self._get_or_register_provider(interface, **defaults)
+        return await self._aresolve_with_provider(provider, create, **defaults)
+
+    def _resolve_with_provider(
+        self, provider: Provider, create: bool, /, **defaults: Any
+    ) -> Any:
         if provider.scope == "transient":
             return self._create_instance(provider, None, **defaults)
+
+        if provider.scope == "request":
+            context = self._get_request_context()
+            if not create:
+                cached = context.get(provider.interface, NOT_SET)
+                if cached is not NOT_SET:
+                    return cached
+            if not create:
+                return self._get_or_create_instance(provider, context)
+            return self._create_instance(provider, context, **defaults)
+
         context = self._get_instance_context(provider.scope)
+        if not create:
+            cached = context.get(provider.interface, NOT_SET)
+            if cached is not NOT_SET:
+                return cached
         with context.lock():
             return (
                 self._get_or_create_instance(provider, context)
@@ -505,14 +546,27 @@ class Container:
                 else self._create_instance(provider, context, **defaults)
             )
 
-    async def _aresolve_or_create(
-        self, interface: Any, create: bool, /, **defaults: Any
+    async def _aresolve_with_provider(
+        self, provider: Provider, create: bool, /, **defaults: Any
     ) -> Any:
-        """Internal method to handle instance resolution and creation asynchronously."""
-        provider = self._get_or_register_provider(interface, **defaults)
         if provider.scope == "transient":
             return await self._acreate_instance(provider, None, **defaults)
+
+        if provider.scope == "request":
+            context = self._get_request_context()
+            if not create:
+                cached = context.get(provider.interface, NOT_SET)
+                if cached is not NOT_SET:
+                    return cached
+            if not create:
+                return await self._aget_or_create_instance(provider, context)
+            return await self._acreate_instance(provider, context, **defaults)
+
         context = self._get_instance_context(provider.scope)
+        if not create:
+            cached = context.get(provider.interface, NOT_SET)
+            if cached is not NOT_SET:
+                return cached
         async with context.alock():
             return (
                 await self._aget_or_create_instance(provider, context)
@@ -524,8 +578,8 @@ class Container:
         self, provider: Provider, context: InstanceContext
     ) -> Any:
         """Get an instance of a dependency from the scoped context."""
-        instance = context.get(provider.interface)
-        if instance is None:
+        instance = context.get(provider.interface, NOT_SET)
+        if instance is NOT_SET:
             instance = self._create_instance(provider, context)
             context.set(provider.interface, instance)
             return instance
@@ -535,8 +589,8 @@ class Container:
         self, provider: Provider, context: InstanceContext
     ) -> Any:
         """Get an async instance of a dependency from the scoped context."""
-        instance = context.get(provider.interface)
-        if instance is None:
+        instance = context.get(provider.interface, NOT_SET)
+        if instance is NOT_SET:
             instance = await self._acreate_instance(provider, context)
             context.set(provider.interface, instance)
             return instance
@@ -552,7 +606,9 @@ class Container:
                 "synchronous mode."
             )
 
-        provider_kwargs = self._get_provided_kwargs(provider, context, **defaults)
+        provider_kwargs = self._get_provided_kwargs(
+            provider, context, defaults=defaults if defaults else None
+        )
 
         if provider.is_generator:
             if context is None:
@@ -570,7 +626,7 @@ class Container:
     ) -> Any:
         """Create an instance asynchronously using the provider."""
         provider_kwargs = await self._aget_provided_kwargs(
-            provider, context, **defaults
+            provider, context, defaults=defaults if defaults else None
         )
 
         if provider.is_coroutine:
@@ -604,97 +660,143 @@ class Container:
         return instance
 
     def _get_provided_kwargs(
-        self, provider: Provider, context: InstanceContext | None, /, **defaults: Any
+        self,
+        provider: Provider,
+        context: InstanceContext | None,
+        /,
+        defaults: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         """Retrieve the arguments for a provider."""
-        provided_kwargs = {}
+        if not provider.parameters:
+            return defaults if defaults else {}
+
+        provided_kwargs = dict(defaults) if defaults else {}
         for parameter in provider.parameters:
             provided_kwargs[parameter.name] = self._get_provider_instance(
-                provider, parameter, context, **defaults
+                provider,
+                parameter,
+                context,
+                defaults=defaults,
             )
-        return {**defaults, **provided_kwargs}
+        return provided_kwargs
 
-    def _get_provider_instance(
+    def _get_provider_instance(  # noqa: C901
         self,
         provider: Provider,
-        parameter: inspect.Parameter,
+        parameter: ProviderParameter,
         context: InstanceContext | None,
         /,
-        **defaults: Any,
+        *,
+        defaults: dict[str, Any] | None = None,
     ) -> Any:
         """Retrieve an instance of a dependency from the scoped context."""
 
-        # Try to get instance from defaults
-        if parameter.name in defaults:
+        if defaults and parameter.name in defaults:
             return defaults[parameter.name]
 
-        # Try to get instance from context
-        elif context and parameter.annotation in context:
-            instance = context[parameter.annotation]
+        sub_provider = parameter.provider
 
-        # Resolve new instance
-        else:
-            try:
-                instance = self._resolve_parameter(provider, parameter)
-            except LookupError:
-                if parameter.default is inspect.Parameter.empty:
-                    raise
-                return parameter.default
-        return instance
+        if context and parameter.shared_scope and sub_provider is not None:
+            existing = context.get(sub_provider.interface, NOT_SET)
+            if existing is not NOT_SET:
+                return existing
+
+        if context:
+            cached = context.get(parameter.annotation, NOT_SET)
+            if cached is not NOT_SET:
+                return cached
+
+        sub_provider = parameter.provider
+
+        if sub_provider:
+            if sub_provider.scope == "transient":
+                return self._create_instance(sub_provider, None)
+            if sub_provider.scope == "singleton" and sub_provider is not provider:
+                return self._resolve_with_provider(sub_provider, False)
+
+        try:
+            return self._resolve_parameter(provider, parameter)
+        except LookupError:
+            if not parameter.has_default:
+                raise
+            return parameter.default
 
     async def _aget_provided_kwargs(
-        self, provider: Provider, context: InstanceContext | None, /, **defaults: Any
+        self,
+        provider: Provider,
+        context: InstanceContext | None,
+        /,
+        defaults: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         """Asynchronously retrieve the arguments for a provider."""
-        provided_kwargs = {}
+        if not provider.parameters:
+            return defaults if defaults else {}
+
+        provided_kwargs = dict(defaults) if defaults else {}
         for parameter in provider.parameters:
             provided_kwargs[parameter.name] = await self._aget_provider_instance(
-                provider, parameter, context, **defaults
+                provider,
+                parameter,
+                context,
+                defaults=defaults,
             )
-        return {**defaults, **provided_kwargs}
+        return provided_kwargs
 
-    async def _aget_provider_instance(
+    async def _aget_provider_instance(  # noqa: C901
         self,
         provider: Provider,
-        parameter: inspect.Parameter,
+        parameter: ProviderParameter,
         context: InstanceContext | None,
         /,
-        **defaults: Any,
+        *,
+        defaults: dict[str, Any] | None = None,
     ) -> Any:
         """Asynchronously retrieve an instance of a dependency from the context."""
 
-        # Try to get instance from defaults
-        if parameter.name in defaults:
+        if defaults and parameter.name in defaults:
             return defaults[parameter.name]
 
-        # Try to get instance from context
-        elif context and parameter.annotation in context:
-            instance = context[parameter.annotation]
+        sub_provider = parameter.provider
 
-        # Resolve new instance
-        else:
-            try:
-                instance = await self._aresolve_parameter(provider, parameter)
-            except LookupError:
-                if parameter.default is inspect.Parameter.empty:
-                    raise
-                return parameter.default
-        return instance
+        if context and parameter.shared_scope and sub_provider is not None:
+            existing = context.get(sub_provider.interface, NOT_SET)
+            if existing is not NOT_SET:
+                return existing
+
+        if context:
+            cached = context.get(parameter.annotation, NOT_SET)
+            if cached is not NOT_SET:
+                return cached
+
+        sub_provider = parameter.provider
+
+        if sub_provider:
+            if sub_provider.scope == "transient":
+                return await self._acreate_instance(sub_provider, None)
+            if sub_provider.scope == "singleton" and sub_provider is not provider:
+                return await self._aresolve_with_provider(sub_provider, False)
+
+        try:
+            return await self._aresolve_parameter(provider, parameter)
+        except LookupError:
+            if not parameter.has_default:
+                raise
+            return parameter.default
 
     def _resolve_parameter(
-        self, provider: Provider, parameter: inspect.Parameter
+        self, provider: Provider, parameter: ProviderParameter
     ) -> Any:
         self._validate_resolvable_parameter(provider, parameter)
         return self._resolve_or_create(parameter.annotation, False)
 
     async def _aresolve_parameter(
-        self, provider: Provider, parameter: inspect.Parameter
+        self, provider: Provider, parameter: ProviderParameter
     ) -> Any:
         self._validate_resolvable_parameter(provider, parameter)
         return await self._aresolve_or_create(parameter.annotation, False)
 
     def _validate_resolvable_parameter(
-        self, provider: Provider, parameter: inspect.Parameter
+        self, provider: Provider, parameter: ProviderParameter
     ) -> None:
         """Ensure that the specified interface is resolved."""
         if parameter.annotation in self._unresolved_interfaces:

{anydi-0.53.0 → anydi-0.54.0}/anydi/_context.py

@@ -8,6 +8,7 @@ from typing import Any
 from typing_extensions import Self
 
 from ._async import AsyncRLock, run_sync
+from ._typing import NOT_SET
 
 
 class InstanceContext:
@@ -22,9 +23,9 @@ class InstanceContext:
         self._lock = threading.RLock()
         self._async_lock = AsyncRLock()
 
-    def get(self, interface: Any) -> Any | None:
+    def get(self, interface: Any, default: Any = NOT_SET) -> Any:
         """Get an instance from the context."""
-        return self._instances.get(interface)
+        return self._instances.get(interface, default)
 
     def set(self, interface: Any, value: Any) -> None:
         """Set an instance in the context."""

{anydi-0.53.0 → anydi-0.54.0}/anydi/_provider.py

@@ -5,7 +5,7 @@ import inspect
 from collections.abc import Callable
 from dataclasses import dataclass
 from functools import cached_property
-from typing import Any, NamedTuple
+from typing import Any
 
 from ._scope import Scope
 from ._typing import NOT_SET
@@ -39,13 +39,23 @@ class ProviderKind(enum.IntEnum):
         return kind in (cls.GENERATOR, cls.ASYNC_GENERATOR)
 
 
+@dataclass(kw_only=True, frozen=True, slots=True)
+class ProviderParameter:
+    name: str
+    annotation: Any
+    default: Any
+    has_default: bool
+    provider: Provider | None = None
+    shared_scope: bool = False
+
+
 @dataclass(kw_only=True, frozen=True)
 class Provider:
     call: Callable[..., Any]
     scope: Scope
     interface: Any
     name: str
-    parameters: list[inspect.Parameter]
+    parameters: tuple[ProviderParameter, ...]
     kind: ProviderKind
 
     def __str__(self) -> str:
@@ -76,7 +86,8 @@ class Provider:
         return ProviderKind.is_resource(self.kind)
 
 
-class ProviderDef(NamedTuple):
+@dataclass(kw_only=True, frozen=True, slots=True)
+class ProviderDef:
     call: Callable[..., Any]
     scope: Scope
     interface: Any = NOT_SET

{anydi-0.53.0 → anydi-0.54.0}/anydi/ext/pytest_plugin.py

@@ -7,6 +7,7 @@ from typing import Any, cast
 
 import pytest
 from anyio.pytest_plugin import extract_backend_and_options, get_runner
+from typing_extensions import get_annotations
 
 from anydi import Container
 
@@ -60,16 +61,14 @@ def _anydi_injected_parameter_iterator(
     )
 
     def _iterator() -> Iterator[tuple[str, inspect.Parameter]]:
-        for parameter in inspect.signature(
+        for name, annotation in get_annotations(
             request.function, eval_str=True
-        ).parameters.values():
-            interface = parameter.annotation
-            if (
-                interface is inspect.Parameter.empty
-                or parameter.name not in fixturenames
-            ):
+        ).items():
+            if name == "return":
                 continue
-            yield parameter.name, interface
+            if name not in fixturenames:
+                continue
+            yield name, annotation
 
     return _iterator
 

{anydi-0.53.0 → anydi-0.54.0}/anydi/testing.py

@@ -1,5 +1,4 @@
 import contextlib
-import inspect
 import logging
 from collections.abc import Iterable, Iterator, Sequence
 from typing import Any, TypeVar
@@ -10,7 +9,7 @@ from typing_extensions import Self, type_repr
 from ._container import Container
 from ._context import InstanceContext
 from ._module import ModuleDef
-from ._provider import Provider, ProviderDef
+from ._provider import Provider, ProviderDef, ProviderParameter
 from ._scope import Scope
 
 T = TypeVar("T")
@@ -76,7 +75,7 @@ class TestContainer(Container):
     def _get_provider_instance(
         self,
         provider: Provider,
-        parameter: inspect.Parameter,
+        parameter: ProviderParameter,
         context: InstanceContext | None,
         /,
         **defaults: Any,
@@ -90,7 +89,7 @@ class TestContainer(Container):
     async def _aget_provider_instance(
         self,
         provider: Provider,
-        parameter: inspect.Parameter,
+        parameter: ProviderParameter,
         context: InstanceContext | None,
         /,
         **defaults: Any,

{anydi-0.53.0 → anydi-0.54.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "anydi"
-version = "0.53.0"
+version = "0.54.0"
 description = "Dependency Injection library"
 authors = [{ name = "Anton Ruhlov", email = "antonruhlov@gmail.com" }]
 requires-python = ">=3.10.0, <3.15"