anydi 0.67.0__tar.gz → 0.67.2__tar.gz

{anydi-0.67.0 → anydi-0.67.2}/PKG-INFO

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

{anydi-0.67.0 → anydi-0.67.2}/anydi/_container.py

@@ -23,14 +23,7 @@ from ._module import ModuleDef, ModuleRegistrar
 from ._provider import Provider, ProviderDef, ProviderKind, ProviderParameter
 from ._resolver import Resolver
 from ._scanner import PackageOrIterable, Scanner
-from ._types import (
-    NOT_SET,
-    Event,
-    Scope,
-    is_event_type,
-    is_iterator_type,
-    is_none_type,
-)
+from ._types import NOT_SET, Event, Scope, is_event_type, is_iterator_type, is_none_type
 
 T = TypeVar("T", bound=Any)
 P = ParamSpec("P")
@@ -390,28 +383,27 @@ class Container:
         name = type_repr(call)
         kind = ProviderKind.from_call(call)
         is_class = kind == ProviderKind.CLASS
-        is_resource = kind in (ProviderKind.GENERATOR, ProviderKind.ASYNC_GENERATOR)
+        is_coroutine = kind == ProviderKind.COROUTINE
+        is_generator = kind == ProviderKind.GENERATOR
+        is_async_generator = kind == ProviderKind.ASYNC_GENERATOR
+        is_resource = is_generator or is_async_generator
 
-        # Validate scope if it provided
+        # Validate scope
         self._validate_provider_scope(scope, name, is_resource)
 
-        # Get the signature
+        # Get signature and detect interface
         signature = inspect.signature(call, eval_str=True)
 
-        # Detect the interface
         if interface is NOT_SET:
-            if is_class:
-                interface = call
-            else:
-                interface = signature.return_annotation
-                if interface is inspect.Signature.empty:
-                    interface = None
+            interface = call if is_class else signature.return_annotation
+            if interface is inspect.Signature.empty:
+                interface = None
 
-        # If the callable is an iterator, return the actual type
-        if is_iterator_type(interface) or is_iterator_type(get_origin(interface)):
+        # Handle iterator types for resources
+        interface_origin = get_origin(interface)
+        if is_iterator_type(interface) or is_iterator_type(interface_origin):
             if args := get_args(interface):
                 interface = args[0]
-                # If the callable is a generator, return the resource type
                 if is_none_type(interface):
                     interface = type(f"Event_{uuid.uuid4().hex}", (Event,), {})
             else:
@@ -420,27 +412,27 @@ class Container:
                     "without actual type argument."
                 )
 
-        # None interface is not allowed
+        # Validate interface
         if is_none_type(interface):
             raise TypeError(f"Missing `{name}` provider return annotation.")
 
-        # Check for existing provider
         if interface in self._providers and not override:
             raise LookupError(
                 f"The provider interface `{type_repr(interface)}` already registered."
             )
 
-        unresolved_parameter = None
-        unresolved_exc: LookupError | None = None
+        # Process parameters
         parameters: list[ProviderParameter] = []
         scope_provider: dict[Scope, Provider] = {}
-
-        # Precompute constant checks
+        unresolved_parameter = None
+        unresolved_exc: LookupError | None = None
         is_scoped = scope not in ("singleton", "transient")
-        has_defaults = defaults is not None
+        scope_hierarchy = self._scopes.get(scope, ()) if scope != "transient" else ()
 
         for parameter in signature.parameters.values():
-            if parameter.annotation is inspect.Parameter.empty:
+            annotation = parameter.annotation
+
+            if annotation is inspect.Parameter.empty:
                 raise TypeError(
                     f"Missing provider `{name}` "
                     f"dependency `{parameter.name}` annotation."
@@ -451,26 +443,21 @@ 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
+            has_default = parameter.default is not inspect.Parameter.empty
+            default = parameter.default if has_default else NOT_SET
 
             try:
-                sub_provider = self._get_or_register_provider(parameter.annotation)
+                sub_provider = self._get_or_register_provider(annotation)
             except LookupError as exc:
-                if (has_defaults and parameter.name in defaults) or has_default:
+                if (defaults and parameter.name in defaults) or has_default:
                     continue
-                # For scoped (request/custom) dependencies, allow unresolved parameters
-                # that will be provided via context.set()
+                # For scoped dependencies, allow unresolved parameters via context.set()
                 if is_scoped:
-                    self._resolver.add_unresolved(parameter.annotation)
+                    self._resolver.add_unresolved(annotation)
                     parameters.append(
                         ProviderParameter(
                             name=parameter.name,
-                            annotation=parameter.annotation,
+                            annotation=annotation,
                             default=default,
                             has_default=has_default,
                             provider=None,
@@ -482,22 +469,21 @@ class Container:
                 unresolved_exc = exc
                 continue
 
-            # Store first provider for each scope
-            if sub_provider.scope not in scope_provider:
-                scope_provider[sub_provider.scope] = sub_provider
+            # Track scope providers for validation
+            scope_provider.setdefault(sub_provider.scope, sub_provider)
 
-            # For scoped dependencies with same scope: if auto-registered provider
-            # has unresolved parameters, defer to context.set() instead
+            # For scoped dependencies with same scope having unresolved params,
+            # defer to context.set() instead
             if (
                 is_scoped
                 and sub_provider.scope == scope
                 and any(p.provider is None for p in sub_provider.parameters)
             ):
-                self._resolver.add_unresolved(parameter.annotation)
+                self._resolver.add_unresolved(annotation)
                 parameters.append(
                     ProviderParameter(
                         name=parameter.name,
-                        annotation=parameter.annotation,
+                        annotation=annotation,
                         default=default,
                         has_default=has_default,
                         provider=None,
@@ -506,10 +492,19 @@ class Container:
                 )
                 continue
 
+            # Validate scope compatibility inline
+            if scope_hierarchy and sub_provider.scope not in scope_hierarchy:
+                raise ValueError(
+                    f"The provider `{name}` with a `{scope}` scope "
+                    f"cannot depend on `{sub_provider}` with a "
+                    f"`{sub_provider.scope}` scope. Please ensure all "
+                    "providers are registered with matching scopes."
+                )
+
             parameters.append(
                 ProviderParameter(
                     name=parameter.name,
-                    annotation=parameter.annotation,
+                    annotation=annotation,
                     default=default,
                     has_default=has_default,
                     provider=sub_provider,
@@ -517,21 +512,11 @@ class Container:
                 )
             )
 
-        # Check scope compatibility
-        # Transient scope can use any scoped dependencies
-        if scope != "transient":
-            for sub_provider in scope_provider.values():
-                if sub_provider.scope not in self._scopes.get(scope, []):
-                    raise ValueError(
-                        f"The provider `{name}` with a `{scope}` scope "
-                        f"cannot depend on `{sub_provider}` with a "
-                        f"`{sub_provider.scope}` scope. Please ensure all "
-                        "providers are registered with matching scopes."
-                    )
-
-        # Check for unresolved parameters
+        # Handle unresolved parameters
         if unresolved_parameter:
-            if scope not in ("singleton", "transient"):
+            if is_scoped:  # pragma: no cover
+                # Note: This branch is currently unreachable because
+                # unresolved_parameter is only set when is_scoped=False
                 self._resolver.add_unresolved(interface)
             else:
                 raise LookupError(
@@ -542,11 +527,7 @@ class Container:
                     f"attempting to use it."
                 ) from unresolved_exc
 
-        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
-
+        # Create and register provider
         provider = Provider(
             call=call,
             scope=scope,
@@ -557,13 +538,12 @@ class Container:
             is_coroutine=is_coroutine,
             is_generator=is_generator,
             is_async_generator=is_async_generator,
-            is_async=is_async,
+            is_async=is_coroutine or is_async_generator,
             is_resource=is_resource,
         )
 
         self._set_provider(provider)
 
-        # Clear cached resolvers when overriding
         if override:
             self._resolver.clear_caches()
 
@@ -589,20 +569,20 @@ class Container:
         """Get provider by interface."""
         try:
             return self._providers[interface]
-        except KeyError as exc:
+        except KeyError:
             raise LookupError(
                 f"The provider interface for `{type_repr(interface)}` has "
                 "not been registered. Please ensure that the provider interface is "
                 "properly registered before attempting to use it."
-            ) from exc
+            ) from None
 
     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]
-        except KeyError:
+            return self._get_provider(interface)
+        except LookupError:
             if inspect.isclass(interface) and is_provided(interface):
                 return self._register_provider(
                     interface,

{anydi-0.67.0 → anydi-0.67.2}/anydi/_resolver.py

@@ -672,6 +672,8 @@ class Resolver:
 
     def _wrap_for_override(self, annotation: Any, value: Any) -> Any:
         """Hook for wrapping dependencies to enable override patching."""
+        if isinstance(value, InstanceProxy):
+            return value
         return InstanceProxy(value, interface=annotation)
 
     def _post_resolve_override(self, interface: Any, instance: Any) -> Any:  # noqa: C901

{anydi-0.67.0 → anydi-0.67.2}/anydi/ext/typer.py

@@ -42,7 +42,7 @@ def _wrap_async_callback_with_injection(
     callback: Callable[..., Awaitable[Any]],
     container: Container,
     sig: inspect.Signature,
-    non_injected_params: set[inspect.Parameter],
+    non_injected_params: list[inspect.Parameter],
     scopes: set[Scope],
 ) -> Any:
     """Wrap async callback with injection in anyio.run()."""
@@ -86,7 +86,7 @@ def _process_callback(callback: Callable[..., Any], container: Container) -> Any
     """Validate and wrap a callback for dependency injection."""
     sig = inspect.signature(callback, eval_str=True)
     injected_param_names: set[str] = set()
-    non_injected_params: set[inspect.Parameter] = set()
+    non_injected_params: list[inspect.Parameter] = []
     scopes: set[Scope] = set()
 
     # Validate parameters and collect which ones need injection
@@ -103,7 +103,7 @@ def _process_callback(callback: Callable[..., Any], container: Container) -> Any
                 if inspect.isclass(interface) and is_provided(interface):
                     scopes.add(interface.__provided__["scope"])
         else:
-            non_injected_params.add(processed_parameter)
+            non_injected_params.append(processed_parameter)
 
     # If no parameters need injection and callback is not async, return original
     if not injected_param_names and not inspect.iscoroutinefunction(callback):

{anydi-0.67.0 → anydi-0.67.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "anydi"
-version = "0.67.0"
+version = "0.67.2"
 description = "Dependency Injection library"
 authors = [{ name = "Anton Ruhlov", email = "antonruhlov@gmail.com" }]
 requires-python = ">=3.10.0, <3.15"
@@ -51,7 +51,7 @@ anydi = "anydi.ext.pytest_plugin"
 [dependency-groups]
 dev = [
     "ruff>=0.14.0",
-    "pyright>=1.1.407",
+    "pyright>=1.1.408",
     "pytest>=8.4.0,<9",
     "pytest-cov>=7.0.0",
     "pytest-mock>=3.14.1",