Replace "msg" with "message"

This is just to make the code extra obvious but it also affects one
function signature: `Sender.send()`, so it is a breaking change.

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

Author: llucax

README.md

@@ -76,8 +76,8 @@ async def main() -> None:
     receiver = hello_channel.new_receiver()
 
     await sender.send("Hello World!")
-    msg = await receiver.receive()
-    print(msg)
+    message = await receiver.receive()
+    print(message)
 
 
 asyncio.run(main())

docs/user-guide/receiving/synchronization/index.md

@@ -9,11 +9,11 @@ not work:
 receiver1: Receiver[int] = channel1.new_receiver()
 receiver2: Receiver[int] = channel2.new_receiver()
 
-msg = await receiver1.receive()
-print(f"Received from channel1: {msg}")
+message = await receiver1.receive()
+print(f"Received from channel1: {message}")
 
-msg = await receiver2.receive()
-print(f"Received from channel2: {msg}")
+message = await receiver2.receive()
+print(f"Received from channel2: {message}")
 ```
 
 The problem is that if the first message is not available in `channel1` but in

src/frequenz/channels/_anycast.py

@@ -101,9 +101,9 @@ class Anycast(Generic[_T]):
 
 
         async def send(sender: Sender[int]) -> None:
-            for msg in range(3):
-                print(f"sending {msg}")
-                await sender.send(msg)
+            for message in range(3):
+                print(f"sending {message}")
+                await sender.send(message)
 
 
         async def main() -> None:
@@ -115,8 +115,8 @@ async def main() -> None:
             async with asyncio.TaskGroup() as task_group:
                 task_group.create_task(send(sender))
                 for _ in range(3):
-                    msg = await receiver.receive()
-                    print(f"received {msg}")
+                    message = await receiver.receive()
+                    print(f"received {message}")
                     await asyncio.sleep(0.1)  # sleep (or work) with the data
 
 
@@ -146,15 +146,15 @@ async def main() -> None:
 
 
         async def send(name: str, sender: Sender[int], start: int, stop: int) -> None:
-            for msg in range(start, stop):
-                print(f"{name} sending {msg}")
-                await sender.send(msg)
+            for message in range(start, stop):
+                print(f"{name} sending {message}")
+                await sender.send(message)
 
 
         async def recv(name: str, receiver: Receiver[int]) -> None:
             try:
-                async for msg in receiver:
-                    print(f"{name} received {msg}")
+                async for message in receiver:
+                    print(f"{name} received {message}")
                 await asyncio.sleep(0.1)  # sleep (or work) with the data
             except ReceiverStoppedError:
                 pass
@@ -318,7 +318,7 @@ def __init__(self, chan: Anycast[_T]) -> None:
         self._chan: Anycast[_T] = chan
         """The channel that this sender belongs to."""
 
-    async def send(self, msg: _T) -> None:
+    async def send(self, message: _T) -> None:
         """Send a message across the channel.
 
         To send, this method inserts the message into the Anycast channel's
@@ -327,7 +327,7 @@ async def send(self, msg: _T) -> None:
         message will be received by exactly one receiver.
 
         Args:
-            msg: The message to be sent.
+            message: The message to be sent.
 
         Raises:
             SenderError: If the underlying channel was closed.
@@ -352,7 +352,7 @@ async def send(self, msg: _T) -> None:
                 "Anycast channel [%s] has space again, resuming the blocked sender",
                 self,
             )
-        self._chan._deque.append(msg)
+        self._chan._deque.append(message)
         async with self._chan._recv_cv:
             self._chan._recv_cv.notify(1)
         # pylint: enable=protected-access

src/frequenz/channels/_broadcast.py

@@ -89,9 +89,9 @@ class Broadcast(Generic[_T]):
 
 
         async def send(sender: Sender[int]) -> None:
-            for msg in range(3):
-                print(f"sending {msg}")
-                await sender.send(msg)
+            for message in range(3):
+                print(f"sending {message}")
+                await sender.send(message)
 
 
         async def main() -> None:
@@ -103,8 +103,8 @@ async def main() -> None:
             async with asyncio.TaskGroup() as task_group:
                 task_group.create_task(send(sender))
                 for _ in range(3):
-                    msg = await receiver.receive()
-                    print(f"received {msg}")
+                    message = await receiver.receive()
+                    print(f"received {message}")
                     await asyncio.sleep(0.1)  # sleep (or work) with the data
 
 
@@ -134,15 +134,15 @@ async def main() -> None:
 
 
         async def send(name: str, sender: Sender[int], start: int, stop: int) -> None:
-            for msg in range(start, stop):
-                print(f"{name} sending {msg}")
-                await sender.send(msg)
+            for message in range(start, stop):
+                print(f"{name} sending {message}")
+                await sender.send(message)
 
 
         async def recv(name: str, receiver: Receiver[int]) -> None:
             try:
-                async for msg in receiver:
-                    print(f"{name} received {msg}")
+                async for message in receiver:
+                    print(f"{name} received {message}")
                 await asyncio.sleep(0.1)  # sleep (or work) with the data
             except ReceiverStoppedError:
                 pass
@@ -317,11 +317,11 @@ def __init__(self, chan: Broadcast[_T]) -> None:
         self._chan: Broadcast[_T] = chan
         """The broadcast channel this sender belongs to."""
 
-    async def send(self, msg: _T) -> None:
+    async def send(self, message: _T) -> None:
         """Send a message to all broadcast receivers.
 
         Args:
-            msg: The message to be broadcast.
+            message: The message to be broadcast.
 
         Raises:
             SenderError: If the underlying channel was closed.
@@ -333,14 +333,14 @@ async def send(self, msg: _T) -> None:
             raise SenderError("The channel was closed", self) from ChannelClosedError(
                 self._chan
             )
-        self._chan._latest = msg
+        self._chan._latest = message
         stale_refs = []
         for _hash, recv_ref in self._chan._receivers.items():
             recv = recv_ref()
             if recv is None:
                 stale_refs.append(_hash)
                 continue
-            recv.enqueue(msg)
+            recv.enqueue(message)
         for _hash in stale_refs:
             del self._chan._receivers[_hash]
         async with self._chan._recv_cv:
@@ -392,23 +392,23 @@ def __init__(self, name: str | None, limit: int, chan: Broadcast[_T]) -> None:
         self._q: deque[_T] = deque(maxlen=limit)
         """The receiver's internal message queue."""
 
-    def enqueue(self, msg: _T) -> None:
+    def enqueue(self, message: _T) -> None:
         """Put a message into this receiver's queue.
 
         To be called by broadcast senders.  If the receiver's queue is already
         full, drop the oldest message to make room for the incoming message, and
         log a warning.
 
         Args:
-            msg: The message to be sent.
+            message: The message to be sent.
         """
         if len(self._q) == self._q.maxlen:
             self._q.popleft()
             _logger.warning(
                 "Broadcast receiver [%s] is full. Oldest message was dropped.",
                 self,
             )
-        self._q.append(msg)
+        self._q.append(message)
 
     def __len__(self) -> int:
         """Return the number of unconsumed messages in the broadcast receiver.

src/frequenz/channels/_merge.py

@@ -75,8 +75,8 @@ def merge(*receivers: Receiver[_T]) -> Merger[_T]:
         receiver1 = channel1.new_receiver()
         receiver2 = channel2.new_receiver()
 
-        async for msg in merge(receiver1, receiver2):
-            print(f"received {msg}")
+        async for message in merge(receiver1, receiver2):
+            print(f"received {message}")
         ```
 
     Args:

src/frequenz/channels/_sender.py

@@ -61,11 +61,11 @@ class Sender(ABC, Generic[_T_contra]):
     """An endpoint to sends messages."""
 
     @abstractmethod
-    async def send(self, msg: _T_contra) -> None:
+    async def send(self, message: _T_contra) -> None:
         """Send a message.
 
         Args:
-            msg: The message to be sent.
+            message: The message to be sent.
 
         Raises:
             SenderError: If there was an error sending the message.