modern-di-faststream 2.0.0a4__py3-none-any.whl

modern_di_faststream/__init__.py

@@ -0,0 +1,4 @@
+from modern_di_faststream.main import FromDI, fetch_di_container, setup_di
+
+
+__all__ = ["FromDI", "fetch_di_container", "setup_di"]

modern_di_faststream/main.py

@@ -0,0 +1,101 @@
+import dataclasses
+import typing
+from collections.abc import Awaitable, Callable
+from importlib.metadata import version
+
+import faststream
+import modern_di
+from faststream.asgi import AsgiFastStream
+from faststream.types import DecodedMessage
+from modern_di import Container, Scope, providers
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+P = typing.ParamSpec("P")
+
+
+faststream_message = providers.ContextProvider(scope=Scope.REQUEST, context_type=faststream.StreamMessage)
+
+
+_major, _minor, *_ = version("faststream").split(".")
+_OLD_MIDDLEWARES = int(_major) == 0 and int(_minor) < 6  # noqa: PLR2004
+
+
+class _DIMiddlewareFactory:
+    __slots__ = ("di_container",)
+
+    def __init__(self, di_container: Container) -> None:
+        self.di_container = di_container
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> "_DiMiddleware[P]":
+        return _DiMiddleware(self.di_container, *args, **kwargs)
+
+
+class _DiMiddleware(faststream.BaseMiddleware, typing.Generic[P]):
+    def __init__(self, di_container: Container, *args: P.args, **kwargs: P.kwargs) -> None:
+        self.di_container = di_container
+        super().__init__(*args, **kwargs)  # type: ignore[arg-type]
+
+    async def consume_scope(
+        self,
+        call_next: Callable[[typing.Any], Awaitable[typing.Any]],
+        msg: faststream.StreamMessage[typing.Any],
+    ) -> typing.AsyncIterator[DecodedMessage]:
+        request_container = self.di_container.build_child_container(
+            scope=modern_di.Scope.REQUEST, context={faststream.StreamMessage: msg}
+        )
+        try:
+            with self.faststream_context.scope("request_container", request_container):
+                return typing.cast(
+                    typing.AsyncIterator[DecodedMessage],
+                    await call_next(msg),
+                )
+        finally:
+            await request_container.close_async()
+
+    if _OLD_MIDDLEWARES:  # pragma: no cover
+
+        @property
+        def faststream_context(self) -> faststream.ContextRepo:
+            return typing.cast(faststream.ContextRepo, faststream.context)  # type: ignore[attr-defined]
+
+    else:
+
+        @property
+        def faststream_context(self) -> faststream.ContextRepo:
+            return self.context
+
+
+def fetch_di_container(app_: faststream.FastStream | AsgiFastStream) -> Container:
+    return typing.cast(Container, app_.context.get("di_container"))
+
+
+def setup_di(
+    app: faststream.FastStream | AsgiFastStream,
+    container: Container,
+) -> Container:
+    if not app.broker:
+        msg = "Broker must be defined to setup DI"
+        raise RuntimeError(msg)
+
+    container.providers_registry.add_providers(faststream_message=faststream_message)
+    app.context.set_global("di_container", container)
+    app.broker.add_middleware(_DIMiddlewareFactory(container))
+    return container
+
+
+@dataclasses.dataclass(slots=True, frozen=True)
+class Dependency(typing.Generic[T_co]):
+    dependency: providers.AbstractProvider[T_co] | type[T_co]
+
+    async def __call__(self, context: faststream.ContextRepo) -> T_co:
+        request_container: Container = context.get("request_container")
+        if isinstance(self.dependency, providers.AbstractProvider):
+            return request_container.resolve_provider(self.dependency)
+        return request_container.resolve(dependency_type=self.dependency)
+
+
+def FromDI(  # noqa: N802
+    dependency: providers.AbstractProvider[T_co] | type[T_co], *, use_cache: bool = True, cast: bool = False
+) -> T_co:
+    return typing.cast(T_co, faststream.Depends(dependency=Dependency(dependency), use_cache=use_cache, cast=cast))

modern_di_faststream-2.0.0a4.dist-info/METADATA

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: modern-di-faststream
+Version: 2.0.0a4
+Summary: Modern-DI integration for FastStream
+Project-URL: repository, https://github.com/modern-python/modern-di
+Project-URL: docs, https://modern-di.readthedocs.io
+Author-email: Artur Shiriev <me@shiriev.ru>
+License-Expression: MIT
+Keywords: DI,FastStream,dependency injector,ioc-container,python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: <4,>=3.10
+Requires-Dist: faststream<1,>=0.5
+Requires-Dist: modern-di>=2.0.0alpha1
+Description-Content-Type: text/markdown
+
+"Modern-DI-FastStream"
+==
+
+Integration of [Modern-DI](https://github.com/modern-python/modern-di) to FastStream
+
+📚 [Documentation](https://modern-di.readthedocs.io)

modern_di_faststream-2.0.0a4.dist-info/RECORD

@@ -0,0 +1,6 @@
+modern_di_faststream/__init__.py,sha256=ENQRyE_73MsxFjo608cUUb5EN1pFPC5HkS5Z3wZ5IC0,132
+modern_di_faststream/main.py,sha256=LtvUtHAnzzb6vSTrZh5CZgQBmvcYQNJW5Z6cCxalazc,3601
+modern_di_faststream/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+modern_di_faststream-2.0.0a4.dist-info/METADATA,sha256=pvC9NqJzbdMj8oMKmN4-yezK1u-8EGM9ZE0BraAVBcY,1011
+modern_di_faststream-2.0.0a4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+modern_di_faststream-2.0.0a4.dist-info/RECORD,,

modern_di_faststream-2.0.0a4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any