anydi 0.55.1__py3-none-any.whl → 0.57.0__py3-none-any.whl

anydi/_types.py

@@ -3,19 +3,21 @@
 from __future__ import annotations
 
 import inspect
-from collections.abc import AsyncIterator, Iterator
+from collections.abc import AsyncIterator, Callable, Iterator
 from types import NoneType
-from typing import Any, Literal
+from typing import TYPE_CHECKING, Annotated, Any, Literal, TypeVar
 
 from typing_extensions import Sentinel
 
+T = TypeVar("T")
+
 Scope = Literal["transient", "singleton", "request"]
 
 NOT_SET = Sentinel("NOT_SET")
 
 
-class InjectMarker:
-    """A marker object for declaring injectable dependencies."""
+class ProvideMarker:
+    """A marker object for declaring dependency."""
 
     __slots__ = ("_interface",)
 
@@ -32,13 +34,52 @@ class InjectMarker:
     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)
+
 
-def is_inject_marker(obj: Any) -> bool:
-    return isinstance(obj, InjectMarker)
+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 InjectMarker()
+    return _provide_factory()
+
+
+# Alias from backward compatibility
+is_inject_marker = is_provide_marker
 
 
 class Event:

anydi/ext/fastapi.py

@@ -11,37 +11,12 @@ from fastapi.dependencies.models import Dependant
 from fastapi.routing import APIRoute
 from starlette.requests import Request
 
-from anydi._container import Container
-from anydi._types import InjectMarker
+from anydi import Container
+from anydi._types import Inject, ProvideMarker, set_provide_factory
 
 from .starlette.middleware import RequestScopedMiddleware
 
-__all__ = ["RequestScopedMiddleware", "install", "get_container", "Inject"]
-
-
-def install(app: FastAPI, container: Container) -> None:
-    """Install AnyDI into a FastAPI application.
-
-    This function installs the AnyDI container into a FastAPI application by attaching
-    it to the application state. It also patches the route dependencies to inject the
-    required dependencies using AnyDI.
-    """
-    app.state.container = container  # noqa
-
-    patched = []
-
-    for route in app.routes:
-        if not isinstance(route, APIRoute):
-            continue
-        for dependant in _iter_dependencies(route.dependant):
-            if dependant.cache_key in patched:
-                continue
-            patched.append(dependant.cache_key)
-            call, *params = dependant.cache_key
-            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)
+__all__ = ["install", "get_container", "Inject", "RequestScopedMiddleware"]
 
 
 def get_container(request: Request) -> Container:
@@ -49,10 +24,10 @@ def get_container(request: Request) -> Container:
     return cast(Container, request.app.state.container)
 
 
-class _Inject(params.Depends, InjectMarker):
+class _ProvideMarker(params.Depends, ProvideMarker):
     def __init__(self) -> None:
         super().__init__(dependency=self._dependency, use_cache=True)
-        InjectMarker.__init__(self)
+        ProvideMarker.__init__(self)
 
     async def _dependency(
         self, container: Annotated[Container, Depends(get_container)]
@@ -60,13 +35,36 @@ class _Inject(params.Depends, InjectMarker):
         return await container.aresolve(self.interface)
 
 
-def Inject() -> Any:
-    return _Inject()
+# Configure Inject() and Provide[T] to use FastAPI-specific marker
+set_provide_factory(_ProvideMarker)
 
 
 def _iter_dependencies(dependant: Dependant) -> Iterator[Dependant]:
-    """Iterate over the dependencies of a dependant."""
     yield dependant
     if dependant.dependencies:
         for sub_dependant in dependant.dependencies:
             yield from _iter_dependencies(sub_dependant)
+
+
+def _validate_route_dependencies(
+    route: APIRoute, container: Container, patched: set[tuple[Any, ...]]
+) -> None:
+    for dependant in _iter_dependencies(route.dependant):
+        if dependant.cache_key in patched:
+            continue
+        patched.add(dependant.cache_key)
+        call, *_ = dependant.cache_key
+        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)
+
+
+def install(app: FastAPI, container: Container) -> None:
+    """Install AnyDI into a FastAPI application."""
+    app.state.container = container  # noqa
+    patched: set[tuple[Any, ...]] = set()
+    for route in app.routes:
+        if not isinstance(route, APIRoute):
+            continue
+        _validate_route_dependencies(route, container, patched)

anydi/ext/faststream.py

@@ -10,49 +10,43 @@ from faststream import ContextRepo
 from faststream.broker.core.usecase import BrokerUsecase
 
 from anydi import Container
-from anydi._types import InjectMarker
+from anydi._types import Inject, ProvideMarker, set_provide_factory
 
-
-def install(broker: BrokerUsecase[Any, Any], container: Container) -> None:
-    """Install AnyDI into a FastStream broker.
-
-    This function installs the AnyDI container into a FastStream broker by attaching
-    it to the broker. It also patches the broker handlers to inject the required
-    dependencies using AnyDI.
-    """
-    broker._container = container  # type: ignore
-
-    for handler in _get_broken_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)
-
-
-def _get_broken_handlers(broker: BrokerUsecase[Any, Any]) -> list[Any]:
-    if (handlers := getattr(broker, "handlers", None)) is not None:
-        return [handler.calls[0][0] for handler in handlers.values()]
-    # faststream > 0.5.0
-    return [
-        subscriber.calls[0].handler
-        for subscriber in broker._subscribers.values()  # noqa
-    ]
+__all__ = ["install", "get_container", "Inject"]
 
 
 def get_container(broker: BrokerUsecase[Any, Any]) -> Container:
+    """Get the AnyDI container from a FastStream broker."""
     return cast(Container, getattr(broker, "_container"))  # noqa
 
 
-class _Inject(Depends, InjectMarker):
-    """Parameter dependency class for injecting dependencies using AnyDI."""
-
+class _ProvideMarker(Depends, ProvideMarker):
     def __init__(self) -> None:
         super().__init__(dependency=self._dependency, use_cache=True, cast=True)
-        InjectMarker.__init__(self)
+        ProvideMarker.__init__(self)
 
     async def _dependency(self, context: ContextRepo) -> Any:
         container = get_container(context.get("broker"))
         return await container.aresolve(self.interface)
 
 
-def Inject() -> Any:
-    return _Inject()
+# Configure Inject() and Provide[T] to use FastStream-specific marker
+set_provide_factory(_ProvideMarker)
+
+
+def _get_broker_handlers(broker: BrokerUsecase[Any, Any]) -> list[Any]:
+    if (handlers := getattr(broker, "handlers", None)) is not None:
+        return [handler.calls[0][0] for handler in handlers.values()]
+    return [
+        subscriber.calls[0].handler
+        for subscriber in broker._subscribers.values()  # noqa
+    ]
+
+
+def install(broker: BrokerUsecase[Any, Any], container: Container) -> None:
+    """Install AnyDI into a FastStream broker."""
+    broker._container = container  # type: ignore
+    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)

anydi/ext/pydantic_settings.py

@@ -22,7 +22,8 @@ def install(
         prefix += "."
 
     def _register_settings(_settings: BaseSettings) -> None:
-        all_fields = {**_settings.model_fields, **_settings.model_computed_fields}
+        settings_cls = type(_settings)
+        all_fields = {**settings_cls.model_fields, **settings_cls.model_computed_fields}
         for setting_name, field_info in all_fields.items():
             if isinstance(field_info, ComputedFieldInfo):
                 interface = field_info.return_type