pydantic-rpc 0.4.1__tar.gz → 0.6.0__tar.gz

pydantic_rpc-0.4.1/README.md → pydantic_rpc-0.6.0/PKG-INFO

@@ -1,3 +1,18 @@
+Metadata-Version: 2.4
+Name: pydantic-rpc
+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.3.2
+Requires-Dist: grpcio-health-checking>=1.56.2
+Requires-Dist: grpcio-reflection>=1.56.2
+Requires-Dist: grpcio-tools>=1.56.2
+Requires-Dist: pydantic>=2.1.1
+Requires-Dist: sonora>=0.2.3
+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/)/[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.
@@ -89,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
 
@@ -242,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:
 
@@ -304,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:
@@ -389,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.4.1/PKG-INFO → pydantic_rpc-0.6.0/README.md

@@ -1,18 +1,3 @@
-Metadata-Version: 2.4
-Name: pydantic-rpc
-Version: 0.4.1
-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: grpcio-health-checking>=1.56.2
-Requires-Dist: grpcio-reflection>=1.56.2
-Requires-Dist: grpcio-tools>=1.56.2
-Requires-Dist: pydantic>=2.1.1
-Requires-Dist: sonora>=0.2.3
-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/)/[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.
@@ -104,6 +89,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 +243,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 +307,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 +395,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.4.1 → pydantic_rpc-0.6.0}/examples/README.md

@@ -2,7 +2,7 @@
 
 ## 📝 Prerequisites
 
-Ensure you have [UV](https://docs.astral.sh/uv/) installed on your system. If not, you can install it using the following command:
+Ensure you have [uv](https://docs.astral.sh/uv/) installed on your system. If not, you can install it using the following command:
 
 ### Linux/macOS
 

{pydantic_rpc-0.4.1 → pydantic_rpc-0.6.0}/examples/greeter_connecpy.py

@@ -43,6 +43,30 @@ class GreeterServer(ConnecpyServer):
         return "greeter.v1.Greeter"
 
 
+class GreeterSync(Protocol):
+    def SayHello(
+        self, req: _pb2.HelloRequest, ctx: ServiceContext
+    ) -> _pb2.HelloReply: ...
+
+
+class GreeterServerSync(ConnecpyServer):
+    def __init__(self, *, service: GreeterSync, server_path_prefix=""):
+        super().__init__()
+        self._prefix = f"{server_path_prefix}/greeter.v1.Greeter"
+        self._endpoints = {
+            "SayHello": Endpoint[_pb2.HelloRequest, _pb2.HelloReply](
+                service_name="Greeter",
+                name="SayHello",
+                function=getattr(service, "SayHello"),
+                input=_pb2.HelloRequest,
+                output=_pb2.HelloReply,
+            ),
+        }
+
+    def serviceName(self):
+        return "greeter.v1.Greeter"
+
+
 class GreeterClient(ConnecpyClient):
     def SayHello(
         self,

{pydantic_rpc-0.4.1 → pydantic_rpc-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pydantic-rpc"
-version = "0.4.1"
+version = "0.6.0"
 description = "A Python library for building gRPC/ConnectRPC services with Pydantic models."
 authors = [
     { name = "Yasushi Itoh" }
@@ -11,11 +11,14 @@ dependencies = [
     "grpcio-reflection>=1.56.2",
     "grpcio-health-checking>=1.56.2",
     "sonora>=0.2.3",
-    "connecpy>=1.2.1",
+    "connecpy>=1.3.2",
 ]
 readme = "README.md"
 requires-python = ">= 3.11"
 
+[project.scripts]
+pydantic-rpc = "pydantic_rpc.core:main"
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
@@ -25,8 +28,15 @@ managed = true
 dev-dependencies = [
     "hypercorn>=0.17.3",
     "pydantic-ai==0.0.20",
+    "pytest>=8.3.4",
+    "pytest-asyncio>=0.20.3",
     "ruff>=0.9.4",
 ]
 
 [tool.hatch.metadata]
 allow-direct-references = true
+
+[tool.pytest.ini_options]
+markers = [
+    "asyncio: mark test as asyncio",
+]

{pydantic_rpc-0.4.1 → pydantic_rpc-0.6.0}/src/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.6.0/tests/asyncechoservice.proto

@@ -0,0 +1,33 @@
+syntax = "proto3";
+
+package asyncecho.v1;
+
+// Echo service.
+// A simple service that echoes messages back in uppercase.
+service AsyncEchoService {
+    // Echo the message back in uppercase.
+    //
+    // Args:
+    //     request (EchoRequest): The request message.
+    //
+    // Returns:
+    //     EchoResponse: The response message.
+    rpc Echo (EchoRequest) returns (EchoResponse);
+}
+
+// Echo response message.
+//
+// Attributes:
+//     text (str): The echoed text.
+message EchoResponse {
+    string text = 1;
+}
+
+// Echo request message.
+//
+// Attributes:
+//     text (str): The text to echo.
+message EchoRequest {
+    string text = 1;
+}
+

pydantic_rpc-0.6.0/tests/asyncechoservice_connecpy.py

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+# Generated by https://github.com/i2y/connecpy/protoc-gen-connecpy.  DO NOT EDIT!
+# source: asyncechoservice.proto
+
+from typing import Any, Protocol, Union
+
+import httpx
+
+from connecpy.async_client import AsyncConnecpyClient
+from connecpy.base import Endpoint
+from connecpy.server import ConnecpyServer
+from connecpy.client import ConnecpyClient
+from connecpy.context import ClientContext, ServiceContext
+
+import asyncechoservice_pb2 as _pb2
+
+from google.protobuf import symbol_database
+
+_sym_db = symbol_database.Default()
+
+
+class AsyncEchoService(Protocol):
+    async def Echo(self, req: _pb2.EchoRequest, ctx: ServiceContext) -> _pb2.EchoResponse: ...
+
+
+class AsyncEchoServiceServer(ConnecpyServer):
+    def __init__(self, *, service: AsyncEchoService, server_path_prefix=""):
+        super().__init__()
+        self._prefix = f"{server_path_prefix}/asyncecho.v1.AsyncEchoService"
+        self._endpoints = {
+            "Echo": Endpoint[_pb2.EchoRequest, _pb2.EchoResponse](
+                service_name="AsyncEchoService",
+                name="Echo",
+                function=getattr(service, "Echo"),
+                input=_pb2.EchoRequest,
+                output=_pb2.EchoResponse,
+            ),
+        }
+
+    def serviceName(self):
+        return "asyncecho.v1.AsyncEchoService"
+
+
+class AsyncEchoServiceSync(Protocol):
+    def Echo(self, req: _pb2.EchoRequest, ctx: ServiceContext) -> _pb2.EchoResponse: ...
+
+
+class AsyncEchoServiceServerSync(ConnecpyServer):
+    def __init__(self, *, service: AsyncEchoServiceSync, server_path_prefix=""):
+        super().__init__()
+        self._prefix = f"{server_path_prefix}/asyncecho.v1.AsyncEchoService"
+        self._endpoints = {
+            "Echo": Endpoint[_pb2.EchoRequest, _pb2.EchoResponse](
+                service_name="AsyncEchoService",
+                name="Echo",
+                function=getattr(service, "Echo"),
+                input=_pb2.EchoRequest,
+                output=_pb2.EchoResponse,
+            ),
+        }
+
+    def serviceName(self):
+        return "asyncecho.v1.AsyncEchoService"
+
+
+class AsyncEchoServiceClient(ConnecpyClient):
+    def Echo(
+        self,
+        *,
+        request: _pb2.EchoRequest,
+        ctx: ClientContext,
+        server_path_prefix: str = "",
+        **kwargs,
+    ) -> _pb2.EchoResponse:
+        return self._make_request(
+            url=f"{server_path_prefix}/asyncecho.v1.AsyncEchoService/Echo",
+            ctx=ctx,
+            request=request,
+            response_obj=_pb2.EchoResponse,
+            **kwargs,
+        )
+
+
+class AsyncAsyncEchoServiceClient(AsyncConnecpyClient):
+    async def Echo(
+        self,
+        *,
+        request: _pb2.EchoRequest,
+        ctx: ClientContext,
+        server_path_prefix: str = "",
+        session: Union[httpx.AsyncClient, None] = None,
+        **kwargs,
+    ) -> _pb2.EchoResponse:
+        return await self._make_request(
+            url=f"{server_path_prefix}/asyncecho.v1.AsyncEchoService/Echo",
+            ctx=ctx,
+            request=request,
+            response_obj=_pb2.EchoResponse,
+            session=session,
+            **kwargs,
+        )

pydantic_rpc-0.6.0/tests/asyncechoservice_pb2.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: asyncechoservice.proto
+# Protobuf Python Version: 5.29.0
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    29,
+    0,
+    '',
+    'asyncechoservice.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x16\x61syncechoservice.proto\x12\x0c\x61syncecho.v1\"\x1c\n\x0c\x45\x63hoResponse\x12\x0c\n\x04text\x18\x01 \x01(\t\"\x1b\n\x0b\x45\x63hoRequest\x12\x0c\n\x04text\x18\x01 \x01(\t2Q\n\x10\x41syncEchoService\x12=\n\x04\x45\x63ho\x12\x19.asyncecho.v1.EchoRequest\x1a\x1a.asyncecho.v1.EchoResponseb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'asyncechoservice_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_ECHORESPONSE']._serialized_start=40
+  _globals['_ECHORESPONSE']._serialized_end=68
+  _globals['_ECHOREQUEST']._serialized_start=70
+  _globals['_ECHOREQUEST']._serialized_end=97
+  _globals['_ASYNCECHOSERVICE']._serialized_start=99
+  _globals['_ASYNCECHOSERVICE']._serialized_end=180
+# @@protoc_insertion_point(module_scope)

pydantic_rpc-0.6.0/tests/asyncechoservice_pb2.pyi

@@ -0,0 +1,17 @@
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from typing import ClassVar as _ClassVar, Optional as _Optional
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class EchoResponse(_message.Message):
+    __slots__ = ("text",)
+    TEXT_FIELD_NUMBER: _ClassVar[int]
+    text: str
+    def __init__(self, text: _Optional[str] = ...) -> None: ...
+
+class EchoRequest(_message.Message):
+    __slots__ = ("text",)
+    TEXT_FIELD_NUMBER: _ClassVar[int]
+    text: str
+    def __init__(self, text: _Optional[str] = ...) -> None: ...

pydantic_rpc-0.6.0/tests/asyncechoservice_pb2_grpc.py

@@ -0,0 +1,110 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+import warnings
+
+import asyncechoservice_pb2 as asyncechoservice__pb2
+
+GRPC_GENERATED_VERSION = '1.70.0'
+GRPC_VERSION = grpc.__version__
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    raise RuntimeError(
+        f'The grpc package installed is at version {GRPC_VERSION},'
+        + f' but the generated code in asyncechoservice_pb2_grpc.py depends on'
+        + f' grpcio>={GRPC_GENERATED_VERSION}.'
+        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
+    )
+
+
+class AsyncEchoServiceStub(object):
+    """Echo service.
+    A simple service that echoes messages back in uppercase.
+    """
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.Echo = channel.unary_unary(
+                '/asyncecho.v1.AsyncEchoService/Echo',
+                request_serializer=asyncechoservice__pb2.EchoRequest.SerializeToString,
+                response_deserializer=asyncechoservice__pb2.EchoResponse.FromString,
+                _registered_method=True)
+
+
+class AsyncEchoServiceServicer(object):
+    """Echo service.
+    A simple service that echoes messages back in uppercase.
+    """
+
+    def Echo(self, request, context):
+        """Echo the message back in uppercase.
+
+        Args:
+        request (EchoRequest): The request message.
+
+        Returns:
+        EchoResponse: The response message.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_AsyncEchoServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'Echo': grpc.unary_unary_rpc_method_handler(
+                    servicer.Echo,
+                    request_deserializer=asyncechoservice__pb2.EchoRequest.FromString,
+                    response_serializer=asyncechoservice__pb2.EchoResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'asyncecho.v1.AsyncEchoService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('asyncecho.v1.AsyncEchoService', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class AsyncEchoService(object):
+    """Echo service.
+    A simple service that echoes messages back in uppercase.
+    """
+
+    @staticmethod
+    def Echo(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/asyncecho.v1.AsyncEchoService/Echo',
+            asyncechoservice__pb2.EchoRequest.SerializeToString,
+            asyncechoservice__pb2.EchoResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)