anydi 0.26.8__tar.gz → 0.27.0__tar.gz

{anydi-0.26.8 → anydi-0.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: anydi
-Version: 0.26.8
+Version: 0.27.0
 Summary: Dependency Injection library
 Home-page: https://github.com/antonrh/anydi
 License: MIT
@@ -32,8 +32,8 @@ Provides-Extra: async
 Provides-Extra: docs
 Requires-Dist: anyio (>=3.6.2,<4.0.0) ; extra == "async"
 Requires-Dist: mkdocs (>=1.4.2,<2.0.0) ; extra == "docs"
-Requires-Dist: mkdocs-material (>=9.1.13,<10.0.0) ; extra == "docs"
-Requires-Dist: typing-extensions (>=4.8.0,<5.0.0)
+Requires-Dist: mkdocs-material (>=9.5.21,<10.0.0) ; extra == "docs"
+Requires-Dist: typing-extensions (>=4.12.1,<5.0.0)
 Project-URL: Repository, https://github.com/antonrh/anydi
 Description-Content-Type: text/markdown
 

{anydi-0.26.8 → anydi-0.27.0}/anydi/_context.py

@@ -251,7 +251,7 @@ class ResourceScopedContext(ScopedContext):
             exc_val: The exception instance, if any.
             exc_tb: The traceback, if any.
         """
-        return self._stack.__exit__(exc_type, exc_val, exc_tb)
+        return self._stack.__exit__(exc_type, exc_val, exc_tb)  # type: ignore[return-value]
 
     @abc.abstractmethod
     def start(self) -> None:

anydi-0.27.0/anydi/ext/_utils.py

@@ -0,0 +1,89 @@
+"""AnyDI FastAPI extension."""
+
+from __future__ import annotations
+
+import inspect
+import logging
+from typing import Any, Callable
+
+from typing_extensions import Annotated, get_args, get_origin
+
+from anydi import Container
+from anydi._utils import get_full_qualname
+
+logger = logging.getLogger(__name__)
+
+
+class HasInterface:
+    _interface: Any = None
+
+    @property
+    def interface(self) -> Any:
+        if self._interface is None:
+            raise TypeError("Interface is not set.")
+        return self._interface
+
+    @interface.setter
+    def interface(self, interface: Any) -> None:
+        self._interface = interface
+
+
+def patch_annotated_parameter(parameter: inspect.Parameter) -> inspect.Parameter:
+    """Patch an annotated parameter to resolve the default value."""
+    if not (
+        get_origin(parameter.annotation) is Annotated
+        and parameter.default is parameter.empty
+    ):
+        return parameter
+
+    tp_origin, *tp_metadata = get_args(parameter.annotation)
+    default = tp_metadata[-1]
+
+    if not isinstance(default, HasInterface):
+        return parameter
+
+    if (num := len(tp_metadata[:-1])) == 0:
+        interface = tp_origin
+    elif num == 1:
+        interface = Annotated[tp_origin, tp_metadata[0]]
+    elif num == 2:
+        interface = Annotated[tp_origin, tp_metadata[0], tp_metadata[1]]
+    elif num == 3:
+        interface = Annotated[
+            tp_origin,
+            tp_metadata[0],
+            tp_metadata[1],
+            tp_metadata[2],
+        ]
+    else:
+        raise TypeError("Too many annotated arguments.")  # pragma: no cover
+    return parameter.replace(annotation=interface, default=default)
+
+
+def patch_call_parameter(
+    call: Callable[..., Any], parameter: inspect.Parameter, container: Container
+) -> None:
+    """Patch a parameter to inject dependencies using AnyDI.
+
+    Args:
+        call:  The call function.
+        parameter: The parameter to patch.
+        container: The AnyDI container.
+    """
+    parameter = patch_annotated_parameter(parameter)
+
+    if not isinstance(parameter.default, HasInterface):
+        return None
+
+    if not container.strict and not container.is_registered(parameter.annotation):
+        logger.debug(
+            f"Callable `{get_full_qualname(call)}` injected parameter "
+            f"`{parameter.name}` with an annotation of "
+            f"`{get_full_qualname(parameter.annotation)}` "
+            "is not registered. It will be registered at runtime with the "
+            "first call because it is running in non-strict mode."
+        )
+    else:
+        container._validate_injected_parameter(call, parameter)  # noqa
+
+    parameter.default.interface = parameter.annotation

anydi-0.27.0/anydi/ext/fastapi.py

@@ -0,0 +1,92 @@
+"""AnyDI FastAPI extension."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Iterator, cast
+
+from fastapi import Depends, FastAPI, params
+from fastapi.dependencies.models import Dependant
+from fastapi.routing import APIRoute
+from starlette.requests import Request
+
+from anydi import Container
+from anydi._utils import get_typed_parameters
+
+from ._utils import HasInterface, patch_call_parameter
+from .starlette.middleware import RequestScopedMiddleware
+
+__all__ = ["RequestScopedMiddleware", "install", "get_container", "Inject"]
+
+logger = logging.getLogger(__name__)
+
+
+def install(app: FastAPI, container: Container) -> None:
+    """Install AnyDI into a FastAPI application.
+
+    Args:
+        app: The FastAPI application instance.
+        container: The container.
+
+    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 get_typed_parameters(call):
+                patch_call_parameter(call, parameter, container)
+
+
+def get_container(request: Request) -> Container:
+    """Get the AnyDI container from a FastAPI request.
+
+    Args:
+        request: The FastAPI request.
+
+    Returns:
+        The AnyDI container associated with the request.
+    """
+    return cast(Container, request.app.state.container)
+
+
+class Resolver(HasInterface, params.Depends):
+    """Parameter dependency class for injecting dependencies using AnyDI."""
+
+    def __init__(self) -> None:
+        super().__init__(dependency=self._dependency, use_cache=True)
+
+    async def _dependency(self, container: Container = Depends(get_container)) -> Any:
+        return await container.aresolve(self.interface)
+
+
+def Inject() -> Any:  # noqa
+    """Decorator for marking a function parameter as requiring injection.
+
+    The `Inject` decorator is used to mark a function parameter as requiring injection
+    of a dependency resolved by AnyDI.
+
+    Returns:
+        The `Resolver` instance representing the parameter dependency.
+    """
+    return Resolver()
+
+
+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)

anydi-0.27.0/anydi/ext/faststream.py

@@ -0,0 +1,65 @@
+"""AnyDI FastStream extension."""
+
+from __future__ import annotations
+
+import logging
+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._utils import get_typed_parameters
+
+from ._utils import HasInterface, patch_call_parameter
+
+logger = logging.getLogger(__name__)
+
+
+def install(broker: BrokerUsecase[Any, Any], container: Container) -> None:
+    """Install AnyDI into a FastStream broker.
+
+    Args:
+        broker: The broker.
+        container: The container.
+
+    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[attr-defined]
+
+    for handler in _get_broken_handlers(broker):
+        call = handler._original_call  # noqa
+        for parameter in get_typed_parameters(call):
+            patch_call_parameter(call, parameter, container)
+
+
+def _get_broken_handlers(broker: BrokerUsecase[Any, Any]) -> list[Any]:
+    if hasattr(broker, "handlers"):
+        return [handler.calls[0][0] for handler in broker.handlers.values()]
+    # faststream > 0.5.0
+    return [
+        subscriber.calls[0].handler
+        for subscriber in broker._subscribers.values()  # noqa
+    ]
+
+
+def get_container(broker: BrokerUsecase[Any, Any]) -> Container:
+    return cast(Container, getattr(broker, "_container"))  # noqa
+
+
+class Resolver(HasInterface, Depends):
+    """Parameter dependency class for injecting dependencies using AnyDI."""
+
+    def __init__(self) -> None:
+        super().__init__(dependency=self._dependency, use_cache=True, cast=True)
+
+    async def _dependency(self, context: ContextRepo) -> Any:
+        container = get_container(context.get("broker"))
+        return await container.aresolve(self.interface)
+
+
+def Inject() -> Any:  # noqa
+    return Resolver()

{anydi-0.26.8 → anydi-0.27.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "anydi"
-version = "0.26.8"
+version = "0.27.0"
 description = "Dependency Injection library"
 authors = ["Anton Ruhlov <antonruhlov@gmail.com>"]
 license = "MIT"
@@ -35,25 +35,27 @@ packages = [
 
 [tool.poetry.dependencies]
 python = "^3.8"
-typing-extensions = "^4.8.0"
+typing-extensions = "^4.12.1"
 anyio = { version = "^3.6.2", optional = true }
 mkdocs = { version = "^1.4.2", optional = true }
-mkdocs-material = { version = "^9.1.13", optional = true }
+mkdocs-material = { version = "^9.5.21", optional = true }
 
 [tool.poetry.extras]
 docs = ["mkdocs", "mkdocs-material"]
 async = ["anyio"]
 
 [tool.poetry.group.dev.dependencies]
-mypy = "^1.10.0"
-ruff = "^0.4.3"
-pytest = "^8.1.0"
+mypy = "^1.11.0"
+ruff = "^0.5.4"
+pytest = "^8.3.1"
 pytest-cov = "^5.0.0"
 fastapi = "^0.100.0"
 httpx = "^0.26.0"
 django = "^4.2"
 django-ninja = "^1.1.0"
 pytest-django = "^4.8.0"
+faststream = "^0.5.10"
+redis = "^5.0.4"
 
 [tool.poetry.plugins.pytest11]
 anydi = "anydi.ext.pytest_plugin"

anydi-0.26.8/anydi/ext/fastapi.py

@@ -1,165 +0,0 @@
-"""AnyDI FastAPI extension."""
-
-from __future__ import annotations
-
-import inspect
-import logging
-from typing import Any, Callable, Iterator, cast
-
-from fastapi import Depends, FastAPI, params
-from fastapi.dependencies.models import Dependant
-from fastapi.routing import APIRoute
-from starlette.requests import Request
-from typing_extensions import Annotated, get_args, get_origin
-
-from anydi import Container
-from anydi._utils import get_full_qualname, get_typed_parameters
-
-from .starlette.middleware import RequestScopedMiddleware
-
-__all__ = ["RequestScopedMiddleware", "install", "get_container", "Inject"]
-
-logger = logging.getLogger(__name__)
-
-
-def install(app: FastAPI, container: Container) -> None:
-    """Install AnyDI into a FastAPI application.
-
-    Args:
-        app: The FastAPI application instance.
-        container: The container.
-
-    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 get_typed_parameters(call):
-                _patch_route_parameter(call, parameter, container)
-
-
-def get_container(request: Request) -> Container:
-    """Get the AnyDI container from a FastAPI request.
-
-    Args:
-        request: The FastAPI request.
-
-    Returns:
-        The AnyDI container associated with the request.
-    """
-    return cast(Container, request.app.state.container)
-
-
-class Resolver(params.Depends):
-    """Parameter dependency class for injecting dependencies using AnyDI."""
-
-    def __init__(self) -> None:
-        super().__init__(dependency=self._dependency, use_cache=True)
-        self._interface: Any = None
-
-    @property
-    def interface(self) -> Any:
-        if self._interface is None:
-            raise TypeError("Interface is not set.")
-        return self._interface
-
-    @interface.setter
-    def interface(self, interface: Any) -> None:
-        self._interface = interface
-
-    async def _dependency(self, container: Container = Depends(get_container)) -> Any:
-        return await container.aresolve(self.interface)
-
-
-def Inject() -> Any:  # noqa
-    """Decorator for marking a function parameter as requiring injection.
-
-    The `Inject` decorator is used to mark a function parameter as requiring injection
-    of a dependency resolved by AnyDI.
-
-    Returns:
-        The `Resolver` instance representing the parameter dependency.
-    """
-    return Resolver()
-
-
-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 _patch_route_parameter(
-    call: Callable[..., Any], parameter: inspect.Parameter, container: Container
-) -> None:
-    """Patch a parameter to inject dependencies using AnyDI.
-
-    Args:
-        call:  The call function.
-        parameter: The parameter to patch.
-        container: The AnyDI container.
-    """
-    parameter = _patch_annotated_parameter(parameter)
-
-    if not isinstance(parameter.default, Resolver):
-        return None
-
-    if not container.strict and not container.is_registered(parameter.annotation):
-        logger.debug(
-            f"Callable `{get_full_qualname(call)}` injected parameter "
-            f"`{parameter.name}` with an annotation of "
-            f"`{get_full_qualname(parameter.annotation)}` "
-            "is not registered. It will be registered at runtime with the "
-            "first call because it is running in non-strict mode."
-        )
-    else:
-        container._validate_injected_parameter(call, parameter)  # noqa
-
-    parameter.default.interface = parameter.annotation
-
-
-def _patch_annotated_parameter(parameter: inspect.Parameter) -> inspect.Parameter:
-    """Patch an annotated parameter to resolve the default value."""
-    if not (
-        get_origin(parameter.annotation) is Annotated
-        and parameter.default is parameter.empty
-    ):
-        return parameter
-
-    tp_origin, *tp_metadata = get_args(parameter.annotation)
-    default = tp_metadata[-1]
-
-    if not isinstance(default, Resolver):
-        return parameter
-
-    if (num := len(tp_metadata[:-1])) == 0:
-        interface = tp_origin
-    elif num == 1:
-        interface = Annotated[tp_origin, tp_metadata[0]]
-    elif num == 2:
-        interface = Annotated[tp_origin, tp_metadata[0], tp_metadata[1]]
-    elif num == 3:
-        interface = Annotated[
-            tp_origin,
-            tp_metadata[0],
-            tp_metadata[1],
-            tp_metadata[2],
-        ]
-    else:
-        raise TypeError("Too many annotated arguments.")  # pragma: no cover
-    return parameter.replace(annotation=interface, default=default)