taskwire 0.2.0__tar.gz → 0.3.0__tar.gz

{taskwire-0.2.0 → taskwire-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: taskwire
-Version: 0.2.0
+Version: 0.3.0
 Summary: Progress reporting and awaitable dialogs for long-running server-side operations.
 Project-URL: Homepage, https://github.com/velis74/taskwire
 Project-URL: Repository, https://github.com/velis74/taskwire
@@ -28,22 +28,30 @@ Requires-Dist: nest-asyncio>=1.6; extra == 'celery'
 Provides-Extra: demo
 Requires-Dist: uvicorn>=0.27; extra == 'demo'
 Provides-Extra: dev
+Requires-Dist: celery>=5.3; extra == 'dev'
 Requires-Dist: coverage; extra == 'dev'
+Requires-Dist: dynamicforms-fastapi-viewsets>=0.11.1; extra == 'dev'
+Requires-Dist: dynamicforms-fastapi-viewsets[muxws]>=0.11.1; extra == 'dev'
+Requires-Dist: fastapi>=0.100; extra == 'dev'
 Requires-Dist: httpx; extra == 'dev'
 Requires-Dist: hypothesis; extra == 'dev'
+Requires-Dist: muxws>=0.4.1; extra == 'dev'
+Requires-Dist: nest-asyncio>=1.6; extra == 'dev'
 Requires-Dist: pytest; extra == 'dev'
 Requires-Dist: pytest-asyncio; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: redis>=5.0; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: uvicorn>=0.27; extra == 'dev'
 Provides-Extra: fastapi
 Requires-Dist: fastapi>=0.100; extra == 'fastapi'
 Provides-Extra: muxws
-Requires-Dist: dynamicforms-fastapi-viewsets[muxws]>=0.9.0; extra == 'muxws'
+Requires-Dist: dynamicforms-fastapi-viewsets[muxws]>=0.11.1; extra == 'muxws'
 Requires-Dist: muxws>=0.4.1; extra == 'muxws'
 Provides-Extra: redis
 Requires-Dist: redis>=5.0; extra == 'redis'
 Provides-Extra: viewsets
-Requires-Dist: dynamicforms-fastapi-viewsets>=0.9.0; extra == 'viewsets'
+Requires-Dist: dynamicforms-fastapi-viewsets>=0.11.1; extra == 'viewsets'
 Description-Content-Type: text/markdown
 
 # <img src="taskwire-icon.svg" alt="" width="40" height="40" style="vertical-align: middle"> taskwire

{taskwire-0.2.0 → taskwire-0.3.0}/pyproject.toml

@@ -30,16 +30,31 @@ dependencies = []   # DELIBERATE: core has no runtime dependency of any kind (TW
 redis = ["redis>=5.0"]
 celery = ["celery>=5.3", "nest_asyncio>=1.6"]
 fastapi = ["fastapi>=0.100"]
-# >=0.9.0: the execution hook, the Idempotency-Key helpers and a muxws command that runs to the end
-# of its action when its stream ends early (TW-CALL-*).
-viewsets = ["dynamicforms-fastapi-viewsets>=0.9.0"]
+# >=0.11.1: the execution hook and the Idempotency-Key helpers; a muxws command that runs to the end
+# of its action when its stream ends early (TW-CALL-*); delivery filters that run on poll as on push,
+# which `contrib/viewsets_events.py` relies on for the display decision (TW-EVT-004); and an executor
+# that reports its outcomes in its own terms - `ActionInterruptedError`, `ActionOutcomeUnknownError`,
+# `Middleware.executor_started()` and `Middleware.on_transition()` - so that `contrib/viewsets.py`
+# imports no Celery (TW-CALL-101, TW-CALL-105), and that reports a process exit to `on_transition()`
+# in every pool.
+viewsets = ["dynamicforms-fastapi-viewsets>=0.11.1"]
 # The socket carries the six request/response calls as viewset commands (TW-REST-004), so the muxws
 # extra needs the viewset layer's muxws half as well as muxws itself. >=0.4.1: `Peer.close()` sends
 # every queued frame before closing the socket, so the `goaway` of `goaway_if_stale` (TW-WS-007)
 # reaches the client.
-muxws = ["muxws>=0.4.1", "dynamicforms-fastapi-viewsets[muxws]>=0.9.0"]
+muxws = ["muxws>=0.4.1", "dynamicforms-fastapi-viewsets[muxws]>=0.11.1"]
 demo = ["uvicorn>=0.27"]
-dev = ["coverage", "pytest", "pytest-asyncio", "pytest-cov", "hypothesis", "httpx", "ruff"]
+# Everything the test suite, the linters and the demo need.
+dev = [
+    "taskwire[redis,celery,fastapi,viewsets,muxws,demo]",
+    "coverage",
+    "pytest",
+    "pytest-asyncio",
+    "pytest-cov",
+    "hypothesis",
+    "httpx",
+    "ruff",
+]
 
 [project.urls]
 Homepage = "https://github.com/velis74/taskwire"
@@ -50,13 +65,13 @@ Documentation = "https://docs.velis.si/taskwire/"
 [tool.hatch.version]
 path = "taskwire/__init__.py"
 
-# The release tool stamps the two manifests by itself. `ts/index.ts` is the third place the version
+# The release tool stamps the two manifests by itself. `vue/index.ts` is the third place the version
 # is written down - the npm half exports it as `VERSION` - and nothing about a Python manifest points
 # at it, so it is named here. `packaging_test.py::test_python_and_npm_versions_match` and
-# `ts/packaging.spec.ts` both compare against `package.json`, transitively pinning all three, but only
+# `vue/packaging.spec.ts` both compare against `package.json`, transitively pinning all three, but only
 # once a release has actually bumped this file too.
 [tool.publish]
-additional_files = ["ts/index.ts"]
+additional_files = ["vue/index.ts"]
 
 [tool.hatch.build.targets.wheel]
 packages = ["taskwire"]

{taskwire-0.2.0 → taskwire-0.3.0}/taskwire/__init__.py

@@ -12,10 +12,10 @@ outside. Nothing in the core imports a framework, a driver or a UI library (TW-C
 
 from __future__ import annotations
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 
 from .ambient import ask, current_reporter, progress
-from .calls import Call, call_token, execute_call, hand_off, receive_call
+from .calls import Call, call_token, end_call, execute_call, hand_off, receive_call
 from .conformance import run_conformance
 from .decorators import (
     declared_result_kind,
@@ -60,7 +60,7 @@ from .reporter import (
     Reporter,
     SyncReporter,
 )
-from .settings import configure, configured, reset_configuration, Settings, settings
+from .settings import configure, configure_executor, configured, reset_configuration, Settings, settings
 from .store import (
     Commit,
     DialogResolution,
@@ -120,6 +120,7 @@ __all__ = [
     "declared_result_kind",
     "declared_result_params",
     "configure",
+    "configure_executor",
     "configured",
     "CONNECTION_HEADER",
     "key",
@@ -130,6 +131,7 @@ __all__ = [
     "TOKEN_HEADER",
     "operation",
     "receive_call",
+    "end_call",
     "execute_call",
     "hand_off",
     "reset_configuration",

{taskwire-0.2.0 → taskwire-0.3.0}/taskwire/calls.py

@@ -11,6 +11,9 @@ each has one primitive:
 - **where the work is handed to another process**, `hand_off()`: the values that cross the boundary,
   and the terminal write left to the process that receives them.
 
+A process that learns that an execution ended without writing its terminal state - an executor that
+ended it from outside - ends the operation with `end_call()`.
+
 The adapters do nothing but read a framework's request into a `Call` and place these primitives:
 `taskwire.contrib.asgi.track_calls`, `taskwire.contrib.wsgi.track_calls` and
 `taskwire.contrib.viewsets.TaskwireMiddleware`. Both context managers have an asynchronous and a
@@ -35,7 +38,7 @@ from dataclasses import dataclass
 from typing import Any
 
 from .headers import TOKEN_HEADER
-from .models import Error, ProgressState, Text
+from .models import DialogState, Error, ProgressState, Text
 from .reporter import mark_failed, mark_queued, operation, OperationScope, Reporter
 from .rest import _is_uuid
 from .settings import configured
@@ -59,6 +62,11 @@ TW-CELERY-004)."""
 DIALOG_TIMEOUT = "dialog_timeout"
 """An execution limit ended the work while it held an open question. `retryable: true` (TW-DLG-006)."""
 
+INTERRUPTED = "interrupted"
+"""The executor ended the work after it started, with no open question: a time limit, a termination, the
+loss of the executing process. `message.params.reason` names which when the executor says. `retryable:
+true` (TW-CALL-008)."""
+
 HTTP_STATUS = "http_status"
 """The call was answered with an error status and no exception (TW-CALL-006)."""
 
@@ -77,6 +85,21 @@ def status_error(status: int) -> Error | None:
     )
 
 
+def dialog_timeout_error() -> Error:
+    """The error of work an execution limit ended while it held an open question (TW-DLG-006)."""
+    return Error(code=DIALOG_TIMEOUT, message=Text(key="taskwire.dialog_timeout"), retryable=True)
+
+
+def interrupted_error(reason: str | None = None) -> Error:
+    """The error of work the executor ended after it started (TW-CALL-008): `interrupted`, with
+    `message.params.reason` when `reason` is given."""
+    return Error(
+        code=INTERRUPTED,
+        message=Text(key="taskwire.interrupted", params={"reason": reason} if reason is not None else None),
+        retryable=True,
+    )
+
+
 class _Unsuccessful(Exception):  # noqa: N818 - never raised; the exit's stand-in for a recorded failure
     pass
 
@@ -399,6 +422,45 @@ def execute_call(call: Call | None, *, timeout_errors: tuple[type[BaseException]
     return CallExecution(call, timeout_errors)
 
 
+async def end_call(
+    call: Call | None,
+    error: Error,
+    *,
+    queued_only: bool = False,
+    asking_error: Error | None = None,
+) -> bool:
+    """End the operation of a call whose execution ended without writing its terminal state
+    (TW-CALL-008). For the process that observes such an end from outside the execution.
+
+    Writes `failed` with `error`, withdrawing the open dialogs in the same step, when the operation is
+    `queued`, `running` or `waiting_input` - only when `queued` with `queued_only`. With an open dialog
+    the error is `asking_error` when one is given. An operation holding a parked result is left as it
+    is: its work finished. Returns whether it wrote.
+
+    `call=None` and a store-less configuration make it a no-op. A store failure is logged and never
+    raised.
+    """
+    store = configured.store
+    if call is None or store is None:
+        return False
+    try:
+        snapshot = await store.snapshot(make_key(call.session, call.token))
+        if snapshot is None or snapshot.progress.is_terminal or snapshot.progress.result is not None:
+            return False
+        if queued_only and ProgressState(snapshot.progress.state) is not ProgressState.QUEUED:
+            return False
+        asking = any(DialogState(dialog.state) is DialogState.OPEN for dialog in snapshot.dialogs)
+        await mark_failed(
+            call.token,
+            session=call.session,
+            error=asking_error if asking and asking_error is not None else error,
+        )
+    except Exception:  # noqa: BLE001 - reporting is an accelerator
+        logger.warning("taskwire: could not end the operation %s", call.token, exc_info=True)
+        return False
+    return True
+
+
 @contextlib.contextmanager
 def hand_off() -> Iterator[dict[str, str]]:
     """Hand the executing call's operation to another process (TW-CALL-007).

{taskwire-0.2.0 → taskwire-0.3.0}/taskwire/contrib/celery.py

@@ -57,7 +57,7 @@ from ..decorators import declared_result_kind
 from ..headers import CONNECTION_HEADER, TOKEN_HEADER  # noqa: F401 - re-exported for callers
 from ..models import Error, Text
 from ..reporter import mark_failed, mark_queued, operation
-from ..settings import configured
+from ..settings import configure_executor
 
 logger = logging.getLogger("taskwire.celery")
 
@@ -170,16 +170,16 @@ async def dispatch(
         raise broker_failure
 
 
-def configure_worker(store: Any) -> None:
-    """A worker configures its own store and `NullTransport`, and **never pushes** (TW-CELERY-002).
+def configure_worker(store: Any, transport: Any = None) -> None:
+    """A worker configures its own store and a transport that pushes to no socket (TW-CELERY-002).
 
-    Store and transport configuration must not travel in a serialized context: they are objects with
-    connections, the serialized form would be a copy nobody owns, and a worker that pushed would
-    duplicate every envelope the reader is already delivering (TW-INV-002).
-
-    The worker writes; the web process's reader pushes. That is the whole division.
+    `transport` None configures `NullTransport`: the worker writes, and the web process's reader
+    pushes. A transport whose `crosses_processes` is True, `ViewsetEventsTransport`, publishes each
+    envelope to the cross-process event store, from which every web process delivers it
+    (TW-EVT-002). Any other transport raises `ValueError`: a worker that pushed would duplicate every
+    envelope the reader is already delivering (TW-INV-002). `taskwire.configure_executor` applies the
+    rule (TW-CALL-009).
     """
     from ..transport import NullTransport
 
-    configured.store = store
-    configured.transport = NullTransport()
+    configure_executor(store=store, transport=transport if transport is not None else NullTransport())

{taskwire-0.2.0 → taskwire-0.3.0}/taskwire/contrib/muxws.py

@@ -37,10 +37,18 @@ from typing import Any
 from muxws import PeerRegistry
 from muxws.errors import ConnectionLost
 
-from ..delivery import Client, effective_delivery, may_be_suppressed, OperationRef, OVERRIDES_TAG
+from ..delivery import (  # noqa: F401 - CONNECTION_TAG is re-exported
+    Client,
+    connection_id,
+    CONNECTION_TAG,
+    effective_delivery,
+    may_be_suppressed,
+    OperationRef,
+    OVERRIDES_TAG,
+)
 from ..models import Envelope, EnvelopeKind, Progress
 from ..reader import unwatch_namespace, watch_namespace
-from ..settings import settings
+from ..settings import configured, settings
 from ..transport import TaskwireTransport
 
 logger = logging.getLogger("taskwire.muxws")
@@ -154,32 +162,6 @@ def tag_peer(peer: Any, session: str) -> None:
 # --------------------------------------------------------------------------- the watch handler
 
 
-CONNECTION_TAG = "taskwire_connection"
-"""The opaque, server-issued id naming one live socket (TW-DEL-016).
-
-It is minted here and handed back only in the `watch` reply, over a socket the caller already
-established. It is NOT stable across a reconnect and decides exactly two things: the
-`progress_delivery` display flag, and which socket a private operation's progress is written to. It
-reaches one store field, `origin_connection`, which is inert data recorded at start and never used
-for authorization (TW-SEC-003).
-"""
-
-
-def connection_id(peer: Any) -> str | None:
-    """This socket's id, minting one on first use."""
-    tags = getattr(peer, "tags", None)
-    if not isinstance(tags, dict):
-        return None
-    existing = tags.get(CONNECTION_TAG)
-    if isinstance(existing, str):
-        return existing
-    import uuid
-
-    minted = str(uuid.uuid4())
-    tags[CONNECTION_TAG] = minted
-    return minted
-
-
 def handle_watch(peer: Any, message: dict[str, Any]) -> dict[str, Any]:
     """The `watch` handler. Declares the **whole** override map, never a delta (TW-DEL-006).
 
@@ -255,6 +237,9 @@ async def serve_peer(peer: Any, session: str) -> StreamHandler:
     (TW-PRIV-003) and `progress_delivery` falls back to the predicate alone. Muting would silently
     do nothing.
 
+    With a transport that has `watch_topics(peer, session)`, `ViewsetEventsTransport`, the `watch`
+    reply also carries `topics`: the event topics this socket subscribes to (TW-EVT-005).
+
     `watch` is the only kind the returned handler answers, and the only one that can never be a
     viewset endpoint: it declares per-connection state held on the Peer, not an action on a resource
     (TW-DEL-006, TW-DEL-016). Everything else - both reads, cancel, collect, dismiss and a dialog
@@ -273,7 +258,13 @@ async def serve_peer(peer: Any, session: str) -> StreamHandler:
             # TW-DEL-007: this reads no store, in either direction. An override for a token that
             # does not exist is accepted and inert - putting a per-tab display preference on the
             # path of every socket's first message would be a poor trade.
-            await stream.reply(handle_watch(peer, payload))
+            reply = handle_watch(peer, payload)
+            # TW-EVT-005: a transport that carries the pushes over event topics names the topics
+            # this socket follows.
+            watch_topics = getattr(configured.transport, "watch_topics", None)
+            if watch_topics is not None:
+                reply["topics"] = watch_topics(peer, session)
+            await stream.reply(reply)
             return
 
         # TW-CORE-007: the wire vocabulary is closed. An unknown kind is answered rather than

{taskwire-0.2.0 → taskwire-0.3.0}/taskwire/contrib/redis_store.py

@@ -28,8 +28,10 @@ it would make the fan-out unit smaller than the security unit.
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import json
 import logging
+import weakref
 
 from typing import Any
 
@@ -45,6 +47,7 @@ from ..models import (
     Result,
     Snapshot,
 )
+from ..settings import configured
 from ..store import CANCELLED_BUTTON, Commit, DialogResolution, DialogVanished, split_key, TaskwireStore
 
 logger = logging.getLogger("taskwire.redis")
@@ -57,6 +60,21 @@ overall deadline. A lost notification costs this much latency rather than hangin
 why the loop re-reads the dialog document on every wakeup *and* on every expiry.
 """
 
+
+def _blpop_seconds(client: Any) -> float:
+    """The `BLPOP` timeout for `client`: `_BLPOP_SECONDS`, or half its `socket_timeout` if that is less.
+
+    A redis-py client aborts a read that outlasts its `socket_timeout` (5 s by default in redis-py 8)
+    with `TimeoutError`, and a blocking command is no exception. A `BLPOP` therefore has to return
+    before the socket timeout does.
+    """
+    pool = getattr(client, "connection_pool", None)
+    socket_timeout = pool.connection_kwargs.get("socket_timeout") if pool is not None else None
+    if not socket_timeout:
+        return _BLPOP_SECONDS
+    return min(_BLPOP_SECONDS, socket_timeout / 2)
+
+
 # --------------------------------------------------------------------------- Lua
 
 _COMMIT = """
@@ -227,6 +245,18 @@ return released
 """
 
 
+class _Scripts:
+    """One Redis client and the five scripts registered on it."""
+
+    def __init__(self, client: Any) -> None:
+        self.redis = client
+        self.commit = client.register_script(_COMMIT)
+        self.put_dialog = client.register_script(_PUT_DIALOG)
+        self.resolve_dialog = client.register_script(_RESOLVE_DIALOG)
+        self.withdraw_dialogs = client.register_script(_WITHDRAW_DIALOGS)
+        self.release_result = client.register_script(_RELEASE_RESULT)
+
+
 class RedisStore(TaskwireStore):
     """The cross-process store. Passes the exported conformance suite unchanged (TW-STORE-011).
 
@@ -235,12 +265,32 @@ class RedisStore(TaskwireStore):
     """
 
     def __init__(self, url: str = "redis://127.0.0.1:6379/0", *, client: Any = None) -> None:
-        self._redis = client if client is not None else aioredis.Redis.from_url(url, decode_responses=True)
-        self._commit = self._redis.register_script(_COMMIT)
-        self._put_dialog = self._redis.register_script(_PUT_DIALOG)
-        self._resolve_dialog = self._redis.register_script(_RESOLVE_DIALOG)
-        self._withdraw_dialogs = self._redis.register_script(_WITHDRAW_DIALOGS)
-        self._release_result = self._redis.register_script(_RELEASE_RESULT)
+        """A store on the Redis at `url`, or on `client`.
+
+        A `redis.asyncio` connection belongs to the event loop it was opened on. Built from `url`, the
+        store opens one client per event loop that uses it, so one store serves every loop of a process:
+        a worker's executions, its own transition loop, and the private loop of each synchronous
+        `operation()`. A `client` passed in is used on every loop as it is, and is the caller's to keep
+        on one.
+        """
+        self._url = url
+        self._fixed = _Scripts(client) if client is not None else None
+        self._per_loop: weakref.WeakKeyDictionary[asyncio.AbstractEventLoop, _Scripts] = weakref.WeakKeyDictionary()
+
+    def _bound(self) -> _Scripts:
+        if self._fixed is not None:
+            return self._fixed
+        loop = asyncio.get_running_loop()
+        bound = self._per_loop.get(loop)
+        if bound is None:
+            bound = _Scripts(aioredis.Redis.from_url(self._url, decode_responses=True))
+            self._per_loop[loop] = bound
+        return bound
+
+    @property
+    def _redis(self) -> Any:
+        """The client of the running event loop."""
+        return self._bound().redis
 
     # ---------------------------------------------------------------- keys
 
@@ -271,7 +321,7 @@ class RedisStore(TaskwireStore):
         """TW-STORE-014: one script call answers with the rev and the cancel flag it saw."""
         k = self._keys(key)
         created_ms = self._now_ms()
-        rev, cancelled = await self._commit(
+        rev, cancelled = await self._bound().commit(
             keys=[k["progress"], k["rev"], k["index"], k["cancel"]],
             args=[
                 json.dumps(progress.to_dict()),
@@ -355,8 +405,18 @@ class RedisStore(TaskwireStore):
     async def publish(self, ns: str, envelope: Envelope) -> None:
         """TW-BP-001: one channel per namespace, `twx:{ns}`, and never one per token.
 
+        With a configured transport whose `crosses_processes` is True the envelope goes to
+        `reader.dispatch` in this process instead, and nothing is published on `twx:{ns}`
+        (TW-EVT-002).
+
         MUST NOT raise (TW-STORE-008): the state is already durable by the time this runs.
         """
+        if getattr(configured.transport, "crosses_processes", False):
+            from .. import reader
+
+            with contextlib.suppress(Exception):
+                await reader.dispatch(ns, envelope)
+            return
         try:
             await self._redis.publish(f"twx:{ns}", json.dumps(envelope.to_dict()))
         except Exception:  # noqa: BLE001 - a publish is a notification, never the copy of record
@@ -430,7 +490,7 @@ class RedisStore(TaskwireStore):
 
     async def put_dialog(self, key: str, dialog: DialogRequest, ttl: float) -> int:  # noqa: A002
         k = self._keys(key)
-        rev = await self._put_dialog(
+        rev = await self._bound().put_dialog(
             keys=[k["dialogs"], k["rev"], k["asking"], f"{k['reply_prefix']}{dialog.id}:reply"],
             args=[dialog.id, json.dumps(dialog.to_dict()), int(ttl), self._now_ms(), k["token"]],
         )
@@ -438,7 +498,7 @@ class RedisStore(TaskwireStore):
 
     async def resolve_dialog(self, key: str, did: str, reply: DialogReply) -> DialogResolution:  # noqa: A002
         k = self._keys(key)
-        outcome, _rev = await self._resolve_dialog(
+        outcome, _rev = await self._bound().resolve_dialog(
             keys=[k["dialogs"], k["rev"], k["asking"], f"{k['reply_prefix']}{did}:reply"],
             args=[did, json.dumps(reply.to_dict()), self._now_ms(), k["token"]],
         )
@@ -446,7 +506,7 @@ class RedisStore(TaskwireStore):
 
     async def withdraw_dialogs(self, key: str) -> list[str]:  # noqa: A002
         k = self._keys(key)
-        withdrawn = await self._withdraw_dialogs(
+        withdrawn = await self._bound().withdraw_dialogs(
             keys=[k["dialogs"], k["rev"], k["asking"]],
             args=[
                 self._now_ms(),
@@ -477,14 +537,15 @@ class RedisStore(TaskwireStore):
             if state is DialogState.CANCELLED:
                 return DialogReply(button=CANCELLED_BUTTON)
 
-            popped = await self._redis.blpop([reply_key], timeout=_BLPOP_SECONDS)
+            client = self._redis
+            popped = await client.blpop([reply_key], timeout=_blpop_seconds(client))
             if popped is not None:
                 return DialogReply.from_dict(json.loads(popped[1])) or DialogReply(button=CANCELLED_BUTTON)
             # Expired: re-read and wait again. No overall deadline is consumed by this.
 
     async def release_result(self, key: str) -> Result | None:  # noqa: A002
         k = self._keys(key)
-        released = await self._release_result(
+        released = await self._bound().release_result(
             keys=[k["progress"], k["rev"], k["dialogs"], k["index"]],
             args=[self._now_ms(), k["token"]],
         )
@@ -499,8 +560,13 @@ class RedisStore(TaskwireStore):
         return RedisReader(self)
 
     async def aclose(self) -> None:
-        """Close the Redis connection this store was built with."""
-        await self._redis.aclose()
+        """Close the Redis client of the running event loop, or the one the store was built with."""
+        if self._fixed is not None:
+            await self._fixed.redis.aclose()
+            return
+        bound = self._per_loop.pop(asyncio.get_running_loop(), None)
+        if bound is not None:
+            await bound.redis.aclose()
 
 
 # --------------------------------------------------------------------------- the reader