anydi 0.59.0__py3-none-any.whl → 0.60.1__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/typer.py

@@ -0,0 +1,139 @@
+"""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"]
+
+from anydi._decorators import is_provided
+
+
+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:  # noqa: C901
+    """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)
+            try:
+                scopes.add(container.providers[interface].scope)
+            except KeyError:
+                if inspect.isclass(interface) and is_provided(interface):
+                    scopes.add(interface.__provided__["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.59.0.dist-info → anydi-0.60.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anydi
-Version: 0.59.0
+Version: 0.60.1
 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.59.0.dist-info → anydi-0.60.1.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
@@ -17,9 +17,10 @@ anydi/ext/pydantic_settings.py,sha256=jVJZ1wPaPpsxdNPlJj9yq282ebqLZ9tckWpZ0eIwWL
 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=__Ve50wRcxmLoCHxHg-75hs6frySGoRvv2Q2TnLElOg,5006
 anydi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anydi/testing.py,sha256=cHg3mMScZbEep9smRqSNQ81BZMQOkyugHe8TvKdPnEg,1347
-anydi-0.59.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-anydi-0.59.0.dist-info/entry_points.txt,sha256=AgOcQYM5KyS4D37QcYb00tiid0QA-pD1VrjHHq4QAps,44
-anydi-0.59.0.dist-info/METADATA,sha256=Hp5PaKyiY5MTVyJiaUG7KH6B7n_74IXnxTUdRVypHUY,7901
-anydi-0.59.0.dist-info/RECORD,,
+anydi-0.60.1.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+anydi-0.60.1.dist-info/entry_points.txt,sha256=AgOcQYM5KyS4D37QcYb00tiid0QA-pD1VrjHHq4QAps,44
+anydi-0.60.1.dist-info/METADATA,sha256=35zPm0rrXV9B_swYvWOzRjCKH36M4tONVeeGlgaXOMI,8007
+anydi-0.60.1.dist-info/RECORD,,