pydantic-rpc 0.14.0__tar.gz → 0.15.1__tar.gz

{pydantic_rpc-0.14.0 → pydantic_rpc-0.15.1}/PKG-INFO

@@ -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 → pydantic_rpc-0.15.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pydantic-rpc"
-version = "0.14.0"
+version = "0.15.1"
 description = "A Python library for building gRPC/ConnectRPC services with Pydantic models."
 authors = [
     { name = "Yasushi Itoh" }
@@ -19,6 +19,12 @@ dependencies = [
 ]
 readme = "README.md"
 requires-python = ">= 3.11"
+classifiers = [
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
 
 
 [build-system]

{pydantic_rpc-0.14.0 → pydantic_rpc-0.15.1}/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.14.0 → pydantic_rpc-0.15.1}/src/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-0.14.0 → pydantic_rpc-0.15.1}/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)