pydantic-rpc 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

pydantic_rpc/core.py

@@ -17,17 +17,20 @@ from typing import (
     get_origin,
     Union,
     TypeAlias,
+    # AsyncIterator,  # Add if not already present
 )
+from collections.abc import AsyncIterator
 
 import grpc
 from grpc_health.v1 import health_pb2, health_pb2_grpc
 from grpc_health.v1.health import HealthServicer
 from grpc_reflection.v1alpha import reflection
 from grpc_tools import protoc
-from pydantic import BaseModel
+from pydantic import BaseModel, ValidationError
 from sonora.wsgi import grpcWSGI
 from sonora.asgi import grpcASGI
 from connecpy.asgi import ConnecpyASGIApp as ConnecpyASGI
+from connecpy.errors import Errors
 
 # Protobuf Python modules for Timestamp, Duration (requires protobuf / grpcio)
 from google.protobuf import timestamp_pb2, duration_pb2
@@ -104,24 +107,26 @@ def generate_converter(annotation: Type) -> Callable:
 
         return dur_converter
 
-    # For list types
-    if get_origin(annotation) is list:
-        item_converter = generate_converter(get_args(annotation)[0])
+    origin = get_origin(annotation)
+    if origin is not None:
+        # For seq types
+        if origin in (list, tuple):
+            item_converter = generate_converter(get_args(annotation)[0])
 
-        def list_converter(value):
-            return [item_converter(v) for v in value]
+            def seq_converter(value):
+                return [item_converter(v) for v in value]
 
-        return list_converter
+            return seq_converter
 
-    # For dict types
-    if get_origin(annotation) is dict:
-        key_converter = generate_converter(get_args(annotation)[0])
-        value_converter = generate_converter(get_args(annotation)[1])
+        # For dict types
+        if origin is dict:
+            key_converter = generate_converter(get_args(annotation)[0])
+            value_converter = generate_converter(get_args(annotation)[1])
 
-        def dict_converter(value):
-            return {key_converter(k): value_converter(v) for k, v in value.items()}
+            def dict_converter(value):
+                return {key_converter(k): value_converter(v) for k, v in value.items()}
 
-        return dict_converter
+            return dict_converter
 
     # For Message classes
     if inspect.isclass(annotation) and issubclass(annotation, Message):
@@ -198,25 +203,35 @@ def connect_obj_with_stub(pb2_grpc_module, pb2_module, service_obj: object) -> t
             case 1:
 
                 def stub_method1(self, request, context, method=method):
-                    # Convert request to Python object
-                    arg = converter(request)
-                    # Invoke the actual method
-                    resp_obj = method(arg)
-                    # Convert the returned Python Message to a protobuf message
-                    return convert_python_message_to_proto(
-                        resp_obj, response_type, pb2_module
-                    )
+                    try:
+                        # Convert request to Python object
+                        arg = converter(request)
+                        # Invoke the actual method
+                        resp_obj = method(arg)
+                        # Convert the returned Python Message to a protobuf message
+                        return convert_python_message_to_proto(
+                            resp_obj, response_type, pb2_module
+                        )
+                    except ValidationError as e:
+                        return context.abort(grpc.StatusCode.INVALID_ARGUMENT, str(e))
+                    except Exception as e:
+                        return context.abort(grpc.StatusCode.INTERNAL, str(e))
 
                 return stub_method1
 
             case 2:
 
                 def stub_method2(self, request, context, method=method):
-                    arg = converter(request)
-                    resp_obj = method(arg, context)
-                    return convert_python_message_to_proto(
-                        resp_obj, response_type, pb2_module
-                    )
+                    try:
+                        arg = converter(request)
+                        resp_obj = method(arg, context)
+                        return convert_python_message_to_proto(
+                            resp_obj, response_type, pb2_module
+                        )
+                    except ValidationError as e:
+                        return context.abort(grpc.StatusCode.INVALID_ARGUMENT, str(e))
+                    except Exception as e:
+                        return context.abort(grpc.StatusCode.INTERNAL, str(e))
 
                 return stub_method2
 
@@ -251,26 +266,80 @@ def connect_obj_with_stub_async(pb2_grpc_module, pb2_module, obj: object) -> typ
         response_type = sig.return_annotation
         size_of_parameters = len(sig.parameters)
 
+        if is_stream_type(response_type):
+            item_type = get_args(response_type)[0]
+            match size_of_parameters:
+                case 1:
+
+                    async def stub_method_stream1(
+                        self, request, context, method=method
+                    ):
+                        try:
+                            arg = converter(request)
+                            async for resp_obj in method(arg):
+                                yield convert_python_message_to_proto(
+                                    resp_obj, item_type, pb2_module
+                                )
+                        except ValidationError as e:
+                            await context.abort(
+                                grpc.StatusCode.INVALID_ARGUMENT, str(e)
+                            )
+                        except Exception as e:
+                            await context.abort(grpc.StatusCode.INTERNAL, str(e))
+
+                    return stub_method_stream1
+                case 2:
+
+                    async def stub_method_stream2(
+                        self, request, context, method=method
+                    ):
+                        try:
+                            arg = converter(request)
+                            async for resp_obj in method(arg, context):
+                                yield convert_python_message_to_proto(
+                                    resp_obj, item_type, pb2_module
+                                )
+                        except ValidationError as e:
+                            await context.abort(
+                                grpc.StatusCode.INVALID_ARGUMENT, str(e)
+                            )
+                        except Exception as e:
+                            await context.abort(grpc.StatusCode.INTERNAL, str(e))
+
+                    return stub_method_stream2
+                case _:
+                    raise Exception("Method must have exactly one or two parameters")
+
         match size_of_parameters:
             case 1:
 
                 async def stub_method1(self, request, context, method=method):
-                    arg = converter(request)
-                    resp_obj = await method(arg)
-                    return convert_python_message_to_proto(
-                        resp_obj, response_type, pb2_module
-                    )
+                    try:
+                        arg = converter(request)
+                        resp_obj = await method(arg)
+                        return convert_python_message_to_proto(
+                            resp_obj, response_type, pb2_module
+                        )
+                    except ValidationError as e:
+                        await context.abort(grpc.StatusCode.INVALID_ARGUMENT, str(e))
+                    except Exception as e:
+                        await context.abort(grpc.StatusCode.INTERNAL, str(e))
 
                 return stub_method1
 
             case 2:
 
                 async def stub_method2(self, request, context, method=method):
-                    arg = converter(request)
-                    resp_obj = await method(arg, context)
-                    return convert_python_message_to_proto(
-                        resp_obj, response_type, pb2_module
-                    )
+                    try:
+                        arg = converter(request)
+                        resp_obj = await method(arg, context)
+                        return convert_python_message_to_proto(
+                            resp_obj, response_type, pb2_module
+                        )
+                    except ValidationError as e:
+                        await context.abort(grpc.StatusCode.INVALID_ARGUMENT, str(e))
+                    except Exception as e:
+                        await context.abort(grpc.StatusCode.INTERNAL, str(e))
 
                 return stub_method2
 
@@ -302,7 +371,6 @@ def connect_obj_with_stub_async_connecpy(
 
     def implement_stub_method(method):
         sig = inspect.signature(method)
-        print(type(method))
         arg_type = get_request_arg_type(sig)
         converter = generate_message_converter(arg_type)
         response_type = sig.return_annotation
@@ -312,22 +380,32 @@ def connect_obj_with_stub_async_connecpy(
             case 1:
 
                 async def stub_method1(self, request, context, method=method):
-                    arg = converter(request)
-                    resp_obj = await method(arg)
-                    return convert_python_message_to_proto(
-                        resp_obj, response_type, pb2_module
-                    )
+                    try:
+                        arg = converter(request)
+                        resp_obj = await method(arg)
+                        return convert_python_message_to_proto(
+                            resp_obj, response_type, pb2_module
+                        )
+                    except ValidationError as e:
+                        await context.abort(Errors.InvalidArgument, str(e))
+                    except Exception as e:
+                        await context.abort(Errors.Internal, str(e))
 
                 return stub_method1
 
             case 2:
 
                 async def stub_method2(self, request, context, method=method):
-                    arg = converter(request)
-                    resp_obj = await method(arg, context)
-                    return convert_python_message_to_proto(
-                        resp_obj, response_type, pb2_module
-                    )
+                    try:
+                        arg = converter(request)
+                        resp_obj = await method(arg, context)
+                        return convert_python_message_to_proto(
+                            resp_obj, response_type, pb2_module
+                        )
+                    except ValidationError as e:
+                        await context.abort(Errors.InvalidArgument, str(e))
+                    except Exception as e:
+                        await context.abort(Errors.Internal, str(e))
 
                 return stub_method2
 
@@ -388,13 +466,14 @@ def python_value_to_proto(field_type: Type, value, pb2_module):
     if inspect.isclass(field_type) and issubclass(field_type, enum.Enum):
         return value.value  # proto3 enum is an int
 
-    # If list
-    if get_origin(field_type) is list:
+    origin = get_origin(field_type)
+    # If seq
+    if origin in (list, tuple):
         inner_type = get_args(field_type)[0]  # type: ignore
         return [python_value_to_proto(inner_type, v, pb2_module) for v in value]
 
     # If dict
-    if get_origin(field_type) is dict:
+    if origin is dict:
         key_type, val_type = get_args(field_type)  # type: ignore
         return {
             python_value_to_proto(key_type, k, pb2_module): python_value_to_proto(
@@ -500,7 +579,7 @@ def protobuf_type_mapping(python_type: Type) -> str | type | None:
         return None  # Handled separately as oneof
 
     if hasattr(python_type, "__origin__"):
-        if python_type.__origin__ is list:
+        if python_type.__origin__ in (list, tuple):
             inner_type = python_type.__args__[0]
             inner_proto_type = protobuf_type_mapping(inner_type)
             if inner_proto_type:
@@ -629,6 +708,14 @@ def generate_message_definition(
     return msg_def, refs
 
 
+def is_stream_type(annotation: Type) -> bool:
+    return get_origin(annotation) is AsyncIterator
+
+
+def is_generic_alias(annotation: Type) -> bool:
+    return get_origin(annotation) is not None
+
+
 def generate_proto(obj: object, package_name: str = "") -> str:
     """
     Generate a .proto definition from a service class.
@@ -672,6 +759,11 @@ def generate_proto(obj: object, package_name: str = "") -> str:
                 continue
             done_messages.add(mt)
 
+            if is_stream_type(mt):
+                item_type = get_args(mt)[0]
+                message_types.append(item_type)
+                continue
+
             for _, field_info in mt.model_fields.items():
                 t = field_info.annotation
                 if is_union_type(t):
@@ -702,9 +794,16 @@ def generate_proto(obj: object, package_name: str = "") -> str:
         if method_docstr:
             for comment_line in comment_out(method_docstr):
                 rpc_definitions.append(comment_line)
-        rpc_definitions.append(
-            f"rpc {method_name} ({request_type.__name__}) returns ({response_type.__name__});"
-        )
+
+        if is_stream_type(response_type):
+            item_type = get_args(response_type)[0]
+            rpc_definitions.append(
+                f"rpc {method_name} ({request_type.__name__}) returns (stream {item_type.__name__});"
+            )
+        else:
+            rpc_definitions.append(
+                f"rpc {method_name} ({request_type.__name__}) returns ({response_type.__name__});"
+            )
 
     if not package_name:
         if service_name.endswith("Service"):

{pydantic_rpc-0.2.1.dist-info → pydantic_rpc-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pydantic-rpc
-Version: 0.2.1
+Version: 0.3.0
 Summary: A Python library for building gRPC/ConnectRPC services with Pydantic models.
 Author: Yasushi Itoh
 Requires-Python: >=3.11
@@ -14,7 +14,7 @@ Description-Content-Type: text/markdown
 
 # 🚀 PydanticRPC
 
-**PydanticRPC** is a Python library that enables you to rapidly expose [Pydantic](https://docs.pydantic.dev/) models via [gRPC](https://grpc.io/)/[ConnectRPC](https://connectrpc.com/docs/protocol/) services without writing any protobuf files. Instead, it automatically generates protobuf files on the fly from the method signatures of your Python objects and the type signatures of your Pydantic models.
+**PydanticRPC** is a Python library that enables you to rapidly expose [Pydantic](https://docs.pydantic.dev/) models via [gRPC](https://grpc.io/)/[Connect RPC](https://connectrpc.com/docs/protocol/) services without writing any protobuf files. Instead, it automatically generates protobuf files on the fly from the method signatures of your Python objects and the type signatures of your Pydantic models.
 
 
 Below is an example of a simple gRPC service that exposes a [PydanticAI](https://ai.pydantic.dev/) agent:
@@ -54,7 +54,7 @@ if __name__ == "__main__":
     loop.run_until_complete(s.run(OlympicsLocationAgent()))
 ```
 
-And here is an example of a simple ConnectRPC service that exposes the same agent as an ASGI application:
+And here is an example of a simple Connect RPC service that exposes the same agent as an ASGI application:
 
 ```python
 import asyncio
@@ -254,6 +254,88 @@ When this variable is set to "true", PydanticRPC will load existing pre-generate
 
 ## 💎 Advanced Features
 
+### 🌊 Response Streaming
+PydanticRPC supports streaming for responses in asynchronous gRPC and gRPC-Web services only.
+
+Please see the sample code below:
+
+```python
+import asyncio
+from typing import AsyncIterator
+
+from pydantic import field_validator
+from pydantic_ai import Agent
+from pydantic_rpc import AsyncIOServer, Message
+
+
+# `Message` is just a pydantic BaseModel alias
+class CityLocation(Message):
+    city: str
+    country: str
+
+
+class OlympicsQuery(Message):
+    year: int
+
+    def prompt(self):
+        return f"Where were the Olympics held in {self.year}?"
+
+    @field_validator("year")
+    def validate_year(cls, value):
+        if value < 1896:
+            raise ValueError("The first modern Olympics was held in 1896.")
+
+        return value
+
+
+class OlympicsDurationQuery(Message):
+    start: int
+    end: int
+
+    def prompt(self):
+        return f"From {self.start} to {self.end}, how many Olympics were held? Please provide the list of countries and cities."
+
+    @field_validator("start")
+    def validate_start(cls, value):
+        if value < 1896:
+            raise ValueError("The first modern Olympics was held in 1896.")
+
+        return value
+
+    @field_validator("end")
+    def validate_end(cls, value):
+        if value < 1896:
+            raise ValueError("The first modern Olympics was held in 1896.")
+
+        return value
+
+
+class StreamingResult(Message):
+    answer: str
+
+
+class OlympicsAgent:
+    def __init__(self):
+        self._agent = Agent("ollama:llama3.2")
+
+    async def ask(self, req: OlympicsQuery) -> CityLocation:
+        result = await self._agent.run(req.prompt(), result_type=CityLocation)
+        return result.data
+
+    async def ask_stream(
+        self, req: OlympicsDurationQuery
+    ) -> AsyncIterator[StreamingResult]:
+        async with self._agent.run_stream(req.prompt(), result_type=str) as result:
+            async for data in result.stream_text(delta=True):
+                yield StreamingResult(answer=data)
+
+
+if __name__ == "__main__":
+    s = AsyncIOServer()
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(s.run(OlympicsAgent()))
+```
+
 ### 🔗 Multiple Services with Custom Interceptors
 
 PydanticRPC supports defining and running multiple services in a single server:
@@ -349,6 +431,17 @@ python core.py a_module.py aClass
 
 Using this generated proto file and tools as `protoc`, `buf` and `BSR`, you could generate code for any desired language other than Python.
 
+## 📖 Data Type Mapping
+
+| Python Type        | Protobuf Type   |
+|--------------------|-----------------|
+| str                | string          |
+| bool               | bool            |
+| int                | int32, int64    |
+| float              | float, double   |
+| list[T], tuple[T]  | repeated T      |
+| dict[K, V]         | map<K, V>       |
+
 
 ## TODO
 - [ ] Streaming Support

pydantic_rpc-0.3.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+pydantic_rpc/__init__.py,sha256=AWYjSmYQcMqsqGmGK4k-pQQhX6RBBgkTvNcQtCtsctU,113
+pydantic_rpc/core.py,sha256=AA2LISRvwNqqVByFzG_7tToZTnchfLIUhD3jlYcm0S4,47299
+pydantic_rpc/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_rpc-0.3.0.dist-info/METADATA,sha256=kobbXfMf1l64C4yMLiyXBDwxdgLHYFeVp-o0eqYvxno,11412
+pydantic_rpc-0.3.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+pydantic_rpc-0.3.0.dist-info/licenses/LICENSE,sha256=Y6jkAm2VqPqoGIGQ-mEQCecNfteQ2LwdpYhC5XiH_cA,1069
+pydantic_rpc-0.3.0.dist-info/RECORD,,

pydantic_rpc-0.2.1.dist-info/RECORD

@@ -1,7 +0,0 @@
-pydantic_rpc/__init__.py,sha256=AWYjSmYQcMqsqGmGK4k-pQQhX6RBBgkTvNcQtCtsctU,113
-pydantic_rpc/core.py,sha256=CUoiQpARAAejnxNv_6foerWvc_vUvXpZOU1LxoR-EiQ,42596
-pydantic_rpc/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_rpc-0.2.1.dist-info/METADATA,sha256=Td5HvDvxy521IB9rClJcsmtxPHAdPRfxcJHgQ3WSEmU,8933
-pydantic_rpc-0.2.1.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-pydantic_rpc-0.2.1.dist-info/licenses/LICENSE,sha256=Y6jkAm2VqPqoGIGQ-mEQCecNfteQ2LwdpYhC5XiH_cA,1069
-pydantic_rpc-0.2.1.dist-info/RECORD,,