Add support for sync clients (#78)

* Sync client test

* Install grpc

* Test sync unary stream

* Test sync stream unary and stream stream

* Make grpcio dependency optional

* Fix workflow

Author: AdrienVannson

.github/workflows/ci.yml

@@ -57,7 +57,7 @@ jobs:
 
       - name: Install dependencies
         shell: bash
-        run: poetry install -E grpc-async
+        run: poetry install -E all
 
       - name: Download compiled test files
         shell: bash
@@ -69,7 +69,7 @@ jobs:
 
       - name: Install dependencies with the Rust codec
         shell: bash
-        run: poetry install -E grpc-async -E rust-codec
+        run: poetry install -E all -E rust-codec
 
       - name: Execute test suite with the Rust codec
         shell: bash

poetry.lock

@@ -18,8 +18,11 @@ Repository = "https://github.com/betterproto/python-betterproto2"
 
 [project.optional-dependencies]
 rust-codec = ["betterproto2-rust-codec"]
+grpc-sync = ["grpcio"]
 grpc-async = ["grpclib"]
-all = ["betterproto2-rust-codec", "grpclib"]
+
+# betterproto2-rust-codec is not included because still experimental
+all = ["grpclib", "grpcio"]
 
 [tool.poetry]
 packages = [
@@ -28,6 +31,7 @@ packages = [
 
 [tool.poetry.dependencies]
 grpclib = { version = "^0.4.1", optional = true }
+grpcio = { version = "^1.71.0", optional = true }
 python-dateutil = "^2.8"
 typing-extensions = "^4.7.1"
 betterproto2-rust-codec = { version = "^0.1.2", optional = true }

pyproject.toml

@@ -0,0 +1,72 @@
+import asyncio
+import threading
+from collections.abc import AsyncIterator
+
+import grpc
+import pytest
+from grpclib.server import Server
+
+from tests.output_betterproto.simple_service import (
+    Request,
+    Response,
+    SimpleServiceBase,
+    SimpleServiceSyncStub,
+)
+
+
+class SimpleService(SimpleServiceBase):
+    async def get_unary_unary(self, message: "Request") -> "Response":
+        return Response(message=f"Hello {message.value}")
+
+    async def get_unary_stream(self, message: "Request") -> "AsyncIterator[Response]":
+        for i in range(5):
+            yield Response(message=f"Hello {message.value} {i}")
+
+    async def get_stream_unary(self, messages: "AsyncIterator[Request]") -> "Response":
+        s = 0
+        async for m in messages:
+            s += m.value
+        return Response(message=f"Hello {s}")
+
+    async def get_stream_stream(self, messages: "AsyncIterator[Request]") -> "AsyncIterator[Response]":
+        async for message in messages:
+            yield Response(message=f"Hello {message.value}")
+
+
+@pytest.mark.asyncio
+async def test_sync_client():
+    def start_server():
+        async def run_server():
+            server = Server([SimpleService()])
+            await server.start("127.0.0.1", 1234)
+            await asyncio.sleep(3)  # Close the server after 3 seconds
+            server.close()
+
+        loop = asyncio.new_event_loop()
+        loop.run_until_complete(run_server())
+        loop.close()
+
+    # We need to start the server in a new thread to avoid a deadlock
+    server_thread = threading.Thread(target=start_server)
+    server_thread.start()
+
+    # Create a sync client
+    with grpc.insecure_channel("localhost:1234") as channel:
+        client = SimpleServiceSyncStub(channel)
+
+        response = client.get_unary_unary(Request(value=42))
+        assert response.message == "Hello 42"
+
+        response = client.get_unary_stream(Request(value=42))
+        assert [r.message for r in response] == [f"Hello 42 {i}" for i in range(5)]
+
+        response = client.get_stream_unary([Request(value=i) for i in range(5)])
+        assert response.message == "Hello 10"
+
+        response = client.get_stream_stream([Request(value=i) for i in range(5)])
+        assert [r.message for r in response] == [f"Hello {i}" for i in range(5)]
+
+    # Create an async client
+    # client = SimpleServiceStub(Channel(host="127.0.0.1", port=1234))
+    # response = await client.get_unary_unary(Request(value=42))
+    # assert response.message == "Hello 42"