grpc-server-kit 0.1.0__py3-none-any.whl

grpc_server_kit-0.1.0.dist-info/METADATA

@@ -0,0 +1,484 @@
+Metadata-Version: 2.5
+Name: grpc-server-kit
+Version: 0.1.0
+Summary: Batteries-optional async gRPC server toolkit (app facade, builder, TLS, lifecycle, health, streaming-aware interceptors, observability)
+Project-URL: Repository, https://github.com/bedrock-python/grpc-server-kit
+Project-URL: Documentation, https://bedrock-python.github.io/grpc-server-kit/
+Project-URL: Changelog, https://github.com/bedrock-python/grpc-server-kit/blob/master/CHANGELOG.md
+Project-URL: Bug Tracker, https://github.com/bedrock-python/grpc-server-kit/issues
+Author-email: Alex Shalaev <shalaevad.alexey@gmail.com>
+License: Apache License
+        Version 2.0, January 2004
+        http://www.apache.org/licenses/
+        
+        TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+        1. Definitions.
+        
+        "License" shall mean the terms and conditions for use, reproduction,
+        and distribution as defined by Sections 1 through 9 of this document.
+        
+        "Licensor" shall mean the copyright owner or entity authorized by
+        the copyright owner that is granting the License.
+        
+        "Legal Entity" shall mean the union of the acting entity and all
+        other entities that control, are controlled by, or are under common
+        control with that entity. For the purposes of this definition,
+        "control" means (i) the power, direct or indirect, to cause the
+        direction or management of such entity, whether by contract or
+        otherwise, or (ii) ownership of fifty percent (50%) or more of the
+        outstanding shares, or (iii) beneficial ownership of such entity.
+        
+        "You" (or "Your") shall mean an individual or Legal Entity
+        exercising permissions granted by this License.
+        
+        "Source" form shall mean the preferred form for making modifications,
+        including but not limited to software source code, documentation
+        source, and configuration files.
+        
+        "Object" form shall mean any form resulting from mechanical
+        transformation or translation of a Source form, including but
+        not limited to compiled object code, generated documentation,
+        and conversions to other media types.
+        
+        "Work" shall mean the work of authorship, whether in Source or
+        Object form, made available under the License, as indicated by a
+        copyright notice that is included in or attached to the work
+        (an example is provided in the Appendix below).
+        
+        "Derivative Works" shall mean any work, whether in Source or Object
+        form, that is based on (or derived from) the Work and for which the
+        editorial revisions, annotations, elaborations, or other modifications
+        represent, as a whole, an original work of authorship. For the purposes
+        of this License, Derivative Works shall not include works that remain
+        separable from, or merely link (or bind by name) to the interfaces of,
+        the Work and Derivative Works thereof.
+        
+        "Contribution" shall mean any work of authorship, including
+        the original version of the Work and any modifications or additions
+        to that Work or Derivative Works thereof, that is intentionally
+        submitted to Licensor for inclusion in the Work by the copyright owner
+        or by an individual or Legal Entity authorized to submit on behalf of
+        the copyright owner. For the purposes of this definition, "submitted"
+        means any form of electronic, verbal, or written communication sent
+        to the Licensor or its representatives, including but not limited to
+        communication on electronic mailing lists, source code control systems,
+        and issue tracking systems that are managed by, or on behalf of, the
+        Licensor for the purpose of discussing and improving the Work, but
+        excluding communication that is conspicuously marked or otherwise
+        designated in writing by the copyright owner as "Not a Contribution."
+        
+        "Contributor" shall mean Licensor and any individual or Legal Entity
+        on behalf of whom a Contribution has been received by Licensor and
+        subsequently incorporated within the Work.
+        
+        2. Grant of Copyright License. Subject to the terms and conditions of
+        this License, each Contributor hereby grants to You a perpetual,
+        worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+        copyright license to reproduce, prepare Derivative Works of,
+        publicly display, publicly perform, sublicense, and distribute the
+        Work and such Derivative Works in Source or Object form.
+        
+        3. Grant of Patent License. Subject to the terms and conditions of
+        this License, each Contributor hereby grants to You a perpetual,
+        worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+        (except as stated in this section) patent license to make, have made,
+        use, offer to sell, sell, import, and otherwise transfer the Work,
+        where such license applies only to those patent claims licensable
+        by such Contributor that are necessarily infringed by their
+        Contribution(s) alone or by combination of their Contribution(s)
+        with the Work to which such Contribution(s) was submitted. If You
+        institute patent litigation against any entity (including a
+        cross-claim or counterclaim in a lawsuit) alleging that the Work
+        or a Contribution incorporated within the Work constitutes direct
+        or contributory patent infringement, then any patent licenses
+        granted to You under this License for that Work shall terminate
+        as of the date such litigation is filed.
+        
+        4. Redistribution. You may reproduce and distribute copies of the
+        Work or Derivative Works thereof in any medium, with or without
+        modifications, and in Source or Object form, provided that You
+        meet the following conditions:
+        
+        (a) You must give any other recipients of the Work or
+        Derivative Works a copy of this License; and
+        
+        (b) You must cause any modified files to carry prominent notices
+        stating that You changed the files; and
+        
+        (c) You must retain, in the Source form of any Derivative Works
+        that You distribute, all copyright, patent, trademark, and
+        attribution notices from the Source form of the Work,
+        excluding those notices that do not pertain to any part of
+        the Derivative Works; and
+        
+        (d) If the Work includes a "NOTICE" text file as part of its
+        distribution, then any Derivative Works that You distribute must
+        include a readable copy of the attribution notices contained
+        within such NOTICE file, excluding those notices that do not
+        pertain to any part of the Derivative Works, in at least one
+        of the following places: within a NOTICE text file distributed
+        as part of the Derivative Works; within the Source form or
+        documentation, if provided along with the Derivative Works; or,
+        within a display generated by the Derivative Works, if and
+        wherever such third-party notices normally appear. The contents
+        of the NOTICE file are for informational purposes only and
+        do not modify the License. You may add Your own attribution
+        notices within Derivative Works that You distribute, alongside
+        or as an addendum to the NOTICE text from the Work, provided
+        that such additional attribution notices cannot be construed
+        as modifying the License.
+        
+        You may add Your own copyright statement to Your modifications and
+        may provide additional or different license terms and conditions
+        for use, reproduction, or distribution of Your modifications, or
+        for any such Derivative Works as a whole, provided Your use,
+        reproduction, and distribution of the Work otherwise complies with
+        the conditions stated in this License.
+        
+        5. Submission of Contributions. Unless You explicitly state otherwise,
+        any Contribution intentionally submitted for inclusion in the Work
+        by You to the Licensor shall be under the terms and conditions of
+        this License, without any additional terms or conditions.
+        Notwithstanding the above, nothing herein shall supersede or modify
+        the terms of any separate license agreement you may have executed
+        with Licensor regarding such Contributions.
+        
+        6. Trademarks. This License does not grant permission to use the trade
+        names, trademarks, service marks, or product names of the Licensor,
+        except as required for reasonable and customary use in describing the
+        origin of the Work and reproducing the content of the NOTICE file.
+        
+        7. Disclaimer of Warranty. Unless required by applicable law or
+        agreed to in writing, Licensor provides the Work (and each
+        Contributor provides its Contributions) on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+        implied, including, without limitation, any warranties or conditions
+        of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+        PARTICULAR PURPOSE. You are solely responsible for determining the
+        appropriateness of using or redistributing the Work and assume any
+        risks associated with Your exercise of permissions under this License.
+        
+        8. Limitation of Liability. In no event and under no legal theory,
+        whether in tort (including negligence), contract, or otherwise,
+        unless required by applicable law (such as deliberate and grossly
+        negligent acts) or agreed to in writing, shall any Contributor be
+        liable to You for damages, including any direct, indirect, special,
+        incidental, or consequential damages of any character arising as a
+        result of this License or out of the use or inability to use the
+        Work (including but not limited to damages for loss of goodwill,
+        work stoppage, computer failure or malfunction, or any and all
+        other commercial damages or losses), even if such Contributor
+        has been advised of the possibility of such damages.
+        
+        9. Accepting Warranty or Additional Liability. While redistributing
+        the Work or Derivative Works thereof, You may choose to offer,
+        and charge a fee for, acceptance of support, warranty, indemnity,
+        or other liability obligations and/or rights consistent with this
+        License. However, in accepting such obligations, You may act only
+        on Your own behalf and on Your sole responsibility, not on behalf
+        of any other Contributor, and only if You agree to indemnify,
+        defend, and hold each Contributor harmless for any liability
+        incurred by, or claims asserted against, such Contributor by reason
+        of your accepting any such warranty or additional liability.
+        
+        END OF TERMS AND CONDITIONS
+        
+        APPENDIX: How to apply the Apache License to your work.
+        
+        To apply the Apache License to your work, attach the following
+        boilerplate notice, with the fields enclosed by brackets "[]"
+        replaced with your own identifying information. (Don't include
+        the brackets!) The text should be enclosed in the appropriate
+        comment syntax for the file format. We also recommend that a
+        file or class name and description of purpose be included on the
+        same "printed page" as the copyright notice for easier
+        identification within third-party archives.
+        
+        Copyright 2026 Alex Shalaev
+        
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+        
+        http://www.apache.org/licenses/LICENSE-2.0
+        
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+License-File: LICENSE
+Keywords: async,asyncio,grpc,grpcio,microservices,observability,server
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: grpcio<2.0.0,>=1.78.0
+Provides-Extra: all
+Requires-Dist: dishka>=1.4.0; extra == 'all'
+Requires-Dist: grpcio-channelz<2.0.0,>=1.78.0; extra == 'all'
+Requires-Dist: grpcio-health-checking<2.0.0,>=1.78.0; extra == 'all'
+Requires-Dist: grpcio-reflection<2.0.0,>=1.78.0; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-grpc>=0.40b0; extra == 'all'
+Requires-Dist: prometheus-client>=0.15.0; extra == 'all'
+Requires-Dist: protobuf>=4.21; extra == 'all'
+Requires-Dist: pydantic<3.0,>=2.0.0; extra == 'all'
+Requires-Dist: redis>=5.0.0; extra == 'all'
+Requires-Dist: sentry-sdk>=2.0.0; extra == 'all'
+Requires-Dist: sqlalchemy[asyncio]<3.0.0,>=2.0.0; extra == 'all'
+Provides-Extra: channelz
+Requires-Dist: grpcio-channelz<2.0.0,>=1.78.0; extra == 'channelz'
+Provides-Extra: dishka
+Requires-Dist: dishka>=1.4.0; extra == 'dishka'
+Requires-Dist: protobuf>=4.21; extra == 'dishka'
+Provides-Extra: health
+Requires-Dist: grpcio-health-checking<2.0.0,>=1.78.0; extra == 'health'
+Provides-Extra: metrics
+Requires-Dist: prometheus-client>=0.15.0; extra == 'metrics'
+Provides-Extra: postgres
+Requires-Dist: sqlalchemy[asyncio]<3.0.0,>=2.0.0; extra == 'postgres'
+Provides-Extra: redis
+Requires-Dist: redis>=5.0.0; extra == 'redis'
+Provides-Extra: reflection
+Requires-Dist: grpcio-reflection<2.0.0,>=1.78.0; extra == 'reflection'
+Provides-Extra: sentry
+Requires-Dist: sentry-sdk>=2.0.0; extra == 'sentry'
+Provides-Extra: settings
+Requires-Dist: pydantic<3.0,>=2.0.0; extra == 'settings'
+Provides-Extra: tracing
+Requires-Dist: opentelemetry-instrumentation-grpc>=0.40b0; extra == 'tracing'
+Description-Content-Type: text/markdown
+
+# grpc-server-kit
+
+Batteries-optional async gRPC server toolkit (app facade, builder, TLS, lifecycle, health, interceptors, observability)
+
+[![PyPI](https://img.shields.io/pypi/v/grpc-server-kit?color=blue)](https://pypi.org/project/grpc-server-kit/)
+[![Python](https://img.shields.io/pypi/pyversions/grpc-server-kit)](https://pypi.org/project/grpc-server-kit/)
+[![License](https://img.shields.io/github/license/bedrock-python/grpc-server-kit)](LICENSE)
+[![CI](https://github.com/bedrock-python/grpc-server-kit/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/bedrock-python/grpc-server-kit/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/bedrock-python/grpc-server-kit/graph/badge.svg)](https://codecov.io/gh/bedrock-python/grpc-server-kit)
+[![Docs](https://img.shields.io/badge/docs-online-blue)](https://bedrock-python.github.io/grpc-server-kit/)
+
+`grpc-server-kit` gives you a clean, production-grade foundation for building
+`grpc.aio` servers: a one-object `GrpcApp` facade, validated channel options,
+TLS/mTLS credential loading, graceful signal-driven shutdown, streaming-aware
+interceptors, and gRPC health checking — with **optional** extras for
+reflection, channelz, Prometheus metrics, OpenTelemetry tracing, Sentry,
+Dishka DI, and typed pydantic settings.
+
+The core depends only on `grpcio`. Every integration is an opt-in extra, so you
+install exactly what you use.
+
+## Installation
+
+```bash
+pip install grpc-server-kit                      # core (grpcio only)
+pip install "grpc-server-kit[settings]"          # + pydantic settings models
+pip install "grpc-server-kit[health]"            # + gRPC health checking
+pip install "grpc-server-kit[metrics,tracing]"   # + Prometheus + OpenTelemetry
+pip install "grpc-server-kit[all]"               # everything
+```
+
+**Requirements:** Python 3.12+
+
+## Quick start
+
+```python
+import asyncio
+
+from grpc_server_kit import GrpcApp
+
+app = GrpcApp(port=50051)
+app.add_servicer(MyServicer(), add_MyServiceServicer_to_server)
+
+asyncio.run(app.run())   # build + bind + SIGINT/SIGTERM + graceful shutdown
+```
+
+That's the whole server. `GrpcApp` builds the `grpc.aio` server, binds the port
+(TLS-aware), installs signal handlers, and serves until termination. More knobs
+when you need them:
+
+```python
+from grpc_server_kit import GrpcApp, GrpcServerConfig
+from grpc_server_kit.aio.interceptors import (
+    AsyncContextInterceptor, AsyncExceptionHandlerInterceptor,
+    AsyncMetricsInterceptor, AsyncRequestLoggerInterceptor, HeaderConfig,
+)
+from grpc_server_kit.observability.metrics import get_grpc_server_metrics
+
+config = GrpcServerConfig(host="[::]", port=50051, grace_period=10.0)   # stdlib dataclass
+app = GrpcApp(config, interceptors=[
+    AsyncMetricsInterceptor(metrics=get_grpc_server_metrics(), service_name="my.pkg.MyService"),
+    AsyncContextInterceptor([HeaderConfig("x-request-id", "request_id")]),
+    AsyncRequestLoggerInterceptor(),
+    AsyncExceptionHandlerInterceptor(MY_ERROR_STATUS_MAP),   # domain error → gRPC status
+])
+app.add_servicer(MyServicer(), add_MyServiceServicer_to_server)
+app.enable_health(checkers=[DatabaseHealthChecker(session_maker)])   # [health] extra
+app.enable_reflection(["my.pkg.MyService"])                          # [reflection] extra
+
+asyncio.run(app.run())
+```
+
+Prefer pydantic-validated, env-friendly settings? Use
+`grpc_server_kit.settings.BaseGrpcServerSettings` (the `[settings]` extra) —
+`GrpcServerConfig` and `BaseGrpcServerSettings` are interchangeable everywhere
+the kit accepts settings.
+
+## Streaming-aware interceptors
+
+Every interceptor wraps the **whole** RPC for all four call kinds — unary-unary,
+unary-stream, stream-unary, stream-stream. Durations cover the full stream,
+errors raised mid-stream are mapped to proper gRPC statuses, and cleanup always
+runs. Write your own by implementing a single async-generator hook:
+
+```python
+from grpc_server_kit.aio.interceptors import AsyncServerInterceptor, RpcCall
+
+class TimingInterceptor(AsyncServerInterceptor):
+    async def around_call(self, call: RpcCall):
+        start = time.perf_counter()
+        try:
+            yield                      # the RPC (or the full response stream) runs here
+        finally:
+            log.info("%s took %.3fs", call.method_name, time.perf_counter() - start)
+```
+
+Canonical chain order (outermost first): `metrics → context → logger → tracing
+→ exception handler → sentry`. The exception handler maps exception types to
+gRPC statuses over the MRO and sends safe, non-leaking details; deliberate
+`context.abort()` calls pass through untouched. Sentry sits **inside** the
+exception handler so it observes raw handler exceptions before they become
+aborts (outside it would never capture anything), with a capture filter that
+reports only server-class errors.
+
+## Advanced API
+
+`GrpcApp` is sugar over small, composable pieces you can use directly — for DI
+containers, custom lifecycles, or embedding:
+
+```python
+from grpc_server_kit import bind_server_port
+from grpc_server_kit.aio import AsyncGrpcServerBuilder, run_async_grpc_server
+
+server = (
+    AsyncGrpcServerBuilder(settings)
+    .with_interceptors(interceptors)
+    .with_servicers(lambda s: add_MyServiceServicer_to_server(MyServicer(), s))
+    .with_reflection(["my.pkg.MyService"])
+    .build()
+)
+bind_server_port(server, settings)            # honors settings.ssl_enabled (TLS/mTLS)
+await run_async_grpc_server(server, address=f"{settings.host}:{settings.port}")
+```
+
+## Dishka DI providers (cut the per-service boilerplate)
+
+If your service uses [Dishka](https://github.com/reagento/dishka), the kit ships ready-made
+providers so you register a handful of providers instead of hand-writing the interceptor
+list, settings aliasing, and a metrics provider. `grpc_server_providers(...)` bundles the
+standard set in one call:
+
+```python
+from dishka import make_async_container
+from grpc_server_kit.dishka import GrpcioProvider, FromDishka, inject
+from grpc_server_kit.aio.dishka import grpc_server_providers
+from grpc_server_kit.aio.server import AsyncServer
+from grpc_server_kit.aio import run_async_grpc_server
+from grpc_server_kit import bind_server_port
+
+container = make_async_container(
+    *grpc_server_providers(                       # settings + metrics + sentry/tracer seams
+        settings.grpc,                            # + the canonical interceptor chain + AsyncServer
+        service_name="my.pkg.MyService",
+        error_status_map=MY_ERROR_STATUS_MAP,     # service-specific domain map (optional)
+        metrics_enabled=settings.grpc.metrics_enabled,
+    ),
+    GrpcioProvider(),                             # request-scoped ServicerContext for FromDishka
+    MyDomainProvider(),                           # your use-cases / repos
+)
+
+server = await container.get(AsyncServer)         # interceptors + options already wired
+add_MyServiceServicer_to_server(MyServicer(), server)   # AsyncServer works directly
+bind_server_port(server, settings.grpc)
+await run_async_grpc_server(server, address=f"{settings.grpc.host}:{settings.grpc.port}")
+```
+
+The interceptor chain is built in the canonical order
+(`metrics → context → logger → tracing → exception → sentry → DishkaAioInterceptor`), with
+`include_*` toggles and `extra_outer` / `extra_inner` slots on
+`GrpcServerInterceptorsProvider`. Providers degrade gracefully: the metrics / Sentry / tracer
+seams resolve to `None` when disabled or their extra is absent, and the interceptors no-op.
+SDK initialization (`sentry_sdk.init`, OpenTelemetry setup, the `/metrics` HTTP server) is a
+process-wide concern and is **not** done by these providers. Requires `[dishka]`
+(+ `[metrics]`/`[sentry]`/`[tracing]` for those seams).
+
+Granular providers (`GrpcServerSettingsProvider`, `PrometheusGrpcServerMetricsProvider`,
+`SentryAdapterProvider`, `TracerAdapterProvider`, `GrpcServerInterceptorsProvider`,
+`AsyncGrpcServerProvider`) are available for finer control.
+
+## What's inside
+
+> **Layout convention:** all async code lives under a single `grpc_server_kit.aio`
+> package (mirroring `grpc.aio`), organized by domain (`aio.health`, `aio.interceptors`,
+> `aio.observability`, `aio.dishka`). Modules that work for both sync and async stay at
+> the top level — either directly (`config`, `options`, `credentials`, `server`,
+> `protocols`, `signals`, `settings`) or as shared domain packages (`interceptors` →
+> constants/utils, `observability` → protocols/metrics/sentry, `dishka` → providers).
+
+| Module | Responsibility | Extra |
+| :--- | :--- | :--- |
+| `aio.GrpcApp` | One-object facade: config → servicers → run | core |
+| `config.GrpcServerConfig` | Zero-dependency settings dataclass | core |
+| `aio.builder.AsyncGrpcServerBuilder` | Fluent builder for an `AsyncServer` | core |
+| `aio.create_async_grpc_server` / `aio.AsyncServer` | Server factory + typed wrapper | core |
+| `aio.ServerLifecycleManager` / `aio.run_async_grpc_server` | Start/serve/stop with graceful shutdown | core |
+| `aio.interceptors.*` | streaming-aware base + context, logger, metrics, tracing, sentry, exception-handler | core |
+| `options` / `credentials` / `server` / `signals` / `protocols` | Channel options, TLS/mTLS, port binding, SIGINT/SIGTERM, seams | core |
+| `settings.BaseGrpcServerSettings` | Pydantic config model | `settings` |
+| `aio.health.*` | gRPC Health v1 servicer, orchestrator, TTL cache, pg/redis checkers | `health` |
+| `observability.metrics.GrpcServerMetrics` | Prometheus metric definitions | `metrics` |
+| `aio.observability.tracing.instrument_aio_server` | OpenTelemetry instrumentation | `tracing` |
+| `observability.sentry.SentrySdkAdapter` | Sentry adapter for the sentry interceptor | `sentry` |
+| `aio.dishka.*` / `dishka.*` | DI providers + `DishkaAioInterceptor` re-export | `dishka` |
+
+## Optional dependencies
+
+| Extra | Pulls in | Enables |
+| :--- | :--- | :--- |
+| `reflection` | `grpcio-reflection` | server reflection |
+| `channelz` | `grpcio-channelz` | channelz debugging |
+| `settings` | `pydantic` | `BaseGrpcServerSettings` / `BaseHealthSettings` |
+| `health` | `grpcio-health-checking` | health servicer / orchestrator / cache |
+| `postgres` | `sqlalchemy[asyncio]` | `DatabaseHealthChecker` |
+| `redis` | `redis` | `RedisHealthChecker` |
+| `metrics` | `prometheus-client` | `GrpcServerMetrics` |
+| `tracing` | `opentelemetry-instrumentation-grpc` | `instrument_aio_server` |
+| `sentry` | `sentry-sdk` | `SentrySdkAdapter` |
+| `dishka` | `dishka`, `protobuf` | DI providers + `DishkaAioInterceptor` |
+| `all` | all of the above | everything |
+
+## Examples
+
+Runnable, self-contained scripts in [`examples/`](examples/) — each prints what it's doing and exits on its own:
+
+- [`minimal_server.py`](examples/minimal_server.py) — the smallest real server: `GrpcApp`, one servicer, `asyncio.run(app.run())`.
+- [`observability_chain.py`](examples/observability_chain.py) — the canonical interceptor chain (metrics → context → logger → tracing → exception handler → sentry) wired by hand.
+- [`custom_interceptor.py`](examples/custom_interceptor.py) — writing your own streaming-aware interceptor with `AsyncServerInterceptor.around_call`.
+- [`health_checks.py`](examples/health_checks.py) — `app.enable_health()` with a custom dependency checker, driven through the real `grpc_health.v1` stubs.
+
+## Documentation
+
+Full documentation at [bedrock-python.github.io/grpc-server-kit](https://bedrock-python.github.io/grpc-server-kit/).
+
+## License
+
+Apache 2.0 — see [LICENSE](LICENSE).

grpc_server_kit-0.1.0.dist-info/RECORD

@@ -0,0 +1,57 @@
+grpc_server_kit/__init__.py,sha256=Y-ubotS6irv9DkW45NcxXXxWSIapd6Zr5sB1zJndY4w,928
+grpc_server_kit/__version__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+grpc_server_kit/config.py,sha256=cRU-O-RGKiLfoZus_45dzSc9y2a9x3qOL8oEJVWZeMs,3638
+grpc_server_kit/constants.py,sha256=ToF7egu4ThA4oSI41SzgFEDWpuZ6nhuvmY-8x4XxT2o,1399
+grpc_server_kit/credentials.py,sha256=pSUWV1PRrN3JIT7ykTuCp5nAfxNHkJZIxymCk5q-aBw,4155
+grpc_server_kit/options.py,sha256=dZuVISoRnMUWwFHQluVBaXvQoBKRkqX1KC-dgakfb9g,5010
+grpc_server_kit/protocols.py,sha256=T_ln67UkrW7txL1asEFMrcpF3DkN5RkjQ0FDlSMrFxI,3639
+grpc_server_kit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+grpc_server_kit/server.py,sha256=NvP7dRFoU0YtAPMjTK-M9hELHur39_KSWakvVItJ2BQ,2155
+grpc_server_kit/settings.py,sha256=pjDuUV-vfy3QtFK4aR5xJF8EwVyyEaAlHGEOglTBWyE,6388
+grpc_server_kit/signals.py,sha256=LcLZjt9x-WOKTGdkBzncsvimfRUWvpEXVeG_DmFe_C0,8632
+grpc_server_kit/aio/__init__.py,sha256=Dc_yu1Uvplzbzzyu05k0AQ4YCesfbPLc2Z7iNbvQ8N0,1261
+grpc_server_kit/aio/app.py,sha256=PcKO7Y280491nk4BZi5YAtiECr1El8k6o5Ae371nNKU,15183
+grpc_server_kit/aio/builder.py,sha256=DX7qFH2jpKDCHKGms771-7UCc9fTLMhsVOLtYdXqKeQ,2283
+grpc_server_kit/aio/runtime.py,sha256=jrif3IyeAtQePAmUrePunGk7vavXkd6T1PORx-k0O8k,8107
+grpc_server_kit/aio/server.py,sha256=WDvixdtnqbSyTRo4xegYAfLSRWpdNHFvMqlLTAgUWY4,7004
+grpc_server_kit/aio/dishka/__init__.py,sha256=yOziJKapPNpbdijt51VT-YqBo-sYFTy9PqRjqwEhaiU,1082
+grpc_server_kit/aio/dishka/bundle.py,sha256=QKhU-fw6LPhBu-wP9gTYdbdwzWzL_jeEpOKBmp3dbY8,2905
+grpc_server_kit/aio/dishka/interceptors.py,sha256=xfr0jDLG0UIbP_gmW3FaQvIrUu-NsS5G30Z-EY8cnzw,5215
+grpc_server_kit/aio/dishka/metrics.py,sha256=OwLvF8Hs1-5xl6qwu3Brdp_v36bZtMsoqCYXv7EqZ94,1833
+grpc_server_kit/aio/dishka/observability.py,sha256=V_t3Z_SVEQhq16NzvFMZUrJy3dDf57GtW7_9VF7H9C8,3093
+grpc_server_kit/aio/dishka/server.py,sha256=lWEQk4hCY2w0cIUA9Md0aJidU_hDnZhigWRRDA_gO0U,2169
+grpc_server_kit/aio/health/__init__.py,sha256=4ihBbqAKlGN2E7Ov2ZHHyqW6veRzGkr_Rm4XIca2IsU,1075
+grpc_server_kit/aio/health/cache.py,sha256=DvCMrO89JBEstpt2hJxDg964YQ2-YKVm7hjAAK2--mI,3250
+grpc_server_kit/aio/health/orchestrator.py,sha256=NJx9LE5hkuyaExG9RvqYOvzfB2xbKmhLqE1VbrI2DTI,4229
+grpc_server_kit/aio/health/protocols.py,sha256=BAyTphxx0fgId5Me2VondQtuy5mGieubzlAoysImYyM,1367
+grpc_server_kit/aio/health/servicer.py,sha256=NpiCNF4RSQnJa9byuHfBIwrlBstMrqPfagE3dEZMlwc,10115
+grpc_server_kit/aio/health/checkers/__init__.py,sha256=26ITNr1oQ1yQ9gsop0uoqcLJrSH2vPOTKm2jBOHoY3s,534
+grpc_server_kit/aio/health/checkers/postgres.py,sha256=Q8reWB2HdjepxXoI5Hl5kBRtn_9_scebET4YQq--pCk,3902
+grpc_server_kit/aio/health/checkers/redis.py,sha256=jGzhFOzho9WC3rAesK1S-QL2GWDKkmZSqqdX5ZGoDwo,2995
+grpc_server_kit/aio/health/checkers/utils.py,sha256=L_KdsBVXk5-wSTduRgWh09TrfszauZYG1vMEgzaKFFg,3486
+grpc_server_kit/aio/interceptors/__init__.py,sha256=J20nStQB26My26rFe73ANt6Cu9FibWgyugjRTYbFgl8,2110
+grpc_server_kit/aio/interceptors/base.py,sha256=HObh5B84M-2PgVou2Msxw5G3FNc6yRFA6RjfxPkOWEw,9435
+grpc_server_kit/aio/interceptors/context.py,sha256=Tp41tyuMVKX_-omLLb-IAJavknci6JXE4osm-FSJurc,6832
+grpc_server_kit/aio/interceptors/exception_handler.py,sha256=T9i05KDxNuFDHj-raCfuthH6P41n0KAvzSTThd7T2Vc,7076
+grpc_server_kit/aio/interceptors/metadata.py,sha256=vjAZ5a1TcS65aV_TKm8E62yPL6f_tlxacaVr5ocrgAE,2109
+grpc_server_kit/aio/interceptors/metrics.py,sha256=VY6-jhY6datryfZVZAl3-yOuzx-ojG6uSALjhrtU2LE,3910
+grpc_server_kit/aio/interceptors/protocols.py,sha256=-mztxVldbyNszNwmcoWfJ5AESbSAwuh-tWiSh_izdiw,1429
+grpc_server_kit/aio/interceptors/request_logger.py,sha256=rQNTmgdzMc7WMUFx6tHwc3qfQ10xhp-6rqPlEhHinfI,4145
+grpc_server_kit/aio/interceptors/sentry.py,sha256=jG-pLQ0YFwJRnkRO6nfL94s5h4EYmw60Rwc__xanyqg,3678
+grpc_server_kit/aio/interceptors/tracing.py,sha256=XEjfR8G5Jst-lSG4kC1FfEuN2UAVNHSekHxVXOBQElc,5285
+grpc_server_kit/aio/observability/__init__.py,sha256=6XGtDzkMPkowOf5B8Z0-N77l8rVCIQqvJz16Im54Rmw,223
+grpc_server_kit/aio/observability/tracing.py,sha256=5ncOM2pDTvSzU0Gt916THFn4PdPBBVMCIGUBSS6MKo0,1530
+grpc_server_kit/dishka/__init__.py,sha256=kY02b-Iuhz3y0mGqKESjRPlp0R7A8WRDF65EouwIg9U,1217
+grpc_server_kit/dishka/settings.py,sha256=yEltiACl5iyNWR3u_HpdjzTuMDMWUDCrCN_JSHm7Fz8,1425
+grpc_server_kit/interceptors/__init__.py,sha256=V7ysONRMzmEBVTABQbXUv4AZjYRNWFSEK27c0niytDA,444
+grpc_server_kit/interceptors/constants.py,sha256=zKrClsT6E1aWy4-2zqLt2FPJUAWSkU_rCOkn5wLpmtw,1105
+grpc_server_kit/interceptors/utils.py,sha256=Z_GvaHbZwmH12W-gA7rIxGGB6QRUPa6r6HwvIbSbowM,2383
+grpc_server_kit/observability/__init__.py,sha256=8EFf9VRvXTaIP3x5zFcBHg4Dd6bsHmxoze3eIFL_OZs,550
+grpc_server_kit/observability/metrics.py,sha256=XsC2stqYzPVHGV1GdP6M3uflHXLGpEBnrTMx0M66-Ls,4114
+grpc_server_kit/observability/naming.py,sha256=gUcnThpGTK8zeSn3IOwOZeIr2DsD9iCQ6iJLyVJmAzo,761
+grpc_server_kit/observability/protocols.py,sha256=0zm2xyM3Tr3Kbsk-07v9Xs6OX9x5aQzE8YcFAef_hgg,2603
+grpc_server_kit/observability/sentry.py,sha256=uJr2_OdLNWLlF5Nn_oJ4pjLQevCjksq8EOvnZeQnG3g,1982
+grpc_server_kit-0.1.0.dist-info/METADATA,sha256=u4SH4oL8Kkm3z1zjeo4WRuOisTFODcoypRy71XNufHI,26155
+grpc_server_kit-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+grpc_server_kit-0.1.0.dist-info/licenses/LICENSE,sha256=HqasrACfRh7mgdbiXMVrs_X8dOCZed1b8KXY7i6Ch14,10239
+grpc_server_kit-0.1.0.dist-info/RECORD,,

grpc_server_kit-0.1.0.dist-info/WHEEL

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