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

pydantic_rpc/__init__.py

@@ -5,9 +5,14 @@ from .core import (
     AsyncIOServer,
     WSGIApp,
     ASGIApp,
-    ConnecpyASGIApp,
-    ConnecpyWSGIApp,
     Message,
+    generate_proto,
+)
+from .decorators import (
+    http_option,
+    proto_option,
+    get_method_options,
+    has_http_option,
 )
 
 __all__ = [
@@ -15,9 +20,12 @@ __all__ = [
     "AsyncIOServer",
     "WSGIApp",
     "ASGIApp",
-    "ConnecpyWSGIApp",
-    "ConnecpyASGIApp",
     "Message",
+    "generate_proto",
+    "http_option",
+    "proto_option",
+    "get_method_options",
+    "has_http_option",
 ]
 
 # Optional MCP support

pydantic_rpc/core.py

@@ -9,7 +9,7 @@ import sys
 import time
 import types
 from typing import Union
-from collections.abc import AsyncIterator, Awaitable, Callable
+from collections.abc import AsyncIterator, Awaitable, Callable, Iterable
 from concurrent import futures
 from pathlib import Path
 from posixpath import basename
@@ -35,8 +35,7 @@ from grpc_health.v1.health import HealthServicer
 from grpc_reflection.v1alpha import reflection
 from grpc_tools import protoc
 from pydantic import BaseModel, ValidationError
-from sonora.asgi import grpcASGI
-from sonora.wsgi import grpcWSGI
+from .decorators import get_method_options, has_http_option
 
 ###############################################################################
 # 1. Message definitions & converter extensions
@@ -838,7 +837,8 @@ def connect_obj_with_stub_connecpy(
         if method.__name__.startswith("_"):
             continue
         a_method = implement_stub_method(method)
-        setattr(ConcreteServiceClass, method_name, a_method)
+        # Use the original snake_case method name for Connecpy v2.2.0 compatibility
+        setattr(ConcreteServiceClass, method.__name__, a_method)
 
     return ConcreteServiceClass
 
@@ -847,7 +847,7 @@ def connect_obj_with_stub_async_connecpy(
     connecpy_module: Any, pb2_module: Any, obj: object
 ) -> type:
     """
-    Connect a Python service object to a Connecpy stub for async methods.
+    Connect a Python service object to a Connecpy stub for async methods with streaming support.
     """
     service_class = obj.__class__
     stub_class_name = service_class.__name__
@@ -857,12 +857,13 @@ def connect_obj_with_stub_async_connecpy(
         pass
 
     def implement_stub_method(
-        method: Callable[..., Awaitable[Message]],
+        method: Callable[..., Any],
     ) -> Callable[[object, Any, Any], Any]:
         sig = inspect.signature(method)
-        arg_type = get_request_arg_type(sig)
-        converter = generate_message_converter(arg_type)
+        input_type = get_request_arg_type(sig)
+        is_input_stream = is_stream_type(input_type)
         response_type = sig.return_annotation
+        is_output_stream = is_stream_type(response_type)
         size_of_parameters = len(sig.parameters)
 
         match size_of_parameters:
@@ -891,63 +892,215 @@ def connect_obj_with_stub_async_connecpy(
 
                 return stub_method0
 
-            case 1:
-
-                async def stub_method1(
-                    self: object,
-                    request: Any,
-                    context: Any,
-                    method: Callable[..., Awaitable[Message]] = method,
-                ) -> Any:
-                    _ = self
-                    try:
-                        if is_none_type(arg_type):
-                            resp_obj = await method(None)
-                        else:
-                            arg = converter(request)
-                            resp_obj = await method(arg)
-
-                        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_method1
-
-            case 2:
-
-                async def stub_method2(
-                    self: object,
-                    request: Any,
-                    context: Any,
-                    method: Callable[..., Awaitable[Message]] = method,
-                ) -> Any:
-                    _ = self
-                    try:
-                        if is_none_type(arg_type):
-                            resp_obj = await method(None, context)
-                        else:
-                            arg = converter(request)
-                            resp_obj = await method(arg, context)
-
-                        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_method2
+            case 1 | 2:
+                if is_input_stream:
+                    # Client streaming or bidirectional streaming
+                    input_item_type = get_args(input_type)[0]
+                    item_converter = generate_message_converter(input_item_type)
+
+                    async def convert_iterator(
+                        proto_iter: AsyncIterator[Any],
+                    ) -> AsyncIterator[Message]:
+                        async for proto in proto_iter:
+                            result = item_converter(proto)
+                            if result is None:
+                                raise TypeError(
+                                    f"Unexpected None result from converter for type {input_item_type}"
+                                )
+                            yield result
+
+                    if is_output_stream:
+                        # Bidirectional streaming
+                        output_item_type = get_args(response_type)[0]
+
+                        if size_of_parameters == 1:
+
+                            async def stub_method(
+                                self: object,
+                                request_iterator: AsyncIterator[Any],
+                                context: Any,
+                            ) -> AsyncIterator[Any]:
+                                _ = self
+                                try:
+                                    arg_iter = convert_iterator(request_iterator)
+                                    async for resp_obj in method(arg_iter):
+                                        yield convert_python_message_to_proto(
+                                            resp_obj, output_item_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))
+                        else:  # size_of_parameters == 2
+
+                            async def stub_method(
+                                self: object,
+                                request_iterator: AsyncIterator[Any],
+                                context: Any,
+                            ) -> AsyncIterator[Any]:
+                                _ = self
+                                try:
+                                    arg_iter = convert_iterator(request_iterator)
+                                    async for resp_obj in method(arg_iter, context):
+                                        yield convert_python_message_to_proto(
+                                            resp_obj, output_item_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_method
+                    else:
+                        # Client streaming
+                        if size_of_parameters == 1:
+
+                            async def stub_method(
+                                self: object,
+                                request_iterator: AsyncIterator[Any],
+                                context: Any,
+                            ) -> Any:
+                                _ = self
+                                try:
+                                    arg_iter = convert_iterator(request_iterator)
+                                    resp_obj = await method(arg_iter)
+                                    if is_none_type(response_type):
+                                        return empty_pb2.Empty()  # type: ignore
+                                    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))
+                        else:  # size_of_parameters == 2
+
+                            async def stub_method(
+                                self: object,
+                                request_iterator: AsyncIterator[Any],
+                                context: Any,
+                            ) -> Any:
+                                _ = self
+                                try:
+                                    arg_iter = convert_iterator(request_iterator)
+                                    resp_obj = await method(arg_iter, context)
+                                    if is_none_type(response_type):
+                                        return empty_pb2.Empty()  # type: ignore
+                                    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_method
+                else:
+                    # Unary request
+                    converter = generate_message_converter(input_type)
+
+                    if is_output_stream:
+                        # Server streaming
+                        output_item_type = get_args(response_type)[0]
+
+                        if size_of_parameters == 1:
+
+                            async def stub_method(
+                                self: object,
+                                request: Any,
+                                context: Any,
+                            ) -> AsyncIterator[Any]:
+                                _ = self
+                                try:
+                                    if is_none_type(input_type):
+                                        arg = None
+                                    else:
+                                        arg = converter(request)
+                                    async for resp_obj in method(arg):
+                                        yield convert_python_message_to_proto(
+                                            resp_obj, output_item_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))
+                        else:  # size_of_parameters == 2
+
+                            async def stub_method(
+                                self: object,
+                                request: Any,
+                                context: Any,
+                            ) -> AsyncIterator[Any]:
+                                _ = self
+                                try:
+                                    if is_none_type(input_type):
+                                        arg = None
+                                    else:
+                                        arg = converter(request)
+                                    async for resp_obj in method(arg, context):
+                                        yield convert_python_message_to_proto(
+                                            resp_obj, output_item_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_method
+                    else:
+                        # Unary RPC
+                        if size_of_parameters == 1:
+
+                            async def stub_method(
+                                self: object,
+                                request: Any,
+                                context: Any,
+                            ) -> Any:
+                                _ = self
+                                try:
+                                    if is_none_type(input_type):
+                                        resp_obj = await method(None)
+                                    else:
+                                        arg = converter(request)
+                                        resp_obj = await method(arg)
+
+                                    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))
+                        else:  # size_of_parameters == 2
+
+                            async def stub_method(
+                                self: object,
+                                request: Any,
+                                context: Any,
+                            ) -> Any:
+                                _ = self
+                                try:
+                                    if is_none_type(input_type):
+                                        resp_obj = await method(None, context)
+                                    else:
+                                        arg = converter(request)
+                                        resp_obj = await method(arg, context)
+
+                                    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_method
 
             case _:
                 raise Exception("Method must have 0, 1, or 2 parameters")
@@ -955,10 +1108,14 @@ def connect_obj_with_stub_async_connecpy(
     for method_name, method in get_rpc_methods(obj):
         if method.__name__.startswith("_"):
             continue
-        if not asyncio.iscoroutinefunction(method):
-            raise Exception("Method must be async", method_name)
+        # Check for async generator functions for streaming support
+        if not (
+            asyncio.iscoroutinefunction(method) or inspect.isasyncgenfunction(method)
+        ):
+            raise Exception(f"Method {method_name} must be async or async generator")
         a_method = implement_stub_method(method)
-        setattr(ConcreteServiceClass, method_name, a_method)
+        # Use the original snake_case method name for Connecpy v2.2.0 compatibility
+        setattr(ConcreteServiceClass, method.__name__, a_method)
 
     return ConcreteServiceClass
 
@@ -1510,11 +1667,11 @@ def generate_message_definition(
                         fields.append("//   length of " + str(metadata_item.len))
                     case annotated_types.MinLen:
                         fields.append(
-                            "//   minimum length of " + str(metadata_item.min_len)
+                            "//   minimum length of " + str(metadata_item.min_length)
                         )
                     case annotated_types.MaxLen:
                         fields.append(
-                            "//   maximum length of " + str(metadata_item.max_len)
+                            "//   maximum length of " + str(metadata_item.max_length)
                         )
                     case _:
                         fields.append("//   " + str(metadata_item))
@@ -1550,6 +1707,39 @@ def is_generic_alias(annotation: Any) -> bool:
     return get_origin(annotation) is not None
 
 
+def format_method_options(method: Any) -> list[str]:
+    """
+    Format protobuf options for a method.
+
+    Args:
+        method: The method to get options from
+
+    Returns:
+        List of formatted option strings
+    """
+    metadata = get_method_options(method)
+    if metadata is None:
+        return []
+
+    return metadata.to_proto_strings()
+
+
+def check_uses_http_options(obj: object) -> bool:
+    """
+    Check if any method in the service uses HTTP options.
+
+    Args:
+        obj: Service instance
+
+    Returns:
+        True if any method has HTTP options
+    """
+    for method_name, method in get_rpc_methods(obj):
+        if has_http_option(method):
+            return True
+    return False
+
+
 def generate_proto(obj: object, package_name: str = "") -> str:
     """
     Generate a .proto definition from a service class.
@@ -1570,6 +1760,7 @@ def generate_proto(obj: object, package_name: str = "") -> str:
     uses_timestamp = False
     uses_duration = False
     uses_empty = False
+    uses_http_options = check_uses_http_options(obj)
 
     def check_and_set_well_known_types_for_fields(py_type: Any):
         """Check well-known types for field annotations (excludes None/Empty)."""
@@ -1729,9 +1920,24 @@ def generate_proto(obj: object, package_name: str = "") -> str:
                 else output_msg_type.__name__
             )
 
-        rpc_definitions.append(
-            f"rpc {method_name} ({input_str}) returns ({output_str});"
-        )
+        # Get method options
+        method_options = format_method_options(method)
+
+        if method_options:
+            # RPC with options - use block format
+            rpc_definitions.append(
+                f"rpc {method_name} ({input_str}) returns ({output_str}) {{"
+            )
+            for option_str in method_options:
+                # Indent each option line
+                for line in option_str.split("\n"):
+                    rpc_definitions.append(f"  {line}")
+            rpc_definitions.append("}")
+        else:
+            # RPC without options - use simple format
+            rpc_definitions.append(
+                f"rpc {method_name} ({input_str}) returns ({output_str});"
+            )
 
     if not package_name:
         if service_name.endswith("Service"):
@@ -1741,6 +1947,8 @@ def generate_proto(obj: object, package_name: str = "") -> str:
         package_name = package_name.lower() + ".v1"
 
     imports: list[str] = []
+    if uses_http_options:
+        imports.append('import "google/api/annotations.proto";')
     if uses_timestamp:
         imports.append('import "google/protobuf/timestamp.proto";')
     if uses_duration:
@@ -2548,116 +2756,19 @@ class AsyncIOServer:
         print("gRPC server shutdown.")
 
 
-class WSGIApp:
-    """
-    A WSGI-compatible application that can serve gRPC via sonora's grpcWSGI.
-    Useful for embedding gRPC within an existing WSGI stack.
-    """
-
-    def __init__(self, app: Any):
-        self._app: grpcWSGI = grpcWSGI(app)
-        self._service_names: list[str] = []
-        self._package_name: str = ""
-
-    def mount(self, obj: object, package_name: str = ""):
-        """Generate and compile proto files, then mount the service implementation."""
-        pb2_grpc_module, pb2_module = generate_and_compile_proto(obj, package_name) or (
-            None,
-            None,
-        )
-        self.mount_using_pb2_modules(pb2_grpc_module, pb2_module, obj)
-
-    def mount_using_pb2_modules(
-        self, pb2_grpc_module: Any, pb2_module: Any, obj: object
-    ):
-        """Connect the compiled gRPC modules with the service implementation."""
-        concreteServiceClass = connect_obj_with_stub(pb2_grpc_module, pb2_module, obj)
-        service_name = obj.__class__.__name__
-        service_impl = concreteServiceClass()
-        getattr(pb2_grpc_module, f"add_{service_name}Servicer_to_server")(
-            service_impl, self._app
-        )
-        full_service_name = pb2_module.DESCRIPTOR.services_by_name[
-            service_name
-        ].full_name
-        self._service_names.append(full_service_name)
-
-    def mount_objs(self, *objs: object):
-        """Mount multiple service objects into this WSGI app."""
-        for obj in objs:
-            self.mount(obj, self._package_name)
-
-    def __call__(
-        self,
-        environ: dict[str, Any],
-        start_response: Callable[[str, list[tuple[str, str]]], None],
-    ) -> Any:
-        """WSGI entry point."""
-        return self._app(environ, start_response)
-
-
-class ASGIApp:
-    """
-    An ASGI-compatible application that can serve gRPC via sonora's grpcASGI.
-    Useful for embedding gRPC within an existing ASGI stack.
-    """
-
-    def __init__(self, app: Any):
-        self._app: grpcASGI = grpcASGI(app)
-        self._service_names: list[str] = []
-        self._package_name: str = ""
-
-    def mount(self, obj: object, package_name: str = ""):
-        """Generate and compile proto files, then mount the async service implementation."""
-        pb2_grpc_module, pb2_module = generate_and_compile_proto(obj, package_name) or (
-            None,
-            None,
-        )
-        self.mount_using_pb2_modules(pb2_grpc_module, pb2_module, obj)
-
-    def mount_using_pb2_modules(
-        self, pb2_grpc_module: Any, pb2_module: Any, obj: object
-    ):
-        """Connect the compiled gRPC modules with the async service implementation."""
-        concreteServiceClass = connect_obj_with_stub_async(
-            pb2_grpc_module, pb2_module, obj
-        )
-        service_name = obj.__class__.__name__
-        service_impl = concreteServiceClass()
-        getattr(pb2_grpc_module, f"add_{service_name}Servicer_to_server")(
-            service_impl, self._app
-        )
-        full_service_name = pb2_module.DESCRIPTOR.services_by_name[
-            service_name
-        ].full_name
-        self._service_names.append(full_service_name)
-
-    def mount_objs(self, *objs: object):
-        """Mount multiple service objects into this ASGI app."""
-        for obj in objs:
-            self.mount(obj, self._package_name)
-
-    async def __call__(
-        self,
-        scope: dict[str, Any],
-        receive: Callable[[], Any],
-        send: Callable[[dict[str, Any]], Any],
-    ) -> Any:
-        """ASGI entry point."""
-        _ = await self._app(scope, receive, send)
-
-
 def get_connecpy_asgi_app_class(connecpy_module: Any, service_name: str):
+    """Get the ASGI application class from connecpy module (Connecpy v2.x)."""
     return getattr(connecpy_module, f"{service_name}ASGIApplication")
 
 
 def get_connecpy_wsgi_app_class(connecpy_module: Any, service_name: str):
+    """Get the WSGI application class from connecpy module (Connecpy v2.x)."""
     return getattr(connecpy_module, f"{service_name}WSGIApplication")
 
 
-class ConnecpyASGIApp:
+class ASGIApp:
     """
-    An ASGI-compatible application that can serve Connect-RPC via Connecpy's ConnecpyASGIApp.
+    An ASGI-compatible application that can serve Connect-RPC via Connecpy.
     """
 
     def __init__(self):
@@ -2727,9 +2838,9 @@ class ConnecpyASGIApp:
         await send({"type": "http.response.body", "body": b"Not Found"})
 
 
-class ConnecpyWSGIApp:
+class WSGIApp:
     """
-    A WSGI-compatible application that can serve Connect-RPC via Connecpy's ConnecpyWSGIApp.
+    A WSGI-compatible application that can serve Connect-RPC via Connecpy.
     """
 
     def __init__(self):
@@ -2774,8 +2885,10 @@ class ConnecpyWSGIApp:
     def __call__(
         self,
         environ: dict[str, Any],
-        start_response: Callable[[str, list[tuple[str, str]]], None],
-    ) -> Any:
+        start_response: Callable[
+            [str, list[tuple[str, str]]], Callable[[bytes], object]
+        ],
+    ) -> Iterable[bytes]:
         """WSGI entry point with routing for multiple services."""
         path = environ.get("PATH_INFO", "")
 

pydantic_rpc/decorators.py

@@ -0,0 +1,138 @@
+"""Decorators for adding protobuf options to RPC methods."""
+
+from typing import Any, Callable, Dict, List, Optional, TypeVar
+from functools import wraps
+
+from .options import OptionMetadata, OPTION_METADATA_ATTR
+
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+def http_option(
+    method: str,
+    path: str,
+    body: Optional[str] = None,
+    response_body: Optional[str] = None,
+    additional_bindings: Optional[List[Dict[str, Any]]] = None,
+) -> Callable[[F], F]:
+    """
+    Decorator to add google.api.http option to an RPC method.
+
+    Args:
+        method: HTTP method (GET, POST, PUT, DELETE, PATCH)
+        path: URL path template (e.g., "/v1/books/{id}")
+        body: Request body mapping (e.g., "*" for entire body)
+        response_body: Response body mapping (specific field to return)
+        additional_bindings: List of additional HTTP bindings
+
+    Example:
+        @http_option(method="GET", path="/v1/books/{id}")
+        async def get_book(self, request: GetBookRequest) -> Book:
+            ...
+    """
+
+    def decorator(func: F) -> F:
+        # Get or create option metadata
+        if not hasattr(func, OPTION_METADATA_ATTR):
+            setattr(func, OPTION_METADATA_ATTR, OptionMetadata())
+
+        metadata: OptionMetadata = getattr(func, OPTION_METADATA_ATTR)
+
+        # Set HTTP option
+        metadata.set_http_option(
+            method=method,
+            path=path,
+            body=body,
+            response_body=response_body,
+            additional_bindings=additional_bindings,
+        )
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        # Preserve the metadata on the wrapper
+        setattr(wrapper, OPTION_METADATA_ATTR, metadata)
+
+        return wrapper  # type: ignore
+
+    return decorator
+
+
+def proto_option(name: str, value: Any) -> Callable[[F], F]:
+    """
+    Decorator to add a generic protobuf option to an RPC method.
+
+    Args:
+        name: Option name (e.g., "deprecated", "idempotency_level")
+        value: Option value
+
+    Example:
+        @proto_option("deprecated", True)
+        @proto_option("idempotency_level", "IDEMPOTENT")
+        async def old_method(self, request: Request) -> Response:
+            ...
+    """
+
+    def decorator(func: F) -> F:
+        # Get or create option metadata
+        if not hasattr(func, OPTION_METADATA_ATTR):
+            setattr(func, OPTION_METADATA_ATTR, OptionMetadata())
+
+        metadata: OptionMetadata = getattr(func, OPTION_METADATA_ATTR)
+
+        # Add proto option
+        metadata.add_proto_option(name=name, value=value)
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        # Preserve the metadata on the wrapper
+        setattr(wrapper, OPTION_METADATA_ATTR, metadata)
+
+        return wrapper  # type: ignore
+
+    return decorator
+
+
+def get_method_options(method: Callable) -> Optional[OptionMetadata]:
+    """
+    Get option metadata from a method.
+
+    Args:
+        method: The method to get options from
+
+    Returns:
+        OptionMetadata if present, None otherwise
+    """
+    return getattr(method, OPTION_METADATA_ATTR, None)
+
+
+def has_http_option(method: Callable) -> bool:
+    """
+    Check if a method has an HTTP option.
+
+    Args:
+        method: The method to check
+
+    Returns:
+        True if the method has an HTTP option, False otherwise
+    """
+    metadata = get_method_options(method)
+    return metadata is not None and metadata.http_option is not None
+
+
+def has_proto_options(method: Callable) -> bool:
+    """
+    Check if a method has any proto options.
+
+    Args:
+        method: The method to check
+
+    Returns:
+        True if the method has proto options, False otherwise
+    """
+    metadata = get_method_options(method)
+    return metadata is not None and len(metadata.proto_options) > 0

pydantic_rpc/options.py

@@ -0,0 +1,134 @@
+"""Protocol Buffer options support for pydantic-rpc."""
+
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field
+
+
+class HttpBinding(BaseModel):
+    """HTTP binding configuration for a single HTTP method."""
+
+    method: str = Field(..., description="HTTP method (get, post, put, delete, patch)")
+    path: Optional[str] = Field(None, description="URL path template")
+    body: Optional[str] = Field(None, description="Request body mapping")
+    response_body: Optional[str] = Field(None, description="Response body mapping")
+
+    def to_proto_dict(self) -> Dict[str, Any]:
+        """Convert to protobuf option format."""
+        result = {}
+        if self.path:
+            result[self.method.lower()] = self.path
+        if self.body:
+            result["body"] = self.body
+        if self.response_body:
+            result["response_body"] = self.response_body
+        return result
+
+
+class HttpOption(BaseModel):
+    """Google API HTTP option configuration."""
+
+    method: str = Field(..., description="Primary HTTP method")
+    path: str = Field(..., description="Primary URL path template")
+    body: Optional[str] = Field(None, description="Request body mapping")
+    response_body: Optional[str] = Field(None, description="Response body mapping")
+    additional_bindings: List[Dict[str, Any]] = Field(
+        default_factory=list, description="Additional HTTP bindings"
+    )
+
+    def to_proto_string(self) -> str:
+        """Convert to protobuf option string format."""
+        lines = []
+        lines.append("option (google.api.http) = {")
+
+        # Primary binding
+        lines.append(f'  {self.method.lower()}: "{self.path}"')
+
+        # Body mapping
+        if self.body:
+            lines.append(f'  body: "{self.body}"')
+
+        # Response body mapping
+        if self.response_body:
+            lines.append(f'  response_body: "{self.response_body}"')
+
+        # Additional bindings
+        for binding in self.additional_bindings:
+            lines.append("  additional_bindings {")
+            for key, value in binding.items():
+                if key == "body":
+                    lines.append(f'    {key}: "{value}"')
+                else:
+                    lines.append(f'    {key}: "{value}"')
+            lines.append("  }")
+
+        lines.append("};")
+        return "\n".join(lines)
+
+
+class ProtoOption(BaseModel):
+    """Generic protocol buffer option."""
+
+    name: str = Field(..., description="Option name")
+    value: Any = Field(..., description="Option value")
+
+    def to_proto_string(self) -> str:
+        """Convert to protobuf option string format."""
+        if isinstance(self.value, bool):
+            value_str = "true" if self.value else "false"
+        elif isinstance(self.value, str):
+            # Check if it's an enum value (no quotes) or string literal (quotes)
+            if self.value.isupper() or "_" in self.value:
+                # Likely an enum value
+                value_str = self.value
+            else:
+                value_str = f'"{self.value}"'
+        else:
+            value_str = str(self.value)
+
+        return f"option {self.name} = {value_str};"
+
+
+class OptionMetadata(BaseModel):
+    """Metadata container for method/service options."""
+
+    http_option: Optional[HttpOption] = None
+    proto_options: List[ProtoOption] = Field(default_factory=list)
+
+    def add_proto_option(self, name: str, value: Any) -> None:
+        """Add a generic proto option."""
+        self.proto_options.append(ProtoOption(name=name, value=value))
+
+    def set_http_option(
+        self,
+        method: str,
+        path: str,
+        body: Optional[str] = None,
+        response_body: Optional[str] = None,
+        additional_bindings: Optional[List[Dict[str, Any]]] = None,
+    ) -> None:
+        """Set the HTTP option configuration."""
+        self.http_option = HttpOption(
+            method=method,
+            path=path,
+            body=body,
+            response_body=response_body,
+            additional_bindings=additional_bindings or [],
+        )
+
+    def to_proto_strings(self) -> List[str]:
+        """Convert all options to protobuf strings."""
+        result = []
+
+        # Add HTTP option first if present
+        if self.http_option:
+            result.append(self.http_option.to_proto_string())
+
+        # Add other proto options
+        for option in self.proto_options:
+            result.append(option.to_proto_string())
+
+        return result
+
+
+# Option metadata attribute name used on methods
+OPTION_METADATA_ATTR = "__pydantic_rpc_options__"

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

@@ -1,16 +1,15 @@
 Metadata-Version: 2.3
 Name: pydantic-rpc
-Version: 0.8.0
+Version: 0.9.0
 Summary: A Python library for building gRPC/ConnectRPC services with Pydantic models.
 Author: Yasushi Itoh
-Requires-Dist: annotated-types>=0.5.0
+Requires-Dist: annotated-types==0.7.0
 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: connecpy>=2.2.0
 Requires-Dist: mcp>=1.9.4
 Requires-Dist: starlette>=0.27.0
 Requires-Python: >=3.11
@@ -76,7 +75,7 @@ import asyncio
 from openai import AsyncOpenAI
 from pydantic_ai import Agent
 from pydantic_ai.models.openai import OpenAIModel
-from pydantic_rpc import ConnecpyASGIApp, Message
+from pydantic_rpc import ASGIApp, Message
 
 
 class CityLocation(Message):
@@ -107,7 +106,7 @@ class OlympicsLocationAgent:
         result = await self._agent.run(req.prompt())
         return result.data
 
-app = ConnecpyASGIApp()
+app = ASGIApp()
 app.mount(OlympicsLocationAgent())
 
 ```
@@ -123,10 +122,10 @@ app.mount(OlympicsLocationAgent())
   - 💚 **Health Checking:** Built-in support for gRPC health checks using `grpc_health.v1`.
   - 🔎 **Server Reflection:** Built-in support for gRPC server reflection.
   - ⚡ **Asynchronous Support:** Easily create asynchronous gRPC services with `AsyncIOServer`.
-- **For gRPC-Web:**
-  - 🌐 **WSGI/ASGI Support:** Create gRPC-Web services that can run as WSGI or ASGI applications powered by `Sonora`.
 - **For Connect-RPC:**
-  - 🌐 **Connecpy Support:** Partially supports Connect-RPC via `Connecpy`.
+  - 🌐 **Full Protocol Support:** Native Connect-RPC support via `Connecpy` v2.2.0+
+  - 🔄 **All Streaming Patterns:** Unary, server streaming, client streaming, and bidirectional streaming
+  - 🌐 **WSGI/ASGI Applications:** Run as standard WSGI or ASGI applications for easy deployment
 - 🛠️ **Pre-generated Protobuf Files and Code:** Pre-generate proto files and corresponding code via the CLI. By setting the environment variable (PYDANTIC_RPC_SKIP_GENERATION), you can skip runtime generation.
 - 🤖 **MCP (Model Context Protocol) Support:** Expose your services as tools for AI assistants using the official MCP SDK, supporting both stdio and HTTP/SSE transports.
 
@@ -140,7 +139,11 @@ pip install pydantic-rpc
 
 ## 🚀 Getting Started
 
-### 🔧 Synchronous Service Example
+PydanticRPC supports two main protocols:
+- **gRPC**: Traditional gRPC services with `Server` and `AsyncIOServer`
+- **Connect-RPC**: Modern HTTP-based RPC with `ASGIApp` and `WSGIApp`
+
+### 🔧 Synchronous gRPC Service Example
 
 ```python
 from pydantic_rpc import Server, Message
@@ -161,7 +164,7 @@ if __name__ == "__main__":
     server.run(Greeter())
 ```
 
-### ⚙️ Asynchronous Service Example
+### ⚙️ Asynchronous gRPC Service Example
 
 ```python
 import asyncio
@@ -194,7 +197,7 @@ if __name__ == "__main__":
 
 The AsyncIOServer automatically handles graceful shutdown on SIGTERM and SIGINT signals.
 
-### 🌐 ASGI Application Example
+### 🌐 Connect-RPC ASGI Application Example
 
 ```python
 from pydantic_rpc import ASGIApp, Message
@@ -206,27 +209,17 @@ class HelloReply(Message):
     message: str
 
 class Greeter:
-    def say_hello(self, request: HelloRequest) -> HelloReply:
+    async def say_hello(self, request: HelloRequest) -> HelloReply:
         return HelloReply(message=f"Hello, {request.name}!")
 
-
-async def app(scope, receive, send):
-    """ASGI application.
-
-    Args:
-        scope (dict): The ASGI scope.
-        receive (callable): The receive function.
-        send (callable): The send function.
-    """
-    pass
-
-# Please note that `app` is any ASGI application, such as FastAPI or Starlette.
-
-app = ASGIApp(app)
+app = ASGIApp()
 app.mount(Greeter())
+
+# Run with uvicorn:
+# uvicorn script:app --host 0.0.0.0 --port 8000
 ```
 
-### 🌐 WSGI Application Example
+### 🌐 Connect-RPC WSGI Application Example
 
 ```python
 from pydantic_rpc import WSGIApp, Message
@@ -241,31 +234,69 @@ class Greeter:
     def say_hello(self, request: HelloRequest) -> HelloReply:
         return HelloReply(message=f"Hello, {request.name}!")
 
-def app(environ, start_response):
-    """WSGI application.
-
-    Args:
-        environ (dict): The WSGI environment.
-        start_response (callable): The start_response function.
-    """
-    pass
-
-# Please note that `app` is any WSGI application, such as Flask or Django.
-
-app = WSGIApp(app)
+app = WSGIApp()
 app.mount(Greeter())
+
+# Run with gunicorn:
+# gunicorn script:app
 ```
 
-### 🏆 Connecpy (Connect-RPC) Example
+### 🏆 Connect-RPC with Streaming Example
 
-PydanticRPC also partially supports Connect-RPC via connecpy. Check out “greeting_connecpy.py” for an example:
+PydanticRPC provides native Connect-RPC support via Connecpy v2.2.0+, including full streaming capabilities and PEP 8 naming conventions. Check out our ASGI examples:
 
 ```bash
-uv run greeting_connecpy.py
+# Run with uvicorn
+uv run uvicorn greeting_asgi:app --port 3000
+
+# Or run streaming example
+uv run python examples/streaming_connecpy.py
 ```
 
 This will launch a Connecpy-based ASGI application that uses the same Pydantic models to serve Connect-RPC requests.
 
+#### Streaming Support with Connecpy
+
+Connecpy v2.2.0 provides full support for streaming RPCs with automatic PEP 8 naming (snake_case):
+
+```python
+from typing import AsyncIterator
+from pydantic_rpc import ASGIApp, Message
+
+class StreamRequest(Message):
+    text: str
+    count: int
+
+class StreamResponse(Message):
+    text: str
+    index: int
+
+class StreamingService:
+    # Server streaming
+    async def server_stream(self, request: StreamRequest) -> AsyncIterator[StreamResponse]:
+        for i in range(request.count):
+            yield StreamResponse(text=f"{request.text}_{i}", index=i)
+    
+    # Client streaming
+    async def client_stream(self, requests: AsyncIterator[StreamRequest]) -> StreamResponse:
+        texts = []
+        async for req in requests:
+            texts.append(req.text)
+        return StreamResponse(text=" ".join(texts), index=len(texts))
+    
+    # Bidirectional streaming
+    async def bidi_stream(
+        self, requests: AsyncIterator[StreamRequest]
+    ) -> AsyncIterator[StreamResponse]:
+        idx = 0
+        async for req in requests:
+            yield StreamResponse(text=f"Echo: {req.text}", index=idx)
+            idx += 1
+
+app = ASGIApp()
+app.mount(StreamingService())
+```
+
 > [!NOTE]
 > Please install `protoc-gen-connecpy` to run the Connecpy example.
 >
@@ -302,9 +333,9 @@ export PYDANTIC_RPC_RESERVED_FIELDS=1
 
 ## 💎 Advanced Features
 
-### 🌊 Response Streaming
-PydanticRPC supports streaming responses only for asynchronous gRPC and gRPC-Web services.
-If a service class method’s return type is `typing.AsyncIterator[T]`, the method is considered a streaming method.
+### 🌊 Response Streaming (gRPC)
+PydanticRPC supports streaming responses for both gRPC and Connect-RPC services.
+If a service class method's return type is `typing.AsyncIterator[T]`, the method is considered a streaming method.
 
 
 Please see the sample code below:
@@ -871,8 +902,9 @@ class GoodMessage(Message):
 - Be aware that errors fail silently
 
 ### 🔗 Multiple Services with Custom Interceptors
+>>>>>>> origin/main
 
-PydanticRPC supports defining and running multiple services in a single server:
+PydanticRPC supports defining and running multiple gRPC services in a single server:
 
 ```python
 from datetime import datetime
@@ -1003,11 +1035,11 @@ Any MCP-compatible client can connect to your service. For example, to configure
 MCP can also be mounted to existing ASGI applications:
 
 ```python
-from pydantic_rpc import ConnecpyASGIApp
+from pydantic_rpc import ASGIApp
 from pydantic_rpc.mcp import MCPExporter
 
 # Create Connect-RPC ASGI app
-app = ConnecpyASGIApp()
+app = ASGIApp()
 app.mount(MathService())
 
 # Add MCP support via HTTP/SSE

pydantic_rpc-0.9.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+pydantic_rpc/__init__.py,sha256=cd21549eab234e0bc3b3744713c65486b00a63e9ca8d4696506b819099fc1f79,590
+pydantic_rpc/core.py,sha256=ccc7a5f91dc471a0ecc253a5fd766a24878308be7905532ee7c6b9b51b9a1b8e,111436
+pydantic_rpc/decorators.py,sha256=2f2dc3f642a6e40d05187901e75269415a70b8f18d555e6c7ac923dee149d34c,3852
+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-0.9.0.dist-info/WHEEL,sha256=ab6157bc637547491fb4567cd7ddf26b04d63382916ca16c29a5c8e94c9c9ef7,79
+pydantic_rpc-0.9.0.dist-info/entry_points.txt,sha256=72a47b1d2cae3abc045710fe0c2c2e6dfbb051fbf6960c22b62488004e9188ba,57
+pydantic_rpc-0.9.0.dist-info/METADATA,sha256=7a022eb4a99c02b665ceb0dca3d48ad587ade87f9be0f08f7b6c378738bd043e,30976
+pydantic_rpc-0.9.0.dist-info/RECORD,,

pydantic_rpc-0.8.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-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,,