pydantic-rpc 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

pydantic_rpc/core.py

@@ -26,8 +26,6 @@ import annotated_types
 import grpc
 from grpc import ServicerContext
 import grpc_tools
-from connecpy.server import ConnecpyASGIApplication as ConnecpyASGI
-from connecpy.server import ConnecpyWSGIApplication as ConnecpyWSGI
 from connecpy.code import Code as Errors
 
 # Protobuf Python modules for Timestamp, Duration (requires protobuf / grpcio)
@@ -49,6 +47,50 @@ from sonora.wsgi import grpcWSGI
 
 Message: TypeAlias = BaseModel
 
+# Cache for serializer checks
+_has_serializers_cache: dict[type[Message], bool] = {}
+_has_field_serializers_cache: dict[type[Message], set[str]] = {}
+
+
+# Serializer strategy configuration
+class SerializerStrategy(enum.Enum):
+    """Strategy for applying Pydantic serializers."""
+
+    NONE = "none"  # No serializers applied
+    SHALLOW = "shallow"  # Only top-level serializers
+    DEEP = "deep"  # Nested serializers too (default)
+
+
+# Get strategy from environment variable
+_SERIALIZER_STRATEGY = SerializerStrategy(
+    os.getenv("PYDANTIC_RPC_SERIALIZER_STRATEGY", "deep").lower()
+)
+
+
+def has_serializers(msg_type: type[Message]) -> bool:
+    """Check if a Message type has any serializers (cached for performance)."""
+    if msg_type not in _has_serializers_cache:
+        # Check for both field and model serializers
+        has_field = bool(getattr(msg_type, "__pydantic_serializer__", None))
+        has_model = bool(
+            getattr(msg_type, "model_dump", None) and msg_type != BaseModel
+        )
+        _has_serializers_cache[msg_type] = has_field or has_model
+    return _has_serializers_cache[msg_type]
+
+
+def get_field_serializers(msg_type: type[Message]) -> set[str]:
+    """Get the set of fields that have serializers (cached for performance)."""
+    if msg_type not in _has_field_serializers_cache:
+        fields_with_serializers = set()
+        # Check model_fields_set or similar for fields with serializers
+        if hasattr(msg_type, "__pydantic_decorators__"):
+            decorators = msg_type.__pydantic_decorators__
+            if hasattr(decorators, "field_serializers"):
+                fields_with_serializers = set(decorators.field_serializers.keys())
+        _has_field_serializers_cache[msg_type] = fields_with_serializers
+    return _has_field_serializers_cache[msg_type]
+
 
 def is_none_type(annotation: Any) -> TypeGuard[type[None] | None]:
     """Check if annotation represents None/NoneType (handles both None and type(None))."""
@@ -149,6 +191,14 @@ def generate_converter(annotation: type[Any] | None) -> Callable[[Any], Any]:
 
     # For Message classes
     if inspect.isclass(annotation) and issubclass(annotation, Message):
+        # Check if it's an empty message class
+        if not annotation.model_fields:
+
+            def empty_message_converter(value: empty_pb2.Empty):  # type: ignore
+                _ = value
+                return annotation()  # Return instance of the empty message class
+
+            return empty_message_converter
         return generate_message_converter(annotation)
 
     # For union types or other unsupported cases, just return the value as-is.
@@ -171,6 +221,15 @@ def generate_message_converter(
 
     arg_type = cast("type[Message]", arg_type)
     fields = arg_type.model_fields
+
+    # Handle empty message classes (no fields)
+    if not fields:
+
+        def empty_message_converter(request: Any) -> Message:
+            _ = request  # The incoming request will be google.protobuf.Empty
+            return arg_type()  # Return an instance of the empty message class
+
+        return empty_message_converter
     converters = {
         field: generate_converter(field_type.annotation)  # type: ignore
         for field, field_type in fields.items()
@@ -238,7 +297,12 @@ def generate_message_converter(
                 # For non-union fields, convert normally
                 rdict[field_name] = converters[field_name](getattr(request, field_name))
 
-        return arg_type(**rdict)
+        # Use model_validate to support @model_validator
+        try:
+            return arg_type.model_validate(rdict)
+        except AttributeError:
+            # Fallback for older Pydantic versions or if model_validate doesn't exist
+            return arg_type(**rdict)
 
     return converter
 
@@ -294,7 +358,7 @@ def connect_obj_with_stub(
         param_count = len(sig.parameters)
         converter = generate_message_converter(arg_type)
 
-        if param_count == 1:
+        if param_count == 0 or param_count == 1:
 
             def stub_method(
                 self: object,
@@ -305,7 +369,10 @@ def connect_obj_with_stub(
             ) -> Any:
                 _ = self
                 try:
-                    if is_none_type(arg_type):
+                    if param_count == 0:
+                        # Method takes no parameters
+                        resp_obj = original()
+                    elif is_none_type(arg_type):
                         resp_obj = original(None)  # Fixed: pass None instead of no args
                     else:
                         arg = converter(request)
@@ -313,6 +380,13 @@ def connect_obj_with_stub(
 
                     if is_none_type(response_type):
                         return empty_pb2.Empty()  # type: ignore
+                    elif (
+                        inspect.isclass(response_type)
+                        and issubclass(response_type, Message)
+                        and not response_type.model_fields
+                    ):
+                        # Empty message class
+                        return empty_pb2.Empty()  # type: ignore
                     else:
                         return convert_python_message_to_proto(
                             resp_obj, response_type, pb2_module
@@ -343,6 +417,13 @@ def connect_obj_with_stub(
 
                     if is_none_type(response_type):
                         return empty_pb2.Empty()  # type: ignore
+                    elif (
+                        inspect.isclass(response_type)
+                        and issubclass(response_type, Message)
+                        and not response_type.model_fields
+                    ):
+                        # Empty message class
+                        return empty_pb2.Empty()  # type: ignore
                     else:
                         return convert_python_message_to_proto(
                             resp_obj, response_type, pb2_module
@@ -391,9 +472,9 @@ def connect_obj_with_stub_async(
         is_output_stream = is_stream_type(response_type)
         size_of_parameters = len(sig.parameters)
 
-        if size_of_parameters not in (1, 2):
+        if size_of_parameters not in (0, 1, 2):
             raise TypeError(
-                f"Method '{method.__name__}' must have 1 or 2 parameters, got {size_of_parameters}"
+                f"Method '{method.__name__}' must have 0, 1 or 2 parameters, got {size_of_parameters}"
             )
 
         if is_input_stream:
@@ -559,7 +640,7 @@ def connect_obj_with_stub_async(
 
             else:
                 # unary-unary
-                if size_of_parameters == 1:
+                if size_of_parameters == 0 or size_of_parameters == 1:
 
                     async def stub_method(
                         self: object,
@@ -568,7 +649,10 @@ def connect_obj_with_stub_async(
                     ) -> Any:
                         _ = self
                         try:
-                            if is_none_type(input_type):
+                            if size_of_parameters == 0:
+                                # Method takes no parameters
+                                resp_obj = await method()
+                            elif is_none_type(input_type):
                                 resp_obj = await method(None)
                             else:
                                 arg = converter(request)
@@ -576,6 +660,13 @@ def connect_obj_with_stub_async(
 
                             if is_none_type(response_type):
                                 return empty_pb2.Empty()  # type: ignore
+                            elif (
+                                inspect.isclass(response_type)
+                                and issubclass(response_type, Message)
+                                and not response_type.model_fields
+                            ):
+                                # Empty message class
+                                return empty_pb2.Empty()  # type: ignore
                             else:
                                 return convert_python_message_to_proto(
                                     resp_obj, response_type, pb2_module
@@ -604,6 +695,13 @@ def connect_obj_with_stub_async(
 
                             if is_none_type(response_type):
                                 return empty_pb2.Empty()  # type: ignore
+                            elif (
+                                inspect.isclass(response_type)
+                                and issubclass(response_type, Message)
+                                and not response_type.model_fields
+                            ):
+                                # Empty message class
+                                return empty_pb2.Empty()  # type: ignore
                             else:
                                 return convert_python_message_to_proto(
                                     resp_obj, response_type, pb2_module
@@ -650,6 +748,31 @@ def connect_obj_with_stub_connecpy(
         size_of_parameters = len(sig.parameters)
 
         match size_of_parameters:
+            case 0:
+                # Method with no parameters (empty request)
+                def stub_method0(
+                    self: object,
+                    request: Any,
+                    context: Any,
+                    method: Callable[..., Message] = method,
+                ) -> Any:
+                    _ = self
+                    try:
+                        resp_obj = method()
+
+                        if is_none_type(response_type):
+                            return empty_pb2.Empty()  # type: ignore
+                        else:
+                            return convert_python_message_to_proto(
+                                resp_obj, response_type, pb2_module
+                            )
+                    except ValidationError as e:
+                        return context.abort(Errors.INVALID_ARGUMENT, str(e))
+                    except Exception as e:
+                        return context.abort(Errors.INTERNAL, str(e))
+
+                return stub_method0
+
             case 1:
 
                 def stub_method1(
@@ -709,7 +832,7 @@ def connect_obj_with_stub_connecpy(
                 return stub_method2
 
             case _:
-                raise Exception("Method must have exactly one or two parameters")
+                raise Exception("Method must have 0, 1, or 2 parameters")
 
     for method_name, method in get_rpc_methods(obj):
         if method.__name__.startswith("_"):
@@ -743,6 +866,31 @@ def connect_obj_with_stub_async_connecpy(
         size_of_parameters = len(sig.parameters)
 
         match size_of_parameters:
+            case 0:
+                # Method with no parameters (empty request)
+                async def stub_method0(
+                    self: object,
+                    request: Any,
+                    context: Any,
+                    method: Callable[..., Awaitable[Message]] = method,
+                ) -> Any:
+                    _ = self
+                    try:
+                        resp_obj = await method()
+
+                        if is_none_type(response_type):
+                            return empty_pb2.Empty()  # type: ignore
+                        else:
+                            return convert_python_message_to_proto(
+                                resp_obj, response_type, pb2_module
+                            )
+                    except ValidationError as e:
+                        await context.abort(Errors.INVALID_ARGUMENT, str(e))
+                    except Exception as e:
+                        await context.abort(Errors.INTERNAL, str(e))
+
+                return stub_method0
+
             case 1:
 
                 async def stub_method1(
@@ -802,7 +950,7 @@ def connect_obj_with_stub_async_connecpy(
                 return stub_method2
 
             case _:
-                raise Exception("Method must have exactly one or two parameters")
+                raise Exception("Method must have 0, 1, or 2 parameters")
 
     for method_name, method in get_rpc_methods(obj):
         if method.__name__.startswith("_"):
@@ -816,7 +964,12 @@ def connect_obj_with_stub_async_connecpy(
 
 
 def python_value_to_proto_oneof(
-    field_name: str, field_type: type[Any], value: Any, pb2_module: Any
+    field_name: str,
+    field_type: type[Any],
+    value: Any,
+    pb2_module: Any,
+    _visited: set[int] | None = None,
+    _depth: int = 0,
 ) -> tuple[str, Any]:
     """
     Converts a Python value from a Union type to a protobuf oneof field.
@@ -847,20 +1000,120 @@ def python_value_to_proto_oneof(
         raise TypeError(f"Unsupported type in oneof: {actual_type}")
 
     oneof_field_name = f"{field_name}_{proto_typename.replace('.', '_')}"
-    converted_value = python_value_to_proto(actual_type, value, pb2_module)
+    converted_value = python_value_to_proto(
+        actual_type, value, pb2_module, _visited, _depth
+    )
     return oneof_field_name, converted_value
 
 
 def convert_python_message_to_proto(
-    py_msg: Message, msg_type: type[Message], pb2_module: Any
+    py_msg: Message,
+    msg_type: type[Message],
+    pb2_module: Any,
+    _visited: set[int] | None = None,
+    _depth: int = 0,
 ) -> object:
-    """Convert a Python Pydantic Message instance to a protobuf message instance. Used for constructing a response."""
+    """Convert a Python Pydantic Message instance to a protobuf message instance. Used for constructing a response.
+
+    Args:
+        py_msg: The Pydantic Message instance to convert
+        msg_type: The type of the Message
+        pb2_module: The protobuf module
+        _visited: Internal set to track visited objects for circular reference detection
+        _depth: Current recursion depth for strategy control
+    """
+    # Handle empty message classes
+    if not msg_type.model_fields:
+        # Return google.protobuf.Empty instance
+        return empty_pb2.Empty()
+
+    # Initialize visited set for circular reference detection
+    if _visited is None:
+        _visited = set()
+
+    # Check for circular references
+    obj_id = id(py_msg)
+    if obj_id in _visited:
+        # Return empty proto to avoid infinite recursion
+        proto_class = getattr(pb2_module, msg_type.__name__)
+        return proto_class()
+    _visited.add(obj_id)
+
+    # Determine if we should apply serializers based on strategy
+    apply_serializers = False
+    if _SERIALIZER_STRATEGY == SerializerStrategy.DEEP:
+        apply_serializers = True  # Always apply at any depth
+    elif _SERIALIZER_STRATEGY == SerializerStrategy.SHALLOW:
+        apply_serializers = _depth == 0  # Only at top level
+    # SerializerStrategy.NONE: never apply
+
+    # Only use model_dump if there are serializers and strategy allows
+    serialized_data = None
+    if apply_serializers and has_serializers(msg_type):
+        try:
+            serialized_data = py_msg.model_dump(mode="python")
+        except Exception:
+            # Fallback to the old approach if model_dump fails
+            serialized_data = None
+
     field_dict = {}
     for name, field_info in msg_type.model_fields.items():
+        field_type = field_info.annotation
+
+        # Check if this field type contains Message types
+        contains_message = False
+        if field_type:
+            if inspect.isclass(field_type) and issubclass(field_type, Message):
+                contains_message = True
+            elif is_union_type(field_type):
+                # Check if any of the union args are Messages
+                for arg in flatten_union(field_type):
+                    if arg and inspect.isclass(arg) and issubclass(arg, Message):
+                        contains_message = True
+                        break
+            else:
+                # Check for list/dict of Messages
+                origin = get_origin(field_type)
+                if origin in (list, tuple):
+                    inner_type = (
+                        get_args(field_type)[0] if get_args(field_type) else None
+                    )
+                    if (
+                        inner_type
+                        and inspect.isclass(inner_type)
+                        and issubclass(inner_type, Message)
+                    ):
+                        contains_message = True
+                elif origin is dict:
+                    args = get_args(field_type)
+                    if len(args) >= 2:
+                        val_type = args[1]
+                        if inspect.isclass(val_type) and issubclass(val_type, Message):
+                            contains_message = True
+
+        # Get the value
         value = getattr(py_msg, name)
         if value is None:
             continue
 
+        # For Message types, recursively apply serialization
+        if contains_message and not is_union_type(field_type):
+            # Direct Message field
+            if inspect.isclass(field_type) and issubclass(field_type, Message):
+                # Recursively convert nested Message with serializers
+                field_dict[name] = convert_python_message_to_proto(
+                    value, field_type, pb2_module, _visited, _depth + 1
+                )
+                continue
+
+        # Use serialized data for non-Message types to respect custom serializers
+        if (
+            serialized_data is not None
+            and name in serialized_data
+            and not contains_message
+        ):
+            value = serialized_data[name]
+
         field_type = field_info.annotation
 
         # Handle oneof fields, which are represented as Unions.
@@ -874,20 +1127,33 @@ def convert_python_message_to_proto(
                 (
                     oneof_field_name,
                     converted_value,
-                ) = python_value_to_proto_oneof(name, field_type, value, pb2_module)
+                ) = python_value_to_proto_oneof(
+                    name, field_type, value, pb2_module, _visited, _depth
+                )
                 field_dict[oneof_field_name] = converted_value
                 continue
 
         # For regular and Optional fields that have a value.
         if field_type is not None:
-            field_dict[name] = python_value_to_proto(field_type, value, pb2_module)
+            field_dict[name] = python_value_to_proto(
+                field_type, value, pb2_module, _visited, _depth
+            )
+
+    # Remove from visited set when done
+    _visited.discard(obj_id)
 
     # Retrieve the appropriate protobuf class dynamically
     proto_class = getattr(pb2_module, msg_type.__name__)
     return proto_class(**field_dict)
 
 
-def python_value_to_proto(field_type: type[Any], value: Any, pb2_module: Any) -> Any:
+def python_value_to_proto(
+    field_type: type[Any],
+    value: Any,
+    pb2_module: Any,
+    _visited: set[int] | None = None,
+    _depth: int = 0,
+) -> Any:
     """
     Perform Python->protobuf type conversion for each field value.
     """
@@ -910,15 +1176,36 @@ def python_value_to_proto(field_type: type[Any], value: Any, pb2_module: Any) ->
     # If seq
     if origin in (list, tuple):
         inner_type = get_args(field_type)[0]
-        return [python_value_to_proto(inner_type, v, pb2_module) for v in value]
+        # Handle list of Messages
+        if inspect.isclass(inner_type) and issubclass(inner_type, Message):
+            return [
+                convert_python_message_to_proto(
+                    v, inner_type, pb2_module, _visited, _depth + 1
+                )
+                for v in value
+            ]
+        return [
+            python_value_to_proto(inner_type, v, pb2_module, _visited, _depth)
+            for v in value
+        ]
 
     # If dict
     if origin is dict:
         key_type, val_type = get_args(field_type)
+        # Handle dict with Message values
+        if inspect.isclass(val_type) and issubclass(val_type, Message):
+            return {
+                python_value_to_proto(
+                    key_type, k, pb2_module, _visited, _depth
+                ): convert_python_message_to_proto(
+                    v, val_type, pb2_module, _visited, _depth + 1
+                )
+                for k, v in value.items()
+            }
         return {
-            python_value_to_proto(key_type, k, pb2_module): python_value_to_proto(
-                val_type, v, pb2_module
-            )
+            python_value_to_proto(
+                key_type, k, pb2_module, _visited, _depth
+            ): python_value_to_proto(val_type, v, pb2_module, _visited, _depth)
             for k, v in value.items()
         }
 
@@ -930,12 +1217,16 @@ def python_value_to_proto(field_type: type[Any], value: Any, pb2_module: Any) ->
         ]
         if non_none_args:
             # Assuming it's an Optional[T], so there's one type left.
-            return python_value_to_proto(non_none_args[0], value, pb2_module)
+            return python_value_to_proto(
+                non_none_args[0], value, pb2_module, _visited, _depth
+            )
         return None  # Should not be reached if value is not None
 
     # If Message
     if inspect.isclass(field_type) and issubclass(field_type, Message):
-        return convert_python_message_to_proto(value, field_type, pb2_module)
+        return convert_python_message_to_proto(
+            value, field_type, pb2_module, _visited, _depth + 1
+        )
 
     # If primitive
     return value
@@ -1023,6 +1314,9 @@ def protobuf_type_mapping(python_type: Any) -> str | None:
                 return f"map<{key_proto_type}, {value_proto_type}>"
 
     if inspect.isclass(python_type) and issubclass(python_type, Message):
+        # Check if it's an empty message
+        if not python_type.model_fields:
+            return "google.protobuf.Empty"
         return python_type.__name__
 
     return mapping.get(python_type)
@@ -1123,6 +1417,12 @@ def generate_message_definition(
     fields: list[str] = []
     refs: list[Any] = []
     pydantic_fields = message_type.model_fields
+
+    # Check if this is an empty message and should use google.protobuf.Empty
+    if not pydantic_fields:
+        # Return a special marker that indicates this should use google.protobuf.Empty
+        return "__EMPTY__", []
+
     index = 1
 
     for field_name, field_info in pydantic_fields.items():
@@ -1328,6 +1628,11 @@ def generate_proto(obj: object, package_name: str = "") -> str:
                     message_types.append(item_type)
                 continue
 
+            # Check if mt is actually a Message type
+            if not (inspect.isclass(mt) and issubclass(mt, Message)):
+                # Not a Message type, skip processing
+                continue
+
             mt = cast(type[Message], mt)
 
             for _, field_info in mt.model_fields.items():
@@ -1343,13 +1648,19 @@ def generate_proto(obj: object, package_name: str = "") -> str:
                     )  # Use the field-specific version
 
             msg_def, refs = generate_message_definition(mt, done_enums, done_messages)
-            mt_doc = inspect.getdoc(mt)
-            if mt_doc:
-                for comment_line in comment_out(mt_doc):
-                    all_type_definitions.append(comment_line)
 
-            all_type_definitions.append(msg_def)
-            all_type_definitions.append("")
+            # Skip adding definition if it's an empty message (will use google.protobuf.Empty)
+            if msg_def != "__EMPTY__":
+                mt_doc = inspect.getdoc(mt)
+                if mt_doc:
+                    for comment_line in comment_out(mt_doc):
+                        all_type_definitions.append(comment_line)
+
+                all_type_definitions.append(msg_def)
+                all_type_definitions.append("")
+            else:
+                # Mark that we need google.protobuf.Empty import
+                uses_empty = True
 
             for r in refs:
                 if is_enum_type(r) and r not in done_enums:
@@ -1379,11 +1690,19 @@ def generate_proto(obj: object, package_name: str = "") -> str:
         else:
             output_msg_type = response_type
 
-        # Handle NoneType by using Empty (but we've already validated no streaming of Empty above)
+        # Handle NoneType and empty messages by using Empty
         if input_msg_type is None or input_msg_type is ServicerContext:
             input_str = "google.protobuf.Empty"  # No need to check for stream since we validated above
             if input_msg_type is ServicerContext:
                 uses_empty = True
+        elif (
+            inspect.isclass(input_msg_type)
+            and issubclass(input_msg_type, Message)
+            and not input_msg_type.model_fields
+        ):
+            # Empty message class
+            input_str = "google.protobuf.Empty"
+            uses_empty = True
         else:
             input_str = (
                 f"stream {input_msg_type.__name__}"
@@ -1395,6 +1714,14 @@ def generate_proto(obj: object, package_name: str = "") -> str:
             output_str = "google.protobuf.Empty"  # No need to check for stream since we validated above
             if output_msg_type is ServicerContext:
                 uses_empty = True
+        elif (
+            inspect.isclass(output_msg_type)
+            and issubclass(output_msg_type, Message)
+            and not output_msg_type.model_fields
+        ):
+            # Empty message class
+            output_str = "google.protobuf.Empty"
+            uses_empty = True
         else:
             output_str = (
                 f"stream {output_msg_type.__name__}"
@@ -1601,11 +1928,18 @@ def generate_pb_code(proto_path: Path) -> types.ModuleType | None:
 
 
 def get_request_arg_type(sig: inspect.Signature) -> Any:
-    """Return the type annotation of the first parameter (request) of a method."""
+    """Return the type annotation of the first parameter (request) of a method.
+
+    If the method has no parameters, return None (implying an empty request).
+    """
     num_of_params = len(sig.parameters)
-    if not (num_of_params == 1 or num_of_params == 2):
-        raise Exception("Method must have exactly one or two parameters")
-    return tuple(sig.parameters.values())[0].annotation
+    if num_of_params == 0:
+        # No parameters means empty request
+        return None
+    elif num_of_params == 1 or num_of_params == 2:
+        return tuple(sig.parameters.values())[0].annotation
+    else:
+        raise Exception("Method must have 0, 1, or 2 parameters")
 
 
 def get_rpc_methods(obj: object) -> list[tuple[str, Callable[..., Any]]]:
@@ -1836,6 +2170,18 @@ def generate_combined_proto(
             if is_none_type(response_type):
                 uses_empty = True
 
+            # Validate that users aren't using protobuf messages directly
+            if hasattr(request_type, "DESCRIPTOR") and not is_none_type(request_type):
+                raise TypeError(
+                    f"Method '{method_name}' uses protobuf message '{request_type.__name__}' directly. "
+                    f"Please use Pydantic Message classes instead, or None/empty Message for empty requests."
+                )
+            if hasattr(response_type, "DESCRIPTOR") and not is_none_type(response_type):
+                raise TypeError(
+                    f"Method '{method_name}' uses protobuf message '{response_type.__name__}' directly. "
+                    f"Please use Pydantic Message classes instead, or None/empty Message for empty responses."
+                )
+
             # Collect message types for processing
             message_types = []
             if not is_none_type(request_type):
@@ -1869,13 +2215,19 @@ def generate_combined_proto(
                 msg_def, refs = generate_message_definition(
                     mt, done_enums, done_messages
                 )
-                mt_doc = inspect.getdoc(mt)
-                if mt_doc:
-                    for comment_line in comment_out(mt_doc):
-                        all_type_definitions.append(comment_line)
 
-                all_type_definitions.append(msg_def)
-                all_type_definitions.append("")
+                # Skip adding definition if it's an empty message (will use google.protobuf.Empty)
+                if msg_def != "__EMPTY__":
+                    mt_doc = inspect.getdoc(mt)
+                    if mt_doc:
+                        for comment_line in comment_out(mt_doc):
+                            all_type_definitions.append(comment_line)
+
+                    all_type_definitions.append(msg_def)
+                    all_type_definitions.append("")
+                else:
+                    # Mark that we need google.protobuf.Empty import
+                    uses_empty = True
 
                 for r in refs:
                     if is_enum_type(r) and r not in done_enums:
@@ -1906,11 +2258,19 @@ def generate_combined_proto(
             else:
                 output_msg_type = response_type
 
-            # Handle NoneType by using Empty
+            # Handle NoneType and empty messages by using Empty
             if input_msg_type is None or input_msg_type is ServicerContext:
                 input_str = "google.protobuf.Empty"  # No need to check for stream since we validated above
                 if input_msg_type is ServicerContext:
                     uses_empty = True
+            elif (
+                inspect.isclass(input_msg_type)
+                and issubclass(input_msg_type, Message)
+                and not input_msg_type.model_fields
+            ):
+                # Empty message class
+                input_str = "google.protobuf.Empty"
+                uses_empty = True
             else:
                 input_str = (
                     f"stream {input_msg_type.__name__}"
@@ -1922,6 +2282,14 @@ def generate_combined_proto(
                 output_str = "google.protobuf.Empty"  # No need to check for stream since we validated above
                 if output_msg_type is ServicerContext:
                     uses_empty = True
+            elif (
+                inspect.isclass(output_msg_type)
+                and issubclass(output_msg_type, Message)
+                and not output_msg_type.model_fields
+            ):
+                # Empty message class
+                output_str = "google.protobuf.Empty"
+                uses_empty = True
             else:
                 output_str = (
                     f"stream {output_msg_type.__name__}"
@@ -1958,12 +2326,14 @@ def generate_combined_proto(
         import_block += "\n"
 
     # Combine everything
+    service_defs = "\n".join(all_service_definitions)
+    type_defs = "\n".join(all_type_definitions)
     proto_definition = f"""syntax = "proto3";
 
 package {package_name};
 
-{import_block}{"".join(all_service_definitions)}
-{indent_lines(all_type_definitions, "")}
+{import_block}{service_defs}
+{type_defs}
 """
     return proto_definition
 

{pydantic_rpc-0.7.0.dist-info → pydantic_rpc-0.8.0.dist-info}/METADATA

@@ -1,20 +1,19 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.3
 Name: pydantic-rpc
-Version: 0.7.0
+Version: 0.8.0
 Summary: A Python library for building gRPC/ConnectRPC services with Pydantic models.
 Author: Yasushi Itoh
-License-File: LICENSE
-Requires-Python: >=3.11
 Requires-Dist: annotated-types>=0.5.0
-Requires-Dist: connecpy==2.0.0
-Requires-Dist: grpcio-health-checking>=1.56.2
-Requires-Dist: grpcio-reflection>=1.56.2
-Requires-Dist: grpcio-tools>=1.56.2
-Requires-Dist: grpcio>=1.56.2
-Requires-Dist: mcp>=1.9.4
 Requires-Dist: pydantic>=2.1.1
+Requires-Dist: grpcio>=1.56.2
+Requires-Dist: grpcio-tools>=1.56.2
+Requires-Dist: grpcio-reflection>=1.56.2
+Requires-Dist: grpcio-health-checking>=1.56.2
 Requires-Dist: sonora>=0.2.3
+Requires-Dist: connecpy==2.0.0
+Requires-Dist: mcp>=1.9.4
 Requires-Dist: starlette>=0.27.0
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 
 # 🚀 PydanticRPC
@@ -674,6 +673,203 @@ buf: * (#2) Call complete
 %
 ```
 
+### 🪶 Empty Messages
+
+Empty request/response messages are automatically mapped to `google.protobuf.Empty`:
+
+```python
+from pydantic_rpc import AsyncIOServer, Message
+
+
+class EmptyRequest(Message):
+    pass  # Automatically uses google.protobuf.Empty
+
+
+class GreetingResponse(Message):
+    message: str
+
+
+class GreetingService:
+    async def say_hello(self, request: EmptyRequest) -> GreetingResponse:
+        return GreetingResponse(message="Hello!")
+    
+    async def get_default_greeting(self) -> GreetingResponse:
+        # Method with no request parameter (implicitly empty)
+        return GreetingResponse(message="Hello, World!")
+```
+
+### 🎨 Custom Serialization
+
+Pydantic's serialization decorators are fully supported:
+
+```python
+from typing import Any
+from pydantic import field_serializer, model_serializer
+from pydantic_rpc import Message
+
+
+class UserMessage(Message):
+    name: str
+    age: int
+    
+    @field_serializer('name')
+    def serialize_name(self, name: str) -> str:
+        """Always uppercase the name when serializing."""
+        return name.upper()
+
+
+class ComplexMessage(Message):
+    value: int
+    multiplier: int
+    
+    @model_serializer
+    def serialize_model(self) -> dict[str, Any]:
+        """Custom serialization with computed fields."""
+        return {
+            'value': self.value,
+            'multiplier': self.multiplier,
+            'result': self.value * self.multiplier  # Computed field
+        }
+```
+
+The serializers are automatically applied when converting between Pydantic models and protobuf messages.
+
+#### ⚠️ Limitations and Considerations
+
+**1. Nested Message serializers are now supported (v0.8.0+)**
+```python
+class Address(Message):
+    city: str
+    
+    @field_serializer("city")
+    def serialize_city(self, city: str) -> str:
+        return city.upper()
+
+class User(Message):
+    name: str
+    address: Address  # ← Address's serializers ARE applied with DEEP strategy
+    
+    @field_serializer("name")
+    def serialize_name(self, name: str) -> str:
+        return name.upper()  # ← This IS applied
+```
+
+**Serializer Strategy Control:**
+You can control how nested serializers are applied via environment variable:
+```bash
+# Apply serializers at all nesting levels (default)
+export PYDANTIC_RPC_SERIALIZER_STRATEGY=deep
+
+# Apply only top-level serializers
+export PYDANTIC_RPC_SERIALIZER_STRATEGY=shallow
+
+# Disable all serializers
+export PYDANTIC_RPC_SERIALIZER_STRATEGY=none
+```
+
+**Performance Impact:**
+- DEEP strategy: ~4% overhead for simple nested structures
+- SHALLOW strategy: ~2% overhead (only top-level)
+- NONE strategy: No overhead (serializers disabled)
+
+**2. New fields added by serializers are ignored**
+```python
+class ComplexMessage(Message):
+    value: int
+    multiplier: int
+    
+    @model_serializer
+    def serialize_model(self) -> dict[str, Any]:
+        return {
+            "value": self.value,
+            "multiplier": self.multiplier,
+            "result": self.value * self.multiplier  # ← Won't appear in protobuf
+        }
+```
+**Problem**: The `result` field doesn't exist in the Message definition, so it's not in the protobuf schema.
+
+**3. Type must remain consistent**
+```python
+class BadExample(Message):
+    number: int
+    
+    @field_serializer("number")
+    def serialize_number(self, number: int) -> str:  # ❌ int → str
+        return str(number)  # This will cause issues
+```
+
+**4. Union/Optional fields have limited support**
+```python
+class UnionExample(Message):
+    data: str | int | None  # Union type
+    
+    @field_serializer("data")
+    def serialize_data(self, data: str | int | None) -> str | int | None:
+        # Serializer may not be applied to Union types
+        return data
+```
+
+**5. Errors fail silently with fallback**
+```python
+class RiskyMessage(Message):
+    value: int
+    
+    @field_serializer("value")
+    def serialize_value(self, value: int) -> int:
+        if value == 0:
+            raise ValueError("Cannot serialize zero")
+        return value * 2
+
+# If error occurs, original value is used (silent fallback)
+```
+
+**6. Circular references are handled gracefully**
+```python
+class Node(Message):
+    value: str
+    child: "Node | None" = None
+    
+    @field_serializer("value")
+    def serialize_value(self, v: str) -> str:
+        return v.upper()
+
+# Circular references are detected and prevented
+node1 = Node(value="first")
+node2 = Node(value="second")
+node1.child = node2
+node2.child = node1  # Circular reference
+
+# When converting to protobuf:
+# - Circular references are detected
+# - Empty proto is returned for repeated objects
+# - No infinite recursion occurs
+# Note: Pydantic's model_dump() will fail on circular refs,
+#       so serializers won't be applied in this case
+```
+
+**✅ Recommended Usage:**
+```python
+class GoodMessage(Message):
+    # Use with primitive types
+    name: str
+    age: int
+    
+    @field_serializer("name")
+    def normalize_name(self, name: str) -> str:
+        return name.strip().title()  # Normalization
+    
+    @field_serializer("age")
+    def clamp_age(self, age: int) -> int:
+        return max(0, min(age, 150))  # Range limiting
+```
+
+**Best Practices:**
+- Use serializers primarily for primitive types (str, int, float, bool)
+- Keep type consistency (int → int, str → str)
+- Avoid complex transformations or side effects
+- Test error cases thoroughly
+- Be aware that errors fail silently
+
 ### 🔗 Multiple Services with Custom Interceptors
 
 PydanticRPC supports defining and running multiple services in a single server:
@@ -905,8 +1101,8 @@ This approach works because protobuf allows message types within `oneof` fields,
   - [x] unary-stream
   - [x] stream-unary
   - [x] stream-stream
-- [ ] Betterproto Support
-- [ ] Sonora-connect Support
+- [x] Empty Message Support (automatic google.protobuf.Empty)
+- [x] Pydantic Serializer Support (@model_serializer, @field_serializer)
 - [ ] Custom Health Check Support
 - [x] MCP (Model Context Protocol) Support via official MCP SDK
 - [ ] Add more examples

pydantic_rpc-0.8.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pydantic_rpc/__init__.py,sha256=7dbedaf58742b13e96954afb68ca91f9800a2faf0799f78da6070c9c88511065,440
+pydantic_rpc/core.py,sha256=2e2bce8aaf677ae50fdcdde51507da605ed77efe5e1a522e52b406c416b18318,104265
+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/py.typed,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
+pydantic_rpc-0.8.0.dist-info/WHEEL,sha256=ab6157bc637547491fb4567cd7ddf26b04d63382916ca16c29a5c8e94c9c9ef7,79
+pydantic_rpc-0.8.0.dist-info/entry_points.txt,sha256=72a47b1d2cae3abc045710fe0c2c2e6dfbb051fbf6960c22b62488004e9188ba,57
+pydantic_rpc-0.8.0.dist-info/METADATA,sha256=1cb4d588db71dd052e24c12c63d368c89520279bc9c9a8b10658fdd0d83ee0ec,29803
+pydantic_rpc-0.8.0.dist-info/RECORD,,

pydantic_rpc-0.8.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.7.22
+Root-Is-Purelib: true
+Tag: py3-none-any

{pydantic_rpc-0.7.0.dist-info → pydantic_rpc-0.8.0.dist-info}/entry_points.txt

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

pydantic_rpc-0.7.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-pydantic_rpc/__init__.py,sha256=fb7a9YdCsT6WlUr7aMqR-YAKL68HmfeNpgcMnIhREGU,440
-pydantic_rpc/core.py,sha256=eDOEvjrIdg8iN_RagvZ5yHvYIOzIhPHNORp-GzbRFTc,89401
-pydantic_rpc/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_rpc/mcp/__init__.py,sha256=8FrWLMONtcWXLhaHDEhFI8WMWsZQ2EVHBvHORTnMelI,123
-pydantic_rpc/mcp/converter.py,sha256=tg3K-C5r_2vksquLHp8tFuCcuY2PABgqT29z0aeISKQ,4158
-pydantic_rpc/mcp/exporter.py,sha256=IIM2Yvmpc-2eGnBbm1mqolM95sUU69h-9mZkpDCg0E8,10239
-pydantic_rpc-0.7.0.dist-info/METADATA,sha256=y6076ec28-4XiQYkEtvbyw8Duk4n-izw2Mp4Yy2LGP4,24343
-pydantic_rpc-0.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_rpc-0.7.0.dist-info/entry_points.txt,sha256=LeZJ6UN-fhjKrEGkcmsAAKuA-fIe7MpvzKMPSZfi0NE,56
-pydantic_rpc-0.7.0.dist-info/licenses/LICENSE,sha256=Y6jkAm2VqPqoGIGQ-mEQCecNfteQ2LwdpYhC5XiH_cA,1069
-pydantic_rpc-0.7.0.dist-info/RECORD,,

pydantic_rpc-0.7.0.dist-info/WHEEL

@@ -1,4 +0,0 @@
-Wheel-Version: 1.0
-Generator: hatchling 1.27.0
-Root-Is-Purelib: true
-Tag: py3-none-any

pydantic_rpc-0.7.0.dist-info/licenses/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 Yasushi Itoh
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.