anydi 0.61.0__py3-none-any.whl → 0.62.0__py3-none-any.whl

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/_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")
@@ -687,7 +695,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/_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/_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/_types.py

@@ -3,85 +3,17 @@
 from __future__ import annotations
 
 import inspect
-from collections.abc import AsyncIterator, Callable, Iterator
+from collections.abc import AsyncIterator, Iterator
 from types import NoneType
-from typing import TYPE_CHECKING, Annotated, Any, Literal, TypeVar
+from typing import Any, Literal
 
 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."""
 

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/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/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.dist-info → anydi-0.62.0.dist-info}/METADATA

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

{anydi-0.61.0.dist-info → anydi-0.62.0.dist-info}/RECORD

@@ -1,26 +1,27 @@
-anydi/__init__.py,sha256=bQKzn9qfNnIMi1m3J-DdSknSDwNg8j08fdQg_-Edkto,613
+anydi/__init__.py,sha256=KFX8OthKXwBuYDPCV61t-044DpJ88tAOzIxeUWRC5OA,633
 anydi/_async_lock.py,sha256=3dwZr0KthXFYha0XKMyXf8jMmGb1lYoNC0O5w29V9ic,1104
-anydi/_container.py,sha256=oJ1EQnQ1tvi3Y0XNJvhmjVKVd-KzzRbNVaazIRuG3w4,27900
+anydi/_container.py,sha256=fXRJGMprZ5heLsVBEy0Ma_tCTciiK2_Qdsb1HW36tj8,27972
 anydi/_context.py,sha256=-9QqeMWo9OpZVXZxZCQgIsswggl3Ch7lgx1KiFX_ezc,3752
 anydi/_decorators.py,sha256=J3W261ZAG7q4XKm4tbAv1wsWr9ysx9_5MUbUvSJB_MQ,2809
-anydi/_injector.py,sha256=IxKTh2rzMHrsW554tbiJl33Hb5sRGKYY_NU1rC4UvxE,4378
+anydi/_injector.py,sha256=1Ux71DhGxu3dLwPJP8gU73olI0pcZ3_tVaVzwKH7100,4411
+anydi/_marker.py,sha256=xVydjGdkxd_DqqwttnJZRkQbhpCTE9OnrhFmFJMlgvI,3415
 anydi/_module.py,sha256=2kN5uEXLd2Dsc58gz5IWK43wJewr_QgIVGSO3iWp798,2609
 anydi/_provider.py,sha256=OV1WFHTYv7W2U0XDk_Kql1r551Vhq8o-pUV5ep1HQcU,1574
 anydi/_resolver.py,sha256=dMtWU4OHWMYP7J2Rks0sdwyjLHF1uKo77lnvTGhhtBo,30222
 anydi/_scanner.py,sha256=rbRkHzyd2zMu7AFLffN6_tZJcMaW9gy7E-lVdHLHYrs,4294
-anydi/_types.py,sha256=tLJS27j0lWJFd4fIIGlGbbfKBVTPTnWgPYqZlenktis,2939
+anydi/_types.py,sha256=lsShY_-_CM2EFajeknAYXvLl-rHfopBT8udnK5_BtS4,1161
 anydi/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anydi/ext/django/__init__.py,sha256=Ve8lncLU9dPY_Vjt4zihPgsSxwAtFHACn0XvBM5JG8k,367
-anydi/ext/fastapi.py,sha256=TQoS1Vh9chV0Tj0qyxjgqoGTYEMC3jp0il9CDZCZLcc,2326
-anydi/ext/faststream.py,sha256=i6uXE21UawmTYDBqRv7yqDMc-lRiYSYf45sD87O2wX4,2442
+anydi/ext/fastapi.py,sha256=ExDuCLtKB4DBk0GUe70JSzAfyKJs-BcPvHINsXoNVos,2560
+anydi/ext/faststream.py,sha256=yszUfSbo3vJ2tr9PNC2GR-uX1XgRSXGH2lvLNoAXkc4,2738
 anydi/ext/pydantic_settings.py,sha256=jVJZ1wPaPpsxdNPlJj9yq282ebqLZ9tckWpZ0eIwWLg,1533
 anydi/ext/pytest_plugin.py,sha256=M54DkA-KxD9GqLnXdoCyn-Qur2c44MB6d0AgJuYCZ5w,16171
 anydi/ext/starlette/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anydi/ext/starlette/middleware.py,sha256=9CQtGg5ZzUz2gFSzJr8U4BWzwNjK8XMctm3n52M77Z0,792
-anydi/ext/typer.py,sha256=Jw3DspLeCD_yF_GSk4eDlC3bZJWMNYpJ3H6zs5PTVAc,5133
+anydi/ext/typer.py,sha256=z-sDd3jZMPTE2CyEuJ0f9uIJB43FjoLWbjpnkOvqSKA,6236
 anydi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anydi/testing.py,sha256=cHg3mMScZbEep9smRqSNQ81BZMQOkyugHe8TvKdPnEg,1347
-anydi-0.61.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-anydi-0.61.0.dist-info/entry_points.txt,sha256=AgOcQYM5KyS4D37QcYb00tiid0QA-pD1VrjHHq4QAps,44
-anydi-0.61.0.dist-info/METADATA,sha256=s2qDGW7f-s4bAkHDjl_QNl1AJY8VHHkXNwDJK1_VEQ8,8007
-anydi-0.61.0.dist-info/RECORD,,
+anydi-0.62.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+anydi-0.62.0.dist-info/entry_points.txt,sha256=AgOcQYM5KyS4D37QcYb00tiid0QA-pD1VrjHHq4QAps,44
+anydi-0.62.0.dist-info/METADATA,sha256=eWtDMEmZnfsaNCmqZ2CN1AS5DzE5gk4swTQCHcDg0WM,8007
+anydi-0.62.0.dist-info/RECORD,,