Move BidirectionalHandle to Bidirectional.Handle

This is a complementary class used by Bidirectional, so it makes sense
to have it scoped in its class.

Signed-off-by: Leandro Lucarella <[email protected]>

Author: llucax

RELEASE_NOTES.md

@@ -26,7 +26,6 @@ time.
   * `frequenz.channels.Broadcast`
   * `frequenz.channels.Anycast`
   * `frequenz.channels.Bidirectional`
-  * `frequenz.channels.BidirectionalHandle`
   * `frequenz.channels.Broadcast`
   * `frequenz.channels.Peekable`
   * `frequenz.channels.Receiver`
@@ -42,6 +41,8 @@ time.
   messages to receiver but just receive from them. If you used it you can
   implement it yourself.
 
+* The class `BidirectionalHandle` was moved to `Bidirectional.Handle`.
+
 ## New Features
 
 <!-- Here goes the main new features and examples or instructions on how to use them -->

src/frequenz/channels/__init__.py

@@ -47,20 +47,13 @@
 
 from . import util
 from ._anycast import Anycast
-from ._base_classes import (
-    ChannelClosedError,
-    ChannelError,
-    Peekable,
-    Receiver,
-    Sender,
-)
-from ._bidirectional import Bidirectional, BidirectionalHandle
+from ._base_classes import ChannelClosedError, ChannelError, Peekable, Receiver, Sender
+from ._bidirectional import Bidirectional
 from ._broadcast import Broadcast
 
 __all__ = [
     "Anycast",
     "Bidirectional",
-    "BidirectionalHandle",
     "Broadcast",
     "ChannelClosedError",
     "ChannelError",

src/frequenz/channels/_bidirectional.py

@@ -5,15 +5,57 @@
 
 from __future__ import annotations
 
-from typing import Generic
+from typing import Generic, TypeVar
 
 from ._base_classes import Receiver, Sender, T, U
 from ._broadcast import Broadcast
 
+V = TypeVar("V")
+W = TypeVar("W")
+
 
 class Bidirectional(Generic[T, U]):
     """A wrapper class for simulating bidirectional channels."""
 
+    class Handle(Sender[V], Receiver[W]):
+        """A handle to a [Bidirectional][frequenz.channels.Bidirectional] instance.
+
+        It can be used to send/receive values between the client and service.
+        """
+
+        def __init__(self, sender: Sender[V], receiver: Receiver[W]) -> None:
+            """Create a `Bidirectional.Handle` instance.
+
+            Args:
+                sender: A sender to send values with.
+                receiver: A receiver to receive values from.
+            """
+            self._sender = sender
+            self._receiver = receiver
+
+        async def send(self, msg: V) -> bool:
+            """Send a value to the other side.
+
+            Args:
+                msg: The value to send.
+
+            Returns:
+                Whether the send was successful or not.
+            """
+            return await self._sender.send(msg)
+
+        async def ready(self) -> None:
+            """Wait until the receiver is ready with a value."""
+            await self._receiver.ready()  # pylint: disable=protected-access
+
+        def consume(self) -> W:
+            """Return the latest value once `_ready` is complete.
+
+            Returns:
+                The next value that was received.
+            """
+            return self._receiver.consume()  # pylint: disable=protected-access
+
     def __init__(self, client_id: str, service_id: str) -> None:
         """Create a `Bidirectional` instance.
 
@@ -27,69 +69,29 @@ def __init__(self, client_id: str, service_id: str) -> None:
             f"resp_{service_id}_{client_id}"
         )
 
-        self._client_handle = BidirectionalHandle(
+        self._client_handle = Bidirectional.Handle(
             self._request_channel.new_sender(),
             self._response_channel.new_receiver(),
         )
-        self._service_handle = BidirectionalHandle(
+        self._service_handle = Bidirectional.Handle(
             self._response_channel.new_sender(),
             self._request_channel.new_receiver(),
         )
 
     @property
-    def client_handle(self) -> BidirectionalHandle[T, U]:
-        """Get a BidirectionalHandle for the client to use.
+    def client_handle(self) -> Bidirectional.Handle[T, U]:
+        """Get a `Handle` for the client side to use.
 
         Returns:
             Object to send/receive messages with.
         """
         return self._client_handle
 
     @property
-    def service_handle(self) -> BidirectionalHandle[U, T]:
-        """Get a `BidirectionalHandle` for the service to use.
+    def service_handle(self) -> Bidirectional.Handle[U, T]:
+        """Get a `Handle` for the service side to use.
 
         Returns:
             Object to send/receive messages with.
         """
         return self._service_handle
-
-
-class BidirectionalHandle(Sender[T], Receiver[U]):
-    """A handle to a [Bidirectional][frequenz.channels.Bidirectional] instance.
-
-    It can be used to send/receive values between the client and service.
-    """
-
-    def __init__(self, sender: Sender[T], receiver: Receiver[U]) -> None:
-        """Create a `BidirectionalHandle` instance.
-
-        Args:
-            sender: A sender to send values with.
-            receiver: A receiver to receive values from.
-        """
-        self._sender = sender
-        self._receiver = receiver
-
-    async def send(self, msg: T) -> bool:
-        """Send a value to the other side.
-
-        Args:
-            msg: The value to send.
-
-        Returns:
-            Whether the send was successful or not.
-        """
-        return await self._sender.send(msg)
-
-    async def ready(self) -> None:
-        """Wait until the receiver is ready with a value."""
-        await self._receiver.ready()  # pylint: disable=protected-access
-
-    def consume(self) -> U:
-        """Return the latest value once `_ready` is complete.
-
-        Returns:
-            The next value that was received.
-        """
-        return self._receiver.consume()  # pylint: disable=protected-access

tests/test_bidirectional.py

@@ -5,15 +5,15 @@
 
 import asyncio
 
-from frequenz.channels import Bidirectional, BidirectionalHandle
+from frequenz.channels import Bidirectional
 
 
 async def test_request_response() -> None:
     """Ensure bi-directional communication is possible."""
 
     req_resp: Bidirectional[int, str] = Bidirectional("test_client", "test_service")
 
-    async def service(handle: BidirectionalHandle[str, int]) -> None:
+    async def service(handle: Bidirectional.Handle[str, int]) -> None:
         while True:
             num = await handle.receive()
             if num is None:
@@ -27,7 +27,7 @@ async def service(handle: BidirectionalHandle[str, int]) -> None:
         service(req_resp.service_handle),
     )
 
-    client_handle: BidirectionalHandle[int, str] = req_resp.client_handle
+    client_handle: Bidirectional.Handle[int, str] = req_resp.client_handle
 
     for ctr in range(-5, 5):
         await client_handle.send(ctr)

tests/test_broadcast.py

@@ -8,7 +8,7 @@
 
 import pytest
 
-from frequenz.channels import Broadcast, Receiver, Sender, ChannelClosedError
+from frequenz.channels import Broadcast, ChannelClosedError, Receiver, Sender
 
 
 async def test_broadcast() -> None: