pydocket 0.26.1__tar.gz → 0.26.2__tar.gz

{pydocket-0.26.1 → pydocket-0.26.2}/.gitignore

@@ -16,3 +16,5 @@ wheels/
 .claude/scheduled_tasks.lock
 coverage.xml
 junit.xml
+target/
+target-*/

{pydocket-0.26.1 → pydocket-0.26.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pydocket
-Version: 0.26.1
+Version: 0.26.2
 Summary: A distributed background task system for Python functions
 Project-URL: Homepage, https://docket.lol/
 Project-URL: Documentation, https://docket.lol/en/latest/
@@ -52,7 +52,7 @@ on the scheduling of future work as seamlessly and efficiently as immediate work
 
 [![PyPI - Version](https://img.shields.io/pypi/v/pydocket)](https://pypi.org/project/pydocket/)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pydocket)](https://pypi.org/project/pydocket/)
-[![GitHub main checks](https://img.shields.io/github/check-runs/chrisguidry/docket/main)](https://github.com/chrisguidry/docket/actions/workflows/ci.yml)
+[![GitHub main checks](https://img.shields.io/github/check-runs/chrisguidry/docket/main)](https://github.com/chrisguidry/docket/actions)
 [![Codecov](https://img.shields.io/codecov/c/github/chrisguidry/docket)](https://app.codecov.io/gh/chrisguidry/docket)
 [![PyPI - License](https://img.shields.io/pypi/l/pydocket)](https://github.com/chrisguidry/docket/blob/main/LICENSE)
 [![Documentation](https://img.shields.io/badge/docs-latest-blue.svg)](https://docket.lol/)

{pydocket-0.26.1 → pydocket-0.26.2}/README.md

@@ -3,7 +3,7 @@ on the scheduling of future work as seamlessly and efficiently as immediate work
 
 [![PyPI - Version](https://img.shields.io/pypi/v/pydocket)](https://pypi.org/project/pydocket/)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pydocket)](https://pypi.org/project/pydocket/)
-[![GitHub main checks](https://img.shields.io/github/check-runs/chrisguidry/docket/main)](https://github.com/chrisguidry/docket/actions/workflows/ci.yml)
+[![GitHub main checks](https://img.shields.io/github/check-runs/chrisguidry/docket/main)](https://github.com/chrisguidry/docket/actions)
 [![Codecov](https://img.shields.io/codecov/c/github/chrisguidry/docket)](https://app.codecov.io/gh/chrisguidry/docket)
 [![PyPI - License](https://img.shields.io/pypi/l/pydocket)](https://github.com/chrisguidry/docket/blob/main/LICENSE)
 [![Documentation](https://img.shields.io/badge/docs-latest-blue.svg)](https://docket.lol/)

{pydocket-0.26.1 → pydocket-0.26.2}/src/docket/lua/acquire_or_park.lua

@@ -88,7 +88,9 @@ redis.call('HSET', runs_key,
     'args', args_data,
     'kwargs', kwargs_data
 )
-redis.call('HDEL', runs_key, 'stream_id')
+-- The claim before admission wrote a worker and a start time, and a parked
+-- task has neither until a worker claims it again.
+redis.call('HDEL', runs_key, 'stream_id', 'worker', 'started_at')
 
 redis.call('PUBLISH', state_channel, state_payload)
 

{pydocket-0.26.1 → pydocket-0.26.2}/src/docket/lua/schedule.lua

@@ -154,12 +154,31 @@ else
     end
 end
 
+-- A key used again after its run ended: terminal.lua gave that run's
+-- record an expiry of execution_ttl, which the new run would inherit, so
+-- the record could expire before a worker claims the new run (it is then
+-- refused as superseded) or while it runs (it then can't be seen, and the
+-- key no longer refuses a duplicate).  The new run starts a record of its
+-- own, keeping only the generation counter.
+local previous_state = redis.call('HGET', runs_key, 'state')
+if previous_state == 'completed' or previous_state == 'failed' or previous_state == 'cancelled' then
+    local previous_generation = redis.call('HGET', runs_key, 'generation')
+    redis.call('DEL', runs_key)
+    if previous_generation then
+        redis.call('HSET', runs_key, 'generation', previous_generation)
+    end
+end
+
 -- Increment generation counter
 local new_gen = redis.call('HINCRBY', runs_key, 'generation', 1)
 if generation_index then
     message[generation_index] = tostring(new_gen)
 end
 
+-- A new run starts without the previous run's ending, so a reused key
+-- never shows the old worker, error, completion time, or result.
+redis.call('HDEL', runs_key, 'worker', 'started_at', 'completed_at', 'error', 'result_key')
+
 if is_immediate then
     -- Add to stream for immediate execution
     local message_id = redis.call('XADD', stream_key, '*', unpack(message))

{pydocket-0.26.1 → pydocket-0.26.2}/src/docket/worker.py

@@ -755,6 +755,20 @@ class Worker:
                         await _wait_for_event(session.cancellation_ready, 0.1)
                     if stopping.is_set():
                         return
+                    # A strike written before the worker started must stop
+                    # its tasks, so nothing runs until the strike stream is
+                    # read.  That takes as long as Redis is unreachable, so
+                    # a stopping worker does not wait for it.
+                    strikes_loaded = asyncio.ensure_future(
+                        self.docket.wait_for_strikes_loaded()
+                    )
+                    try:
+                        while not strikes_loaded.done() and not stopping.is_set():
+                            await asyncio.wait([strikes_loaded], timeout=0.1)
+                    finally:
+                        strikes_loaded.cancel()
+                    if stopping.is_set():
+                        return
                     if self.schedule_automatic_tasks:
                         try:
                             await self._schedule_all_automatic_perpetual_tasks()
@@ -1137,7 +1151,10 @@ class Worker:
                             encoded_result = base64.b64encode(pickled_result).decode(
                                 "ascii"
                             )
-                            result_key = execution.key
+                            # Each run stores under its own generation, so a replaced run
+                            # that finishes last writes where nobody reads: terminal.lua
+                            # leaves a superseded run's result_key out of the run state.
+                            result_key = f"{execution.key}:{execution.generation}"
                             ttl_seconds = int(self.docket.execution_ttl.total_seconds())
                             await self.docket.result_storage.put(
                                 result_key, {"data": encoded_result}, ttl=ttl_seconds
@@ -1225,7 +1242,7 @@ class Worker:
                         encoded_exception = base64.b64encode(pickled_exception).decode(
                             "ascii"
                         )
-                        result_key = execution.key
+                        result_key = f"{execution.key}:{execution.generation}"
                         ttl_seconds = int(self.docket.execution_ttl.total_seconds())
                         await self.docket.result_storage.put(
                             result_key, {"data": encoded_exception}, ttl=ttl_seconds

{pydocket-0.26.1 → pydocket-0.26.2}/tests/_rotating_provider.py

@@ -8,7 +8,6 @@ connections get, and pushes them to that one callback as an AUTH token whose
 "oid" claim is the username.
 """
 
-import inspect
 from typing import Any, Callable
 
 from redis.auth.token import SimpleToken
@@ -20,9 +19,8 @@ class RotatingProvider(StreamingCredentialProvider):
         self.credentials = (username, password)
         self._on_next: Callable[[Any], Any] | None = None
 
-    def get_credentials(self) -> tuple[str, str]:
-        return self.credentials
-
+    # Only the async method: docket's clients are all asyncio, so redis-py
+    # never asks for the credentials synchronously.
     async def get_credentials_async(self) -> tuple[str, str]:
         return self.credentials
 
@@ -40,6 +38,5 @@ class RotatingProvider(StreamingCredentialProvider):
         if self._on_next is None:
             return
         token = SimpleToken(password, -1, -1, {"oid": username})
-        result = self._on_next(token)
-        if inspect.isawaitable(result):
-            await result
+        # redis-py's asyncio clients register a coroutine function.
+        await self._on_next(token)

pydocket-0.26.2/tests/concurrency_limits/test_parked_status.py

@@ -0,0 +1,40 @@
+"""A task parked on a concurrency limit shows no worker and no start time."""
+
+import asyncio
+
+from docket import ConcurrencyLimit, Docket, Worker
+from docket.execution import ExecutionState
+
+from tests.concurrency_limits.waiters import wait_for_xlen
+
+
+async def test_a_parked_task_has_no_worker_or_start_time(
+    docket: Docket, worker: Worker
+):
+    started = asyncio.Event()
+    hold = asyncio.Event()
+
+    async def holder(
+        customer_id: int,
+        concurrency: ConcurrencyLimit = ConcurrencyLimit(
+            "customer_id", max_concurrent=1
+        ),
+    ):
+        started.set()
+        await hold.wait()
+
+    # The waiter goes in only after the holder has its slot, because the
+    # worker may start either of two tasks it reads together.
+    await docket.add(holder)(customer_id=1)
+    worker_task = asyncio.create_task(worker.run_until_finished())
+    await started.wait()
+    waiter = await docket.add(holder)(customer_id=1)
+    await wait_for_xlen(docket, f"{docket.prefix}:concurrency:customer_id:1:waiters", 1)
+
+    await waiter.sync()
+    parked = (waiter.state, waiter.worker, waiter.started_at)
+
+    hold.set()
+    await worker_task
+
+    assert parked == (ExecutionState.SCHEDULED, None, None)

{pydocket-0.26.1 → pydocket-0.26.2}/tests/concurrency_limits/test_waiter_queue.py

@@ -4,7 +4,6 @@ frees up, rather than polling via the future queue).
 """
 
 import asyncio
-import time
 from datetime import datetime, timezone
 
 from docket import (
@@ -13,18 +12,7 @@ from docket import (
     Worker,
 )
 
-
-async def _wait_for_xlen(docket: Docket, key: str, target: int) -> None:
-    deadline = time.monotonic() + 2.0
-    while time.monotonic() < deadline:
-        async with docket.redis() as redis:
-            size = await redis.xlen(key)
-        if size == target:
-            return
-        await asyncio.sleep(0.01)
-    raise AssertionError(  # pragma: no cover
-        f"XLEN({key}) did not reach {target} in time"
-    )
+from tests.concurrency_limits.waiters import wait_for_xlen
 
 
 async def test_blocked_task_parks_on_waiter_stream(docket: Docket, worker: Worker):
@@ -51,7 +39,7 @@ async def test_blocked_task_parks_on_waiter_stream(docket: Docket, worker: Worke
     await started.wait()
 
     waiters_stream = f"{docket.prefix}:concurrency:customer_id:1:waiters"
-    await _wait_for_xlen(docket, waiters_stream, 1)
+    await wait_for_xlen(docket, waiters_stream, 1)
 
     async with docket.redis() as redis:
         entries = await redis.xrange(waiters_stream, "-", "+")
@@ -95,7 +83,7 @@ async def test_release_wakes_oldest_waiter_first(docket: Docket, worker: Worker)
     waiters_stream = f"{docket.prefix}:concurrency:customer_id:1:waiters"
     for tid in (1, 2, 3):
         await docket.add(task)(customer_id=1, task_id=tid)
-        await _wait_for_xlen(docket, waiters_stream, tid)
+        await wait_for_xlen(docket, waiters_stream, tid)
 
     release_holder.set()
     await worker_task
@@ -146,7 +134,7 @@ async def test_blocked_task_makes_no_polling_retries(docket: Docket, worker: Wor
     # Wait for the blocked task to actually park on the waiter stream
     # before releasing the holder.
     waiters_stream = f"{docket.prefix}:concurrency:customer_id:1:waiters"
-    await _wait_for_xlen(docket, waiters_stream, 1)
+    await wait_for_xlen(docket, waiters_stream, 1)
 
     release_holder.set()
     await worker_task
@@ -198,7 +186,7 @@ async def test_safeguard_wakes_waiter_when_holder_died_without_releasing(
         runner = asyncio.create_task(worker.run_forever())
 
         # Waiter parks because the (live-looking) fake slot is full.
-        await _wait_for_xlen(docket, waiters_stream, 1)
+        await wait_for_xlen(docket, waiters_stream, 1)
 
         # Now forge a stale-holder state.  No lease renewer is touching
         # this slot, so the timestamp stays at 0 until the safeguard
@@ -262,7 +250,7 @@ async def test_cancel_of_parked_task_prevents_wake_and_run(
 
     # Make sure `blocked` is actually parked on the waiter stream
     waiters_stream = f"{docket.prefix}:concurrency:customer_id:1:waiters"
-    await _wait_for_xlen(docket, waiters_stream, 1)
+    await wait_for_xlen(docket, waiters_stream, 1)
 
     # Cancel the parked task; release the holder; verify blocked never ran
     await docket.cancel(blocked_exec.key)
@@ -310,10 +298,10 @@ async def test_cancel_of_parked_task_removes_waiter_entry_before_release(
 
     parked = await docket.add(holder)(customer_id=1)
     waiters_stream = f"{docket.prefix}:concurrency:customer_id:1:waiters"
-    await _wait_for_xlen(docket, waiters_stream, 1)
+    await wait_for_xlen(docket, waiters_stream, 1)
 
     await docket.cancel(parked.key)
-    await _wait_for_xlen(docket, waiters_stream, 0)
+    await wait_for_xlen(docket, waiters_stream, 0)
 
     release_holder.set()
     await asyncio.wait_for(worker_task, timeout=5)
@@ -326,7 +314,9 @@ async def test_cancel_cleanup_script_drains_waiter_entry(docket: Docket):
     ``ConcurrencyLimit._cleanup_cancelled_waiter`` when a parked task is
     cancelled.  Driving the script directly tests it without a worker.
     """
-    from docket.dependencies._concurrency import _cancel_cleanup  # pyright: ignore[reportPrivateUsage]
+    from docket.dependencies._concurrency import (
+        _cancel_cleanup,  # pyright: ignore[reportPrivateUsage]
+    )
 
     waiter_stream = f"{docket.prefix}:concurrency:cleanup-direct:waiters"
     task_key = "cleanup-direct"

pydocket-0.26.2/tests/concurrency_limits/waiters.py

@@ -0,0 +1,21 @@
+"""Waits on the waiter streams that concurrency limits park tasks on."""
+
+import asyncio
+
+from docket import Docket
+
+
+async def wait_for_xlen(docket: Docket, key: str, target: int) -> None:
+    # Sleeping before each read, not after a failed one, runs every line on
+    # every call, so coverage does not depend on how fast the stream fills.
+    # The loop-again branch happens only when the stream is behind on a read,
+    # so it is excluded from branch coverage.
+    # asyncio.timeout needs Python 3.11, so wait_for bounds the loop instead.
+    async def poll() -> None:
+        while True:
+            await asyncio.sleep(0.01)
+            async with docket.redis() as redis:
+                if await redis.xlen(key) == target:  # pragma: no branch
+                    return
+
+    await asyncio.wait_for(poll(), timeout=2.0)

{pydocket-0.26.1 → pydocket-0.26.2}/tests/test_credential_rotation.py

@@ -9,7 +9,7 @@ which user each connection is authenticated as.
 
 import asyncio
 import gc
-from contextlib import asynccontextmanager
+from contextlib import asynccontextmanager, suppress
 from datetime import timedelta
 from typing import Any, AsyncGenerator, Callable, NamedTuple
 from uuid import uuid4
@@ -147,10 +147,11 @@ async def reading(pubsub: Any) -> AsyncGenerator[list[bytes], None]:
     try:
         yield received
     finally:
-        if reader.done():
-            reader.result()  # the reader's own error, if it failed
+        # Cancelling a reader that already failed does nothing, so awaiting it
+        # raises the reader's own error.
         reader.cancel()
-        await asyncio.gather(reader, return_exceptions=True)
+        with suppress(asyncio.CancelledError):
+            await reader
 
 
 async def test_a_rotation_leaves_a_reading_subscriber_alone(
@@ -160,23 +161,43 @@ async def test_a_rotation_leaves_a_reading_subscriber_alone(
     rotation leaves it alone: one connection, still getting messages."""
     old, new = users
     provider = RotatingProvider(*old)
-    async with RedisConnection(credential_less_url, provider) as connection:
-        async with connection.pubsub() as pubsub:
-            await pubsub.subscribe("rotation")
-            async with reading(pubsub) as received:
-                await wait_until(
-                    lambda: subscribed_as(admin, users, old),
-                    description="the subscriber to authenticate as the old user",
-                )
+    # One statement for both, because coverage.py's sys.monitoring core reports
+    # a false partial branch on the innermost of three nested with statements.
+    async with (
+        RedisConnection(credential_less_url, provider) as connection,
+        connection.pubsub() as pubsub,
+    ):
+        await pubsub.subscribe("rotation")
+        async with reading(pubsub) as received:
+            await wait_until(
+                lambda: subscribed_as(admin, users, old),
+                description="the subscriber to authenticate as the old user",
+            )
 
-                await provider.rotate(*new)
-                await admin.publish("rotation", "after")  # type: ignore[reportUnknownMemberType]
-                await wait_until(
-                    lambda: b"after" in received,
-                    description="a message published after the rotation",
-                )
+            await provider.rotate(*new)
+            await admin.publish("rotation", "after")  # type: ignore[reportUnknownMemberType]
+            await wait_until(
+                lambda: b"after" in received,
+                description="a message published after the rotation",
+            )
 
-                assert await subscribers(admin, users) == [old.name]
+            assert await subscribers(admin, users) == [old.name]
+
+
+async def test_a_rotation_before_connecting_reaches_the_first_connection(
+    credential_less_url: str, admin: Redis, users: tuple[User, User]
+):
+    """A token refresh can land before docket opens any connection, and the
+    first connection must authenticate with the refreshed token."""
+    old, new = users
+    provider = RotatingProvider(*old)
+
+    await provider.rotate(*new)
+
+    async with RedisConnection(credential_less_url, provider) as connection:
+        async with connection.client() as r:
+            await r.exists("rotation")
+        assert await authenticated_as(admin, users, subscribed=False) == {new.name}
 
 
 async def test_a_rotation_after_close_opens_no_connections(
@@ -237,3 +258,8 @@ async def test_a_worker_keeps_working_when_the_old_user_is_revoked(
             after = await docket.add(add)(3, 4)
             await worker.run_until_finished()
             assert await after.get_result() == 7
+
+
+def test_the_provider_streams():
+    """It says it streams, as redis-entraid's provider does."""
+    assert RotatingProvider("user", "secret").is_streaming()

{pydocket-0.26.1 → pydocket-0.26.2}/tests/test_results_storage.py

@@ -189,7 +189,7 @@ async def test_result_key_stored_in_execution_record(docket: Docket, worker: Wor
 
     # Sync and check result field
     await execution.sync()
-    assert execution.result_key == execution.key
+    assert execution.result_key == f"{execution.key}:1"
 
 
 async def test_result_storage_uses_provided_or_default(docket: Docket):

pydocket-0.26.2/tests/test_reused_keys.py

@@ -0,0 +1,113 @@
+"""A key used again, or replaced while it runs, shows only its current run:
+its result, its error, and its ending."""
+
+import asyncio
+from datetime import datetime, timedelta, timezone
+from typing import Callable
+
+from docket import Docket, Worker
+from docket.execution import ExecutionState
+
+
+async def test_a_replaced_run_that_finishes_last_keeps_its_successors_result(
+    docket: Docket, worker: Worker
+):
+    started = asyncio.Event()
+    release = asyncio.Event()
+
+    async def echo(text: str) -> str:
+        if text == "old":
+            started.set()
+            await release.wait()
+        return text
+
+    docket.register(echo)
+    await docket.add(echo, key="swapped")("old")
+    running = asyncio.create_task(worker.run_until_finished())
+    await started.wait()
+
+    replacement = await docket.replace(
+        echo, when=datetime.now(timezone.utc), key="swapped"
+    )("new")
+    while replacement.state != ExecutionState.COMPLETED:
+        await asyncio.sleep(0.02)
+        await replacement.sync()
+    release.set()
+    await running
+
+    assert await replacement.get_result() == "new"
+
+
+async def test_a_reused_key_does_not_return_the_previous_runs_result(
+    docket: Docket, worker: Worker
+):
+    async def maybe(text: str | None) -> str | None:
+        return text
+
+    docket.register(maybe)
+    first = await docket.add(maybe, key="reused")("first")
+    await worker.run_until_finished()
+    assert await first.get_result() == "first"
+
+    second = await docket.add(maybe, key="reused")(None)
+    await worker.run_until_finished()
+
+    assert await second.get_result() is None
+
+
+async def test_a_reused_key_does_not_show_the_previous_runs_ending(
+    docket: Docket, worker: Worker
+):
+    async def echo(text: str) -> str:
+        if text == "fail":
+            raise ValueError("the first run failed")
+        return text
+
+    docket.register(echo)
+    await docket.add(echo, key="again")("fail")
+    await worker.run_until_finished()
+
+    later = datetime.now(timezone.utc) + timedelta(minutes=1)
+    second = await docket.add(echo, when=later, key="again")("fine")
+    await second.sync()
+    assert (second.state, second.error, second.completed_at, second.worker) == (
+        ExecutionState.SCHEDULED,
+        None,
+        None,
+        None,
+    )
+
+    await docket.replace(echo, when=datetime.now(timezone.utc), key="again")("fine")
+    await worker.run_until_finished()
+    await second.sync()
+    assert (second.state, second.error) == (ExecutionState.COMPLETED, None)
+
+
+async def test_a_key_used_again_soon_after_its_run_ended_keeps_its_record(
+    redis_url: str, make_docket_name: Callable[[], str]
+):
+    """An ended run's record expires execution_ttl after the ending.  A run added
+    under the same key before then has a record of its own: it waits to be claimed
+    and runs, however long it waits."""
+    ran: list[int] = []
+
+    async def count(n: int) -> None:
+        ran.append(n)
+
+    async with Docket(
+        name=make_docket_name(), url=redis_url, execution_ttl=timedelta(seconds=1)
+    ) as docket:
+        docket.register(count)
+        await docket.add(count, key="again")(1)
+        async with Worker(docket) as worker:
+            await worker.run_until_finished()
+
+        second = await docket.add(count, key="again")(2)
+        await asyncio.sleep(1.5)  # the ended run's record would have expired by now
+        await second.sync()
+        assert second.state == ExecutionState.QUEUED
+
+        async with Worker(docket) as worker:
+            await worker.run_until_finished()
+
+    assert ran == [1, 2]

pydocket-0.26.2/tests/worker/test_strikes_at_startup.py

@@ -0,0 +1,68 @@
+"""A worker reads the strikes that exist when it starts before it runs
+anything, so a strike written earlier is never missed."""
+
+import asyncio
+from datetime import timedelta
+from typing import Any
+from unittest.mock import AsyncMock
+
+import pytest
+
+from docket import Docket, Worker
+from docket.execution import ExecutionState
+from docket.strikelist import StrikeList
+
+
+def block_strike_reads(monkeypatch: pytest.MonkeyPatch) -> asyncio.Event:
+    """Holds every strike monitor's reads until the returned event is set."""
+    loading = asyncio.Event()
+    read_strikes = StrikeList._read_strikes  # pyright: ignore[reportPrivateUsage]
+
+    async def slow_read_strikes(self: StrikeList, *args: Any) -> Any:
+        await loading.wait()
+        return await read_strikes(self, *args)
+
+    monkeypatch.setattr(StrikeList, "_read_strikes", slow_read_strikes)
+    return loading
+
+
+async def test_a_worker_waits_for_the_strikes_before_it_runs_anything(
+    docket: Docket, the_task: AsyncMock, monkeypatch: pytest.MonkeyPatch
+):
+    docket.register(the_task)
+    execution = await docket.add(the_task)()
+    await docket.strike(the_task)
+
+    # A second connection to the docket, whose strike monitor cannot read
+    # the stream until the test lets it, the way it can be slow after a
+    # restart.
+    loading = block_strike_reads(monkeypatch)
+
+    async with Docket(name=docket.name, url=docket.url) as second:
+        second.register(the_task)
+        async with Worker(
+            second,
+            schedule_automatic_tasks=False,
+            minimum_check_interval=timedelta(milliseconds=5),
+        ) as worker:
+            running = asyncio.create_task(worker.run_until_finished())
+            await asyncio.sleep(0.5)
+            loading.set()
+            await running
+
+    the_task.assert_not_awaited()
+    await execution.sync()
+    assert execution.state == ExecutionState.CANCELLED
+
+
+async def test_a_worker_stops_while_it_waits_for_the_strikes(
+    docket: Docket, monkeypatch: pytest.MonkeyPatch
+):
+    block_strike_reads(monkeypatch)
+
+    async with Docket(name=docket.name, url=docket.url) as second:
+        async with Worker(second, schedule_automatic_tasks=False) as worker:
+            running = asyncio.create_task(worker.run_forever())
+            await asyncio.sleep(0.2)
+        # Leaving the worker stops it, though the strikes never loaded.
+        await asyncio.wait_for(running, timeout=5)