pydantic-rpc 0.10.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

pydantic_rpc/__init__.py

@@ -13,6 +13,8 @@ from .decorators import (
     proto_option,
     get_method_options,
     has_http_option,
+    error_handler,
+    get_error_handlers,
 )
 from .tls import (
     GrpcTLSConfig,
@@ -31,6 +33,8 @@ __all__ = [
     "proto_option",
     "get_method_options",
     "has_http_option",
+    "error_handler",
+    "get_error_handlers",
     "GrpcTLSConfig",
     "extract_peer_identity",
     "extract_peer_certificate_chain",

pydantic_rpc/core.py

@@ -27,7 +27,7 @@ import annotated_types
 import grpc
 from grpc import ServicerContext
 import grpc_tools
-from connecpy.code import Code as Errors
+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
@@ -726,15 +726,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 +845,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 +2030,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 +2051,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 +2065,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 +2074,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 +2259,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 +2268,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 +2278,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 +2306,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:
@@ -2606,6 +2606,9 @@ class Server:
 
     def __init__(
         self,
+        service: Optional[object] = None,
+        port: int = 50051,
+        package_name: str = "",
         max_workers: int = 8,
         *interceptors: Any,
         tls: Optional["GrpcTLSConfig"] = None,
@@ -2614,9 +2617,10 @@ class Server:
             futures.ThreadPoolExecutor(max_workers), interceptors=interceptors
         )
         self._service_names: list[str] = []
-        self._package_name: str = ""
-        self._port: int = 50051
+        self._package_name: str = package_name
+        self._port: int = port
         self._tls_config = tls
+        self._initial_service = service
 
     def set_package_name(self, package_name: str):
         """Set the package name for .proto generation."""
@@ -2654,6 +2658,11 @@ class Server:
         Mount multiple services and run the gRPC server with reflection and health check.
         Press Ctrl+C or send SIGTERM to stop.
         """
+        # Mount initial service if provided
+        if self._initial_service:
+            self.mount(self._initial_service, self._package_name)
+
+        # Mount additional services
         for obj in objs:
             self.mount(obj, self._package_name)
 
@@ -2699,14 +2708,18 @@ class AsyncIOServer:
 
     def __init__(
         self,
+        service: Optional[object] = None,
+        port: int = 50051,
+        package_name: str = "",
         *interceptors: grpc.ServerInterceptor,
         tls: Optional["GrpcTLSConfig"] = None,
     ) -> None:
         self._server: grpc.aio.Server = grpc.aio.server(interceptors=interceptors)
         self._service_names: list[str] = []
-        self._package_name: str = ""
-        self._port: int = 50051
+        self._package_name: str = package_name
+        self._port: int = port
         self._tls_config = tls
+        self._initial_service = service
 
     def set_package_name(self, package_name: str):
         """Set the package name for .proto generation."""
@@ -2746,6 +2759,11 @@ class AsyncIOServer:
         Mount multiple async services and run the gRPC server with reflection and health check.
         Press Ctrl+C or send SIGTERM to stop.
         """
+        # Mount initial service if provided
+        if self._initial_service:
+            self.mount(self._initial_service, self._package_name)
+
+        # Mount additional services
         for obj in objs:
             self.mount(obj, self._package_name)
 
@@ -2786,46 +2804,53 @@ 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):
+    def __init__(self, service: Optional[object] = None, package_name: str = ""):
         self._services: list[tuple[Any, str]] = []  # List of (app, path) tuples
         self._service_names: list[str] = []
-        self._package_name: str = ""
+        self._package_name: str = package_name
+        self._initial_service = service
 
     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
@@ -2838,6 +2863,11 @@ class ASGIApp:
 
     def mount_objs(self, *objs: object):
         """Mount multiple service objects into this ASGI app."""
+        # Mount initial service if provided
+        if self._initial_service:
+            self.mount(self._initial_service, self._package_name)
+
+        # Mount additional services
         for obj in objs:
             self.mount(obj, self._package_name)
 
@@ -2848,6 +2878,10 @@ class ASGIApp:
         send: Callable[[dict[str, Any]], Any],
     ):
         """ASGI entry point with routing for multiple services."""
+        # Mount initial service on first call if not already mounted
+        if self._initial_service and not self._services:
+            self.mount(self._initial_service, self._package_name)
+
         if scope["type"] != "http":
             await send({"type": "http.response.start", "status": 404})
             await send({"type": "http.response.body", "body": b"Not Found"})
@@ -2871,33 +2905,36 @@ 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):
+    def __init__(self, service: Optional[object] = None, package_name: str = ""):
         self._services: list[tuple[Any, str]] = []  # List of (app, path) tuples
         self._service_names: list[str] = []
-        self._package_name: str = ""
+        self._package_name: str = package_name
+        self._initial_service = service
 
     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
@@ -2910,6 +2947,11 @@ class WSGIApp:
 
     def mount_objs(self, *objs: object):
         """Mount multiple service objects into this WSGI app."""
+        # Mount initial service if provided
+        if self._initial_service:
+            self.mount(self._initial_service, self._package_name)
+
+        # Mount additional services
         for obj in objs:
             self.mount(obj, self._package_name)
 
@@ -2921,6 +2963,10 @@ class WSGIApp:
         ],
     ) -> Iterable[bytes]:
         """WSGI entry point with routing for multiple services."""
+        # Mount initial service on first call if not already mounted
+        if self._initial_service and not self._services:
+            self.mount(self._initial_service, self._package_name)
+
         path = environ.get("PATH_INFO", "")
 
         # Route to the appropriate service based on path

pydantic_rpc/decorators.py

@@ -1,12 +1,15 @@
 """Decorators for adding protobuf options to RPC methods."""
 
-from typing import Any, Callable, Dict, List, Optional, TypeVar
+from typing import Any, Callable, Dict, List, Optional, TypeVar, Type
 from functools import wraps
+import grpc
+from connectrpc.code import Code as ConnectErrors
 
 from .options import OptionMetadata, OPTION_METADATA_ATTR
 
 
 F = TypeVar("F", bound=Callable[..., Any])
+ERROR_HANDLER_ATTR = "__pydantic_rpc_error_handlers__"
 
 
 def http_option(
@@ -136,3 +139,71 @@ def has_proto_options(method: Callable) -> bool:
     """
     metadata = get_method_options(method)
     return metadata is not None and len(metadata.proto_options) > 0
+
+
+def error_handler(
+    exception_type: Type[Exception],
+    status_code: Optional[grpc.StatusCode] = None,
+    connect_code: Optional[ConnectErrors] = None,
+    handler: Optional[Callable[[Exception], tuple[str, Any]]] = None,
+) -> Callable[[F], F]:
+    """
+    Decorator to add automatic error handling to an RPC method.
+
+    Args:
+        exception_type: The type of exception to handle
+        status_code: The gRPC status code to return (for gRPC services)
+        connect_code: The Connect error code to return (for Connect services)
+        handler: Optional custom handler function that returns (message, details)
+
+    Example:
+        @error_handler(ValidationError, status_code=grpc.StatusCode.INVALID_ARGUMENT)
+        @error_handler(KeyError, status_code=grpc.StatusCode.NOT_FOUND)
+        async def get_user(self, request: GetUserRequest) -> User:
+            ...
+    """
+
+    def decorator(func: F) -> F:
+        # Get or create error handlers list
+        if not hasattr(func, ERROR_HANDLER_ATTR):
+            setattr(func, ERROR_HANDLER_ATTR, [])
+
+        handlers = getattr(func, ERROR_HANDLER_ATTR)
+
+        # Add this handler to the list
+        handlers.append(
+            {
+                "exception_type": exception_type,
+                "status_code": status_code or grpc.StatusCode.INTERNAL,
+                "connect_code": connect_code or ConnectErrors.INTERNAL,
+                "handler": handler,
+            }
+        )
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        # Preserve the error handlers on the wrapper
+        setattr(wrapper, ERROR_HANDLER_ATTR, handlers)
+
+        # Preserve any existing option metadata
+        if hasattr(func, OPTION_METADATA_ATTR):
+            setattr(wrapper, OPTION_METADATA_ATTR, getattr(func, OPTION_METADATA_ATTR))
+
+        return wrapper  # type: ignore
+
+    return decorator
+
+
+def get_error_handlers(method: Callable) -> Optional[List[Dict[str, Any]]]:
+    """
+    Get error handlers from a method.
+
+    Args:
+        method: The method to get error handlers from
+
+    Returns:
+        List of error handler configurations if present, None otherwise
+    """
+    return getattr(method, ERROR_HANDLER_ATTR, None)

{pydantic_rpc-0.10.0.dist-info → pydantic_rpc-0.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pydantic-rpc
-Version: 0.10.0
+Version: 0.12.0
 Summary: A Python library for building gRPC/ConnectRPC services with Pydantic models.
 Author: Yasushi Itoh
 Requires-Dist: annotated-types==0.7.0
@@ -9,7 +9,8 @@ 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: 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
@@ -62,9 +63,10 @@ class OlympicsLocationAgent:
 
 
 if __name__ == "__main__":
-    s = AsyncIOServer()
+    # New enhanced initialization API (optional - backward compatible)
+    s = AsyncIOServer(service=OlympicsLocationAgent(), port=50051)
     loop = asyncio.get_event_loop()
-    loop.run_until_complete(s.run(OlympicsLocationAgent()))
+    loop.run_until_complete(s.run())
 ```
 
 And here is an example of a simple Connect RPC service that exposes the same agent as an ASGI application:
@@ -106,8 +108,8 @@ class OlympicsLocationAgent:
         result = await self._agent.run(req.prompt())
         return result.data
 
-app = ASGIApp()
-app.mount(OlympicsLocationAgent())
+# New enhanced initialization API (optional - backward compatible)
+app = ASGIApp(service=OlympicsLocationAgent())
 
 ```
 
@@ -129,6 +131,17 @@ app.mount(OlympicsLocationAgent())
 - 🛠️ **Pre-generated Protobuf Files and Code:** Pre-generate proto files and corresponding code via the CLI. By setting the environment variable (PYDANTIC_RPC_SKIP_GENERATION), you can skip runtime generation.
 - 🤖 **MCP (Model Context Protocol) Support:** Expose your services as tools for AI assistants using the official MCP SDK, supporting both stdio and HTTP/SSE transports.
 
+## ⚠️ Important Notes for Connect-RPC
+
+When using Connect-RPC with ASGIApp:
+
+- **Endpoint Path Format**: Connect-RPC endpoints use CamelCase method names in the path: `/<package>.<service>/<Method>` (e.g., `/chat.v1.ChatService/SendMessage`)
+- **Content-Type**: Set `Content-Type: application/json` or `application/connect+json` for requests
+- **HTTP/2 Requirement**: Bidirectional streaming requires HTTP/2. Use Hypercorn instead of uvicorn for HTTP/2 support
+- **Testing**: Use [buf curl](https://buf.build/docs/ecosystem/cli/curl) for testing Connect-RPC endpoints with proper streaming support
+
+For detailed examples and testing instructions, see the [examples directory](examples/).
+
 ## 📦 Installation
 
 Install PydanticRPC via pip:
@@ -137,6 +150,54 @@ Install PydanticRPC via pip:
 pip install pydantic-rpc
 ```
 
+For CLI support with built-in server runners:
+
+```bash
+pip install pydantic-rpc-cli  # Includes hypercorn and gunicorn
+```
+
+## 🆕 Enhanced Features (v0.10.0+)
+
+**Note: All new features are fully backward compatible. Existing code continues to work without modification.**
+
+### Enhanced Initialization API
+All server classes now support optional initialization with services:
+
+```python
+# Traditional API (still works)
+server = AsyncIOServer()
+server.set_port(50051)
+await server.run(MyService())
+
+# New enhanced API (optional)
+server = AsyncIOServer(
+    service=MyService(),
+    port=50051,
+    package_name="my.package"
+)
+await server.run()
+
+# Same for ASGI/WSGI apps
+app = ASGIApp(service=MyService(), package_name="my.package")
+```
+
+### Error Handling with Decorators
+Automatically map exceptions to gRPC/Connect status codes:
+
+```python
+from pydantic_rpc import error_handler
+import grpc
+
+class MyService:
+    @error_handler(ValidationError, status_code=grpc.StatusCode.INVALID_ARGUMENT)
+    @error_handler(KeyError, status_code=grpc.StatusCode.NOT_FOUND)
+    async def get_user(self, request: GetUserRequest) -> User:
+        # Exceptions are automatically converted to proper status codes
+        if request.id not in users_db:
+            raise KeyError(f"User {request.id} not found")
+        return users_db[request.id]
+```
+
 ## 🚀 Getting Started
 
 PydanticRPC supports two main protocols:
@@ -1090,15 +1151,40 @@ MCP endpoints will be available at:
 - SSE: `GET http://localhost:8000/mcp/sse`
 - Messages: `POST http://localhost:8000/mcp/messages/`
 
-### 🗄️ Protobuf file and code (Python files) generation using CLI
+### 🗄️ CLI Tool (pydantic-rpc-cli)
+
+The CLI tool provides powerful features for generating protobuf files and running servers. Install it separately:
+
+```bash
+pip install pydantic-rpc-cli
+```
+
+#### Generate Protobuf Files
 
-You can genereate protobuf files and code for a given module and a specified class using `pydantic-rpc` CLI command:
+```bash
+# Generate .proto file from a service class
+pydantic-rpc generate myapp.services.UserService --output ./proto/
+
+# Also compile to Python code
+pydantic-rpc generate myapp.services.UserService --compile
+```
+
+#### Run Servers Directly
+
+The CLI can run any type of server:
 
 ```bash
-pydantic-rpc a_module.py aClassName
+# Run as gRPC server (auto-detects async/sync)
+pydantic-rpc serve myapp.services.UserService --port 50051
+
+# Run as Connect-RPC with ASGI (HTTP/2, uses Hypercorn)
+pydantic-rpc serve myapp.services.UserService --asgi --port 8000
+
+# Run as Connect-RPC with WSGI (HTTP/1.1, uses Gunicorn)
+pydantic-rpc serve myapp.services.UserService --wsgi --port 8000 --workers 4
 ```
 
-Using this generated proto file and tools as `protoc`, `buf` and `BSR`, you could generate code for any desired language other than Python.
+Using the generated proto files with tools like `protoc`, `buf` and `BSR`, you can generate code for any desired language.
 
 
 ## 📖 Data Type Mapping
@@ -1162,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.10.0.dist-info → pydantic_rpc-0.12.0.dist-info}/RECORD

@@ -1,13 +1,12 @@
-pydantic_rpc/__init__.py,sha256=a8c4ed1a731b7f601006cbbd4aff16d43bbca0b7ffb02c698f1c79dccefe2f8e,781
-pydantic_rpc/core.py,sha256=b2867838460a23b1ce302c9d7e6ef2a2e711c6c84887a50e3ad40b94ff5dc53c,112505
-pydantic_rpc/decorators.py,sha256=2f2dc3f642a6e40d05187901e75269415a70b8f18d555e6c7ac923dee149d34c,3852
+pydantic_rpc/__init__.py,sha256=c5e0b5d4ed6de3e3c7c1ada5389e704ce149ea56ca0930392db6abdf222b4e86,871
+pydantic_rpc/core.py,sha256=450c03111224052a3e2b85567ffd16a0ff6dd4d6f02bcfa23c09f6d39cf30861,114578
+pydantic_rpc/decorators.py,sha256=94d87825e034b6303df46dd74e6c8c7ed5c88133aa504d61249a83dbf82f1de3,6219
 pydantic_rpc/mcp/__init__.py,sha256=f05ad62cc38db5c5972e16870c484523c58c5ac650d8454706f1ce4539cc7a52,123
 pydantic_rpc/mcp/converter.py,sha256=b60dcaf82e6bff6be4b2ab8b1e9f2d16e09cb98d8f00182a4f6f73d1a78848a4,4158
 pydantic_rpc/mcp/exporter.py,sha256=20833662f9a973ed9e1a705b9b59aaa2533de6c514ebd87ef66664a430a0d04f,10239
 pydantic_rpc/options.py,sha256=6094036184a500b92715fd91d31ecc501460a56de47dcf6024c6335ae8e5d6e3,4561
 pydantic_rpc/py.typed,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
 pydantic_rpc/tls.py,sha256=0eb290cc09c8ebedc71e7a97c01736d9675a314f70ebd80a2ce73e3f1689d359,3567
-pydantic_rpc-0.10.0.dist-info/WHEEL,sha256=ab6157bc637547491fb4567cd7ddf26b04d63382916ca16c29a5c8e94c9c9ef7,79
-pydantic_rpc-0.10.0.dist-info/entry_points.txt,sha256=72a47b1d2cae3abc045710fe0c2c2e6dfbb051fbf6960c22b62488004e9188ba,57
-pydantic_rpc-0.10.0.dist-info/METADATA,sha256=8819d19940dcb5a2718e9455725e976babebeeee32ba2b016135f29ba3dda67c,32096
-pydantic_rpc-0.10.0.dist-info/RECORD,,
+pydantic_rpc-0.12.0.dist-info/WHEEL,sha256=ab6157bc637547491fb4567cd7ddf26b04d63382916ca16c29a5c8e94c9c9ef7,79
+pydantic_rpc-0.12.0.dist-info/METADATA,sha256=daa91c220e04adae53cb3e654d249f2feaca8e461f84e9d03f70fad2b48e403b,36156
+pydantic_rpc-0.12.0.dist-info/RECORD,,

pydantic_rpc-0.10.0.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-pydantic-rpc = pydantic_rpc.core:main
-