pydantic-rpc 0.14.0__py3-none-any.whl → 0.15.1__py3-none-any.whl

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/core.py

@@ -14,6 +14,8 @@ import types
 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,13 @@ 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 +1082,13 @@ 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 +1110,13 @@ 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 +1134,13 @@ 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 +1169,13 @@ 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 +1194,13 @@ 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 +1227,13 @@ 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 +1256,13 @@ 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
 
@@ -2811,12 +2972,13 @@ class AsyncIOServer:
         await self._server.start()
 
         shutdown_event = asyncio.Event()
+        loop = asyncio.get_running_loop()
 
         def shutdown(signum: signal.Signals, frame: Any):
             _ = signum
             _ = frame
             print("Received shutdown signal...")
-            shutdown_event.set()
+            loop.call_soon_threadsafe(shutdown_event.set)
 
         for s in [signal.SIGTERM, signal.SIGINT]:
             _ = signal.signal(s, shutdown)  # pyright:ignore[reportArgumentType]

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)

{pydantic_rpc-0.14.0.dist-info → pydantic_rpc-0.15.1.dist-info}/METADATA

@@ -1,8 +1,12 @@
 Metadata-Version: 2.3
 Name: pydantic-rpc
-Version: 0.14.0
+Version: 0.15.1
 Summary: A Python library for building gRPC/ConnectRPC services with Pydantic models.
 Author: Yasushi Itoh
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: annotated-types==0.7.0
 Requires-Dist: pydantic>=2.1.1
 Requires-Dist: grpcio>=1.56.2

{pydantic_rpc-0.14.0.dist-info → pydantic_rpc-0.15.1.dist-info}/RECORD

@@ -1,12 +1,12 @@
-pydantic_rpc/__init__.py,sha256=c5e0b5d4ed6de3e3c7c1ada5389e704ce149ea56ca0930392db6abdf222b4e86,871
-pydantic_rpc/core.py,sha256=422cbccacdf857e0c1d29e04784562de1bc47764d0f464b1086cceb7a3719c70,115689
-pydantic_rpc/decorators.py,sha256=94d87825e034b6303df46dd74e6c8c7ed5c88133aa504d61249a83dbf82f1de3,6219
+pydantic_rpc/__init__.py,sha256=1b57454e64c68891868ea3993af9e11100c579b56af99f4aa0f836934ddf883d,925
+pydantic_rpc/core.py,sha256=d7cc8d95425361bd7a63c0eee7d90f9e759067f1d959dfa67c1e15aa73697495,121896
+pydantic_rpc/decorators.py,sha256=3ee29ded407c888793694452f0b32fbcf46aedd09b42275a2eedaffda9e0e5f4,7465
 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.14.0.dist-info/WHEEL,sha256=ab6157bc637547491fb4567cd7ddf26b04d63382916ca16c29a5c8e94c9c9ef7,79
-pydantic_rpc-0.14.0.dist-info/METADATA,sha256=d2ea2414284c138bb9eb0f47fb63ff282bd4aa4e915c1ad9cc08d1840fa57ea1,35957
-pydantic_rpc-0.14.0.dist-info/RECORD,,
+pydantic_rpc-0.15.1.dist-info/WHEEL,sha256=ab6157bc637547491fb4567cd7ddf26b04d63382916ca16c29a5c8e94c9c9ef7,79
+pydantic_rpc-0.15.1.dist-info/METADATA,sha256=2606ce6f0ca5e7ce38c3292d1c1a9c9f8a6797094594c186df876eb897f79d14,36161
+pydantic_rpc-0.15.1.dist-info/RECORD,,