pydantic-rpc 0.4.1__py3-none-any.whl → 0.6.0__py3-none-any.whl

pydantic_rpc/core.py

@@ -31,6 +31,7 @@ from sonora.wsgi import grpcWSGI
 from sonora.asgi import grpcASGI
 from connecpy.asgi import ConnecpyASGIApp as ConnecpyASGI
 from connecpy.errors import Errors
+from connecpy.wsgi import ConnecpyWSGIApp as ConnecpyWSGI
 
 # Protobuf Python modules for Timestamp, Duration (requires protobuf / grpcio)
 from google.protobuf import timestamp_pb2, duration_pb2
@@ -356,6 +357,69 @@ def connect_obj_with_stub_async(pb2_grpc_module, pb2_module, obj: object) -> typ
     return ConcreteServiceClass
 
 
+def connect_obj_with_stub_connecpy(connecpy_module, pb2_module, obj: object) -> type:
+    """
+    Connect a Python service object to a Connecpy stub.
+    """
+    service_class = obj.__class__
+    stub_class_name = service_class.__name__
+    stub_class = getattr(connecpy_module, stub_class_name)
+
+    class ConcreteServiceClass(stub_class):
+        pass
+
+    def implement_stub_method(method):
+        sig = inspect.signature(method)
+        arg_type = get_request_arg_type(sig)
+        converter = generate_message_converter(arg_type)
+        response_type = sig.return_annotation
+        size_of_parameters = len(sig.parameters)
+
+        match size_of_parameters:
+            case 1:
+
+                def stub_method1(self, request, context, method=method):
+                    try:
+                        arg = converter(request)
+                        resp_obj = method(arg)
+                        return convert_python_message_to_proto(
+                            resp_obj, response_type, pb2_module
+                        )
+                    except ValidationError as e:
+                        return context.abort(Errors.InvalidArgument, str(e))
+                    except Exception as e:
+                        return context.abort(Errors.Internal, str(e))
+
+                return stub_method1
+
+            case 2:
+
+                def stub_method2(self, request, context, method=method):
+                    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(Errors.InvalidArgument, str(e))
+                    except Exception as e:
+                        return context.abort(Errors.Internal, str(e))
+
+                return stub_method2
+
+            case _:
+                raise Exception("Method must have exactly one or two parameters")
+
+    for method_name, method in get_rpc_methods(obj):
+        if method.__name__.startswith("_"):
+            continue
+        a_method = implement_stub_method(method)
+        setattr(ConcreteServiceClass, method_name, a_method)
+
+    return ConcreteServiceClass
+
+
 def connect_obj_with_stub_async_connecpy(
     connecpy_module, pb2_module, obj: object
 ) -> type:
@@ -1330,14 +1394,62 @@ class ConnecpyASGIApp:
         await self._app(scope, receive, send)
 
 
-if __name__ == "__main__":
+class ConnecpyWSGIApp:
     """
-    If executed as a script, generate the .proto files for a given class.
-    Usage: python core.py some_module.py SomeServiceClass
+    A WSGI-compatible application that can serve Connect-RPC via Connecpy's ConnecpyWSGIApp.
     """
-    py_file_name = sys.argv[1]
-    class_name = sys.argv[2]
-    module_name = os.path.splitext(basename(py_file_name))[0]
+
+    def __init__(self):
+        self._app = ConnecpyWSGI()
+        self._service_names = []
+        self._package_name = ""
+
+    def mount(self, obj: object, package_name: str = ""):
+        """Generate and compile proto files, then mount the async service implementation."""
+        connecpy_module, pb2_module = generate_and_compile_proto_using_connecpy(
+            obj, package_name
+        )
+        self.mount_using_pb2_modules(connecpy_module, pb2_module, obj)
+
+    def mount_using_pb2_modules(self, connecpy_module, pb2_module, obj: object):
+        """Connect the compiled connecpy and pb2 modules with the async service implementation."""
+        concreteServiceClass = connect_obj_with_stub_connecpy(
+            connecpy_module, pb2_module, obj
+        )
+        service_name = obj.__class__.__name__
+        service_impl = concreteServiceClass()
+        connecpy_server = get_connecpy_server_class(connecpy_module, service_name)
+        self._app.add_service(connecpy_server(service=service_impl))
+        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):
+        """Mount multiple service objects into this WSGI app."""
+        for obj in objs:
+            self.mount(obj, self._package_name)
+
+    def __call__(self, environ, start_response):
+        """WSGI entry point."""
+        return self._app(environ, start_response)
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Generate and compile proto files.")
+    parser.add_argument(
+        "py_file", type=str, help="The Python file containing the service class."
+    )
+    parser.add_argument("class_name", type=str, help="The name of the service class.")
+    args = parser.parse_args()
+
+    module_name = os.path.splitext(basename(args.py_file))[0]
     module = importlib.import_module(module_name)
-    klass = getattr(module, class_name)
+    klass = getattr(module, args.class_name)
     generate_and_compile_proto(klass())
+
+
+if __name__ == "__main__":
+    main()

{pydantic_rpc-0.4.1.dist-info → pydantic_rpc-0.6.0.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: pydantic-rpc
-Version: 0.4.1
+Version: 0.6.0
 Summary: A Python library for building gRPC/ConnectRPC services with Pydantic models.
 Author: Yasushi Itoh
 License-File: LICENSE
 Requires-Python: >=3.11
-Requires-Dist: connecpy>=1.2.1
+Requires-Dist: connecpy>=1.3.2
 Requires-Dist: grpcio-health-checking>=1.56.2
 Requires-Dist: grpcio-reflection>=1.56.2
 Requires-Dist: grpcio-tools>=1.56.2
@@ -104,6 +104,7 @@ app.mount(OlympicsLocationAgent())
   - 🌐 **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`.
+- 🛠️ **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.
 
 ## 📦 Installation
 
@@ -257,7 +258,9 @@ 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.
+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.
+
 
 Please see the sample code below:
 
@@ -319,6 +322,9 @@ if __name__ == "__main__":
     loop.run_until_complete(s.run(OlympicsAgent()))
 ```
 
+In the example above, the `ask_stream` method returns an `AsyncIterator[StreamingResult]` object, which is considered a streaming method. The `StreamingResult` class is a Pydantic model that defines the response type of the streaming method. You can use any Pydantic model as the response type.
+
+
 ### 🔗 Multiple Services with Custom Interceptors
 
 PydanticRPC supports defining and running multiple services in a single server:
@@ -404,16 +410,17 @@ if __name__ == "__main__":
 
 TODO
 
-### 🗄️ Protobuf file generation
+### 🗄️ Protobuf file and code (Python files) generation using CLI
 
-You can generate protobuf files for a given module and a specified class using `core.py`:
+You can genereate protobuf files and code for a given module and a specified class using `pydantic-rpc` CLI command:
 
 ```bash
-python core.py a_module.py aClass
+pydantic-rpc a_module.py aClassName
 ```
 
 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             |

pydantic_rpc-0.6.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+pydantic_rpc/__init__.py,sha256=oomSVGmh_zddQQaphQt1L2xSVh9dD1LVyaAq1cN1FW4,231
+pydantic_rpc/core.py,sha256=SB9GDZRxsMWQFxphinYQUAqrOx10eUn40fPTc7t1xYs,52107
+pydantic_rpc/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_rpc-0.6.0.dist-info/METADATA,sha256=oTCJJH4yB2VW-eVGXN3EoGtinuC9kllMQFThk2QuPlo,12698
+pydantic_rpc-0.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_rpc-0.6.0.dist-info/entry_points.txt,sha256=LeZJ6UN-fhjKrEGkcmsAAKuA-fIe7MpvzKMPSZfi0NE,56
+pydantic_rpc-0.6.0.dist-info/licenses/LICENSE,sha256=Y6jkAm2VqPqoGIGQ-mEQCecNfteQ2LwdpYhC5XiH_cA,1069
+pydantic_rpc-0.6.0.dist-info/RECORD,,

pydantic_rpc-0.6.0.dist-info/entry_points.txt

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

pydantic_rpc-0.4.1.dist-info/RECORD

@@ -1,7 +0,0 @@
-pydantic_rpc/__init__.py,sha256=oomSVGmh_zddQQaphQt1L2xSVh9dD1LVyaAq1cN1FW4,231
-pydantic_rpc/core.py,sha256=e6zO5qx9vJvOZR8yiBVx41jnIGEg2d_uDHzp6WgkN70,47938
-pydantic_rpc/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_rpc-0.4.1.dist-info/METADATA,sha256=4EwQ-24LOPI8h0eNivTcN9aI9n0db80HWEzLi9QZBqI,12007
-pydantic_rpc-0.4.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_rpc-0.4.1.dist-info/licenses/LICENSE,sha256=Y6jkAm2VqPqoGIGQ-mEQCecNfteQ2LwdpYhC5XiH_cA,1069
-pydantic_rpc-0.4.1.dist-info/RECORD,,