fastgrpc3 0.1.0__tar.gz

fastgrpc3-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 William Nauroy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fastgrpc3-0.1.0/PKG-INFO

@@ -0,0 +1,214 @@
+Metadata-Version: 2.4
+Name: fastgrpc3
+Version: 0.1.0
+Summary: FastAPI-like gRPC framework for Python: contracts from .proto files or Pydantic models, powered by protoruf (Rust)
+Author: William Nauroy
+Author-email: William Nauroy <william.nauroy@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 1 - Planning
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: System :: Networking
+Classifier: Typing :: Typed
+Requires-Dist: grpcio>=1.75.1
+Requires-Dist: protoruf>=0.5.3
+Requires-Dist: pydantic>=2.11
+Requires-Dist: uvicorn>=0.30 ; extra == 'docs'
+Requires-Dist: fastgrpc3-transport>=0.1,<0.2 ; extra == 'tonic'
+Requires-Python: >=3.12
+Provides-Extra: docs
+Provides-Extra: tonic
+Description-Content-Type: text/markdown
+
+# fastgrpc3
+
+A FastAPI-like gRPC framework for Python: async handlers, Pydantic models, dependency
+injection and typed clients, on top of `grpc.aio`.
+
+> **Status: early development.** Contracts, server, client, health checking, reflection and
+> multi-process serving work; documentation is still to come. The API may change.
+
+On a 20-field message, the codec is 4× faster than fastgrpc2's and the framework costs ~7 %
+over plain `grpc.aio` with generated stubs, validation included (`benches/results/`).
+
+- **Two ways to declare a contract.** Start from `.proto` files and generate the Pydantic
+  models, services and clients, or write Pydantic models and get the `.proto` generated.
+- **Fast protobuf codec.** Encoding and decoding run in Rust through
+  [protoruf](https://github.com/EdwinAlkins/protoruf), straight between protobuf bytes and
+  Python objects, without any JSON step.
+- **Standard gRPC.** Real protobuf on the wire, standard error details, health checking and
+  server reflection, so clients in any language can talk to it.
+- **Two transports.** `grpc.aio` by default, or tonic, a Rust server 6 to 10× faster per
+  core under concurrency (`--transport tonic`, extra `fastgrpc3[tonic]`, experimental).
+- **Interactive docs.** Swagger UI generated from the models, with a JSON gateway to try the
+  RPCs from the browser (`app.enable_docs()`, extra `fastgrpc3[docs]`).
+
+Requires Python 3.12 or later (tested on 3.12, 3.13 and 3.14).
+
+A complete example, a bookstore service with its client and tests, is in
+[`examples/`](examples/README.md).
+
+## Server and client
+
+```python
+import asyncio
+from collections.abc import AsyncIterator
+
+from pydantic import BaseModel
+from fastgrpc3 import Context, Depends, GrpcApp, GrpcError, GrpcService, Insecure, StatusCode
+
+
+class GetOrder(BaseModel):
+    order_number: str
+
+
+class Order(BaseModel):
+    order_number: str
+    paid: bool = False
+
+
+service = GrpcService("Orders", package="orders.v1")
+
+
+def get_repo() -> dict[str, Order]:
+    return {"A": Order(order_number="A", paid=True)}
+
+
+@service.unary()
+async def Get(req: GetOrder, ctx: Context, repo: dict[str, Order] = Depends(get_repo)) -> Order:
+    if req.order_number not in repo:
+        raise GrpcError(StatusCode.NOT_FOUND, "no such order")
+    return repo[req.order_number]
+
+
+@service.unary_stream()
+async def Watch(req: GetOrder) -> AsyncIterator[Order]:
+    yield Order(order_number=req.order_number)
+
+
+app = GrpcApp(address="[::]:50051", tls=Insecure())  # or TLS(cert=..., key=...)
+app.add_service(service)
+app.enable_health()  # grpc.health.v1: Check, Watch, List (grpc-health-probe, Kubernetes)
+app.enable_reflection()  # grpc.reflection v1 and v1alpha (grpcurl list / describe / call)
+app.enable_docs(gateway=True)  # Swagger UI on 127.0.0.1:8080/docs (fastgrpc3[docs])
+
+if __name__ == "__main__":
+    asyncio.run(app.run())  # stops cleanly on SIGINT / SIGTERM
+```
+
+```python
+from fastgrpc3 import Channel, GrpcClient, Insecure
+
+
+class OrdersClient(GrpcClient):
+    package = "orders.v1"
+    service = "Orders"
+    get = GrpcClient.unary("Get", GetOrder, Order)
+    watch = GrpcClient.unary_stream("Watch", GetOrder, Order)
+
+
+async def main() -> None:
+    async with Channel("localhost:50051", tls=Insecure()) as channel:
+        orders = OrdersClient(channel)
+        order = await orders.get(GetOrder(order_number="A"))
+        async for update in orders.watch(GetOrder(order_number="A")):
+            print(update)
+```
+
+Also: dependencies with sub-dependencies, per-call cache and `yield` cleanup;
+`app.add_interceptor` (pre-call hooks), `@app.middleware` (around the handler) and
+`@app.exception_handler`; rich errors with the standard `google.rpc` details (`ErrorInfo`,
+`BadRequest`…); deadline propagation to calls made from a handler; `TLS` / `MTLS` /
+`Insecure` always explicit; `fastgrpc3.testing.TestClient` for tests.
+
+```bash
+fastgrpc3 run myapp.main:app --address [::]:50051 --workers 4   # one process per core
+```
+
+Workers share the port with `SO_REUSEPORT` (Linux); otherwise a busy port makes the server
+fail to start instead of silently sharing it.
+
+## Code first: Pydantic models -> `.proto`
+
+`fastgrpc3 lock`, `check` and `export` take an app (`myapp.main:app`) or a `SchemaRegistry`.
+
+```python
+from pydantic import BaseModel
+from fastgrpc3 import MethodDef, SchemaRegistry, ServiceDef, field
+from fastgrpc3.types import UInt32
+
+
+class GetOrder(BaseModel):
+    order_number: str
+
+
+class Order(BaseModel):
+    order_number: str
+    qty: UInt32 = 0  # proto uint32, bounds checked by Pydantic
+    note: str | None = field(5, default=None)  # explicit number
+
+
+registry = SchemaRegistry()
+registry.add_service(ServiceDef("Orders", "orders.v1", (MethodDef("Get", GetOrder, Order),)))
+```
+
+```bash
+fastgrpc3 lock myapp.contract:registry     # number new fields, write proto.lock (commit it)
+fastgrpc3 check myapp.contract:registry    # CI: fail if proto.lock is out of date
+fastgrpc3 export myapp.contract:registry -o proto/   # one .proto file per package
+```
+
+Fields without an explicit number get one the first time they are locked, wherever they are
+declared; a removed field's number is reserved for good. Types without a proto equivalent
+(`Decimal`, `UUID`, unions…) travel as a JSON string, marked `// json` in the `.proto`.
+
+## Proto first: `.proto` -> Pydantic models
+
+```bash
+fastgrpc3 generate proto/ -o src/myapp/gen   # -I third_party/ for extra imports
+fastgrpc3 generate proto/ -o src/myapp/gen --check   # CI: fail if not up to date
+```
+
+`orders/v1/orders.proto` gives `orders/v1/orders_models.py` (one `ProtoModel` per message,
+one open `ProtoEnum` per enum) and `orders/v1/orders_service.py`; `_descriptor.py` embeds the
+compiled descriptor, so nothing is compiled at startup. Defaults can live in `pyproject.toml`:
+
+```toml
+[tool.fastgrpc3.generate]
+proto_paths = ["proto"]
+output = "src/myapp/gen"
+```
+
+Each service module also holds the contract (`Orders`, to serve with
+`GrpcService.implement(Orders)`) and a typed client (`OrdersClient`). Generated code passes
+`mypy --strict` and `ruff`. Well-known types become Python types
+(`Timestamp` -> `datetime`, `Struct` -> `dict[str, Any]`, wrappers -> `X | None`…).
+
+## Documentation
+
+The guide and the reference live in [`docs/`](docs/index.md) (MkDocs). To build the site
+into `site/`, or to serve it locally with live reload:
+
+```bash
+uv run --project docs mkdocs build --strict
+uv run --project docs mkdocs serve          # http://127.0.0.1:8000
+```
+
+## Development
+
+```bash
+uv sync                     # install the package and the dev tools
+uv run pytest               # tests
+uv run ruff check .         # lint
+uv run ruff format --check  # formatting
+uv run mypy src tests       # type checking
+```
+
+## License
+
+MIT, see [LICENSE](LICENSE).

fastgrpc3-0.1.0/README.md

@@ -0,0 +1,187 @@
+# fastgrpc3
+
+A FastAPI-like gRPC framework for Python: async handlers, Pydantic models, dependency
+injection and typed clients, on top of `grpc.aio`.
+
+> **Status: early development.** Contracts, server, client, health checking, reflection and
+> multi-process serving work; documentation is still to come. The API may change.
+
+On a 20-field message, the codec is 4× faster than fastgrpc2's and the framework costs ~7 %
+over plain `grpc.aio` with generated stubs, validation included (`benches/results/`).
+
+- **Two ways to declare a contract.** Start from `.proto` files and generate the Pydantic
+  models, services and clients, or write Pydantic models and get the `.proto` generated.
+- **Fast protobuf codec.** Encoding and decoding run in Rust through
+  [protoruf](https://github.com/EdwinAlkins/protoruf), straight between protobuf bytes and
+  Python objects, without any JSON step.
+- **Standard gRPC.** Real protobuf on the wire, standard error details, health checking and
+  server reflection, so clients in any language can talk to it.
+- **Two transports.** `grpc.aio` by default, or tonic, a Rust server 6 to 10× faster per
+  core under concurrency (`--transport tonic`, extra `fastgrpc3[tonic]`, experimental).
+- **Interactive docs.** Swagger UI generated from the models, with a JSON gateway to try the
+  RPCs from the browser (`app.enable_docs()`, extra `fastgrpc3[docs]`).
+
+Requires Python 3.12 or later (tested on 3.12, 3.13 and 3.14).
+
+A complete example, a bookstore service with its client and tests, is in
+[`examples/`](examples/README.md).
+
+## Server and client
+
+```python
+import asyncio
+from collections.abc import AsyncIterator
+
+from pydantic import BaseModel
+from fastgrpc3 import Context, Depends, GrpcApp, GrpcError, GrpcService, Insecure, StatusCode
+
+
+class GetOrder(BaseModel):
+    order_number: str
+
+
+class Order(BaseModel):
+    order_number: str
+    paid: bool = False
+
+
+service = GrpcService("Orders", package="orders.v1")
+
+
+def get_repo() -> dict[str, Order]:
+    return {"A": Order(order_number="A", paid=True)}
+
+
+@service.unary()
+async def Get(req: GetOrder, ctx: Context, repo: dict[str, Order] = Depends(get_repo)) -> Order:
+    if req.order_number not in repo:
+        raise GrpcError(StatusCode.NOT_FOUND, "no such order")
+    return repo[req.order_number]
+
+
+@service.unary_stream()
+async def Watch(req: GetOrder) -> AsyncIterator[Order]:
+    yield Order(order_number=req.order_number)
+
+
+app = GrpcApp(address="[::]:50051", tls=Insecure())  # or TLS(cert=..., key=...)
+app.add_service(service)
+app.enable_health()  # grpc.health.v1: Check, Watch, List (grpc-health-probe, Kubernetes)
+app.enable_reflection()  # grpc.reflection v1 and v1alpha (grpcurl list / describe / call)
+app.enable_docs(gateway=True)  # Swagger UI on 127.0.0.1:8080/docs (fastgrpc3[docs])
+
+if __name__ == "__main__":
+    asyncio.run(app.run())  # stops cleanly on SIGINT / SIGTERM
+```
+
+```python
+from fastgrpc3 import Channel, GrpcClient, Insecure
+
+
+class OrdersClient(GrpcClient):
+    package = "orders.v1"
+    service = "Orders"
+    get = GrpcClient.unary("Get", GetOrder, Order)
+    watch = GrpcClient.unary_stream("Watch", GetOrder, Order)
+
+
+async def main() -> None:
+    async with Channel("localhost:50051", tls=Insecure()) as channel:
+        orders = OrdersClient(channel)
+        order = await orders.get(GetOrder(order_number="A"))
+        async for update in orders.watch(GetOrder(order_number="A")):
+            print(update)
+```
+
+Also: dependencies with sub-dependencies, per-call cache and `yield` cleanup;
+`app.add_interceptor` (pre-call hooks), `@app.middleware` (around the handler) and
+`@app.exception_handler`; rich errors with the standard `google.rpc` details (`ErrorInfo`,
+`BadRequest`…); deadline propagation to calls made from a handler; `TLS` / `MTLS` /
+`Insecure` always explicit; `fastgrpc3.testing.TestClient` for tests.
+
+```bash
+fastgrpc3 run myapp.main:app --address [::]:50051 --workers 4   # one process per core
+```
+
+Workers share the port with `SO_REUSEPORT` (Linux); otherwise a busy port makes the server
+fail to start instead of silently sharing it.
+
+## Code first: Pydantic models -> `.proto`
+
+`fastgrpc3 lock`, `check` and `export` take an app (`myapp.main:app`) or a `SchemaRegistry`.
+
+```python
+from pydantic import BaseModel
+from fastgrpc3 import MethodDef, SchemaRegistry, ServiceDef, field
+from fastgrpc3.types import UInt32
+
+
+class GetOrder(BaseModel):
+    order_number: str
+
+
+class Order(BaseModel):
+    order_number: str
+    qty: UInt32 = 0  # proto uint32, bounds checked by Pydantic
+    note: str | None = field(5, default=None)  # explicit number
+
+
+registry = SchemaRegistry()
+registry.add_service(ServiceDef("Orders", "orders.v1", (MethodDef("Get", GetOrder, Order),)))
+```
+
+```bash
+fastgrpc3 lock myapp.contract:registry     # number new fields, write proto.lock (commit it)
+fastgrpc3 check myapp.contract:registry    # CI: fail if proto.lock is out of date
+fastgrpc3 export myapp.contract:registry -o proto/   # one .proto file per package
+```
+
+Fields without an explicit number get one the first time they are locked, wherever they are
+declared; a removed field's number is reserved for good. Types without a proto equivalent
+(`Decimal`, `UUID`, unions…) travel as a JSON string, marked `// json` in the `.proto`.
+
+## Proto first: `.proto` -> Pydantic models
+
+```bash
+fastgrpc3 generate proto/ -o src/myapp/gen   # -I third_party/ for extra imports
+fastgrpc3 generate proto/ -o src/myapp/gen --check   # CI: fail if not up to date
+```
+
+`orders/v1/orders.proto` gives `orders/v1/orders_models.py` (one `ProtoModel` per message,
+one open `ProtoEnum` per enum) and `orders/v1/orders_service.py`; `_descriptor.py` embeds the
+compiled descriptor, so nothing is compiled at startup. Defaults can live in `pyproject.toml`:
+
+```toml
+[tool.fastgrpc3.generate]
+proto_paths = ["proto"]
+output = "src/myapp/gen"
+```
+
+Each service module also holds the contract (`Orders`, to serve with
+`GrpcService.implement(Orders)`) and a typed client (`OrdersClient`). Generated code passes
+`mypy --strict` and `ruff`. Well-known types become Python types
+(`Timestamp` -> `datetime`, `Struct` -> `dict[str, Any]`, wrappers -> `X | None`…).
+
+## Documentation
+
+The guide and the reference live in [`docs/`](docs/index.md) (MkDocs). To build the site
+into `site/`, or to serve it locally with live reload:
+
+```bash
+uv run --project docs mkdocs build --strict
+uv run --project docs mkdocs serve          # http://127.0.0.1:8000
+```
+
+## Development
+
+```bash
+uv sync                     # install the package and the dev tools
+uv run pytest               # tests
+uv run ruff check .         # lint
+uv run ruff format --check  # formatting
+uv run mypy src tests       # type checking
+```
+
+## License
+
+MIT, see [LICENSE](LICENSE).

fastgrpc3-0.1.0/pyproject.toml

@@ -0,0 +1,93 @@
+[project]
+name = "fastgrpc3"
+version = "0.1.0"
+description = "FastAPI-like gRPC framework for Python: contracts from .proto files or Pydantic models, powered by protoruf (Rust)"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+classifiers = [
+    "Development Status :: 1 - Planning",
+    "Framework :: AsyncIO",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: System :: Networking",
+    "Typing :: Typed",
+]
+dependencies = [
+    "grpcio>=1.75.1",
+    "protoruf>=0.5.3",
+    "pydantic>=2.11",
+]
+
+[[project.authors]]
+name = "William Nauroy"
+email = "william.nauroy@gmail.com"
+
+[project.scripts]
+fastgrpc3 = "fastgrpc3.cli:main"
+
+[project.optional-dependencies]
+docs = ["uvicorn>=0.30"]
+tonic = ["fastgrpc3-transport>=0.1,<0.2"]
+
+[dependency-groups]
+bench = [
+    "fastgrpc2==0.5.0",
+    "protobuf>=7.36.2",
+]
+dev = [
+    "mypy>=2.4",
+    "pytest>=9.2",
+    "pytest-asyncio>=1.4",
+    "ruff>=0.17",
+    "types-grpcio>=1.85.0.20261028",
+    "uvicorn>=0.30",
+]
+
+[build-system]
+requires = ["uv_build>=0.13.4,<0.14.0"]
+build-backend = "uv_build"
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+extend-exclude = ["src/fastgrpc3/_proto"]
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "W",
+    "I",
+    "UP",
+    "B",
+    "SIM",
+    "RUF",
+]
+
+[tool.ruff.lint.flake8-bugbear]
+extend-immutable-calls = [
+    "fastgrpc3.Depends",
+    "fastgrpc3.api.deps.Depends",
+]
+
+[tool.mypy]
+python_version = "3.12"
+strict = true
+
+[[tool.mypy.overrides]]
+module = ["fastgrpc3_transport"]
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = ["fastgrpc3.transport.tonic"]
+warn_return_any = false
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"

fastgrpc3-0.1.0/pyproject.toml.orig

@@ -0,0 +1,91 @@
+[project]
+name = "fastgrpc3"
+version = "0.1.0"
+description = "FastAPI-like gRPC framework for Python: contracts from .proto files or Pydantic models, powered by protoruf (Rust)"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "William Nauroy", email = "william.nauroy@gmail.com" }
+]
+requires-python = ">=3.12"
+classifiers = [
+    "Development Status :: 1 - Planning",
+    "Framework :: AsyncIO",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: System :: Networking",
+    "Typing :: Typed",
+]
+dependencies = [
+    # First release shipping CPython 3.14 wheels.
+    "grpcio>=1.75.1",
+    "protoruf>=0.5.3",
+    # `model_validate(..., by_name=True)` appeared in 2.11.
+    "pydantic>=2.11",
+]
+
+[project.scripts]
+fastgrpc3 = "fastgrpc3.cli:main"
+
+[project.optional-dependencies]
+docs = [
+    "uvicorn>=0.30",
+]
+# The tonic transport (`GrpcApp(transport="tonic")`), a Rust server.
+tonic = [
+    "fastgrpc3-transport>=0.1,<0.2",
+]
+
+[dependency-groups]
+bench = [
+    "fastgrpc2==0.5.0",
+    "protobuf>=7.36.2",
+]
+dev = [
+    "mypy>=2.4",
+    "pytest>=9.2",
+    "pytest-asyncio>=1.4",
+    "ruff>=0.17",
+    "types-grpcio>=1.85.0.20261028",
+    "uvicorn>=0.30",
+]
+
+[build-system]
+requires = ["uv_build>=0.13.4,<0.14.0"]
+build-backend = "uv_build"
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+# Generated by scripts/generate_standard_protos.py (proto comments make long lines).
+extend-exclude = ["src/fastgrpc3/_proto"]
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP", "B", "SIM", "RUF"]
+
+[tool.ruff.lint.flake8-bugbear]
+# `x: Repo = Depends(get_repo)` is the documented way to declare a dependency.
+extend-immutable-calls = ["fastgrpc3.Depends", "fastgrpc3.api.deps.Depends"]
+
+[tool.mypy]
+python_version = "3.12"
+strict = true
+
+[[tool.mypy.overrides]]
+# The tonic transport, optional (`fastgrpc3-transport`, typed when installed).
+module = ["fastgrpc3_transport"]
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+# Returns what the extension gives, typed only when fastgrpc3-transport is installed.
+module = ["fastgrpc3.transport.tonic"]
+warn_return_any = false
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"

fastgrpc3-0.1.0/src/fastgrpc3/__init__.py

@@ -0,0 +1,75 @@
+"""fastgrpc3: a FastAPI-like gRPC framework for Python, powered by protoruf."""
+
+from fastgrpc3.api.app import GrpcApp
+from fastgrpc3.api.client import Channel, GrpcClient
+from fastgrpc3.api.config import Compression, Keepalive, RetryPolicy
+from fastgrpc3.api.context import Context
+from fastgrpc3.api.deps import Depends, blocking, non_blocking
+from fastgrpc3.api.errors import (
+    BadRequest,
+    ErrorInfo,
+    FieldViolation,
+    GrpcError,
+    StatusCode,
+    register_detail,
+)
+from fastgrpc3.api.metadata import Metadata
+from fastgrpc3.api.security import MTLS, TLS, BearerToken, Insecure
+from fastgrpc3.api.service import GrpcService
+from fastgrpc3.runtime.dispatch import CallNext
+from fastgrpc3.schema import (
+    Lock,
+    LockError,
+    MethodDef,
+    Schema,
+    SchemaError,
+    SchemaRegistry,
+    ServiceDef,
+)
+from fastgrpc3.transport import Transport, TransportCapabilities, available_transports
+from fastgrpc3.types import ProtoEnum, ProtoField, ProtoModel, field, key, proto_enum
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "MTLS",
+    "TLS",
+    "BadRequest",
+    "BearerToken",
+    "CallNext",
+    "Channel",
+    "Compression",
+    "Context",
+    "Depends",
+    "ErrorInfo",
+    "FieldViolation",
+    "GrpcApp",
+    "GrpcClient",
+    "GrpcError",
+    "GrpcService",
+    "Insecure",
+    "Keepalive",
+    "Lock",
+    "LockError",
+    "Metadata",
+    "MethodDef",
+    "ProtoEnum",
+    "ProtoField",
+    "ProtoModel",
+    "RetryPolicy",
+    "Schema",
+    "SchemaError",
+    "SchemaRegistry",
+    "ServiceDef",
+    "StatusCode",
+    "Transport",
+    "TransportCapabilities",
+    "__version__",
+    "available_transports",
+    "blocking",
+    "field",
+    "key",
+    "non_blocking",
+    "proto_enum",
+    "register_detail",
+]

fastgrpc3-0.1.0/src/fastgrpc3/__main__.py

@@ -0,0 +1,7 @@
+"""`python -m fastgrpc3`: same as the `fastgrpc3` command."""
+
+import sys
+
+from fastgrpc3.cli import main
+
+sys.exit(main())

fastgrpc3-0.1.0/src/fastgrpc3/_proto/__init__.py

@@ -0,0 +1 @@
+# Generated by fastgrpc3: do not edit.