Fix typos in code documentation and tests

daniel-zullo-frequenz · daniel-zullo-frequenz · commit d215c3e5d101 · 2023-09-18T16:34:57.000+02:00
Signed-off-by: Daniel Zullo &lt;daniel.zullo@frequenz.com&gt;
diff --git a/src/frequenz/channels/_anycast.py b/src/frequenz/channels/_anycast.py
@@ -111,7 +111,7 @@ def new_receiver(self) -> Receiver[T]:
 class Sender(BaseSender[T]):
     """A sender to send messages to an Anycast channel.
 
-    Should not be created directly, but through the `Anycast.ggetet_sender()`
+    Should not be created directly, but through the `Anycast.new_sender()`
     method.
     """
 
@@ -211,7 +211,7 @@ def consume(self) -> T:
 
         assert (
             self._next is not _Empty
-        ), "`consume()` must be preceeded by a call to `ready()`"
+        ), "`consume()` must be preceded by a call to `ready()`"
         # mypy doesn't understand that the assert above ensures that self._next is not
         # _Sentinel.  So we have to use a type ignore here.
         next_val: T = self._next  # type: ignore[assignment]
diff --git a/src/frequenz/channels/_bidirectional.py b/src/frequenz/channels/_bidirectional.py
@@ -57,7 +57,7 @@ async def send(self, msg: V) -> None:
             except SenderError as err:
                 # If this comes from a channel error, then we inject another
                 # ChannelError having the information about the Bidirectional
-                # channel to hide (at least partially) the underlaying
+                # channel to hide (at least partially) the underlying
                 # Broadcast channels we use.
                 if isinstance(err.__cause__, ChannelError):
                     this_chan_error = ChannelError(
@@ -98,7 +98,7 @@ def consume(self) -> W:
             except ReceiverError as err:
                 # If this comes from a channel error, then we inject another
                 # ChannelError having the information about the Bidirectional
-                # channel to hide (at least partially) the underlaying
+                # channel to hide (at least partially) the underlying
                 # Broadcast channels we use.
                 if isinstance(err.__cause__, ChannelError):
                     this_chan_error = ChannelError(
diff --git a/src/frequenz/channels/_broadcast.py b/src/frequenz/channels/_broadcast.py
@@ -311,7 +311,7 @@ def consume(self) -> T:
         if not self._q and self._chan.closed:
             raise ReceiverStoppedError(self) from ChannelClosedError(self._chan)
 
-        assert self._q, "`consume()` must be preceeded by a call to `ready()`"
+        assert self._q, "`consume()` must be preceded by a call to `ready()`"
         return self._q.popleft()
 
     def into_peekable(self) -> Peekable[T]:
diff --git a/src/frequenz/channels/util/_event.py b/src/frequenz/channels/util/_event.py
@@ -41,7 +41,7 @@ async def exit_after_10_seconds() -> None:
             if selected_from(selected, other_receiver):
                 print(selected.value)
             else:
-                assert False, "Unknow receiver selected"
+                assert False, "Unknown receiver selected"
         ```
     """
 
diff --git a/src/frequenz/channels/util/_file_watcher.py b/src/frequenz/channels/util/_file_watcher.py
@@ -129,7 +129,7 @@ def consume(self) -> Event:
         if not self._changes and self._awatch_stopped_exc is not None:
             raise ReceiverStoppedError(self) from self._awatch_stopped_exc
 
-        assert self._changes, "`consume()` must be preceeded by a call to `ready()`"
+        assert self._changes, "`consume()` must be preceded by a call to `ready()`"
         # Tuple of (Change, path) returned by watchfiles
         change, path_str = self._changes.pop()
         return FileWatcher.Event(
diff --git a/src/frequenz/channels/util/_merge.py b/src/frequenz/channels/util/_merge.py
@@ -113,6 +113,6 @@ def consume(self) -> T:
         if not self._results and not self._pending:
             raise ReceiverStoppedError(self)
 
-        assert self._results, "`consume()` must be preceeded by a call to `ready()`"
+        assert self._results, "`consume()` must be preceded by a call to `ready()`"
 
         return self._results.popleft()
diff --git a/src/frequenz/channels/util/_merge_named.py b/src/frequenz/channels/util/_merge_named.py
@@ -94,6 +94,6 @@ def consume(self) -> tuple[str, T]:
         if not self._results and not self._pending:
             raise ReceiverStoppedError(self)
 
-        assert self._results, "`consume()` must be preceeded by a call to `ready()`"
+        assert self._results, "`consume()` must be preceded by a call to `ready()`"
 
         return self._results.popleft()
diff --git a/src/frequenz/channels/util/_select.py b/src/frequenz/channels/util/_select.py
@@ -198,7 +198,7 @@ class SelectErrorGroup(BaseExceptionGroup[BaseException], SelectError):
     """An exception group for [`select()`][frequenz.channels.util.select] operation.
 
     This exception group is raised when a `select()` loops fails while cleaning up
-    runing tasts to check for ready receivers.
+    running tests to check for ready receivers.
     """
 
 
diff --git a/src/frequenz/channels/util/_timer.py b/src/frequenz/channels/util/_timer.py
@@ -81,7 +81,7 @@ class TriggerAllMissed(MissedTickPolicy):
     Example:
         Assume a timer with interval 1 second, the tick `T0` happens exactly
         at time 0, the second tick, `T1`, happens at time 1.2 (0.2 seconds
-        late), so it trigges immediately.  The third tick, `T2`, happens at
+        late), so it triggers immediately.  The third tick, `T2`, happens at
         time 2.3 (0.3 seconds late), so it also triggers immediately.  The
         fourth tick, `T3`, happens at time 4.3 (1.3 seconds late), so it also
         triggers immediately as well as the fifth tick, `T4`, which was also
@@ -120,15 +120,15 @@ def calculate_next_tick_time(
 class SkipMissedAndResync(MissedTickPolicy):
     """A policy that drops all the missed ticks, triggers immediately and resyncs.
 
-    If ticks are missed, the timer will trigger immediately returing the drift
+    If ticks are missed, the timer will trigger immediately returning the drift
     and it will schedule to trigger again on the next multiple of `interval`,
     effectively skipping any missed ticks, but resyncing with the original start
     time.
 
     Example:
         Assume a timer with interval 1 second, the tick `T0` happens exactly
         at time 0, the second tick, `T1`, happens at time 1.2 (0.2 seconds
-        late), so it trigges immediately.  The third tick, `T2`, happens at
+        late), so it triggers immediately.  The third tick, `T2`, happens at
         time 2.3 (0.3 seconds late), so it also triggers immediately.  The
         fourth tick, `T3`, happens at time 4.3 (1.3 seconds late), so it also
         triggers immediately but the fifth tick, `T4`, which was also
@@ -180,7 +180,7 @@ class SkipMissedAndDrift(MissedTickPolicy):
         Assume a timer with interval 1 second and `delay_tolerance=0.1`, the
         first tick, `T0`, happens exactly at time 0, the second tick, `T1`,
         happens at time 1.2 (0.2 seconds late), so the timer triggers
-        immmediately but drifts a bit. The next tick, `T2.2`, happens at 2.3 seconds
+        immediately but drifts a bit. The next tick, `T2.2`, happens at 2.3 seconds
         (0.1 seconds late), so it also triggers immediately but it doesn't
         drift because the delay is under the `delay_tolerance`. The next tick,
         `T3.2`, triggers at 4.3 seconds (1.1 seconds late), so it also triggers
@@ -200,7 +200,7 @@ def __init__(self, *, delay_tolerance: timedelta = timedelta(0)):
         """
         Create an instance.
 
-        See the class documenation for more details.
+        See the class documentation for more details.
 
         Args:
             delay_tolerance: The maximum delay that is tolerated before
diff --git a/tests/test_anycast.py b/tests/test_anycast.py
@@ -28,7 +28,7 @@ async def test_anycast() -> None:
     expected_sum = num_senders * num_receivers * (num_receivers + 1) / 2
 
     # a list of `num_receivers` elements, where each element with get
-    # incremented by values the corrosponding receiver receives.  Once the run
+    # incremented by values the corresponding receiver receives.  Once the run
     # finishes, we will check if their sum equals `expected_sum`.
     recv_trackers = [0] * num_receivers
 
@@ -46,7 +46,7 @@ async def update_tracker_on_receive(receiver_id: int, recv: Receiver[int]) -> No
                 assert isinstance(err.__cause__, ChannelClosedError)
                 return
             recv_trackers[receiver_id] += msg
-            # without the sleep, decomissioning receivers temporarily, all
+            # without the sleep, decommissioning receivers temporarily, all
             # messages go to the first receiver.
             await asyncio.sleep(0)
 
diff --git a/tests/test_broadcast.py b/tests/test_broadcast.py
@@ -29,7 +29,7 @@ async def test_broadcast() -> None:
     expected_sum = num_senders * num_receivers * num_receivers * (num_receivers + 1) / 2
 
     # a list of `num_receivers` elements, where each element with get
-    # incremented by values the corrosponding receiver receives.  Once the run
+    # incremented by values the corresponding receiver receives.  Once the run
     # finishes, we will check if their sum equals `expected_sum`.
     recv_trackers = [0] * num_receivers
 
diff --git a/tests/test_merge.py b/tests/test_merge.py
@@ -34,7 +34,7 @@ async def send(ch1: Sender[int], ch2: Sender[int]) -> None:
         # It is hard to get messages from multiple channels in the same order,
         # so we use a `set` to check the next N messages are the same, in any
         # order, where N is the number of channels.  This only works in this
-        # example because the `send` method sends values in immeidate
+        # example because the `send` method sends values in immediate
         # succession.
         assert set(results[idx : idx + 2]) == {ctr + 1, ctr + 101}
     assert results[-1] == 1000
diff --git a/tests/test_mergenamed.py b/tests/test_mergenamed.py
@@ -35,7 +35,7 @@ async def send(ch1: Sender[int], ch2: Sender[int]) -> None:
         # It is hard to get messages from multiple channels in the same order,
         # so we use a `set` to check the next N messages are the same, in any
         # order, where N is the number of channels.  This only works in this
-        # example because the `send` method sends values in immeidate
+        # example because the `send` method sends values in immediate
         # succession.
         assert set(results[idx : idx + 2]) == {
             ("chan1", ctr + 1),
diff --git a/tests/utils/test_select_integration.py b/tests/utils/test_select_integration.py
@@ -356,7 +356,7 @@ async def test_multiple_ready(
         self,
         start_run_multiple_ready: asyncio.Task[None],  # pylint: disable=unused-argument
     ) -> None:
-        """Test that multiple ready receviers are handled properly.
+        """Test that multiple ready receivers are handled properly.
 
         Also test that the loop waits forever if there are no more receivers ready.
         """
@@ -401,7 +401,7 @@ async def test_multiple_ready(
                         assert False, "Should not reach this point"
         except asyncio.TimeoutError:
             assert self.loop.time() == 15
-            # This happened after time == 3, but the loop never resumes becuase
+            # This happened after time == 3, but the loop never resumes because
             # there is nothing ready, so we need to check it after the timeout.
             assert received == {
                 self.recv1.name,
diff --git a/tests/utils/test_timer.py b/tests/utils/test_timer.py
@@ -211,7 +211,7 @@ def test_policy_skip_missed_and_drift_examples() -> None:
     )
 
 
-async def test_timer_contruction_defaults() -> None:
+async def test_timer_construction_defaults() -> None:
     """Test the construction of a periodic timer with default values."""
     timer = Timer(timedelta(seconds=1.0), TriggerAllMissed())
     assert timer.interval == timedelta(seconds=1.0)
@@ -220,7 +220,7 @@ async def test_timer_contruction_defaults() -> None:
     assert timer.is_running is True
 
 
-def test_timer_contruction_no_async() -> None:
+def test_timer_construction_no_async() -> None:
     """Test the construction outside of async (using a custom loop)."""
     loop = async_solipsism.EventLoop()
     timer = Timer(timedelta(seconds=1.0), TriggerAllMissed(), loop=loop)
@@ -230,13 +230,13 @@ def test_timer_contruction_no_async() -> None:
     assert timer.is_running is True
 
 
-def test_timer_contruction_no_event_loop() -> None:
+def test_timer_construction_no_event_loop() -> None:
     """Test the construction outside of async (without a custom loop) fails."""
     with pytest.raises(RuntimeError, match="no running event loop"):
         Timer(timedelta(seconds=1.0), TriggerAllMissed())
 
 
-async def test_timer_contruction_auto_start() -> None:
+async def test_timer_construction_auto_start() -> None:
     """Test the construction of a periodic timer with auto_start=False."""
     policy = TriggerAllMissed()
     timer = Timer(
@@ -251,7 +251,7 @@ async def test_timer_contruction_auto_start() -> None:
     assert timer.is_running is False
 
 
-async def test_timer_contruction_custom_args() -> None:
+async def test_timer_construction_custom_args() -> None:
     """Test the construction of a periodic timer with custom arguments."""
     policy = TriggerAllMissed()
     timer = Timer(
@@ -266,7 +266,7 @@ async def test_timer_contruction_custom_args() -> None:
     assert timer.is_running is True
 
 
-async def test_timer_contruction_timeout_custom_args() -> None:
+async def test_timer_construction_timeout_custom_args() -> None:
     """Test the construction of a timeout timer with custom arguments."""
     timer = Timer.timeout(
         timedelta(seconds=5.0),
@@ -280,7 +280,7 @@ async def test_timer_contruction_timeout_custom_args() -> None:
     assert timer.is_running is True
 
 
-async def test_timer_contruction_periodic_defaults() -> None:
+async def test_timer_construction_periodic_defaults() -> None:
     """Test the construction of a periodic timer."""
     timer = Timer.periodic(timedelta(seconds=5.0))
     assert timer.interval == timedelta(seconds=5.0)
@@ -289,7 +289,7 @@ async def test_timer_contruction_periodic_defaults() -> None:
     assert timer.is_running is True
 
 
-async def test_timer_contruction_periodic_custom_args() -> None:
+async def test_timer_construction_periodic_custom_args() -> None:
     """Test the construction of a timeout timer with custom arguments."""
     timer = Timer.periodic(
         timedelta(seconds=5.0),
@@ -304,7 +304,7 @@ async def test_timer_contruction_periodic_custom_args() -> None:
     assert timer.is_running is True
 
 
-async def test_timer_contruction_wrong_args() -> None:
+async def test_timer_construction_wrong_args() -> None:
     """Test the construction of a timeout timer with wrong arguments."""
     with pytest.raises(
         ValueError,
