pydantic-rpc 0.11.0__tar.gz → 0.13.0__tar.gz

pydantic_rpc-0.11.0/README.md → pydantic_rpc-0.13.0/PKG-INFO

@@ -1,3 +1,21 @@
+Metadata-Version: 2.3
+Name: pydantic-rpc
+Version: 0.13.0
+Summary: A Python library for building gRPC/ConnectRPC services with Pydantic models.
+Author: Yasushi Itoh
+Requires-Dist: annotated-types==0.7.0
+Requires-Dist: pydantic>=2.1.1
+Requires-Dist: grpcio>=1.56.2
+Requires-Dist: grpcio-tools>=1.56.2
+Requires-Dist: grpcio-reflection>=1.56.2
+Requires-Dist: grpcio-health-checking>=1.56.2
+Requires-Dist: connect-python>=0.5.0
+Requires-Dist: protoc-gen-connect-python>=0.1.0
+Requires-Dist: mcp>=1.9.4
+Requires-Dist: starlette>=0.27.0
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
 # 🚀 PydanticRPC
 
 **PydanticRPC** is a Python library that enables you to rapidly expose [Pydantic](https://docs.pydantic.dev/) models via [gRPC](https://grpc.io/)/[Connect RPC](https://connectrpc.com/docs/protocol/) services without writing any protobuf files. Instead, it automatically generates protobuf files on the fly from the method signatures of your Python objects and the type signatures of your Pydantic models.
@@ -1230,6 +1248,64 @@ class MyMessage(Message):
 
 This approach works because protobuf allows message types within `oneof` fields, and the collections are contained within those messages.
 
+## 🔧 Development
+
+This project uses [`just`](https://github.com/casey/just) as a command runner for development tasks.
+
+### Installing just
+
+**macOS:**
+```bash
+brew install just
+```
+
+**Linux:**
+```bash
+curl --proto '=https' --tlsv1.2 -sSf https://just.systems/install.sh | bash -s -- --to ~/bin
+```
+
+**Windows:**
+Download from [GitHub releases](https://github.com/casey/just/releases)
+
+### Quick Start
+
+```bash
+# Install dependencies
+just install
+
+# Run tests
+just test  # or just t
+
+# Format and lint code
+just format  # or just f
+just lint    # or just l
+
+# Run all checks (lint + tests)
+just check   # or just c
+
+# See all available commands
+just --list
+```
+
+### Running Examples
+
+```bash
+# Start servers
+just greeting-server  # gRPC server on port 50051
+just greeting-asgi    # Connect RPC ASGI on port 8000
+just greeting-wsgi    # Connect RPC WSGI on port 3000
+
+# Test with buf curl (in another terminal)
+just greet            # gRPC request
+just connect-greet    # Connect RPC request
+just wsgi-greet       # WSGI request
+
+# Custom names
+just greet-name Alice
+just connect-greet-name Bob
+```
+
+For more development commands and options, see the [Justfile](Justfile) or run `just --list`.
 
 ## TODO
 - [x] Streaming Support

pydantic_rpc-0.11.0/PKG-INFO → pydantic_rpc-0.13.0/README.md

@@ -1,20 +1,3 @@
-Metadata-Version: 2.3
-Name: pydantic-rpc
-Version: 0.11.0
-Summary: A Python library for building gRPC/ConnectRPC services with Pydantic models.
-Author: Yasushi Itoh
-Requires-Dist: annotated-types==0.7.0
-Requires-Dist: pydantic>=2.1.1
-Requires-Dist: grpcio>=1.56.2
-Requires-Dist: grpcio-tools>=1.56.2
-Requires-Dist: grpcio-reflection>=1.56.2
-Requires-Dist: grpcio-health-checking>=1.56.2
-Requires-Dist: connecpy>=2.2.0
-Requires-Dist: mcp>=1.9.4
-Requires-Dist: starlette>=0.27.0
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-
 # 🚀 PydanticRPC
 
 **PydanticRPC** is a Python library that enables you to rapidly expose [Pydantic](https://docs.pydantic.dev/) models via [gRPC](https://grpc.io/)/[Connect RPC](https://connectrpc.com/docs/protocol/) services without writing any protobuf files. Instead, it automatically generates protobuf files on the fly from the method signatures of your Python objects and the type signatures of your Pydantic models.
@@ -1247,6 +1230,64 @@ class MyMessage(Message):
 
 This approach works because protobuf allows message types within `oneof` fields, and the collections are contained within those messages.
 
+## 🔧 Development
+
+This project uses [`just`](https://github.com/casey/just) as a command runner for development tasks.
+
+### Installing just
+
+**macOS:**
+```bash
+brew install just
+```
+
+**Linux:**
+```bash
+curl --proto '=https' --tlsv1.2 -sSf https://just.systems/install.sh | bash -s -- --to ~/bin
+```
+
+**Windows:**
+Download from [GitHub releases](https://github.com/casey/just/releases)
+
+### Quick Start
+
+```bash
+# Install dependencies
+just install
+
+# Run tests
+just test  # or just t
+
+# Format and lint code
+just format  # or just f
+just lint    # or just l
+
+# Run all checks (lint + tests)
+just check   # or just c
+
+# See all available commands
+just --list
+```
+
+### Running Examples
+
+```bash
+# Start servers
+just greeting-server  # gRPC server on port 50051
+just greeting-asgi    # Connect RPC ASGI on port 8000
+just greeting-wsgi    # Connect RPC WSGI on port 3000
+
+# Test with buf curl (in another terminal)
+just greet            # gRPC request
+just connect-greet    # Connect RPC request
+just wsgi-greet       # WSGI request
+
+# Custom names
+just greet-name Alice
+just connect-greet-name Bob
+```
+
+For more development commands and options, see the [Justfile](Justfile) or run `just --list`.
 
 ## TODO
 - [x] Streaming Support

{pydantic_rpc-0.11.0 → pydantic_rpc-0.13.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pydantic-rpc"
-version = "0.11.0"
+version = "0.13.0"
 description = "A Python library for building gRPC/ConnectRPC services with Pydantic models."
 authors = [
     { name = "Yasushi Itoh" }
@@ -12,7 +12,8 @@ dependencies = [
     "grpcio-tools>=1.56.2",
     "grpcio-reflection>=1.56.2",
     "grpcio-health-checking>=1.56.2",
-    "connecpy>=2.2.0",
+    "connect-python>=0.5.0",
+    "protoc-gen-connect-python>=0.1.0",
     "mcp>=1.9.4",
     "starlette>=0.27.0",
 ]
@@ -32,6 +33,7 @@ dev-dependencies = [
     "pytest>=8.3.4",
     "pytest-asyncio>=0.20.3",
     "ruff>=0.9.4",
+    "uvicorn>=0.34.0",
 ]
 
 [tool.pytest.ini_options]

{pydantic_rpc-0.11.0 → pydantic_rpc-0.13.0}/src/pydantic_rpc/core.py

@@ -1,6 +1,9 @@
+import annotated_types
 import asyncio
 import datetime
 import enum
+import grpc
+import grpc_tools
 import importlib.util
 import inspect
 import os
@@ -8,11 +11,19 @@ import signal
 import sys
 import time
 import types
-from typing import Union
 from collections.abc import AsyncIterator, Awaitable, Callable, Iterable
 from concurrent import futures
+from connectrpc.code import Code as Errors
+# Protobuf Python modules for Timestamp, Duration (requires protobuf / grpcio)
+from google.protobuf import duration_pb2, timestamp_pb2, empty_pb2
+from grpc import ServicerContext
+from grpc_health.v1 import health_pb2, health_pb2_grpc
+from grpc_health.v1.health import HealthServicer
+from grpc_reflection.v1alpha import reflection
+from grpc_tools import protoc
 from pathlib import Path
 from posixpath import basename
+from pydantic import BaseModel, ValidationError
 from typing import (
     Any,
     Optional,
@@ -22,20 +33,10 @@ from typing import (
     cast,
     TypeGuard,
 )
+from typing import Union
+from typing import Union, Sequence, Tuple
+from concurrent.futures import Executor
 
-import annotated_types
-import grpc
-from grpc import ServicerContext
-import grpc_tools
-from connecpy.code import Code as Errors
-
-# Protobuf Python modules for Timestamp, Duration (requires protobuf / grpcio)
-from google.protobuf import duration_pb2, timestamp_pb2, empty_pb2
-from grpc_health.v1 import health_pb2, health_pb2_grpc
-from grpc_health.v1.health import HealthServicer
-from grpc_reflection.v1alpha import reflection
-from grpc_tools import protoc
-from pydantic import BaseModel, ValidationError
 from .decorators import get_method_options, has_http_option
 from .tls import GrpcTLSConfig
 
@@ -726,15 +727,15 @@ def connect_obj_with_stub_async(
     return ConcreteServiceClass
 
 
-def connect_obj_with_stub_connecpy(
-    connecpy_module: Any, pb2_module: Any, obj: object
+def connect_obj_with_stub_connect_python(
+    connect_python_module: Any, pb2_module: Any, obj: object
 ) -> type:
     """
-    Connect a Python service object to a Connecpy stub.
+    Connect a Python service object to a Connect Python stub.
     """
     service_class = obj.__class__
     stub_class_name = service_class.__name__
-    stub_class = getattr(connecpy_module, stub_class_name)
+    stub_class = getattr(connect_python_module, stub_class_name)
 
     class ConcreteServiceClass(stub_class):
         pass
@@ -845,15 +846,15 @@ def connect_obj_with_stub_connecpy(
     return ConcreteServiceClass
 
 
-def connect_obj_with_stub_async_connecpy(
-    connecpy_module: Any, pb2_module: Any, obj: object
+def connect_obj_with_stub_async_connect_python(
+    connect_python_module: Any, pb2_module: Any, obj: object
 ) -> type:
     """
-    Connect a Python service object to a Connecpy stub for async methods with streaming support.
+    Connect a Python service object to a Connect Python stub for async methods with streaming support.
     """
     service_class = obj.__class__
     stub_class_name = service_class.__name__
-    stub_class = getattr(connecpy_module, stub_class_name)
+    stub_class = getattr(connect_python_module, stub_class_name)
 
     class ConcreteServiceClass(stub_class):
         pass
@@ -2030,10 +2031,10 @@ def generate_grpc_code(proto_path: Path) -> types.ModuleType | None:
     return module
 
 
-def generate_connecpy_code(proto_path: Path) -> types.ModuleType | None:
+def generate_connect_python_code(proto_path: Path) -> types.ModuleType | None:
     """
-    Run protoc with the Connecpy plugin to generate Python Connecpy code from proto_path.
-    Writes foo_connecpy.py next to proto_path, then imports and returns that module.
+    Run protoc with the Connect Python plugin to generate Python Connect code from proto_path.
+    Writes foo_connect_python.py next to proto_path, then imports and returns that module.
     """
     # 1) Ensure the .proto exists
     if not proto_path.is_file():
@@ -2051,7 +2052,7 @@ def generate_connecpy_code(proto_path: Path) -> types.ModuleType | None:
         "protoc",  # Dummy program name (required for protoc.main)
         "-I.",
         f"-I{well_known_path}",
-        f"--connecpy_out={out_str}",
+        f"--connect-python_out={out_str}",
         proto_path.name,
     ]
 
@@ -2065,7 +2066,7 @@ def generate_connecpy_code(proto_path: Path) -> types.ModuleType | None:
 
     # 4) Locate the generated file
     base_name = proto_path.stem  # "foo"
-    generated_filename = f"{base_name}_connecpy.py"  # "foo_connecpy.py"
+    generated_filename = f"{base_name}_connect.py"  # "foo_connect.py"
     generated_filepath = out_dir / generated_filename
 
     # 5) Add out_dir to sys.path so we can import by filename
@@ -2074,7 +2075,7 @@ def generate_connecpy_code(proto_path: Path) -> types.ModuleType | None:
 
     # 6) Load and return the module
     spec = importlib.util.spec_from_file_location(
-        base_name + "_connecpy", str(generated_filepath)
+        base_name + "_connect", str(generated_filepath)
     )
     if spec is None or spec.loader is None:
         return None
@@ -2259,7 +2260,7 @@ def get_proto_path(proto_filename: str) -> Path:
     return base / proto_filename
 
 
-def generate_and_compile_proto_using_connecpy(
+def generate_and_compile_proto_using_connect_python(
     obj: object,
     package_name: str = "",
     existing_proto_path: Path | None = None,
@@ -2268,7 +2269,7 @@ def generate_and_compile_proto_using_connecpy(
         import importlib
 
         pb2_module = None
-        connecpy_module = None
+        connect_python_module = None
 
         try:
             pb2_module = importlib.import_module(
@@ -2278,14 +2279,14 @@ def generate_and_compile_proto_using_connecpy(
             pass
 
         try:
-            connecpy_module = importlib.import_module(
-                f"{obj.__class__.__name__.lower()}_connecpy"
+            connect_python_module = importlib.import_module(
+                f"{obj.__class__.__name__.lower()}_connect"
             )
         except ImportError:
             pass
 
-        if connecpy_module is not None and pb2_module is not None:
-            return connecpy_module, pb2_module
+        if connect_python_module is not None and pb2_module is not None:
+            return connect_python_module, pb2_module
 
         # If the modules are not found, generate and compile the proto files.
 
@@ -2306,10 +2307,10 @@ def generate_and_compile_proto_using_connecpy(
     if gen_pb is None:
         raise Exception("Generating pb code")
 
-    gen_connecpy = generate_connecpy_code(proto_file_path)
-    if gen_connecpy is None:
-        raise Exception("Generating Connecpy code")
-    return gen_connecpy, gen_pb
+    gen_connect_python = generate_connect_python_code(proto_file_path)
+    if gen_connect_python is None:
+        raise Exception("Generating Connect Python code")
+    return gen_connect_python, gen_pb
 
 
 def is_combined_proto_enabled() -> bool:
@@ -2711,10 +2712,22 @@ class AsyncIOServer:
         service: Optional[object] = None,
         port: int = 50051,
         package_name: str = "",
-        *interceptors: grpc.ServerInterceptor,
         tls: Optional["GrpcTLSConfig"] = None,
+        interceptors: Optional[Sequence[grpc.ServerInterceptor]] = None,
+        migration_thread_pool: Optional[Executor] = None,
+        handlers: Optional[Sequence[grpc.GenericRpcHandler]] = None,
+        options: Optional[Sequence[Tuple[str, Any]]] = None,
+        maximum_concurrent_rpcs: Optional[int] = None,
+        compression: Optional[grpc.Compression] = None,
     ) -> None:
-        self._server: grpc.aio.Server = grpc.aio.server(interceptors=interceptors)
+        self._server: grpc.aio.Server = grpc.aio.server(
+            migration_thread_pool=migration_thread_pool,
+            handlers=handlers,
+            interceptors=interceptors,
+            options=options,
+            maximum_concurrent_rpcs=maximum_concurrent_rpcs,
+            compression=compression,
+        )
         self._service_names: list[str] = []
         self._package_name: str = package_name
         self._port: int = port
@@ -2804,20 +2817,24 @@ class AsyncIOServer:
         await self._server.stop(10)
         print("gRPC server shutdown.")
 
+    async def stop(self, grace: float = 10.0):
+        """Stop the gRPC server gracefully."""
+        await self._server.stop(grace)
 
-def get_connecpy_asgi_app_class(connecpy_module: Any, service_name: str):
-    """Get the ASGI application class from connecpy module (Connecpy v2.x)."""
-    return getattr(connecpy_module, f"{service_name}ASGIApplication")
 
+def get_connect_python_asgi_app_class(connect_python_module: Any, service_name: str):
+    """Get the ASGI application class from connect-python module."""
+    return getattr(connect_python_module, f"{service_name}ASGIApplication")
 
-def get_connecpy_wsgi_app_class(connecpy_module: Any, service_name: str):
-    """Get the WSGI application class from connecpy module (Connecpy v2.x)."""
-    return getattr(connecpy_module, f"{service_name}WSGIApplication")
+
+def get_connect_python_wsgi_app_class(connect_python_module: Any, service_name: str):
+    """Get the WSGI application class from connect-python module."""
+    return getattr(connect_python_module, f"{service_name}WSGIApplication")
 
 
 class ASGIApp:
     """
-    An ASGI-compatible application that can serve Connect-RPC via Connecpy.
+    An ASGI-compatible application that can serve Connect-RPC via connect-python.
     """
 
     def __init__(self, service: Optional[object] = None, package_name: str = ""):
@@ -2828,23 +2845,25 @@ class ASGIApp:
 
     def mount(self, obj: object, package_name: str = ""):
         """Generate and compile proto files, then mount the async service implementation."""
-        connecpy_module, pb2_module = generate_and_compile_proto_using_connecpy(
-            obj, package_name
+        connect_python_module, pb2_module = (
+            generate_and_compile_proto_using_connect_python(obj, package_name)
         )
-        self.mount_using_pb2_modules(connecpy_module, pb2_module, obj)
+        self.mount_using_pb2_modules(connect_python_module, pb2_module, obj)
 
     def mount_using_pb2_modules(
-        self, connecpy_module: Any, pb2_module: Any, obj: object
+        self, connect_python_module: Any, pb2_module: Any, obj: object
     ):
-        """Connect the compiled connecpy and pb2 modules with the async service implementation."""
-        concreteServiceClass = connect_obj_with_stub_async_connecpy(
-            connecpy_module, pb2_module, obj
+        """Connect the compiled connect-python and pb2 modules with the async service implementation."""
+        concreteServiceClass = connect_obj_with_stub_async_connect_python(
+            connect_python_module, pb2_module, obj
         )
         service_name = obj.__class__.__name__
         service_impl = concreteServiceClass()
 
         # Get the service-specific ASGI application class
-        app_class = get_connecpy_asgi_app_class(connecpy_module, service_name)
+        app_class = get_connect_python_asgi_app_class(
+            connect_python_module, service_name
+        )
         app = app_class(service=service_impl)
 
         # Store the app and its path for routing
@@ -2899,7 +2918,7 @@ class ASGIApp:
 
 class WSGIApp:
     """
-    A WSGI-compatible application that can serve Connect-RPC via Connecpy.
+    A WSGI-compatible application that can serve Connect-RPC via connect-python.
     """
 
     def __init__(self, service: Optional[object] = None, package_name: str = ""):
@@ -2910,23 +2929,25 @@ class WSGIApp:
 
     def mount(self, obj: object, package_name: str = ""):
         """Generate and compile proto files, then mount the sync service implementation."""
-        connecpy_module, pb2_module = generate_and_compile_proto_using_connecpy(
-            obj, package_name
+        connect_python_module, pb2_module = (
+            generate_and_compile_proto_using_connect_python(obj, package_name)
         )
-        self.mount_using_pb2_modules(connecpy_module, pb2_module, obj)
+        self.mount_using_pb2_modules(connect_python_module, pb2_module, obj)
 
     def mount_using_pb2_modules(
-        self, connecpy_module: Any, pb2_module: Any, obj: object
+        self, connect_python_module: Any, pb2_module: Any, obj: object
     ):
-        """Connect the compiled connecpy and pb2 modules with the sync service implementation."""
-        concreteServiceClass = connect_obj_with_stub_connecpy(
-            connecpy_module, pb2_module, obj
+        """Connect the compiled connect-python and pb2 modules with the sync service implementation."""
+        concreteServiceClass = connect_obj_with_stub_connect_python(
+            connect_python_module, pb2_module, obj
         )
         service_name = obj.__class__.__name__
         service_impl = concreteServiceClass()
 
         # Get the service-specific WSGI application class
-        app_class = get_connecpy_wsgi_app_class(connecpy_module, service_name)
+        app_class = get_connect_python_wsgi_app_class(
+            connect_python_module, service_name
+        )
         app = app_class(service=service_impl)
 
         # Store the app and its path for routing

{pydantic_rpc-0.11.0 → pydantic_rpc-0.13.0}/src/pydantic_rpc/decorators.py

@@ -3,7 +3,7 @@
 from typing import Any, Callable, Dict, List, Optional, TypeVar, Type
 from functools import wraps
 import grpc
-from connecpy.code import Code as ConnectErrors
+from connectrpc.code import Code as ConnectErrors
 
 from .options import OptionMetadata, OPTION_METADATA_ATTR