modern-di-grpc 2.0.0__tar.gz

modern_di_grpc-2.0.0/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: modern-di-grpc
+Version: 2.0.0
+Summary: modern-di integration for gRPC
+Keywords: dependency-injection,di,ioc-container,modern-di,grpc,grpcio,python
+Author: Artur Shiriev
+Author-email: Artur Shiriev <me@shiriev.ru>
+License-Expression: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+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: Typing :: Typed
+Classifier: Topic :: Software Development :: Libraries
+Requires-Dist: grpcio>=1.48,<2
+Requires-Dist: modern-di>=2.25,<3
+Requires-Python: >=3.10, <4
+Project-URL: Homepage, https://modern-di.modern-python.org
+Project-URL: Documentation, https://modern-di.modern-python.org
+Project-URL: Repository, https://github.com/modern-python/modern-di-grpc
+Project-URL: Issues, https://github.com/modern-python/modern-di-grpc/issues
+Project-URL: Changelog, https://github.com/modern-python/modern-di-grpc/releases
+Description-Content-Type: text/markdown
+
+# modern-di-grpc
+
+[Modern-DI](https://github.com/modern-python/modern-di) integration for [gRPC](https://grpc.io) (`grpcio`).
+
+See the [documentation](https://modern-di.modern-python.org).

modern_di_grpc-2.0.0/README.md

@@ -0,0 +1,5 @@
+# modern-di-grpc
+
+[Modern-DI](https://github.com/modern-python/modern-di) integration for [gRPC](https://grpc.io) (`grpcio`).
+
+See the [documentation](https://modern-di.modern-python.org).

modern_di_grpc-2.0.0/modern_di_grpc/__init__.py

@@ -0,0 +1,18 @@
+from modern_di_grpc.main import (
+    DIAioInterceptor,
+    DIInterceptor,
+    FromDI,
+    fetch_di_container,
+    grpc_context_provider,
+    inject,
+)
+
+
+__all__ = [
+    "DIAioInterceptor",
+    "DIInterceptor",
+    "FromDI",
+    "fetch_di_container",
+    "grpc_context_provider",
+    "inject",
+]

modern_di_grpc-2.0.0/modern_di_grpc/main.py

@@ -0,0 +1,238 @@
+"""modern-di integration for gRPC (grpcio)."""
+
+import contextvars
+import dataclasses
+import functools
+import inspect
+import typing
+
+import grpc
+import grpc.aio
+from grpc import ServicerContext
+from modern_di import Container, Scope, providers
+
+
+grpc_context_provider = providers.ContextProvider(ServicerContext, scope=Scope.REQUEST)
+
+_request_container: contextvars.ContextVar[Container] = contextvars.ContextVar("modern_di_request_container")
+
+
+def _build_child(container: Container, context: ServicerContext) -> Container:
+    child = container.build_child_container(scope=Scope.REQUEST)
+    child.set_context(ServicerContext, context)
+    return child
+
+
+def fetch_di_container() -> Container:
+    """Return the current RPC's child container. Raises ``LookupError`` outside an intercepted RPC."""
+    return _request_container.get()
+
+
+def _ensure_context_provider(container: Container) -> None:
+    # Register grpc_context_provider once (idempotent) so ServicerContext injects out of the box.
+    if container.providers_registry.find_provider(ServicerContext) is None:
+        container.add_providers(grpc_context_provider)
+
+
+T = typing.TypeVar("T")
+T_co = typing.TypeVar("T_co", covariant=True)
+
+
+@dataclasses.dataclass(slots=True, frozen=True)
+class _FromDI(typing.Generic[T_co]):
+    dependency: "providers.AbstractProvider[T_co] | type[T_co]"
+
+
+def FromDI(dependency: "providers.AbstractProvider[T] | type[T]") -> T:  # noqa: N802
+    """Mark a servicer-method parameter for DI injection via ``Annotated[T, FromDI]``."""
+    return typing.cast(T, _FromDI(dependency))
+
+
+def _parse_inject_params(func: typing.Callable[..., typing.Any]) -> dict[str, _FromDI[typing.Any]]:
+    hints = typing.get_type_hints(func, include_extras=True)
+    di_params: dict[str, _FromDI[typing.Any]] = {}
+    for name, hint in hints.items():
+        if name == "return":
+            continue
+        if typing.get_origin(hint) is typing.Annotated:
+            for meta in typing.get_args(hint)[1:]:
+                if isinstance(meta, _FromDI):
+                    di_params[name] = meta
+                    break
+    return di_params
+
+
+def _resolve(di_params: dict[str, _FromDI[typing.Any]]) -> dict[str, typing.Any]:
+    container = _request_container.get()
+    return {name: container.resolve_dependency(marker.dependency) for name, marker in di_params.items()}
+
+
+def inject(func: typing.Callable[..., typing.Any]) -> typing.Callable[..., typing.Any]:
+    """Resolve ``FromDI`` params of a gRPC servicer method from the current RPC's child container.
+
+    Produces a sync, async, or async-generator wrapper matching *func*. gRPC always calls a
+    behavior as ``(request, context)`` positionally, so resolved params are appended as keywords
+    (no bind-by-name needed). A method with no ``FromDI`` parameter is returned unchanged.
+    """
+    di_params = _parse_inject_params(func)
+    if not di_params:
+        return func
+
+    if inspect.isasyncgenfunction(func):
+
+        @functools.wraps(func)
+        async def async_gen_wrapper(
+            *args: typing.Any,  # noqa: ANN401
+            **kwargs: typing.Any,  # noqa: ANN401
+        ) -> typing.AsyncIterator[typing.Any]:
+            async for item in func(*args, **kwargs, **_resolve(di_params)):
+                yield item
+
+        return async_gen_wrapper
+
+    if inspect.iscoroutinefunction(func):
+
+        @functools.wraps(func)
+        async def async_wrapper(*args: typing.Any, **kwargs: typing.Any) -> typing.Any:  # noqa: ANN401
+            return await func(*args, **kwargs, **_resolve(di_params))
+
+        return async_wrapper
+
+    @functools.wraps(func)
+    def sync_wrapper(*args: typing.Any, **kwargs: typing.Any) -> typing.Any:  # noqa: ANN401
+        return func(*args, **kwargs, **_resolve(di_params))
+
+    return sync_wrapper
+
+
+def _rewrap(
+    handler: grpc.RpcMethodHandler,
+    unary_builder: typing.Callable[[typing.Callable[..., typing.Any]], typing.Callable[..., typing.Any]],
+    stream_builder: typing.Callable[[typing.Callable[..., typing.Any]], typing.Callable[..., typing.Any]],
+) -> grpc.RpcMethodHandler:
+    # grpc.RpcMethodHandler is an abc.ABC documenting these attributes only in its docstring (no annotated
+    # fields), so ty cannot resolve them on the concrete instances the runtime actually hands back.
+    deserializer = handler.request_deserializer  # ty: ignore[unresolved-attribute]
+    serializer = handler.response_serializer  # ty: ignore[unresolved-attribute]
+    if unary_unary := handler.unary_unary:  # ty: ignore[unresolved-attribute]
+        return grpc.unary_unary_rpc_method_handler(unary_builder(unary_unary), deserializer, serializer)
+    if unary_stream := handler.unary_stream:  # ty: ignore[unresolved-attribute]
+        return grpc.unary_stream_rpc_method_handler(stream_builder(unary_stream), deserializer, serializer)
+    if stream_unary := handler.stream_unary:  # ty: ignore[unresolved-attribute]
+        return grpc.stream_unary_rpc_method_handler(unary_builder(stream_unary), deserializer, serializer)
+    if stream_stream := handler.stream_stream:  # ty: ignore[unresolved-attribute]
+        return grpc.stream_stream_rpc_method_handler(stream_builder(stream_stream), deserializer, serializer)
+    return handler  # pragma: no cover  (every RpcMethodHandler sets exactly one behavior)
+
+
+def _wrap_unary_sync(
+    behavior: typing.Callable[..., typing.Any], container: Container
+) -> typing.Callable[..., typing.Any]:
+    def wrapper(request_or_iterator: typing.Any, context: ServicerContext) -> typing.Any:  # noqa: ANN401
+        child = _build_child(container, context)
+        token = _request_container.set(child)
+        try:
+            return behavior(request_or_iterator, context)
+        finally:
+            try:
+                child.close_sync()
+            finally:
+                _request_container.reset(token)
+
+    return wrapper
+
+
+def _wrap_stream_sync(
+    behavior: typing.Callable[..., typing.Any], container: Container
+) -> typing.Callable[..., typing.Any]:
+    def wrapper(request_or_iterator: typing.Any, context: ServicerContext) -> typing.Iterator[typing.Any]:  # noqa: ANN401
+        child = _build_child(container, context)
+        token = _request_container.set(child)
+        try:
+            yield from behavior(request_or_iterator, context)
+        finally:
+            try:
+                child.close_sync()
+            finally:
+                _request_container.reset(token)
+
+    return wrapper
+
+
+class DIInterceptor(grpc.ServerInterceptor):
+    """Server interceptor that opens a ``Scope.REQUEST`` child container per RPC (sync server)."""
+
+    def __init__(self, container: Container) -> None:
+        self._container = container
+        _ensure_context_provider(container)
+
+    def intercept_service(
+        self,
+        continuation: typing.Callable[[grpc.HandlerCallDetails], grpc.RpcMethodHandler],
+        handler_call_details: grpc.HandlerCallDetails,
+    ) -> grpc.RpcMethodHandler:
+        handler = continuation(handler_call_details)
+        if handler is None:
+            return handler
+        return _rewrap(
+            handler,
+            lambda behavior: _wrap_unary_sync(behavior, self._container),
+            lambda behavior: _wrap_stream_sync(behavior, self._container),
+        )
+
+
+def _wrap_unary_aio(
+    behavior: typing.Callable[..., typing.Any], container: Container
+) -> typing.Callable[..., typing.Any]:
+    async def wrapper(request_or_iterator: typing.Any, context: ServicerContext) -> typing.Any:  # noqa: ANN401
+        child = _build_child(container, context)
+        token = _request_container.set(child)
+        try:
+            return await behavior(request_or_iterator, context)
+        finally:
+            try:
+                await child.close_async()
+            finally:
+                _request_container.reset(token)
+
+    return wrapper
+
+
+def _wrap_stream_aio(
+    behavior: typing.Callable[..., typing.Any], container: Container
+) -> typing.Callable[..., typing.Any]:
+    async def wrapper(request_or_iterator: typing.Any, context: ServicerContext) -> typing.AsyncIterator[typing.Any]:  # noqa: ANN401
+        child = _build_child(container, context)
+        token = _request_container.set(child)
+        try:
+            async for item in behavior(request_or_iterator, context):
+                yield item
+        finally:
+            try:
+                await child.close_async()
+            finally:
+                _request_container.reset(token)
+
+    return wrapper
+
+
+class DIAioInterceptor(grpc.aio.ServerInterceptor):
+    """Server interceptor that opens a ``Scope.REQUEST`` child container per RPC (async server)."""
+
+    def __init__(self, container: Container) -> None:
+        self._container = container
+        _ensure_context_provider(container)
+
+    async def intercept_service(
+        self,
+        continuation: typing.Callable[[grpc.HandlerCallDetails], typing.Awaitable[grpc.RpcMethodHandler]],
+        handler_call_details: grpc.HandlerCallDetails,
+    ) -> grpc.RpcMethodHandler:
+        handler = await continuation(handler_call_details)
+        if handler is None:
+            return handler
+        return _rewrap(
+            handler,
+            lambda behavior: _wrap_unary_aio(behavior, self._container),
+            lambda behavior: _wrap_stream_aio(behavior, self._container),
+        )

modern_di_grpc-2.0.0/pyproject.toml

@@ -0,0 +1,73 @@
+[project]
+name = "modern-di-grpc"
+description = "modern-di integration for gRPC"
+authors = [{ name = "Artur Shiriev", email = "me@shiriev.ru" }]
+requires-python = ">=3.10,<4"
+license = "MIT"
+readme = "README.md"
+keywords = ["dependency-injection", "di", "ioc-container", "modern-di", "grpc", "grpcio", "python"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Typing :: Typed",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = ["grpcio>=1.48,<2", "modern-di>=2.25,<3"]
+version = "2.0.0"
+
+[project.urls]
+Homepage = "https://modern-di.modern-python.org"
+Documentation = "https://modern-di.modern-python.org"
+Repository = "https://github.com/modern-python/modern-di-grpc"
+Issues = "https://github.com/modern-python/modern-di-grpc/issues"
+Changelog = "https://github.com/modern-python/modern-di-grpc/releases"
+
+[dependency-groups]
+dev = ["pytest", "pytest-cov", "pytest-asyncio", "grpcio-tools", "protobuf"]
+lint = ["ty", "ruff", "eof-fixer", "typing-extensions"]
+
+[build-system]
+requires = ["uv_build>=0.11,<1.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "modern_di_grpc"
+module-root = ""
+
+[tool.ruff]
+fix = false
+unsafe-fixes = true
+line-length = 120
+target-version = "py310"
+extend-exclude = ["tests/protos"]
+
+[tool.ruff.format]
+docstring-code-format = true
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = ["D1", "S101", "TCH", "FBT", "D203", "D213", "COM812", "ISC001", "G004"]
+isort.lines-after-imports = 2
+isort.no-lines-before = ["standard-library", "local-folder"]
+
+[tool.ruff.lint.extend-per-file-ignores]
+"tests/*.py" = ["PLR2004", "SLF001"]
+
+[tool.ty.src]
+exclude = ["tests/protos"]
+
+[tool.pytest.ini_options]
+addopts = ""
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.coverage.run]
+omit = ["tests/protos/*"]
+
+[tool.coverage.report]
+exclude_also = ["if typing.TYPE_CHECKING:"]