anydi 0.58.0__tar.gz → 0.60.0__tar.gz

{anydi-0.58.0 → anydi-0.60.0}/PKG-INFO

@@ -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 → anydi-0.60.0}/README.md

@@ -245,6 +245,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 → anydi-0.60.0}/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-0.60.0/anydi/ext/faststream.py

@@ -0,0 +1,74 @@
+"""AnyDI FastStream extension."""
+
+from __future__ import annotations
+
+import inspect
+from functools import cached_property
+from typing import TYPE_CHECKING, Any, cast
+
+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
+
+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:
+    """Get the AnyDI container from a FastStream broker."""
+    return cast(Container, getattr(broker, "_container"))  # noqa
+
+
+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__(self._dependency, use_cache=True, cast=True, cast_result=True)
+        ProvideMarker.__init__(self)
+
+    async def _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)
+
+
+def _get_broker_handlers(broker: BrokerUsecase[Any, Any]) -> list[Any]:
+    return [subscriber.calls[0].handler for subscriber in broker.subscribers]
+
+
+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-0.60.0/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 → anydi-0.60.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "anydi"
-version = "0.58.0"
+version = "0.60.0"
 description = "Dependency Injection library"
 authors = [{ name = "Anton Ruhlov", email = "antonruhlov@gmail.com" }]
 requires-python = ">=3.10.0, <3.15"
@@ -58,9 +58,10 @@ dev = [
     "starlette>=0.37.2",
     "fastapi>=0.100.0",
     "httpx>=0.26.0",
-    "faststream>=0.5.10,<0.6",
+    "faststream>=0.6,<0.7",
     "redis>=5.0.4,<6",
     "pydantic-settings>=2.4.0,<3",
+    "typer>=0.20.0",
 ]
 docs = [
     "mkdocs>=1.4.2,<2",

anydi-0.58.0/anydi/ext/faststream.py

@@ -1,52 +0,0 @@
-"""AnyDI FastStream extension."""
-
-from __future__ import annotations
-
-import inspect
-from typing import Any, cast
-
-from fast_depends.dependencies import Depends
-from faststream import ContextRepo
-from faststream.broker.core.usecase import BrokerUsecase
-
-from anydi import Container
-from anydi._types import Inject, ProvideMarker, set_provide_factory
-
-__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 _ProvideMarker(Depends, ProvideMarker):
-    def __init__(self) -> None:
-        super().__init__(dependency=self._dependency, use_cache=True, cast=True)
-        ProvideMarker.__init__(self)
-
-    async def _dependency(self, context: ContextRepo) -> Any:
-        container = get_container(context.get("broker"))
-        return await container.aresolve(self.interface)
-
-
-# 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)