anydi 0.58.0__py3-none-any.whl → 0.60.0__py3-none-any.whl

anydi/_container.py

@@ -257,6 +257,32 @@ class Container:
         # Register the scope
         self._scopes[scope] = tuple({scope, "singleton"} | set(parents))
 
+    def get_ordered_scopes(self, scopes: set[Scope]) -> list[str]:
+        """Get ordered list of scopes to enter."""
+        # Expand scopes to include all parent scopes
+        expanded_scopes: set[str] = set()
+        for scope in scopes:
+            if scope == "transient":
+                continue
+            elif scope == "singleton":
+                expanded_scopes.add("singleton")
+            else:
+                # Add the scope and all its parents from container._scopes
+                expanded_scopes.update(self._scopes[scope])
+
+        # Separate singleton from other scopes
+        has_singleton = "singleton" in expanded_scopes
+        other_scopes = expanded_scopes - {"singleton"}
+
+        # Sort other scopes by dependency depth (parents before children)
+        # Scopes with fewer parents come first
+        ordered_scopes = sorted(
+            other_scopes, key=lambda scope: len(self._scopes[scope])
+        )
+
+        # Return with singleton first if needed
+        return ["singleton", *ordered_scopes] if has_singleton else ordered_scopes
+
     # == Provider Registry ==
 
     def register(

anydi/ext/faststream.py

@@ -3,16 +3,27 @@
 from __future__ import annotations
 
 import inspect
-from typing import Any, cast
+from functools import cached_property
+from typing import TYPE_CHECKING, Any, cast
 
-from fast_depends.dependencies import Depends
-from faststream import ContextRepo
-from faststream.broker.core.usecase import BrokerUsecase
+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
 
-__all__ = ["install", "get_container", "Inject"]
+if TYPE_CHECKING:
+    from faststream._internal.basic_types import AsyncFuncAny
+    from faststream._internal.broker import BrokerUsecase
+    from faststream._internal.types import AnyMsg
+
+__all__ = [
+    "install",
+    "get_container",
+    "get_container_from_context",
+    "Inject",
+    "RequestScopedMiddleware",
+]
 
 
 def get_container(broker: BrokerUsecase[Any, Any]) -> Container:
@@ -20,13 +31,29 @@ def get_container(broker: BrokerUsecase[Any, Any]) -> Container:
     return cast(Container, getattr(broker, "_container"))  # noqa
 
 
-class _ProvideMarker(Depends, ProvideMarker):
+def get_container_from_context(context: ContextRepo) -> Container:
+    return get_container(context.broker)
+
+
+class RequestScopedMiddleware(BaseMiddleware):
+    @cached_property
+    def container(self) -> Container:
+        return get_container_from_context(self.context)
+
+    async def consume_scope(
+        self, call_next: AsyncFuncAny, msg: StreamMessage[AnyMsg]
+    ) -> Any:
+        async with self.container.arequest_context():
+            return await call_next(msg)
+
+
+class _ProvideMarker(Dependant, ProvideMarker):
     def __init__(self) -> None:
-        super().__init__(dependency=self._dependency, use_cache=True, cast=True)
+        super().__init__(self._dependency, use_cache=True, cast=True, cast_result=True)
         ProvideMarker.__init__(self)
 
     async def _dependency(self, context: ContextRepo) -> Any:
-        container = get_container(context.get("broker"))
+        container = get_container_from_context(context)
         return await container.aresolve(self.interface)
 
 
@@ -35,12 +62,7 @@ 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
-    ]
+    return [subscriber.calls[0].handler for subscriber in broker.subscribers]
 
 
 def install(broker: BrokerUsecase[Any, Any], container: Container) -> None:

anydi/ext/typer.py

@@ -0,0 +1,133 @@
+"""AnyDI Typer extension."""
+
+from __future__ import annotations
+
+import contextlib
+import functools
+import inspect
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+import anyio
+from typer import Typer
+
+from anydi import Container, Scope
+
+__all__ = ["install"]
+
+
+def _wrap_async_callback_no_injection(callback: Callable[..., Any]) -> Any:
+    """Wrap async callback without injection in anyio.run()."""
+
+    @functools.wraps(callback)
+    def async_no_injection_wrapper(*args: Any, **kwargs: Any) -> Any:
+        return anyio.run(callback, *args, **kwargs)
+
+    return async_no_injection_wrapper
+
+
+def _wrap_async_callback_with_injection(
+    callback: Callable[..., Awaitable[Any]],
+    container: Container,
+    sig: inspect.Signature,
+    non_injected_params: set[inspect.Parameter],
+    scopes: set[Scope],
+) -> Any:
+    """Wrap async callback with injection in anyio.run()."""
+
+    @functools.wraps(callback)
+    def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+        async def _run() -> Any:
+            ordered_scopes = container.get_ordered_scopes(scopes)
+
+            async with contextlib.AsyncExitStack() as stack:
+                # Start scoped contexts in dependency order
+                for scope in ordered_scopes:
+                    if scope == "singleton":
+                        await stack.enter_async_context(container)
+                    else:
+                        await stack.enter_async_context(
+                            container.ascoped_context(scope)
+                        )
+
+                return await container.run(callback, *args, **kwargs)
+
+        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
+
+    return async_wrapper
+
+
+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()
+    scopes: set[Scope] = set()
+
+    # Validate parameters and collect which ones need injection
+    for parameter in sig.parameters.values():
+        interface, should_inject = container.validate_injected_parameter(
+            parameter, call=callback
+        )
+        if should_inject:
+            injected_param_names.add(parameter.name)
+            scopes.add(container.providers[interface].scope)
+        else:
+            non_injected_params.add(parameter)
+
+    # If no parameters need injection and callback is not async, return original
+    if not injected_param_names and not inspect.iscoroutinefunction(callback):
+        return callback
+
+    # If async callback with no injection, just wrap in anyio.run()
+    if not injected_param_names and inspect.iscoroutinefunction(callback):
+        return _wrap_async_callback_no_injection(callback)
+
+    # Handle async callbacks - wrap them in anyio.run() for Typer
+    if inspect.iscoroutinefunction(callback):
+        return _wrap_async_callback_with_injection(
+            callback, container, sig, non_injected_params, scopes
+        )
+
+    @functools.wraps(callback)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        ordered_scopes = container.get_ordered_scopes(scopes)
+
+        with contextlib.ExitStack() as stack:
+            # Start scoped contexts in dependency order
+            for scope in ordered_scopes:
+                if scope == "singleton":
+                    stack.enter_context(container)
+                else:
+                    stack.enter_context(container.scoped_context(scope))
+
+            return container.run(callback, *args, **kwargs)
+
+    # Update the wrapper's signature to only show non-injected parameters to Typer
+    wrapper.__signature__ = sig.replace(parameters=non_injected_params)  # type: ignore
+
+    return wrapper
+
+
+def install(app: Typer, container: Container) -> None:
+    """Install AnyDI into a Typer application."""
+    # Process main callback if exists
+    if app.registered_callback:
+        callback = app.registered_callback.callback
+        if callback:
+            app.registered_callback.callback = _process_callback(callback, container)
+
+    # Process all registered commands
+    for command_info in app.registered_commands:
+        callback = command_info.callback
+        if callback:
+            command_info.callback = _process_callback(callback, container)
+
+    # Process nested Typer groups
+    for group_info in app.registered_groups:
+        # Recursively install for nested Typer apps
+        if group_info.typer_instance:
+            install(group_info.typer_instance, container)

{anydi-0.58.0.dist-info → anydi-0.60.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anydi
-Version: 0.58.0
+Version: 0.60.0
 Summary: Dependency Injection library
 Keywords: dependency injection,dependencies,di,async,asyncio,application
 Author: Anton Ruhlov
@@ -280,6 +280,7 @@ Ready to learn more? Check out these resources:
 - [FastAPI](https://anydi.readthedocs.io/en/latest/extensions/fastapi/) - Build modern APIs with automatic dependency injection
 - [Django](https://anydi.readthedocs.io/en/latest/extensions/django/) - Integrate with Django and Django Ninja
 - [FastStream](https://anydi.readthedocs.io/en/latest/extensions/faststream/) - Message broker applications
+- [Typer](https://anydi.readthedocs.io/en/latest/extensions/typer/) - CLI applications with async support
 - [Pydantic Settings](https://anydi.readthedocs.io/en/latest/extensions/pydantic_settings/) - Configuration management
 
 **Full Documentation:**

{anydi-0.58.0.dist-info → anydi-0.60.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 anydi/__init__.py,sha256=bQKzn9qfNnIMi1m3J-DdSknSDwNg8j08fdQg_-Edkto,613
 anydi/_async_lock.py,sha256=3dwZr0KthXFYha0XKMyXf8jMmGb1lYoNC0O5w29V9ic,1104
-anydi/_container.py,sha256=j8XM5UYw3PVwPq92TMtEwLwqcMObs-9ZTGAEsTj4caE,26023
+anydi/_container.py,sha256=r7qcUCu4KO0YLPaUO5SEgUwnNOcZsP7aVDZ1oDTi0kA,27093
 anydi/_context.py,sha256=-9QqeMWo9OpZVXZxZCQgIsswggl3Ch7lgx1KiFX_ezc,3752
 anydi/_decorators.py,sha256=J3W261ZAG7q4XKm4tbAv1wsWr9ysx9_5MUbUvSJB_MQ,2809
 anydi/_injector.py,sha256=IxKTh2rzMHrsW554tbiJl33Hb5sRGKYY_NU1rC4UvxE,4378
@@ -12,14 +12,15 @@ anydi/_types.py,sha256=tLJS27j0lWJFd4fIIGlGbbfKBVTPTnWgPYqZlenktis,2939
 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=XT80r1FGL-xlU7r8urm9sNpUfl4OPMJseW4dade_fR4,1836
+anydi/ext/faststream.py,sha256=i6uXE21UawmTYDBqRv7yqDMc-lRiYSYf45sD87O2wX4,2442
 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=3_3Q1fhxx7qElB6AQ_8dZUe5gIrrBHw7PbznAEzW5wA,4761
 anydi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anydi/testing.py,sha256=cHg3mMScZbEep9smRqSNQ81BZMQOkyugHe8TvKdPnEg,1347
-anydi-0.58.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-anydi-0.58.0.dist-info/entry_points.txt,sha256=AgOcQYM5KyS4D37QcYb00tiid0QA-pD1VrjHHq4QAps,44
-anydi-0.58.0.dist-info/METADATA,sha256=KE1cG2fc8ZyuoUBMhGP0pUqcUkr2z8ZOGjPVy3-ILV0,7901
-anydi-0.58.0.dist-info/RECORD,,
+anydi-0.60.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+anydi-0.60.0.dist-info/entry_points.txt,sha256=AgOcQYM5KyS4D37QcYb00tiid0QA-pD1VrjHHq4QAps,44
+anydi-0.60.0.dist-info/METADATA,sha256=_KyXL81AfiP_HtBSOQmdVVxPaV7jqt_KPgWOLPmDK-I,8007
+anydi-0.60.0.dist-info/RECORD,,