anydi 0.61.0__tar.gz → 0.63.0__tar.gz

{anydi-0.61.0 → anydi-0.63.0}/PKG-INFO

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

{anydi-0.61.0 → anydi-0.63.0}/anydi/__init__.py

@@ -2,9 +2,10 @@
 
 from ._container import Container, import_container
 from ._decorators import injectable, provided, provider, request, singleton, transient
+from ._marker import Inject, Provide
 from ._module import Module
 from ._provider import ProviderDef as Provider
-from ._types import Inject, Provide, Scope
+from ._types import Scope
 
 # Alias for dependency auto marker
 # TODO: deprecate it

{anydi-0.61.0 → anydi-0.63.0}/anydi/_container.py

@@ -18,11 +18,19 @@ from typing_extensions import ParamSpec, Self, type_repr
 from ._context import InstanceContext
 from ._decorators import is_provided
 from ._injector import Injector
+from ._marker import Marker
 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")
@@ -423,6 +431,10 @@ class Container:
         parameters: list[ProviderParameter] = []
         scope_provider: dict[Scope, Provider] = {}
 
+        # Precompute constant checks
+        is_scoped = scope not in ("singleton", "transient")
+        has_defaults = defaults is not None
+
         for parameter in signature.parameters.values():
             if parameter.annotation is inspect.Parameter.empty:
                 raise TypeError(
@@ -442,10 +454,32 @@ class Container:
             )
             has_default = default is not NOT_SET
 
+            # Check if provider exists before attempting to register (for scoped only)
+            was_auto_registered = (
+                is_scoped and parameter.annotation not in self._providers
+            )
+
             try:
                 sub_provider = self._get_or_register_provider(parameter.annotation)
             except LookupError as exc:
-                if parameter.name in defaults if defaults else False or has_default:
+                if (has_defaults and parameter.name in defaults) or has_default:
+                    continue
+                # For request/custom scopes, allow unregistered dependencies
+                # They might be provided via context.set()
+                if is_scoped:
+                    # Add to unresolved list to provide better error messages
+                    # and prevent infinite recursion
+                    self._resolver.add_unresolved(parameter.annotation)
+                    parameters.append(
+                        ProviderParameter(
+                            name=parameter.name,
+                            annotation=parameter.annotation,
+                            default=default,
+                            has_default=has_default,
+                            provider=None,  # Will check context at runtime
+                            shared_scope=True,  # Same scope, check context
+                        )
+                    )
                     continue
                 unresolved_parameter = parameter
                 unresolved_exc = exc
@@ -455,6 +489,10 @@ class Container:
             if sub_provider.scope not in scope_provider:
                 scope_provider[sub_provider.scope] = sub_provider
 
+            # If provider was auto-registered and has same scope, mark as unresolved
+            if was_auto_registered and sub_provider.scope == scope:
+                self._resolver.add_unresolved(parameter.annotation)
+
             parameters.append(
                 ProviderParameter(
                     name=parameter.name,
@@ -687,7 +725,7 @@ class Container:
 
     def validate_injected_parameter(
         self, parameter: inspect.Parameter, *, call: Callable[..., Any]
-    ) -> tuple[Any, bool]:
+    ) -> tuple[Any, bool, Marker | None]:
         """Validate an injected parameter."""
         return self._injector.validate_parameter(parameter, call=call)
 

{anydi-0.61.0 → anydi-0.63.0}/anydi/_injector.py

@@ -17,7 +17,7 @@ from typing import (
 
 from typing_extensions import ParamSpec, type_repr
 
-from ._types import is_provide_marker
+from ._marker import Marker, is_marker
 
 if TYPE_CHECKING:
     from ._container import Container
@@ -69,20 +69,21 @@ class Injector:
         """Get the injected parameters of a callable object."""
         injected_params: dict[str, Any] = {}
         for parameter in inspect.signature(call, eval_str=True).parameters.values():
-            interface, should_inject = self.validate_parameter(parameter, call=call)
+            interface, should_inject, _ = self.validate_parameter(parameter, call=call)
             if should_inject:
                 injected_params[parameter.name] = interface
         return injected_params
 
     def validate_parameter(
         self, parameter: inspect.Parameter, *, call: Callable[..., Any]
-    ) -> tuple[Any, bool]:
+    ) -> tuple[Any, bool, Marker | None]:
         """Validate an injected parameter."""
         parameter = self.unwrap_parameter(parameter)
         interface = parameter.annotation
 
-        if not is_provide_marker(parameter.default):
-            return interface, False
+        marker = parameter.default
+        if not is_marker(marker):
+            return interface, False, None
 
         if interface is inspect.Parameter.empty:
             raise TypeError(
@@ -99,7 +100,7 @@ class Injector:
                 f"`{type_repr(interface)}`."
             )
 
-        return interface, True
+        return interface, True, marker
 
     @staticmethod
     def unwrap_parameter(parameter: inspect.Parameter) -> inspect.Parameter:
@@ -108,10 +109,10 @@ class Injector:
 
         origin, *metadata = get_args(parameter.annotation)
 
-        if not metadata or not is_provide_marker(metadata[-1]):
+        if not metadata or not is_marker(metadata[-1]):
             return parameter
 
-        if is_provide_marker(parameter.default):
+        if is_marker(parameter.default):
             raise TypeError(
                 "Cannot specify `Inject` in `Annotated` and "
                 f"default value together for '{parameter.name}'"

anydi-0.63.0/anydi/_marker.py

@@ -0,0 +1,116 @@
+"""Provide marker implementation and utilities."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Annotated, Any, TypeVar
+
+from ._types import NOT_SET
+
+T = TypeVar("T")
+
+
+class Marker:
+    """Marker stored in annotations or defaults to request injection."""
+
+    __slots__ = ("_interface", "_attrs", "_preferred_owner", "_current_owner")
+
+    _FRAMEWORK_ATTRS = frozenset({"dependency", "use_cache", "cast", "cast_result"})
+
+    def __init__(self, interface: Any = NOT_SET) -> None:
+        # Avoid reinitializing attributes when mixins call __init__ multiple times
+        if not hasattr(self, "_attrs"):
+            super().__init__()
+            self._attrs: dict[str, dict[str, Any]] = {}
+            self._preferred_owner = "fastapi"
+            self._current_owner: str | None = None
+        self._interface = interface
+
+    def set_owner(self, owner: str) -> None:
+        self._preferred_owner = owner
+
+    def _store_attr(self, name: str, value: Any) -> None:
+        owner = self._current_owner or self._preferred_owner
+        self._attrs.setdefault(owner, {})[name] = value
+
+    def _get_attr(self, name: str) -> Any:
+        owner = self._preferred_owner
+        if owner in self._attrs and name in self._attrs[owner]:
+            return self._attrs[owner][name]
+        for attrs in self._attrs.values():
+            if name in attrs:
+                return attrs[name]
+        raise AttributeError(name)
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        if name in self._FRAMEWORK_ATTRS and hasattr(self, "_attrs"):
+            self._store_attr(name, value)
+        else:
+            super().__setattr__(name, value)
+
+    def __getattr__(self, name: str) -> Any:
+        if name in self._FRAMEWORK_ATTRS and hasattr(self, "_attrs"):
+            return self._get_attr(name)
+        raise AttributeError(name)
+
+    @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
+
+    def __class_getitem__(cls, item: Any) -> Any:
+        return Annotated[item, cls()]
+
+
+_marker_cls: type[Marker] = Marker
+
+
+def extend_marker(marker_cls: type[Marker]) -> None:
+    """Register an additional framework-specific provide marker."""
+
+    global _marker_cls
+    previous = _marker_cls
+
+    if previous is Marker:
+        _marker_cls = marker_cls
+    else:
+        name = f"Marker_{marker_cls.__name__}_{previous.__name__}"
+
+        def __init__(self: Marker) -> None:
+            marker_cls.__init__(self)
+            previous.__init__(self)
+
+        combined: type[Marker] = type(
+            name, (marker_cls, previous), {"__init__": __init__}
+        )
+        _marker_cls = combined
+
+
+def is_marker(obj: Any) -> bool:
+    return isinstance(obj, Marker)
+
+
+class _ProvideMeta(type):
+    """Metaclass for Provide that delegates __class_getitem__ to the active marker."""
+
+    def __getitem__(cls, item: Any) -> Any:
+        if hasattr(_marker_cls, "__class_getitem__"):
+            return _marker_cls.__class_getitem__(item)  # type: ignore
+        return Annotated[item, _marker_cls()]
+
+
+if TYPE_CHECKING:
+    Provide = Annotated[T, Marker()]
+
+else:
+
+    class Provide(metaclass=_ProvideMeta):
+        pass
+
+
+def Inject() -> Any:
+    return _marker_cls()

{anydi-0.61.0 → anydi-0.63.0}/anydi/_resolver.py

@@ -228,11 +228,15 @@ class Resolver:
                 )
                 create_lines.append(f"        arg_{idx} = defaults['{name}']")
                 create_lines.append("    else:")
-                create_lines.append("        cached = NOT_SET_")
-                create_lines.append("        if context is not None:")
-                create_lines.append(
-                    f"            cached = context.get(_param_annotations[{idx}])"
-                )
+                # Direct dict access for shared scope params (avoids method call)
+                if param_shared_scopes[idx]:
+                    create_lines.append(
+                        f"        cached = (context._instances.get("
+                        f"_param_annotations[{idx}], NOT_SET_) "
+                        f"if context is not None else NOT_SET_)"
+                    )
+                else:
+                    create_lines.append("        cached = NOT_SET_")
                 create_lines.append("        if cached is NOT_SET_:")
                 create_lines.append(
                     f"            if _param_annotations[{idx}] in "

anydi-0.63.0/anydi/_types.py

@@ -0,0 +1,45 @@
+"""Shared AnyDI utils module."""
+
+from __future__ import annotations
+
+import inspect
+from collections.abc import AsyncIterator, Iterator
+from types import NoneType
+from typing import Any, Literal
+
+from typing_extensions import Sentinel
+
+Scope = Literal["transient", "singleton", "request"] | str
+
+NOT_SET = Sentinel("NOT_SET")
+
+
+class Event:
+    """Represents an event object."""
+
+    __slots__ = ()
+
+
+def is_event_type(obj: Any) -> bool:
+    """Checks if an object is an event type."""
+    return inspect.isclass(obj) and issubclass(obj, Event)
+
+
+def is_context_manager(obj: Any) -> bool:
+    """Check if the given object is a context manager."""
+    return hasattr(obj, "__enter__") and hasattr(obj, "__exit__")
+
+
+def is_async_context_manager(obj: Any) -> bool:
+    """Check if the given object is an async context manager."""
+    return hasattr(obj, "__aenter__") and hasattr(obj, "__aexit__")
+
+
+def is_none_type(tp: Any) -> bool:
+    """Check if the given object is a None type."""
+    return tp in (None, NoneType)
+
+
+def is_iterator_type(tp: Any) -> bool:
+    """Check if the given object is an iterator type."""
+    return tp in (Iterator, AsyncIterator)

{anydi-0.61.0 → anydi-0.63.0}/anydi/ext/fastapi.py

@@ -12,7 +12,7 @@ from fastapi.routing import APIRoute
 from starlette.requests import Request
 
 from anydi import Container, Inject
-from anydi._types import ProvideMarker, set_provide_factory
+from anydi._marker import Marker, extend_marker
 
 from .starlette.middleware import RequestScopedMiddleware
 
@@ -24,19 +24,23 @@ def get_container(request: Request) -> Container:
     return cast(Container, request.app.state.container)
 
 
-class _ProvideMarker(params.Depends, ProvideMarker):
+class FastAPIMarker(params.Depends, Marker):
     def __init__(self) -> None:
-        super().__init__(dependency=self._dependency, use_cache=True)
-        ProvideMarker.__init__(self)
-
-    async def _dependency(
+        Marker.__init__(self)
+        self._current_owner = "fastapi"
+        params.Depends.__init__(
+            self, dependency=self._fastapi_dependency, use_cache=True
+        )
+        self._current_owner = None
+
+    async def _fastapi_dependency(
         self, container: Annotated[Container, Depends(get_container)]
     ) -> Any:
         return await container.aresolve(self.interface)
 
 
 # Configure Inject() and Provide[T] to use FastAPI-specific marker
-set_provide_factory(_ProvideMarker)
+extend_marker(FastAPIMarker)
 
 
 def _iter_dependencies(dependant: Dependant) -> Iterator[Dependant]:
@@ -57,7 +61,11 @@ def _validate_route_dependencies(
         if not call:
             continue  # pragma: no cover
         for parameter in inspect.signature(call, eval_str=True).parameters.values():
-            container.validate_injected_parameter(parameter, call=call)
+            _, should_inject, marker = container.validate_injected_parameter(
+                parameter, call=call
+            )
+            if should_inject and marker:
+                marker.set_owner("fastapi")
 
 
 def install(app: FastAPI, container: Container) -> None:

{anydi-0.61.0 → anydi-0.63.0}/anydi/ext/faststream.py

@@ -10,7 +10,7 @@ from fast_depends.dependencies import Dependant
 from faststream import BaseMiddleware, ContextRepo, StreamMessage
 
 from anydi import Container
-from anydi._types import Inject, ProvideMarker, set_provide_factory
+from anydi._marker import Inject, Marker, extend_marker
 
 if TYPE_CHECKING:
     from faststream._internal.basic_types import AsyncFuncAny
@@ -47,18 +47,26 @@ class RequestScopedMiddleware(BaseMiddleware):
             return await call_next(msg)
 
 
-class _ProvideMarker(Dependant, ProvideMarker):
+class FastStreamMarker(Dependant, Marker):
     def __init__(self) -> None:
-        super().__init__(self._dependency, use_cache=True, cast=True, cast_result=True)
-        ProvideMarker.__init__(self)
-
-    async def _dependency(self, context: ContextRepo) -> Any:
+        Marker.__init__(self)
+        self._current_owner = "faststream"
+        Dependant.__init__(
+            self,
+            self._faststream_dependency,
+            use_cache=True,
+            cast=True,
+            cast_result=True,
+        )
+        self._current_owner = None
+
+    async def _faststream_dependency(self, context: ContextRepo) -> Any:
         container = get_container_from_context(context)
         return await container.aresolve(self.interface)
 
 
 # Configure Inject() and Provide[T] to use FastStream-specific marker
-set_provide_factory(_ProvideMarker)
+extend_marker(FastStreamMarker)
 
 
 def _get_broker_handlers(broker: BrokerUsecase[Any, Any]) -> list[Any]:
@@ -71,4 +79,8 @@ def install(broker: BrokerUsecase[Any, Any], container: Container) -> None:
     for handler in _get_broker_handlers(broker):
         call = handler._original_call  # noqa
         for parameter in inspect.signature(call, eval_str=True).parameters.values():
-            container.validate_injected_parameter(parameter, call=call)
+            _, should_inject, marker = container.validate_injected_parameter(
+                parameter, call=call
+            )
+            if should_inject and marker:
+                marker.set_owner("faststream")

{anydi-0.61.0 → anydi-0.63.0}/anydi/ext/typer.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import concurrent.futures
 import contextlib
 import functools
 import inspect
@@ -9,6 +10,7 @@ from collections.abc import Awaitable, Callable
 from typing import Any
 
 import anyio
+import sniffio
 from typer import Typer
 
 from anydi import Container, Scope
@@ -22,7 +24,16 @@ def _wrap_async_callback_no_injection(callback: Callable[..., Any]) -> Any:
 
     @functools.wraps(callback)
     def async_no_injection_wrapper(*args: Any, **kwargs: Any) -> Any:
-        return anyio.run(callback, *args, **kwargs)
+        # Check if we're already in an async context
+        try:
+            sniffio.current_async_library()
+            # We're in an async context, run anyio.run() in a separate thread
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                future = executor.submit(anyio.run, callback, *args, **kwargs)
+                return future.result()
+        except sniffio.AsyncLibraryNotFoundError:
+            # Not in an async context, can use anyio.run directly
+            return anyio.run(callback, *args, **kwargs)
 
     return async_no_injection_wrapper
 
@@ -54,7 +65,16 @@ def _wrap_async_callback_with_injection(
 
                 return await container.run(callback, *args, **kwargs)
 
-        return anyio.run(_run)
+        # Check if we're already in an async context
+        try:
+            sniffio.current_async_library()
+            # We're in an async context, run anyio.run() in a separate thread
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                future = executor.submit(anyio.run, _run)
+                return future.result()
+        except sniffio.AsyncLibraryNotFoundError:
+            # Not in an async context, can use anyio.run directly
+            return anyio.run(_run)
 
     # Update the wrapper's signature to only show non-injected parameters to Typer
     async_wrapper.__signature__ = sig.replace(parameters=non_injected_params)  # type: ignore
@@ -71,9 +91,10 @@ def _process_callback(callback: Callable[..., Any], container: Container) -> Any
 
     # Validate parameters and collect which ones need injection
     for parameter in sig.parameters.values():
-        interface, should_inject = container.validate_injected_parameter(
+        interface, should_inject, _ = container.validate_injected_parameter(
             parameter, call=callback
         )
+        processed_parameter = container._injector.unwrap_parameter(parameter)
         if should_inject:
             injected_param_names.add(parameter.name)
             try:
@@ -82,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(parameter)
+            non_injected_params.add(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.61.0 → anydi-0.63.0}/pyproject.toml

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

anydi-0.61.0/anydi/_types.py

@@ -1,113 +0,0 @@
-"""Shared AnyDI utils module."""
-
-from __future__ import annotations
-
-import inspect
-from collections.abc import AsyncIterator, Callable, Iterator
-from types import NoneType
-from typing import TYPE_CHECKING, Annotated, Any, Literal, TypeVar
-
-from typing_extensions import Sentinel
-
-T = TypeVar("T")
-
-Scope = Literal["transient", "singleton", "request"] | str
-
-NOT_SET = Sentinel("NOT_SET")
-
-
-class ProvideMarker:
-    """A marker object for declaring dependency."""
-
-    __slots__ = ("_interface",)
-
-    def __init__(self, interface: Any = NOT_SET) -> None:
-        self._interface = interface
-
-    @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
-
-    def __class_getitem__(cls, item: Any) -> Any:
-        return Annotated[item, cls()]
-
-
-_provide_factory: Callable[[], Any] = ProvideMarker
-
-
-def set_provide_factory(factory: Callable[[], Any]) -> Callable[[], Any]:
-    """Set the global factory used by Inject() and Provide."""
-    global _provide_factory
-    previous = _provide_factory
-    _provide_factory = factory
-    return previous
-
-
-def is_provide_marker(obj: Any) -> bool:
-    return isinstance(obj, ProvideMarker)
-
-
-class _ProvideMeta(type):
-    """Metaclass for Provide that delegates __class_getitem__ to the current factory."""
-
-    def __getitem__(cls, item: Any) -> Any:
-        # Use the current factory's __class_getitem__ if available
-        factory = _provide_factory
-        if hasattr(factory, "__class_getitem__"):
-            return factory.__class_getitem__(item)  # type: ignore[attr-defined]
-        # Fallback to creating Annotated with factory instance
-        return Annotated[item, factory()]
-
-
-if TYPE_CHECKING:
-    Provide = Annotated[T, ProvideMarker()]
-
-else:
-
-    class Provide(metaclass=_ProvideMeta):
-        pass
-
-
-def Inject() -> Any:
-    return _provide_factory()
-
-
-# Alias from backward compatibility
-is_inject_marker = is_provide_marker
-
-
-class Event:
-    """Represents an event object."""
-
-    __slots__ = ()
-
-
-def is_event_type(obj: Any) -> bool:
-    """Checks if an object is an event type."""
-    return inspect.isclass(obj) and issubclass(obj, Event)
-
-
-def is_context_manager(obj: Any) -> bool:
-    """Check if the given object is a context manager."""
-    return hasattr(obj, "__enter__") and hasattr(obj, "__exit__")
-
-
-def is_async_context_manager(obj: Any) -> bool:
-    """Check if the given object is an async context manager."""
-    return hasattr(obj, "__aenter__") and hasattr(obj, "__aexit__")
-
-
-def is_none_type(tp: Any) -> bool:
-    """Check if the given object is a None type."""
-    return tp in (None, NoneType)
-
-
-def is_iterator_type(tp: Any) -> bool:
-    """Check if the given object is an iterator type."""
-    return tp in (Iterator, AsyncIterator)