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

{pydantic_rpc-0.13.0 → pydantic_rpc-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pydantic-rpc
-Version: 0.13.0
+Version: 0.15.0
 Summary: A Python library for building gRPC/ConnectRPC services with Pydantic models.
 Author: Yasushi Itoh
 Requires-Dist: annotated-types==0.7.0
@@ -125,7 +125,7 @@ app = ASGIApp(service=OlympicsLocationAgent())
   - 🔎 **Server Reflection:** Built-in support for gRPC server reflection.
   - ⚡ **Asynchronous Support:** Easily create asynchronous gRPC services with `AsyncIOServer`.
 - **For Connect-RPC:**
-  - 🌐 **Full Protocol Support:** Native Connect-RPC support via `Connecpy` v2.2.0+
+  - 🌐 **Full Protocol Support:** Native Connect-RPC support via `connect-python`
   - 🔄 **All Streaming Patterns:** Unary, server streaming, client streaming, and bidirectional streaming
   - 🌐 **WSGI/ASGI Applications:** Run as standard WSGI or ASGI applications for easy deployment
 - 🛠️ **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.
@@ -304,21 +304,21 @@ app.mount(Greeter())
 
 ### 🏆 Connect-RPC with Streaming Example
 
-PydanticRPC provides native Connect-RPC support via Connecpy v2.2.0+, including full streaming capabilities and PEP 8 naming conventions. Check out our ASGI examples:
+PydanticRPC provides native Connect-RPC support via connect-python, including full streaming capabilities and PEP 8 naming conventions. Check out our ASGI examples:
 
 ```bash
 # Run with uvicorn
 uv run uvicorn greeting_asgi:app --port 3000
 
 # Or run streaming example
-uv run python examples/streaming_connecpy.py
+uv run python examples/streaming_connect_python.py
 ```
 
-This will launch a Connecpy-based ASGI application that uses the same Pydantic models to serve Connect-RPC requests.
+This will launch a connect-python-based ASGI application that uses the same Pydantic models to serve Connect-RPC requests.
 
-#### Streaming Support with Connecpy
+#### Streaming Support with connect-python
 
-Connecpy v2.2.0 provides full support for streaming RPCs with automatic PEP 8 naming (snake_case):
+connect-python provides full support for streaming RPCs with automatic PEP 8 naming (snake_case):
 
 ```python
 from typing import AsyncIterator
@@ -359,14 +359,7 @@ app.mount(StreamingService())
 ```
 
 > [!NOTE]
-> Please install `protoc-gen-connecpy` to run the Connecpy example.
->
-> 1. Install Go.
->     - Please follow the instruction described in https://go.dev/doc/install.
-> 2. Install `protoc-gen-connecpy`:
->     ```bash
->     go install github.com/i2y/connecpy/v2/protoc-gen-connecpy@latest
->     ```
+> Please install `protoc-gen-connect-python` to run the connect-python example.
 
 ## ♻️ Skipping Protobuf Generation
 By default, PydanticRPC generates .proto files and code at runtime. If you wish to skip the code-generation step (for example, in production environment), set the environment variable below:
@@ -375,9 +368,9 @@ By default, PydanticRPC generates .proto files and code at runtime. If you wish
 export PYDANTIC_RPC_SKIP_GENERATION=true
 ```
 
-When this variable is set to "true", PydanticRPC will load existing pre-generated modules rather than generating them on the fly.
+When this variable is set to "true", PydanticRPC will load existing pre-generated modules rather than generating theƒm on the fly.
 
-## 🪧 Setting Protobuf and Connecpy/gRPC generation directory
+## 🪧 Setting Protobuf and Connect RPC/gRPC generation directory
 By default your files will be generated in the current working directory where you ran the code from, but you can set a custom specific directory by setting the environment variable below:
 
 ```bash

{pydantic_rpc-0.13.0 → pydantic_rpc-0.15.0}/README.md

@@ -107,7 +107,7 @@ app = ASGIApp(service=OlympicsLocationAgent())
   - 🔎 **Server Reflection:** Built-in support for gRPC server reflection.
   - ⚡ **Asynchronous Support:** Easily create asynchronous gRPC services with `AsyncIOServer`.
 - **For Connect-RPC:**
-  - 🌐 **Full Protocol Support:** Native Connect-RPC support via `Connecpy` v2.2.0+
+  - 🌐 **Full Protocol Support:** Native Connect-RPC support via `connect-python`
   - 🔄 **All Streaming Patterns:** Unary, server streaming, client streaming, and bidirectional streaming
   - 🌐 **WSGI/ASGI Applications:** Run as standard WSGI or ASGI applications for easy deployment
 - 🛠️ **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.
@@ -286,21 +286,21 @@ app.mount(Greeter())
 
 ### 🏆 Connect-RPC with Streaming Example
 
-PydanticRPC provides native Connect-RPC support via Connecpy v2.2.0+, including full streaming capabilities and PEP 8 naming conventions. Check out our ASGI examples:
+PydanticRPC provides native Connect-RPC support via connect-python, including full streaming capabilities and PEP 8 naming conventions. Check out our ASGI examples:
 
 ```bash
 # Run with uvicorn
 uv run uvicorn greeting_asgi:app --port 3000
 
 # Or run streaming example
-uv run python examples/streaming_connecpy.py
+uv run python examples/streaming_connect_python.py
 ```
 
-This will launch a Connecpy-based ASGI application that uses the same Pydantic models to serve Connect-RPC requests.
+This will launch a connect-python-based ASGI application that uses the same Pydantic models to serve Connect-RPC requests.
 
-#### Streaming Support with Connecpy
+#### Streaming Support with connect-python
 
-Connecpy v2.2.0 provides full support for streaming RPCs with automatic PEP 8 naming (snake_case):
+connect-python provides full support for streaming RPCs with automatic PEP 8 naming (snake_case):
 
 ```python
 from typing import AsyncIterator
@@ -341,14 +341,7 @@ app.mount(StreamingService())
 ```
 
 > [!NOTE]
-> Please install `protoc-gen-connecpy` to run the Connecpy example.
->
-> 1. Install Go.
->     - Please follow the instruction described in https://go.dev/doc/install.
-> 2. Install `protoc-gen-connecpy`:
->     ```bash
->     go install github.com/i2y/connecpy/v2/protoc-gen-connecpy@latest
->     ```
+> Please install `protoc-gen-connect-python` to run the connect-python example.
 
 ## ♻️ Skipping Protobuf Generation
 By default, PydanticRPC generates .proto files and code at runtime. If you wish to skip the code-generation step (for example, in production environment), set the environment variable below:
@@ -357,9 +350,9 @@ By default, PydanticRPC generates .proto files and code at runtime. If you wish
 export PYDANTIC_RPC_SKIP_GENERATION=true
 ```
 
-When this variable is set to "true", PydanticRPC will load existing pre-generated modules rather than generating them on the fly.
+When this variable is set to "true", PydanticRPC will load existing pre-generated modules rather than generating theƒm on the fly.
 
-## 🪧 Setting Protobuf and Connecpy/gRPC generation directory
+## 🪧 Setting Protobuf and Connect RPC/gRPC generation directory
 By default your files will be generated in the current working directory where you ran the code from, but you can set a custom specific directory by setting the environment variable below:
 
 ```bash

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

@@ -1,6 +1,6 @@
 [project]
 name = "pydantic-rpc"
-version = "0.13.0"
+version = "0.15.0"
 description = "A Python library for building gRPC/ConnectRPC services with Pydantic models."
 authors = [
     { name = "Yasushi Itoh" }

{pydantic_rpc-0.13.0 → pydantic_rpc-0.15.0}/src/pydantic_rpc/__init__.py

@@ -15,6 +15,7 @@ from .decorators import (
     has_http_option,
     error_handler,
     get_error_handlers,
+    invoke_error_handler,
 )
 from .tls import (
     GrpcTLSConfig,
@@ -35,6 +36,7 @@ __all__ = [
     "has_http_option",
     "error_handler",
     "get_error_handlers",
+    "invoke_error_handler",
     "GrpcTLSConfig",
     "extract_peer_identity",
     "extract_peer_certificate_chain",

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

@@ -11,9 +11,11 @@ import signal
 import sys
 import time
 import types
-from collections.abc import AsyncIterator, Awaitable, Callable, Iterable
+from collections.abc import AsyncIterator, Awaitable, Callable, Iterable, Sequence
 from concurrent import futures
 from connectrpc.code import Code as Errors
+from connectrpc.errors import ConnectError
+
 # Protobuf Python modules for Timestamp, Duration (requires protobuf / grpcio)
 from google.protobuf import duration_pb2, timestamp_pb2, empty_pb2
 from grpc import ServicerContext
@@ -32,12 +34,17 @@ from typing import (
     get_origin,
     cast,
     TypeGuard,
+    Union,
+    Tuple,
 )
-from typing import Union
-from typing import Union, Sequence, Tuple
 from concurrent.futures import Executor
 
-from .decorators import get_method_options, has_http_option
+from .decorators import (
+    get_method_options,
+    has_http_option,
+    get_error_handlers,
+    invoke_error_handler,
+)
 from .tls import GrpcTLSConfig
 
 ###############################################################################
@@ -309,6 +316,116 @@ def generate_message_converter(
     return converter
 
 
+def handle_validation_error_sync(
+    exc: ValidationError,
+    method: Callable,
+    context: Any,
+    request: Any = None,
+    is_grpc: bool = True,
+) -> Any:
+    """
+    Handle ValidationError with custom error handlers or default behavior (sync version).
+
+    Args:
+        exc: The ValidationError that was raised
+        method: The RPC method being called
+        context: The gRPC or Connect context
+        request: Optional raw request data
+        is_grpc: True for gRPC, False for Connect RPC
+
+    Returns:
+        Result of context.abort() call
+    """
+    error_handlers = get_error_handlers(method)
+
+    if error_handlers:
+        # Check if there's a handler for ValidationError
+        for handler_config in error_handlers:
+            if isinstance(exc, handler_config["exception_type"]):
+                if handler_config["handler"]:
+                    # Custom handler function
+                    try:
+                        msg, _details = invoke_error_handler(
+                            handler_config["handler"], exc, request
+                        )
+                    except Exception:
+                        # Handler failed, fall back to default
+                        msg = str(exc)
+                else:
+                    # No custom handler, use default message
+                    msg = str(exc)
+
+                # Use the configured status code
+                if is_grpc:
+                    status_code = handler_config["status_code"]
+                    return context.abort(status_code, msg)
+                else:
+                    status_code = handler_config["connect_code"]
+                    raise ConnectError(code=status_code, message=msg)
+
+    # No handler found, use default behavior
+    if is_grpc:
+        return context.abort(grpc.StatusCode.INVALID_ARGUMENT, str(exc))
+    else:
+        raise ConnectError(code=Errors.INVALID_ARGUMENT, message=str(exc))
+
+
+async def handle_validation_error_async(
+    exc: ValidationError,
+    method: Callable,
+    context: Any,
+    request: Any = None,
+    is_grpc: bool = True,
+) -> Any:
+    """
+    Handle ValidationError with custom error handlers or default behavior (async version).
+
+    Args:
+        exc: The ValidationError that was raised
+        method: The RPC method being called
+        context: The gRPC or Connect context
+        request: Optional raw request data
+        is_grpc: True for gRPC, False for Connect RPC
+
+    Returns:
+        Result of context.abort() call
+    """
+    error_handlers = get_error_handlers(method)
+
+    if error_handlers:
+        # Check if there's a handler for ValidationError
+        for handler_config in error_handlers:
+            if isinstance(exc, handler_config["exception_type"]):
+                # Found a matching handler
+                if handler_config["handler"]:
+                    # Custom handler function
+                    try:
+                        msg, _details = invoke_error_handler(
+                            handler_config["handler"], exc, request
+                        )
+                    except Exception:
+                        # Handler failed, fall back to default
+                        msg = str(exc)
+                else:
+                    # No custom handler, use default message
+                    msg = str(exc)
+
+                # Use the configured status code
+                if is_grpc:
+                    status_code = handler_config["status_code"]
+                    await context.abort(status_code, msg)
+                    return
+                else:
+                    status_code = handler_config["connect_code"]
+                    raise ConnectError(code=status_code, message=msg)
+
+    # No handler found, use default behavior
+    if is_grpc:
+        await context.abort(grpc.StatusCode.INVALID_ARGUMENT, str(exc))
+    else:
+        raise ConnectError(code=Errors.INVALID_ARGUMENT, message=str(exc))
+
+
 def python_value_to_proto_value(field_type: type[Any], value: Any) -> Any:
     """
     Converts Python values to protobuf values.
@@ -394,7 +511,9 @@ def connect_obj_with_stub(
                             resp_obj, response_type, pb2_module
                         )
                 except ValidationError as e:
-                    return context.abort(grpc.StatusCode.INVALID_ARGUMENT, str(e))
+                    return handle_validation_error_sync(
+                        e, original, context, request, is_grpc=True
+                    )
                 except Exception as e:
                     return context.abort(grpc.StatusCode.INTERNAL, str(e))
 
@@ -431,7 +550,9 @@ def connect_obj_with_stub(
                             resp_obj, response_type, pb2_module
                         )
                 except ValidationError as e:
-                    return context.abort(grpc.StatusCode.INVALID_ARGUMENT, str(e))
+                    return handle_validation_error_sync(
+                        e, original, context, request, is_grpc=True
+                    )
                 except Exception as e:
                     return context.abort(grpc.StatusCode.INTERNAL, str(e))
 
@@ -513,8 +634,8 @@ def connect_obj_with_stub_async(
                                     resp_obj, output_item_type, pb2_module
                                 )
                         except ValidationError as e:
-                            await context.abort(
-                                grpc.StatusCode.INVALID_ARGUMENT, str(e)
+                            await handle_validation_error_async(
+                                e, method, context, None, is_grpc=True
                             )
                         except Exception as e:
                             await context.abort(grpc.StatusCode.INTERNAL, str(e))
@@ -534,8 +655,8 @@ def connect_obj_with_stub_async(
                                     resp_obj, output_item_type, pb2_module
                                 )
                         except ValidationError as e:
-                            await context.abort(
-                                grpc.StatusCode.INVALID_ARGUMENT, str(e)
+                            await handle_validation_error_async(
+                                e, method, context, None, is_grpc=True
                             )
                         except Exception as e:
                             await context.abort(grpc.StatusCode.INTERNAL, str(e))
@@ -559,8 +680,8 @@ def connect_obj_with_stub_async(
                                 resp_obj, response_type, pb2_module
                             )
                         except ValidationError as e:
-                            await context.abort(
-                                grpc.StatusCode.INVALID_ARGUMENT, str(e)
+                            await handle_validation_error_async(
+                                e, method, context, None, is_grpc=True
                             )
                         except Exception as e:
                             await context.abort(grpc.StatusCode.INTERNAL, str(e))
@@ -580,8 +701,8 @@ def connect_obj_with_stub_async(
                                 resp_obj, response_type, pb2_module
                             )
                         except ValidationError as e:
-                            await context.abort(
-                                grpc.StatusCode.INVALID_ARGUMENT, str(e)
+                            await handle_validation_error_async(
+                                e, method, context, None, is_grpc=True
                             )
                         except Exception as e:
                             await context.abort(grpc.StatusCode.INTERNAL, str(e))
@@ -611,8 +732,8 @@ def connect_obj_with_stub_async(
                                     resp_obj, output_item_type, pb2_module
                                 )
                         except ValidationError as e:
-                            await context.abort(
-                                grpc.StatusCode.INVALID_ARGUMENT, str(e)
+                            await handle_validation_error_async(
+                                e, method, context, request, is_grpc=True
                             )
                         except Exception as e:
                             await context.abort(grpc.StatusCode.INTERNAL, str(e))
@@ -632,8 +753,8 @@ def connect_obj_with_stub_async(
                                     resp_obj, output_item_type, pb2_module
                                 )
                         except ValidationError as e:
-                            await context.abort(
-                                grpc.StatusCode.INVALID_ARGUMENT, str(e)
+                            await handle_validation_error_async(
+                                e, method, context, request, is_grpc=True
                             )
                         except Exception as e:
                             await context.abort(grpc.StatusCode.INTERNAL, str(e))
@@ -674,8 +795,8 @@ def connect_obj_with_stub_async(
                                     resp_obj, response_type, pb2_module
                                 )
                         except ValidationError as e:
-                            await context.abort(
-                                grpc.StatusCode.INVALID_ARGUMENT, str(e)
+                            await handle_validation_error_async(
+                                e, method, context, request, is_grpc=True
                             )
                         except Exception as e:
                             await context.abort(grpc.StatusCode.INTERNAL, str(e))
@@ -709,8 +830,8 @@ def connect_obj_with_stub_async(
                                     resp_obj, response_type, pb2_module
                                 )
                         except ValidationError as e:
-                            await context.abort(
-                                grpc.StatusCode.INVALID_ARGUMENT, str(e)
+                            await handle_validation_error_async(
+                                e, method, context, request, is_grpc=True
                             )
                         except Exception as e:
                             await context.abort(grpc.StatusCode.INTERNAL, str(e))
@@ -769,9 +890,11 @@ def connect_obj_with_stub_connect_python(
                                 resp_obj, response_type, pb2_module
                             )
                     except ValidationError as e:
-                        return context.abort(Errors.INVALID_ARGUMENT, str(e))
+                        return handle_validation_error_sync(
+                            e, method, context, request, is_grpc=False
+                        )
                     except Exception as e:
-                        return context.abort(Errors.INTERNAL, str(e))
+                        raise ConnectError(code=Errors.INTERNAL, message=str(e))
 
                 return stub_method0
 
@@ -798,9 +921,11 @@ def connect_obj_with_stub_connect_python(
                                 resp_obj, response_type, pb2_module
                             )
                     except ValidationError as e:
-                        return context.abort(Errors.INVALID_ARGUMENT, str(e))
+                        return handle_validation_error_sync(
+                            e, method, context, request, is_grpc=False
+                        )
                     except Exception as e:
-                        return context.abort(Errors.INTERNAL, str(e))
+                        raise ConnectError(code=Errors.INTERNAL, message=str(e))
 
                 return stub_method1
 
@@ -827,9 +952,11 @@ def connect_obj_with_stub_connect_python(
                                 resp_obj, response_type, pb2_module
                             )
                     except ValidationError as e:
-                        return context.abort(Errors.INVALID_ARGUMENT, str(e))
+                        return handle_validation_error_sync(
+                            e, method, context, request, is_grpc=False
+                        )
                     except Exception as e:
-                        return context.abort(Errors.INTERNAL, str(e))
+                        raise ConnectError(code=Errors.INTERNAL, message=str(e))
 
                 return stub_method2
 
@@ -889,9 +1016,11 @@ def connect_obj_with_stub_async_connect_python(
                                 resp_obj, response_type, pb2_module
                             )
                     except ValidationError as e:
-                        await context.abort(Errors.INVALID_ARGUMENT, str(e))
+                        await handle_validation_error_async(
+                            e, method, context, request, is_grpc=False
+                        )
                     except Exception as e:
-                        await context.abort(Errors.INTERNAL, str(e))
+                        raise ConnectError(code=Errors.INTERNAL, message=str(e))
 
                 return stub_method0
 
@@ -931,9 +1060,11 @@ def connect_obj_with_stub_async_connect_python(
                                             resp_obj, output_item_type, pb2_module
                                         )
                                 except ValidationError as e:
-                                    await context.abort(Errors.INVALID_ARGUMENT, str(e))
+                                    await handle_validation_error_async(
+                                        e, method, context, None, is_grpc=False
+                                    )
                                 except Exception as e:
-                                    await context.abort(Errors.INTERNAL, str(e))
+                                    raise ConnectError(code=Errors.INTERNAL, message=str(e))
                         else:  # size_of_parameters == 2
 
                             async def stub_method(
@@ -949,9 +1080,11 @@ def connect_obj_with_stub_async_connect_python(
                                             resp_obj, output_item_type, pb2_module
                                         )
                                 except ValidationError as e:
-                                    await context.abort(Errors.INVALID_ARGUMENT, str(e))
+                                    await handle_validation_error_async(
+                                        e, method, context, None, is_grpc=False
+                                    )
                                 except Exception as e:
-                                    await context.abort(Errors.INTERNAL, str(e))
+                                    raise ConnectError(code=Errors.INTERNAL, message=str(e))
 
                         return stub_method
                     else:
@@ -973,9 +1106,11 @@ def connect_obj_with_stub_async_connect_python(
                                         resp_obj, response_type, pb2_module
                                     )
                                 except ValidationError as e:
-                                    await context.abort(Errors.INVALID_ARGUMENT, str(e))
+                                    await handle_validation_error_async(
+                                        e, method, context, None, is_grpc=False
+                                    )
                                 except Exception as e:
-                                    await context.abort(Errors.INTERNAL, str(e))
+                                    raise ConnectError(code=Errors.INTERNAL, message=str(e))
                         else:  # size_of_parameters == 2
 
                             async def stub_method(
@@ -993,9 +1128,11 @@ def connect_obj_with_stub_async_connect_python(
                                         resp_obj, response_type, pb2_module
                                     )
                                 except ValidationError as e:
-                                    await context.abort(Errors.INVALID_ARGUMENT, str(e))
+                                    await handle_validation_error_async(
+                                        e, method, context, None, is_grpc=False
+                                    )
                                 except Exception as e:
-                                    await context.abort(Errors.INTERNAL, str(e))
+                                    raise ConnectError(code=Errors.INTERNAL, message=str(e))
 
                         return stub_method
                 else:
@@ -1024,9 +1161,11 @@ def connect_obj_with_stub_async_connect_python(
                                             resp_obj, output_item_type, pb2_module
                                         )
                                 except ValidationError as e:
-                                    await context.abort(Errors.INVALID_ARGUMENT, str(e))
+                                    await handle_validation_error_async(
+                                        e, method, context, request, is_grpc=False
+                                    )
                                 except Exception as e:
-                                    await context.abort(Errors.INTERNAL, str(e))
+                                    raise ConnectError(code=Errors.INTERNAL, message=str(e))
                         else:  # size_of_parameters == 2
 
                             async def stub_method(
@@ -1045,9 +1184,11 @@ def connect_obj_with_stub_async_connect_python(
                                             resp_obj, output_item_type, pb2_module
                                         )
                                 except ValidationError as e:
-                                    await context.abort(Errors.INVALID_ARGUMENT, str(e))
+                                    await handle_validation_error_async(
+                                        e, method, context, request, is_grpc=False
+                                    )
                                 except Exception as e:
-                                    await context.abort(Errors.INTERNAL, str(e))
+                                    raise ConnectError(code=Errors.INTERNAL, message=str(e))
 
                         return stub_method
                     else:
@@ -1074,9 +1215,11 @@ def connect_obj_with_stub_async_connect_python(
                                             resp_obj, response_type, pb2_module
                                         )
                                 except ValidationError as e:
-                                    await context.abort(Errors.INVALID_ARGUMENT, str(e))
+                                    await handle_validation_error_async(
+                                        e, method, context, request, is_grpc=False
+                                    )
                                 except Exception as e:
-                                    await context.abort(Errors.INTERNAL, str(e))
+                                    raise ConnectError(code=Errors.INTERNAL, message=str(e))
                         else:  # size_of_parameters == 2
 
                             async def stub_method(
@@ -1099,9 +1242,11 @@ def connect_obj_with_stub_async_connect_python(
                                             resp_obj, response_type, pb2_module
                                         )
                                 except ValidationError as e:
-                                    await context.abort(Errors.INVALID_ARGUMENT, str(e))
+                                    await handle_validation_error_async(
+                                        e, method, context, request, is_grpc=False
+                                    )
                                 except Exception as e:
-                                    await context.abort(Errors.INTERNAL, str(e))
+                                    raise ConnectError(code=Errors.INTERNAL, message=str(e))
 
                         return stub_method
 
@@ -2611,11 +2756,20 @@ class Server:
         port: int = 50051,
         package_name: str = "",
         max_workers: int = 8,
-        *interceptors: Any,
         tls: Optional["GrpcTLSConfig"] = None,
+        interceptors: Optional[Sequence[grpc.ServerInterceptor]] = 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.Server = grpc.server(
-            futures.ThreadPoolExecutor(max_workers), interceptors=interceptors
+            futures.ThreadPoolExecutor(max_workers),
+            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

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

@@ -2,6 +2,7 @@
 
 from typing import Any, Callable, Dict, List, Optional, TypeVar, Type
 from functools import wraps
+import inspect
 import grpc
 from connectrpc.code import Code as ConnectErrors
 
@@ -145,7 +146,10 @@ 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,
+    handler: Optional[
+        Callable[[Exception], tuple[str, Any]]
+        | Callable[[Exception, Any], tuple[str, Any]]
+    ] = None,
 ) -> Callable[[F], F]:
     """
     Decorator to add automatic error handling to an RPC method.
@@ -154,13 +158,22 @@ def error_handler(
         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)
+        handler: Optional custom handler function that returns (message, details).
+                Can accept either (exception) or (exception, request_data) as parameters.
 
     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:
             ...
+
+        # With custom handler that accesses request data
+        def validation_handler(exc: ValidationError, request_data: Any) -> tuple[str, dict]:
+            return f"Validation failed for {request_data}", {"errors": exc.errors()}
+
+        @error_handler(ValidationError, handler=validation_handler)
+        async def create_user(self, request: CreateUserRequest) -> User:
+            ...
     """
 
     def decorator(func: F) -> F:
@@ -180,18 +193,11 @@ def error_handler(
             }
         )
 
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            return func(*args, **kwargs)
-
-        # Preserve the error handlers on the wrapper
-        setattr(wrapper, ERROR_HANDLER_ATTR, handlers)
+        # Set the error handlers directly on the function
+        # No need for a wrapper - we're just storing metadata
+        setattr(func, 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 func  # type: ignore
 
     return decorator
 
@@ -207,3 +213,31 @@ def get_error_handlers(method: Callable) -> Optional[List[Dict[str, Any]]]:
         List of error handler configurations if present, None otherwise
     """
     return getattr(method, ERROR_HANDLER_ATTR, None)
+
+
+def invoke_error_handler(
+    handler_func: Callable, exception: Exception, request_data: Any = None
+) -> tuple[str, Any]:
+    """
+    Invoke an error handler function with appropriate parameters based on its signature.
+
+    Args:
+        handler_func: The error handler function to invoke
+        exception: The exception that was raised
+        request_data: Optional request data (raw protobuf request)
+
+    Returns:
+        Tuple of (error_message, error_details)
+    """
+    sig = inspect.signature(handler_func)
+    param_count = len(sig.parameters)
+
+    if param_count == 1:
+        # Handler only accepts exception
+        return handler_func(exception)
+    elif param_count == 2:
+        # Handler accepts exception and request_data
+        return handler_func(exception, request_data)
+    else:
+        # Invalid signature, fall back to exception only
+        return handler_func(exception)