anydi 0.54.0__py3-none-any.whl → 0.55.0__py3-none-any.whl

anydi/__init__.py

@@ -4,8 +4,7 @@ from ._container import Container
 from ._decorators import injectable, provided, provider, request, singleton, transient
 from ._module import Module
 from ._provider import ProviderDef as Provider
-from ._scope import Scope
-from ._typing import Inject
+from ._types import Inject, Scope
 
 # Alias for dependency auto marker
 # TODO: deprecate it

anydi/{_async.py → _async_lock.py}

@@ -1,18 +1,8 @@
-import functools
-from collections.abc import Callable
 from types import TracebackType
-from typing import Any, TypeVar
+from typing import Any
 
-import anyio.to_thread
-from typing_extensions import ParamSpec, Self
-
-T = TypeVar("T")
-P = ParamSpec("P")
-
-
-async def run_sync(func: Callable[P, T], /, *args: P.args, **kwargs: P.kwargs) -> T:
-    """Runs the given function asynchronously using the `anyio` library."""
-    return await anyio.to_thread.run_sync(functools.partial(func, *args, **kwargs))
+import anyio
+from typing_extensions import Self
 
 
 class AsyncRLock:

anydi/_container.py

@@ -15,18 +15,16 @@ from typing import Annotated, Any, TypeVar, cast, get_args, get_origin, overload
 
 from typing_extensions import ParamSpec, Self, type_repr
 
-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, ProviderParameter
-from ._scan import PackageOrIterable, Scanner
-from ._scope import ALLOWED_SCOPES, Scope
-from ._typing import (
+from ._resolver import Resolver
+from ._scanner import PackageOrIterable, Scanner
+from ._types import (
     NOT_SET,
     Event,
-    is_async_context_manager,
-    is_context_manager,
+    Scope,
     is_event_type,
     is_inject_marker,
     is_iterator_type,
@@ -36,6 +34,12 @@ from ._typing import (
 T = TypeVar("T", bound=Any)
 P = ParamSpec("P")
 
+ALLOWED_SCOPES: dict[Scope, list[Scope]] = {
+    "singleton": ["singleton"],
+    "request": ["request", "singleton"],
+    "transient": ["transient", "request", "singleton"],
+}
+
 
 class Container:
     """AnyDI is a dependency injection container."""
@@ -54,10 +58,10 @@ class Container:
         self._request_context_var: ContextVar[InstanceContext | None] = ContextVar(
             "request_context", default=None
         )
-        self._unresolved_interfaces: set[Any] = set()
         self._inject_cache: dict[Callable[..., Any], Callable[..., Any]] = {}
 
         # Components
+        self._resolver = Resolver(self)
         self._modules = ModuleRegistrar(self)
         self._scanner = Scanner(self)
 
@@ -75,9 +79,7 @@ class Container:
         for module in modules:
             self.register_module(module)
 
-    ############################
-    # Properties
-    ############################
+    # == Container Properties ==
 
     @property
     def providers(self) -> dict[type[Any], Provider]:
@@ -89,9 +91,7 @@ class Container:
         """Get the logger instance."""
         return self._logger
 
-    ############################
-    # Lifespan/Context Methods
-    ############################
+    # == Context & Lifespan Management ==
 
     def __enter__(self) -> Self:
         """Enter the singleton context."""
@@ -190,9 +190,7 @@ class Container:
             return self._singleton_context
         return self._get_request_context()
 
-    ############################
-    # Provider Methods
-    ############################
+    # == Provider Registry ==
 
     def register(
         self,
@@ -251,22 +249,23 @@ class Container:
         scope: Scope,
         interface: Any = NOT_SET,
         override: bool = False,
-        /,
-        **defaults: Any,
+        defaults: dict[str, Any] | None = None,
     ) -> Provider:
         """Register a provider with the specified scope."""
         name = type_repr(call)
         kind = ProviderKind.from_call(call)
+        is_class = kind == ProviderKind.CLASS
+        is_resource = kind in (ProviderKind.GENERATOR, ProviderKind.ASYNC_GENERATOR)
 
         # Validate scope if it provided
-        self._validate_provider_scope(scope, name, kind)
+        self._validate_provider_scope(scope, name, is_resource)
 
         # Get the signature
         signature = inspect.signature(call, eval_str=True)
 
         # Detect the interface
         if interface is NOT_SET:
-            if kind == ProviderKind.CLASS:
+            if is_class:
                 interface = call
             else:
                 interface = signature.return_annotation
@@ -313,10 +312,17 @@ class Container:
                     f"are not allowed in the provider `{name}`."
                 )
 
+            default = (
+                parameter.default
+                if parameter.default is not inspect.Parameter.empty
+                else NOT_SET
+            )
+            has_default = default is not NOT_SET
+
             try:
                 sub_provider = self._get_or_register_provider(parameter.annotation)
             except LookupError as exc:
-                if self._parameter_has_default(parameter, **defaults):
+                if parameter.name in defaults if defaults else False or has_default:
                     continue
                 unresolved_parameter = parameter
                 unresolved_exc = exc
@@ -326,26 +332,20 @@ class Container:
             if sub_provider.scope not in scopes:
                 scopes[sub_provider.scope] = sub_provider
 
-            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,
+                    has_default=has_default,
                     provider=sub_provider,
-                    shared_scope=sub_provider.scope == scope and scope != "transient",
                 )
             )
 
         # Check for unresolved parameters
         if unresolved_parameter:
             if scope not in ("singleton", "transient"):
-                self._unresolved_interfaces.add(interface)
+                self._resolver.add_unresolved(interface)
             else:
                 raise LookupError(
                     f"The provider `{name}` depends on `{unresolved_parameter.name}` "
@@ -364,20 +364,30 @@ class Container:
                     "Please ensure all providers are registered with matching scopes."
                 )
 
+        is_coroutine = kind == ProviderKind.COROUTINE
+        is_generator = kind == ProviderKind.GENERATOR
+        is_async_generator = kind == ProviderKind.ASYNC_GENERATOR
+        is_async = is_coroutine or is_async_generator
+
         provider = Provider(
             call=call,
             scope=scope,
             interface=interface,
             name=name,
-            kind=kind,
             parameters=tuple(parameters),
+            is_class=is_class,
+            is_coroutine=is_coroutine,
+            is_generator=is_generator,
+            is_async_generator=is_async_generator,
+            is_async=is_async,
+            is_resource=is_resource,
         )
 
         self._set_provider(provider)
         return provider
 
     @staticmethod
-    def _validate_provider_scope(scope: Scope, name: str, kind: ProviderKind) -> None:
+    def _validate_provider_scope(scope: Scope, name: str, is_resource: bool) -> None:
         """Validate the provider scope."""
         if scope not in (allowed_scopes := get_args(Scope)):
             raise ValueError(
@@ -385,7 +395,7 @@ class Container:
                 f"scopes are supported: {', '.join(allowed_scopes)}. "
                 "Please use one of the supported scopes when registering a provider."
             )
-        if scope == "transient" and ProviderKind.is_resource(kind):
+        if scope == "transient" and is_resource:
             raise TypeError(
                 f"The resource provider `{name}` is attempting to register "
                 "with a transient scope, which is not allowed."
@@ -402,7 +412,9 @@ class Container:
                 "properly registered before attempting to use it."
             ) from exc
 
-    def _get_or_register_provider(self, interface: Any, /, **defaults: Any) -> Provider:
+    def _get_or_register_provider(
+        self, interface: Any, defaults: dict[str, Any] | None = None
+    ) -> Provider:
         """Get or register a provider by interface."""
         try:
             return self._providers[interface]
@@ -412,7 +424,8 @@ class Container:
                     interface,
                     interface.__provided__["scope"],
                     NOT_SET,
-                    **defaults,
+                    False,
+                    defaults,
                 )
             raise LookupError(
                 f"The provider interface `{type_repr(interface)}` is either not "
@@ -434,17 +447,7 @@ class Container:
         if provider.is_resource:
             self._resources[provider.scope].remove(provider.interface)
 
-    @staticmethod
-    def _parameter_has_default(
-        parameter: inspect.Parameter, /, **defaults: Any
-    ) -> bool:
-        has_default_in_kwargs = parameter.name in defaults if defaults else False
-        has_default = parameter.default is not inspect.Parameter.empty
-        return has_default_in_kwargs or has_default
-
-    ############################
-    # Instance Methods
-    ############################
+    # == Instance Resolution ==
 
     @overload
     def resolve(self, interface: type[T]) -> T: ...
@@ -453,8 +456,14 @@ class Container:
     def resolve(self, interface: T) -> T: ...  # type: ignore
 
     def resolve(self, interface: type[T]) -> T:
-        """Resolve an instance by interface."""
-        return self._resolve_or_create(interface, False)
+        """Resolve an instance by interface using compiled sync resolver."""
+        cached = self._resolver.get_cached(interface, is_async=False)
+        if cached is not None:
+            return cached.resolve(self)
+
+        provider = self._get_or_register_provider(interface)
+        compiled = self._resolver.compile(provider, is_async=False)
+        return compiled.resolve(self)
 
     @overload
     async def aresolve(self, interface: type[T]) -> T: ...
@@ -464,15 +473,35 @@ class Container:
 
     async def aresolve(self, interface: type[T]) -> T:
         """Resolve an instance by interface asynchronously."""
-        return await self._aresolve_or_create(interface, False)
+        cached = self._resolver.get_cached(interface, is_async=True)
+        if cached is not None:
+            return await cached.resolve(self)
+
+        provider = self._get_or_register_provider(interface)
+        compiled = self._resolver.compile(provider, is_async=True)
+        return await compiled.resolve(self)
 
     def create(self, interface: type[T], /, **defaults: Any) -> T:
         """Create an instance by interface."""
-        return self._resolve_or_create(interface, True, **defaults)
+        if not defaults:
+            cached = self._resolver.get_cached(interface, is_async=False)
+            if cached is not None:
+                return cached.create(self, None)
+
+        provider = self._get_or_register_provider(interface, defaults)
+        compiled = self._resolver.compile(provider, is_async=False)
+        return compiled.create(self, defaults or None)
 
     async def acreate(self, interface: type[T], /, **defaults: Any) -> T:
         """Create an instance by interface asynchronously."""
-        return await self._aresolve_or_create(interface, True, **defaults)
+        if not defaults:
+            cached = self._resolver.get_cached(interface, is_async=True)
+            if cached is not None:
+                return await cached.create(self, None)
+
+        provider = self._get_or_register_provider(interface, defaults)
+        compiled = self._resolver.compile(provider, is_async=True)
+        return await compiled.create(self, defaults or None)
 
     def is_resolved(self, interface: Any) -> bool:
         """Check if an instance by interface exists."""
@@ -504,312 +533,7 @@ class Container:
                 continue
             del context[interface]
 
-    def _resolve_or_create(
-        self, interface: Any, create: bool, /, **defaults: Any
-    ) -> 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)
-                if not create
-                else self._create_instance(provider, context, **defaults)
-            )
-
-    async def _aresolve_with_provider(
-        self, provider: Provider, create: bool, /, **defaults: Any
-    ) -> Any:
-        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)
-                if not create
-                else await self._acreate_instance(provider, context, **defaults)
-            )
-
-    def _get_or_create_instance(
-        self, provider: Provider, context: InstanceContext
-    ) -> Any:
-        """Get an instance of a dependency from the scoped context."""
-        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
-        return instance
-
-    async def _aget_or_create_instance(
-        self, provider: Provider, context: InstanceContext
-    ) -> Any:
-        """Get an async instance of a dependency from the scoped context."""
-        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
-        return instance
-
-    def _create_instance(
-        self, provider: Provider, context: InstanceContext | None, /, **defaults: Any
-    ) -> Any:
-        """Create an instance using the provider."""
-        if provider.is_async:
-            raise TypeError(
-                f"The instance for the provider `{provider}` cannot be created in "
-                "synchronous mode."
-            )
-
-        provider_kwargs = self._get_provided_kwargs(
-            provider, context, defaults=defaults if defaults else None
-        )
-
-        if provider.is_generator:
-            if context is None:
-                raise ValueError("The context is required for generator providers.")
-            cm = contextlib.contextmanager(provider.call)(**provider_kwargs)
-            return context.enter(cm)
-
-        instance = provider.call(**provider_kwargs)
-        if context is not None and provider.is_class and is_context_manager(instance):
-            context.enter(instance)
-        return instance
-
-    async def _acreate_instance(
-        self, provider: Provider, context: InstanceContext | None, /, **defaults: Any
-    ) -> Any:
-        """Create an instance asynchronously using the provider."""
-        provider_kwargs = await self._aget_provided_kwargs(
-            provider, context, defaults=defaults if defaults else None
-        )
-
-        if provider.is_coroutine:
-            return await provider.call(**provider_kwargs)
-
-        if provider.is_async_generator:
-            if context is None:
-                raise ValueError(
-                    "The async stack is required for async generator providers."
-                )
-            cm = contextlib.asynccontextmanager(provider.call)(**provider_kwargs)
-            return await context.aenter(cm)
-
-        if provider.is_generator:
-
-            def _create() -> Any:
-                if context is None:
-                    raise ValueError("The stack is required for generator providers.")
-                cm = contextlib.contextmanager(provider.call)(**provider_kwargs)
-                return context.enter(cm)
-
-            return await run_sync(_create)
-
-        instance = await run_sync(provider.call, **provider_kwargs)
-        if (
-            context is not None
-            and provider.is_class
-            and is_async_context_manager(instance)
-        ):
-            await context.aenter(instance)
-        return instance
-
-    def _get_provided_kwargs(
-        self,
-        provider: Provider,
-        context: InstanceContext | None,
-        /,
-        defaults: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        """Retrieve the arguments for a provider."""
-        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=defaults,
-            )
-        return provided_kwargs
-
-    def _get_provider_instance(  # noqa: C901
-        self,
-        provider: Provider,
-        parameter: ProviderParameter,
-        context: InstanceContext | None,
-        /,
-        *,
-        defaults: dict[str, Any] | None = None,
-    ) -> Any:
-        """Retrieve an instance of a dependency from the scoped context."""
-
-        if defaults and parameter.name in defaults:
-            return defaults[parameter.name]
-
-        sub_provider = parameter.provider
-
-        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: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        """Asynchronously retrieve the arguments for a provider."""
-        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=defaults,
-            )
-        return provided_kwargs
-
-    async def _aget_provider_instance(  # noqa: C901
-        self,
-        provider: Provider,
-        parameter: ProviderParameter,
-        context: InstanceContext | None,
-        /,
-        *,
-        defaults: dict[str, Any] | None = None,
-    ) -> Any:
-        """Asynchronously retrieve an instance of a dependency from the context."""
-
-        if defaults and parameter.name in defaults:
-            return defaults[parameter.name]
-
-        sub_provider = parameter.provider
-
-        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: ProviderParameter
-    ) -> Any:
-        self._validate_resolvable_parameter(provider, parameter)
-        return self._resolve_or_create(parameter.annotation, False)
-
-    async def _aresolve_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: ProviderParameter
-    ) -> None:
-        """Ensure that the specified interface is resolved."""
-        if parameter.annotation in self._unresolved_interfaces:
-            raise LookupError(
-                f"You are attempting to get the parameter `{parameter.name}` with the "
-                f"annotation `{type_repr(parameter.annotation)}` as a "
-                f"dependency into `{type_repr(provider.call)}` which is "
-                "not registered or set in the scoped context."
-            )
-
-    ############################
-    # Injector Methods
-    ############################
+    # == Injection Utilities ==
 
     @overload
     def inject(self, func: Callable[P, T]) -> Callable[P, T]: ...
@@ -933,26 +657,20 @@ class Container:
 
         return interface, True
 
-    ############################
-    # Module Methods
-    ############################
+    # == Module Registration ==
 
     def register_module(self, module: ModuleDef) -> None:
         """Register a module as a callable, module type, or module instance."""
         self._modules.register(module)
 
-    ############################
-    # Scanner Methods
-    ############################
+    # == Package Scanning ==
 
     def scan(
         self, /, packages: PackageOrIterable, *, tags: Iterable[str] | None = None
     ) -> None:
         self._scanner.scan(packages=packages, tags=tags)
 
-    ############################
-    # Testing
-    ############################
+    # == Testing ==
 
     @contextlib.contextmanager
     def override(self, interface: Any, instance: Any) -> Iterator[None]: