Let acount count down to a stop

With a negative step the stop is a lower bound, the way range reads it.
acount(10, -2, stop=0) yielded nothing.

Author: wolph

_python_utils_tests/test_aio.py

@@ -25,6 +25,43 @@ async def mock_sleep(delay: float) -> None:
     assert sum(sleeps) == 4
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'start,step,stop,expected',
+    [
+        (10, -2, 0, [10, 8, 6, 4, 2]),
+        (0, -1, -3, [0, -1, -2]),
+        (1.5, -0.5, 0, [1.5, 1.0, 0.5]),
+        # Nothing to count when `start` is already past `stop`, in either
+        # direction. This is what `range` does as well.
+        (0, -1, 5, []),
+        (5, 1, 3, []),
+        (0, 2, 5, [0, 2, 4]),
+    ],
+)
+async def test_acount_stop_follows_step_direction(
+    start: float, step: float, stop: float, expected: types.List[float]
+) -> None:
+    """Count down to a lower ``stop`` when the step is negative."""
+    limit: int = len(expected) + 5
+    items: types.List[float] = []
+    item: float
+    # `acount` is annotated as a plain iterator, closing takes a generator.
+    counter: types.AsyncGenerator[float, None] = types.cast(
+        types.AsyncGenerator[float, None],
+        aio.acount(start=start, step=step, stop=stop),
+    )
+    async for item in counter:
+        items.append(item)
+        # A counter that misses its `stop` never ends by itself.
+        if len(items) == limit:
+            break
+
+    await counter.aclose()
+
+    assert items == expected
+
+
 @pytest.mark.asyncio
 async def test_acontainer() -> None:
     """Collect an async iterable into the requested container."""

python_utils/aio.py

@@ -35,7 +35,9 @@ async def acount(
         start: First value to yield.
         step: Amount added between successive values.
         delay: Seconds to ``asyncio.sleep`` between yields.
-        stop: Exclusive upper bound; ``None`` counts forever.
+        stop: Exclusive bound, ``None`` counts forever. It is an upper bound
+            for a positive ``step`` and a lower bound for a negative one, the
+            way ``range`` reads it.
 
     Yields:
         The successive counter values.
@@ -46,7 +48,8 @@ async def acount(
     [0, 1, 2]
     """
     for item in itertools.count(start, step):  # pragma: no branch
-        if stop is not None and item >= stop:
+        # A negative step counts down, so `stop` is the lower bound there.
+        if stop is not None and (item <= stop if step < 0 else item >= stop):
             break
 
         yield item