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

pydantic_rpc/core.py

@@ -9,12 +9,13 @@ 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
 from typing import (
     Any,
+    Optional,
     TypeAlias,
     get_args,
     get_origin,
@@ -35,8 +36,8 @@ 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
+from .tls import GrpcTLSConfig
 
 ###############################################################################
 # 1. Message definitions & converter extensions
@@ -838,7 +839,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 +849,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 +859,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 +894,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 +1110,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 +1669,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 +1709,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 +1762,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 +1922,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 +1949,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:
@@ -2394,13 +2604,19 @@ def generate_combined_descriptor_set(
 class Server:
     """A simple gRPC server that uses ThreadPoolExecutor for concurrency."""
 
-    def __init__(self, max_workers: int = 8, *interceptors: Any) -> None:
+    def __init__(
+        self,
+        max_workers: int = 8,
+        *interceptors: Any,
+        tls: Optional["GrpcTLSConfig"] = None,
+    ) -> None:
         self._server: grpc.Server = grpc.server(
             futures.ThreadPoolExecutor(max_workers), interceptors=interceptors
         )
         self._service_names: list[str] = []
         self._package_name: str = ""
         self._port: int = 50051
+        self._tls_config = tls
 
     def set_package_name(self, package_name: str):
         """Set the package name for .proto generation."""
@@ -2450,7 +2666,16 @@ class Server:
         health_pb2_grpc.add_HealthServicer_to_server(health_servicer, self._server)
         reflection.enable_server_reflection(SERVICE_NAMES, self._server)
 
-        self._server.add_insecure_port(f"[::]:{self._port}")
+        if self._tls_config:
+            # Use secure port with TLS
+            credentials = self._tls_config.to_server_credentials()
+            self._server.add_secure_port(f"[::]:{self._port}", credentials)
+            print(f"gRPC server starting with TLS on port {self._port}...")
+        else:
+            # Use insecure port
+            self._server.add_insecure_port(f"[::]:{self._port}")
+            print(f"gRPC server starting on port {self._port}...")
+
         self._server.start()
 
         def handle_signal(signum: signal.Signals, frame: Any):
@@ -2472,11 +2697,16 @@ class Server:
 class AsyncIOServer:
     """An async gRPC server using asyncio."""
 
-    def __init__(self, *interceptors: grpc.ServerInterceptor) -> None:
+    def __init__(
+        self,
+        *interceptors: grpc.ServerInterceptor,
+        tls: Optional["GrpcTLSConfig"] = None,
+    ) -> None:
         self._server: grpc.aio.Server = grpc.aio.server(interceptors=interceptors)
         self._service_names: list[str] = []
         self._package_name: str = ""
         self._port: int = 50051
+        self._tls_config = tls
 
     def set_package_name(self, package_name: str):
         """Set the package name for .proto generation."""
@@ -2528,7 +2758,16 @@ class AsyncIOServer:
         health_pb2_grpc.add_HealthServicer_to_server(health_servicer, self._server)
         reflection.enable_server_reflection(SERVICE_NAMES, self._server)
 
-        _ = self._server.add_insecure_port(f"[::]:{self._port}")
+        if self._tls_config:
+            # Use secure port with TLS
+            credentials = self._tls_config.to_server_credentials()
+            _ = self._server.add_secure_port(f"[::]:{self._port}", credentials)
+            print(f"gRPC server starting with TLS on port {self._port}...")
+        else:
+            # Use insecure port
+            _ = self._server.add_insecure_port(f"[::]:{self._port}")
+            print(f"gRPC server starting on port {self._port}...")
+
         await self._server.start()
 
         shutdown_event = asyncio.Event()
@@ -2548,116 +2787,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 +2869,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 +2916,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", "")