dynamicforms-fastapi-viewsets 0.9.1__tar.gz → 0.10.0__tar.gz

{dynamicforms_fastapi_viewsets-0.9.1 → dynamicforms_fastapi_viewsets-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: dynamicforms-fastapi-viewsets
-Version: 0.9.1
+Version: 0.10.0
 Summary: Django REST Framework-style viewsets for FastAPI, with optional Celery-backed async execution and a Vue/TypeScript client counterpart.
 Project-URL: Homepage, https://github.com/dynamicforms/fastapi-viewsets
 Project-URL: Repository, https://github.com/dynamicforms/fastapi-viewsets
@@ -40,6 +40,8 @@ Requires-Dist: pytest; extra == 'dev'
 Requires-Dist: pytest-asyncio; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
 Requires-Dist: redis; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: uvicorn; extra == 'dev'
 Provides-Extra: django
 Requires-Dist: asgiref>=3.6; extra == 'django'
 Requires-Dist: django>=4.2; extra == 'django'

dynamicforms_fastapi_viewsets-0.10.0/fastapi_viewsets/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.10.0"

{dynamicforms_fastapi_viewsets-0.9.1 → dynamicforms_fastapi_viewsets-0.10.0}/fastapi_viewsets/conf.py

@@ -70,8 +70,8 @@ class Settings:
         self.viewsets_event_store: EventStore | None = None
         """
         The `EventStore` of `fastapi_viewsets.events`: it assigns each event its rev, keeps the
-        topic's log for `poll` and carries the event to `deliver()` in every process that watches
-        the topic. None is one `MemoryEventStore` for this process. A deployment of more than one
+        topic's log for `poll` and carries the event to `deliver()` in every process whose store
+        is started. None is one `MemoryEventStore` for this process. A deployment of more than one
         process, a Celery worker included, sets a `RedisEventStore` in every process.
         """
         self.viewsets_event_authorizers: list[EventAuthorizer] = []

{dynamicforms_fastapi_viewsets-0.9.1 → dynamicforms_fastapi_viewsets-0.10.0}/fastapi_viewsets/events/__init__.py

@@ -31,6 +31,7 @@ from .delivery import (
     deliver,
     DeliveryFilter,
     drop_peer,
+    passes_filters,
     reset_subscriptions,
     subscribe,
     Subscription,
@@ -74,6 +75,7 @@ __all__ = [
     "get_store",
     "is_valid_topic",
     "is_viewset_topic",
+    "passes_filters",
     "publish",
     "register_events",
     "reset_sources",

{dynamicforms_fastapi_viewsets-0.9.1 → dynamicforms_fastapi_viewsets-0.10.0}/fastapi_viewsets/events/conftest.py

@@ -3,6 +3,7 @@
 import asyncio
 import time
 
+from collections.abc import Callable
 from typing import Any
 
 import pytest
@@ -89,6 +90,8 @@ class FakeRedis:
         self.expires: dict[str, float] = {}
         self.channels: dict[str, list[FakePubSub]] = {}
         self.commands: list[str] = []
+        self.pubsub_held = False
+        self.opened: list[FakePubSub] = []
 
     def _expire(self, key: str) -> None:
         if key in self.expires and self.expires[key] <= time.monotonic():
@@ -160,36 +163,68 @@ class FakeRedis:
         return len(subscribers)
 
     def pubsub(self) -> "FakePubSub":
-        return FakePubSub(self)
+        """A new pub/sub connection, `held` while `pubsub_held` is set; kept in `opened`."""
+        pubsub = FakePubSub(self)
+        pubsub.held = self.pubsub_held
+        self.opened.append(pubsub)
+        return pubsub
 
 
 class FakePubSub:
     """
-    A pub/sub connection. `subscribe` sends the command and returns, as redis-py's does; Redis
-    applies it and queues its confirmation at once, or, while `held` is set, when `release()` is
-    called.
+    A pub/sub connection, as `redis.asyncio.client.PubSub` without `decode_responses`.
+
+    `subscribe` and `unsubscribe` send the command and return, as redis-py's do; Redis applies it
+    and queues its confirmation at once, or, while `held` is set, when `release()` is called, in the
+    order the commands were sent. `channels` holds the channels the client has SUBSCRIBEd and not
+    UNSUBSCRIBEd. `lose_connection()` reconnects as redis-py does.
     """
 
     def __init__(self, redis: FakeRedis):
         self.redis = redis
         self.queue: asyncio.Queue = asyncio.Queue()
         self.subscribed: set[str] = set()
+        self.channels: set[str] = set()
         self.closed = False
         self.held = False
-        self._unapplied: list[str] = []
+        self._unapplied: list[tuple[Callable[[str], None], str]] = []
 
     async def subscribe(self, *channels: str) -> None:
         for channel in channels:
-            if self.held:
-                self._unapplied.append(channel)
-            else:
-                self._apply_subscribe(channel)
+            self.channels.add(channel)
+            self._send(self._apply_subscribe, channel)
+
+    async def unsubscribe(self, *channels: str) -> None:
+        for channel in channels:
+            self.channels.discard(channel)
+            self._send(self._apply_unsubscribe, channel)
+
+    def _send(self, apply: Callable[[str], None], channel: str) -> None:
+        if self.held or self._unapplied:
+            self._unapplied.append((apply, channel))
+        else:
+            apply(channel)
 
     def release(self) -> None:
-        """Applies and confirms the SUBSCRIBEs sent while `held` was set."""
+        """Applies and confirms the commands sent while `held` was set."""
         self.held = False
         unapplied, self._unapplied = self._unapplied, []
-        for channel in unapplied:
+        for apply, channel in unapplied:
+            apply(channel)
+
+    def lose_connection(self) -> None:
+        """
+        Drops the connection with every command Redis has not applied and every reply not read, and
+        reconnects as redis-py does: SUBSCRIBEs every channel in `channels`. Clears `held`.
+        """
+        for channel in self.subscribed:
+            self.redis.channels[channel].remove(self)
+        self.subscribed.clear()
+        self._unapplied.clear()
+        while not self.queue.empty():
+            self.queue.get_nowait()
+        self.held = False
+        for channel in sorted(self.channels):
             self._apply_subscribe(channel)
 
     def _apply_subscribe(self, channel: str) -> None:
@@ -198,12 +233,11 @@ class FakePubSub:
             self.redis.channels.setdefault(channel, []).append(self)
         self.queue.put_nowait({"type": "subscribe", "channel": channel.encode(), "data": len(self.subscribed)})
 
-    async def unsubscribe(self, *channels: str) -> None:
-        for channel in channels:
-            if channel in self.subscribed:
-                self.subscribed.discard(channel)
-                self.redis.channels[channel].remove(self)
-            self.queue.put_nowait({"type": "unsubscribe", "channel": channel.encode(), "data": len(self.subscribed)})
+    def _apply_unsubscribe(self, channel: str) -> None:
+        if channel in self.subscribed:
+            self.subscribed.discard(channel)
+            self.redis.channels[channel].remove(self)
+        self.queue.put_nowait({"type": "unsubscribe", "channel": channel.encode(), "data": len(self.subscribed)})
 
     async def get_message(self, ignore_subscribe_messages: bool = False, timeout: float = 0.0):
         try:

{dynamicforms_fastapi_viewsets-0.9.1 → dynamicforms_fastapi_viewsets-0.10.0}/fastapi_viewsets/events/delivery.py

@@ -17,27 +17,32 @@ from typing import Any
 from ..conf import settings
 from ..context import Context
 from ..exceptions import EventSubscriptionsExceededError
-from .store import get_store
 
 logger = logging.getLogger(__name__)
 
 
 @dataclass(frozen=True, eq=False)
 class Subscription:
-    """One socket following one topic."""
+    """
+    One socket following one topic, or, for the delivery filters of a poll, the poll of one topic.
+    """
 
-    peer: Any
-    """The muxws peer of the socket."""
+    peer: Any | None
+    """The muxws peer of the socket. On a poll, the peer the poll arrived on; None for a poll over
+    REST."""
     context: Context
-    """The context of the `subscribe` call that made the subscription."""
+    """The context of the `subscribe` call that made the subscription; on a poll, the context of the
+    poll call."""
     topic: str
 
 
 DeliveryFilter = Callable[[Subscription, str, int, str, Any, int], "bool | Awaitable[bool]"]
 """
 `filter(subscription, topic, rev, event_name, payload, version)`, sync or async; `version` is the
-event's `event_version`. False skips the push to that subscription's socket; an exception counts as
-True.
+event's `event_version`. The filters run on every push and on every event a poll answers. False
+skips the push to that subscription's socket, or leaves the event out of the poll answer; an
+exception counts as True. On a poll, `subscription` is built from the poll call and its `peer` is
+None for a poll over REST.
 """
 
 # topic -> id(peer) -> Subscription
@@ -46,12 +51,7 @@ _by_topic: dict[str, dict[int, Subscription]] = {}
 _by_peer: dict[int, dict[str, Subscription]] = {}
 # id(peer) of every socket whose on_close handler is installed
 _close_installed: set[int] = set()
-# the topics this process has called store.watch() for and not store.unwatch() since
-_watched: set[str] = set()
-# topic -> the future that completes when the running call bringing its watch in line with the
-# table ends
-_syncing: dict[str, asyncio.Future] = {}
-# background tasks: pushes, and unwatches after a socket loss
+# background tasks: pushes
 _tasks: set[asyncio.Task] = set()
 
 
@@ -66,45 +66,6 @@ def _spawn(coroutine: Coroutine[Any, Any, Any]) -> asyncio.Task | None:
     return task
 
 
-async def _sync_watch(topic: str) -> None:
-    """
-    Calls `store.watch(topic)` when the topic has subscriptions and is not watched, and
-    `store.unwatch(topic)` when it has none and is watched, until the two agree, and returns when
-    they agree. One call per topic runs the store at a time: a call made while another runs waits
-    for it to end, whatever its outcome, and then checks again. An exception of a store call this
-    call made propagates.
-    """
-    while (running := _syncing.get(topic)) is not None:
-        await asyncio.shield(running)
-    done = asyncio.get_running_loop().create_future()
-    _syncing[topic] = done
-    try:
-        while True:
-            wanted = topic in _by_topic
-            if wanted == (topic in _watched):
-                return
-            store = get_store()
-            if wanted:
-                await store.watch(topic)
-                _watched.add(topic)
-            else:
-                _watched.discard(topic)
-                await store.unwatch(topic)
-    finally:
-        if _syncing.get(topic) is done:
-            del _syncing[topic]
-        done.set_result(None)
-
-
-async def _sync_watch_logged(topic: str) -> None:
-    try:
-        await _sync_watch(topic)
-    except Exception:
-        logger.warning(
-            "events: bringing the watch of topic %s in line with its subscriptions failed", topic, exc_info=True
-        )
-
-
 def _remove(key: int, topic: str) -> Subscription | None:
     held = _by_peer.get(key)
     subscription = held.pop(topic, None) if held is not None else None
@@ -120,18 +81,16 @@ def _remove(key: int, topic: str) -> Subscription | None:
 
 async def subscribe(peer: Any, context: Context, topic: str) -> Subscription:
     """
-    Subscribes the socket `peer` to `topic` and returns the subscription once the store watches the
-    topic. A topic the socket already holds is subscribed again with `context`, and counts once.
+    Subscribes the socket `peer` to `topic` and returns the subscription. A topic the socket already
+    holds is subscribed again with `context`, and counts once. From then on `deliver()` pushes the
+    topic's events to the socket.
 
     Raises `EventSubscriptionsExceededError` (409) when the socket already holds
-    `settings.viewsets_event_max_subscriptions` other topics. The first subscription of a topic in
-    this process calls `store.watch(topic)`; when that raises, the subscription is removed and the
-    exception propagates. A subscribe that arrives while the topic's watch is being brought in line
-    waits for it. The first subscription of a socket installs one `peer.on_close` handler, which
-    drops every subscription of the socket.
+    `settings.viewsets_event_max_subscriptions` other topics. The first subscription of a socket
+    installs one `peer.on_close` handler, which drops every subscription of the socket.
 
     A socket whose `is_open` is false is closed, and its `on_close` handlers have run: the
-    subscription is returned without entering the table, and the store is not called.
+    subscription is returned without entering the table.
     """
     subscription = Subscription(peer, context, topic)
     if not getattr(peer, "is_open", True):
@@ -146,31 +105,20 @@ async def subscribe(peer: Any, context: Context, topic: str) -> Subscription:
     if key not in _close_installed:
         _close_installed.add(key)
         peer.on_close(lambda _reason: drop_peer(peer))
-    try:
-        await _sync_watch(topic)
-    except BaseException:
-        if _by_peer.get(key, {}).get(topic) is subscription:
-            _remove(key, topic)
-        raise
     return subscription
 
 
 async def unsubscribe(peer: Any, topic: str) -> None:
-    """Removes the socket's subscription to `topic`, if it holds one. The last subscription of a
-    topic in this process calls `store.unwatch(topic)`; an exception it raises is logged."""
-    if _remove(id(peer), topic) is not None and topic not in _by_topic:
-        await _sync_watch_logged(topic)
+    """Removes the socket's subscription to `topic`, if it holds one."""
+    _remove(id(peer), topic)
 
 
 def drop_peer(peer: Any) -> None:
-    """Removes every subscription of the socket `peer`. The topics left without subscriptions are
-    unwatched in a background task of the running event loop."""
+    """Removes every subscription of the socket `peer`."""
     key = id(peer)
     _close_installed.discard(key)
     for topic in list(_by_peer.get(key, {})):
         _remove(key, topic)
-        if topic not in _by_topic:
-            _spawn(_sync_watch_logged(topic))
 
 
 def subscriptions(topic: str) -> list[Subscription]:
@@ -187,7 +135,13 @@ def _is_connection_lost(error: BaseException) -> bool:
     return any(cls.__name__ == "ConnectionLost" for cls in type(error).__mro__)
 
 
-async def _admitted(subscription: Subscription, topic: str, rev: int, name: str, payload: Any, version: int) -> bool:
+async def passes_filters(
+    subscription: Subscription, topic: str, rev: int, name: str, payload: Any, version: int
+) -> bool:
+    """
+    Runs `settings.viewsets_event_delivery_filters` in order and answers False when one of them
+    answers False. A filter that raises counts as True; the exception is logged at debug level.
+    """
     for delivery_filter in settings.viewsets_event_delivery_filters:
         try:
             result = delivery_filter(subscription, topic, rev, name, payload, version)
@@ -207,7 +161,7 @@ async def _push(
     subscription: Subscription, topic: str, rev: int, prev: int, name: str, payload: Any, version: int
 ) -> None:
     async def push() -> None:
-        if await _admitted(subscription, topic, rev, name, payload, version):
+        if await passes_filters(subscription, topic, rev, name, payload, version):
             headers = {":event": name, ":version": version, ":topic": topic, ":rev": rev, ":prev": prev}
             await subscription.peer.notify(payload, headers=headers)
 
@@ -243,9 +197,7 @@ async def wait_for_pushes() -> None:
 
 
 def reset_subscriptions() -> None:
-    """Forgets every subscription and watch of this process without calling the store."""
+    """Forgets every subscription of this process."""
     _by_topic.clear()
     _by_peer.clear()
     _close_installed.clear()
-    _watched.clear()
-    _syncing.clear()

{dynamicforms_fastapi_viewsets-0.9.1 → dynamicforms_fastapi_viewsets-0.10.0}/fastapi_viewsets/events/lifecycle.py

@@ -8,8 +8,8 @@ logger = logging.getLogger(__name__)
 
 
 async def start_events() -> None:
-    """Starts the configured store: a `RedisEventStore` starts its reader, which carries the events of
-    the topics this process watches to `deliver()`. Called from the application's lifespan."""
+    """Starts the configured store: a `RedisEventStore` starts its reader, which carries every event
+    to `deliver()`. Called from the application's lifespan."""
     await get_store().start()
 
 

{dynamicforms_fastapi_viewsets-0.9.1 → dynamicforms_fastapi_viewsets-0.10.0}/fastapi_viewsets/events/redis.py

@@ -9,7 +9,6 @@ import asyncio
 import json
 import logging
 
-from collections import deque
 from typing import Any, TYPE_CHECKING
 
 from ..conf import settings
@@ -50,7 +49,7 @@ return {rev_text, prev_text}
 # Seconds the reader waits for a message before it checks again, and waits after a failed read.
 _READ_TIMEOUT = 1.0
 
-# Seconds `watch` waits for Redis to confirm a SUBSCRIBE.
+# Seconds `start` waits for Redis to confirm the SUBSCRIBE of the events channel.
 _SUBSCRIBE_TIMEOUT = 5.0
 
 
@@ -62,27 +61,24 @@ class RedisEventStore:
     - `{prefix}log:{topic}`, the topic's log, a list of JSON entries, newest first, of at most
       `settings.viewsets_event_log_size` entries, expiring `settings.viewsets_event_log_ttl` seconds
       after the topic's last event;
-    - `{prefix}ch:{topic}`, the channel `publish` publishes the event on, as the JSON object
+    - `{prefix}events`, the one channel `publish` publishes every event on, as the JSON object
       `{"topic", "rev", "prev", "name", "payload", "version"}`.
 
-    `append` is one Lua script. `start()` opens the reader, a task on one pub/sub connection that
-    subscribes to the channel of every topic `watch` names and calls `deliver()` for each message;
-    `stop()` closes it. A topic watched before `start()` is subscribed when the reader opens.
+    `append` is one Lua script. `start()` SUBSCRIBEs the events channel on one pub/sub connection,
+    returns once Redis has confirmed it, and runs the reader, a task that calls `deliver()` for each
+    message; `deliver()` pushes the event to the subscriptions of its topic in this process and
+    leaves out a topic without one. `stop()` closes the connection.
 
-    While the reader runs, `watch` returns once the reader has read Redis's confirmation of the
-    SUBSCRIBE, so every event published on the channel after `watch` returns reaches this process.
+    When redis-py reconnects the pub/sub connection it SUBSCRIBEs the channel again. An event
+    published while the connection is down does not reach this process; the event client finds it
+    by poll, on the topic's next push or its check poll.
     """
 
     def __init__(self, redis_client: "Redis", key_prefix: str = "events:"):
         self.redis_client = redis_client
         self.key_prefix = key_prefix
-        self._watched: set[str] = set()
-        self._listening: set[str] = set()
         self._pubsub: Any = None
         self._reader: asyncio.Task | None = None
-        self._wake: asyncio.Event | None = None
-        # channel -> one future per SUBSCRIBE sent and not yet confirmed, oldest first
-        self._confirming: dict[str, deque[asyncio.Future]] = {}
 
     def rev_key(self, topic: str) -> str:
         return f"{self.key_prefix}rev:{topic}"
@@ -90,8 +86,10 @@ class RedisEventStore:
     def log_key(self, topic: str) -> str:
         return f"{self.key_prefix}log:{topic}"
 
-    def channel(self, topic: str) -> str:
-        return f"{self.key_prefix}ch:{topic}"
+    @property
+    def channel(self) -> str:
+        """The channel every event is published on."""
+        return f"{self.key_prefix}events"
 
     @property
     def reader_running(self) -> bool:
@@ -99,15 +97,30 @@ class RedisEventStore:
         return self._reader is not None and not self._reader.done()
 
     async def start(self) -> None:
+        """
+        SUBSCRIBEs the events channel and starts the reader once Redis has confirmed the SUBSCRIBE.
+        Raises `asyncio.TimeoutError` when the confirmation does not arrive within 5 seconds, and
+        the error of the connection when it fails; the store is then not started.
+        """
         if self.reader_running:
             return
-        self._pubsub = self.redis_client.pubsub()
-        self._wake = asyncio.Event()
-        for topic in sorted(self._watched):
-            await self._pubsub.subscribe(self.channel(topic))
-            self._listening.add(topic)
+        pubsub = self.redis_client.pubsub()
+        try:
+            await pubsub.subscribe(self.channel)
+            await asyncio.wait_for(self._confirmed(pubsub), _SUBSCRIBE_TIMEOUT)
+        except BaseException:
+            await _close(pubsub)
+            raise
+        self._pubsub = pubsub
         self._reader = asyncio.create_task(self._read())
 
+    @staticmethod
+    async def _confirmed(pubsub: Any) -> None:
+        while True:
+            message = await pubsub.get_message(ignore_subscribe_messages=False, timeout=_READ_TIMEOUT)
+            if message is not None and message.get("type") == "subscribe":
+                return
+
     async def stop(self) -> None:
         reader, self._reader = self._reader, None
         if reader is not None and not reader.done():
@@ -117,20 +130,8 @@ class RedisEventStore:
             except asyncio.CancelledError:
                 pass
         pubsub, self._pubsub = self._pubsub, None
-        self._listening.clear()
-        for pending in self._confirming.values():
-            for confirmed in pending:
-                if not confirmed.done():
-                    confirmed.set_exception(
-                        ConnectionError("the event reader stopped before Redis confirmed SUBSCRIBE")
-                    )
-                    confirmed.exception()
-        self._confirming.clear()
         if pubsub is not None:
-            try:
-                await pubsub.aclose()
-            except Exception:
-                logger.debug("events: closing the reader connection failed", exc_info=True)
+            await _close(pubsub)
 
     async def append(self, topic: str, name: str, payload: Any, version: int) -> tuple[int, int]:
         result = await self.redis_client.eval(
@@ -176,84 +177,32 @@ class RedisEventStore:
         message = json.dumps(
             {"topic": topic, "rev": rev, "prev": prev, "name": name, "payload": payload, "version": version}
         )
-        await self.redis_client.publish(self.channel(topic), message)
+        await self.redis_client.publish(self.channel, message)
 
     async def drop(self, topic: str) -> None:
         await self.redis_client.delete(self.rev_key(topic), self.log_key(topic))
 
-    async def watch(self, topic: str) -> None:
-        """
-        Records `topic` for `start()`. While the reader runs, SUBSCRIBEs its channel, unless it is
-        subscribed, and returns once the reader has read the confirmation of that SUBSCRIBE, or of
-        the one still unconfirmed. Raises `asyncio.TimeoutError` when no confirmation arrives within
-        5 seconds, and `ConnectionError` when the reader stops first.
-        """
-        self._watched.add(topic)
-        if self._pubsub is None:
-            return
-        channel = self.channel(topic)
-        if topic in self._listening:
-            pending = self._confirming.get(channel)
-            if not pending:
-                return
-            confirmed = pending[-1]
-        else:
-            confirmed = asyncio.get_running_loop().create_future()
-            pending = self._confirming.setdefault(channel, deque())
-            pending.append(confirmed)
-            try:
-                await self._pubsub.subscribe(channel)
-            except BaseException:
-                pending.remove(confirmed)
-                if not pending and self._confirming.get(channel) is pending:
-                    del self._confirming[channel]
-                raise
-            self._listening.add(topic)
-            self._wake.set()
-        await asyncio.wait_for(asyncio.shield(confirmed), _SUBSCRIBE_TIMEOUT)
-
-    def _confirm(self, channel: Any) -> None:
-        """Completes the oldest unconfirmed SUBSCRIBE of `channel`."""
-        if isinstance(channel, bytes):
-            channel = channel.decode()
-        pending = self._confirming.get(channel)
-        if not pending:
-            return
-        confirmed = pending.popleft()
-        if not pending:
-            del self._confirming[channel]
-        if not confirmed.done():
-            confirmed.set_result(None)
-
-    async def unwatch(self, topic: str) -> None:
-        self._watched.discard(topic)
-        if self._pubsub is not None and topic in self._listening:
-            self._listening.discard(topic)
-            await self._pubsub.unsubscribe(self.channel(topic))
-
     async def _read(self) -> None:
         while True:
-            if not self._listening:
-                self._wake.clear()
-                await self._wake.wait()
-                continue
             try:
-                message = await self._pubsub.get_message(ignore_subscribe_messages=False, timeout=_READ_TIMEOUT)
+                message = await self._pubsub.get_message(ignore_subscribe_messages=True, timeout=_READ_TIMEOUT)
             except asyncio.CancelledError:
                 raise
             except Exception:
-                logger.exception("events: reading the event channels failed")
+                logger.exception("events: reading the events channel failed")
                 await asyncio.sleep(_READ_TIMEOUT)
                 continue
-            if message is None:
-                continue
-            if message.get("type") == "subscribe":
-                self._confirm(message.get("channel"))
-                continue
-            if message.get("type") != "message":
+            if message is None or message.get("type") != "message":
                 continue
             try:
                 data = json.loads(message["data"])
                 await deliver(data["topic"], data["rev"], data["prev"], data["name"], data["payload"], data["version"])
             except Exception:
-                logger.exception("events: a message on %s could not be delivered", message.get("channel"))
+                logger.exception("events: an event on %s could not be delivered", message.get("channel"))
+
+
+async def _close(pubsub: Any) -> None:
+    try:
+        await pubsub.aclose()
+    except Exception:
+        logger.debug("events: closing the reader connection failed", exc_info=True)

{dynamicforms_fastapi_viewsets-0.9.1 → dynamicforms_fastapi_viewsets-0.10.0}/fastapi_viewsets/events/sources.py

@@ -20,7 +20,7 @@ async def publish(topic: str, event: Event) -> tuple[int, int]:
 
     Raises `ValueError` for a topic of neither form; the form is all that is checked. Records the
     event's `event_name`, payload and `event_version` with `store.append`, then carries them to
-    every process that watches the topic with `store.publish`. An exception of `store.publish` is
+    every process whose store is started with `store.publish`. An exception of `store.publish` is
     logged and not raised: the event is recorded, and a frontend learns of it on its next poll.
     """
     validate_topic(topic)
@@ -35,7 +35,7 @@ async def publish(topic: str, event: Event) -> tuple[int, int]:
         await store.publish(topic, rev, prev, name, payload, version)
     except Exception:
         logger.warning(
-            "events: carrying %s rev %s of topic %s to the watching processes failed", name, rev, topic, exc_info=True
+            "events: carrying %s rev %s of topic %s to the processes failed", name, rev, topic, exc_info=True
         )
     return rev, prev
 

{dynamicforms_fastapi_viewsets-0.9.1 → dynamicforms_fastapi_viewsets-0.10.0}/fastapi_viewsets/events/store.py

@@ -1,6 +1,6 @@
 """
 The event store: it assigns each event of a topic its rev, keeps the topic's log for `poll`, and
-carries a published event to `deliver()` in every process that watches the topic.
+carries a published event to `deliver()` in every process whose store is started.
 """
 
 import time
@@ -50,17 +50,11 @@ class EventStore(Protocol):
 
     async def publish(self, topic: str, rev: int, prev: int, name: str, payload: Any, version: int) -> None:
         """Carries the event to `deliver(topic, rev, prev, name, payload, version)` in every process
-        that watches the topic."""
+        whose store is started; `deliver()` pushes it to the subscriptions of the topic there."""
 
     async def drop(self, topic: str) -> None:
         """Removes the topic's rev and log."""
 
-    async def watch(self, topic: str) -> None:
-        """Starts carrying the topic's events to this process."""
-
-    async def unwatch(self, topic: str) -> None:
-        """Stops carrying the topic's events to this process."""
-
 
 def _now_ms() -> int:
     return time.time_ns() // 1_000_000
@@ -147,12 +141,6 @@ class MemoryEventStore:
     async def drop(self, topic: str) -> None:
         self._topics.pop(topic, None)
 
-    async def watch(self, topic: str) -> None:
-        pass
-
-    async def unwatch(self, topic: str) -> None:
-        pass
-
 
 _default_store: MemoryEventStore | None = None
 

{dynamicforms_fastapi_viewsets-0.9.1 → dynamicforms_fastapi_viewsets-0.10.0}/fastapi_viewsets/events/viewset.py

@@ -55,6 +55,7 @@ class PolledEvent(BaseModel):
 
     rev: int
     prev: int
+    """The rev of the event before it in the answer; for the first event, the cursor."""
     event: str
     """The event's `event_name`."""
     version: int = Field(ge=1, description="The event's `event_version`: the version of the payload's shape.")
@@ -161,6 +162,12 @@ class EventsViewSet:
         to it `[]`, and any other cursor the events since it, or `events: null` when the log holds
         no event whose `prev` is the cursor. 422 `event_cursors_exceeded` for more cursors than
         `settings.viewsets_event_max_subscriptions`.
+
+        The delivery filters run on every event since the cursor, with a `Subscription` of the
+        topic whose `peer` is the socket the poll arrived on, None over REST, and whose `context` is
+        the poll call's. An event a filter refuses is left out of `events`, and each event's `prev`
+        is the rev of the event before it in the answer, the cursor for the first. The answer's
+        `rev` covers every event since the cursor, the ones left out included.
         """
         cursors = body.cursors
         limit = settings.viewsets_event_max_subscriptions
@@ -180,6 +187,7 @@ class EventsViewSet:
                 continue
             admitted.append(topic)
 
+        peer = request.scope.get(PEER_SCOPE_KEY)
         store = get_store()
         revs = await store.revs(admitted) if admitted else {}
         for topic in admitted:
@@ -192,11 +200,15 @@ class EventsViewSet:
             if logged is None:
                 answers[topic] = TopicAnswer(rev=rev, events=None)
                 continue
-            events = [
-                PolledEvent(rev=e.rev, prev=e.prev, event=e.name, version=e.version, payload=e.payload) for e in logged
-            ]
+            subscription = delivery.Subscription(peer, context, topic)
+            events: list[PolledEvent] = []
+            prev = cursor
+            for e in logged:
+                if await delivery.passes_filters(subscription, topic, e.rev, e.name, e.payload, e.version):
+                    events.append(PolledEvent(rev=e.rev, prev=prev, event=e.name, version=e.version, payload=e.payload))
+                    prev = e.rev
             # an event appended between `revs` and `since` is in the chain; the answer's rev covers it
-            answers[topic] = TopicAnswer(rev=max([rev, *(e.rev for e in events)]), events=events)
+            answers[topic] = TopicAnswer(rev=max([rev, *(e.rev for e in logged)]), events=events)
 
         return PollAnswer(
             topics={topic: answers[topic] for topic in cursors},

{dynamicforms_fastapi_viewsets-0.9.1 → dynamicforms_fastapi_viewsets-0.10.0}/fastapi_viewsets/middleware/idempotency.py

@@ -63,6 +63,19 @@ redis.call('SET', KEYS[2], '1', 'PX', ttl)
 return 1
 """
 
+# Extends the running record KEYS[1] and its attached mark KEYS[2] to ARGV[2] milliseconds, only while
+# KEYS[1] is still the running record ARGV[1] this process wrote. Returns 1 when it was extended.
+_RENEW_SCRIPT = """
+if redis.call('GET', KEYS[1]) ~= ARGV[1] then
+    return 0
+end
+redis.call('PEXPIRE', KEYS[1], ARGV[2])
+if redis.call('EXISTS', KEYS[2]) == 1 then
+    redis.call('PEXPIRE', KEYS[2], ARGV[2])
+end
+return 1
+"""
+
 
 def parse_idempotency_key(value: str) -> str:
     """
@@ -232,7 +245,9 @@ class Idempotency(Middleware):
       (`request_fingerprint`). A key recorded with a different fingerprint raises
       `IdempotencyKeyReusedError` (422).
     - The record is written when the chain reaches this middleware, as running, for
-      `settings.viewsets_idempotency_lock_ttl` seconds. When the call completes, its outcome replaces
+      `settings.viewsets_idempotency_lock_ttl` seconds. While the call runs, this process extends the
+      running record to the lock TTL every third of the lock TTL, so it expires only once the process
+      stops running the call without completing it. When the call completes, its outcome replaces
       the running record for `settings.viewsets_idempotency_ttl` seconds. An outcome of `GET` or
       `HEAD` is stored only when a repeat attached while the call ran; an outcome with a cookie or a
       `set-cookie` header is never stored. A record that is not stored is deleted.
@@ -294,7 +309,7 @@ class Idempotency(Middleware):
         self, storage_key: str, run: _Run, method: str, call_next: Callable[[], Awaitable[ViewSetResult]]
     ) -> ViewSetResult:
         try:
-            result = await call_next()
+            result = await self._call_renewing(storage_key, run, call_next)
         except ActionDispatchError:
             await self._finish(storage_key, run, None, method)
             raise
@@ -307,6 +322,34 @@ class Idempotency(Middleware):
         await self._finish(storage_key, run, _Outcome(result=result), method)
         return result
 
+    async def _call_renewing(
+        self, storage_key: str, run: _Run, call_next: Callable[[], Awaitable[ViewSetResult]]
+    ) -> ViewSetResult:
+        renewal = asyncio.ensure_future(self._renew(storage_key, run))
+        try:
+            return await call_next()
+        finally:
+            renewal.cancel()
+
+    async def _renew(self, storage_key: str, run: _Run) -> None:
+        """Extends the running record of `run` to the lock TTL every third of the lock TTL, until it is
+        cancelled or the record is no longer the one this process wrote."""
+        lock_ttl = settings.viewsets_idempotency_lock_ttl
+        while True:
+            await asyncio.sleep(lock_ttl / 3)
+            try:
+                if self.redis_client is None:
+                    renewed = self._renew_in_memory(storage_key, run, lock_ttl)
+                else:
+                    renewed = await self.redis_client.eval(
+                        _RENEW_SCRIPT, 2, storage_key, storage_key + ":attached", run.running, _milliseconds(lock_ttl)
+                    )
+            except Exception:
+                logger.exception("Idempotency: extending the running record of %s failed", storage_key)
+                continue
+            if not renewed:
+                return
+
     async def _finish(self, storage_key: str, run: _Run, outcome: _Outcome | None, method: str) -> None:
         """Stores the outcome or deletes the record, publishes on the key's channel and resolves the
         in-process repeats, in that order. `outcome` None (the call was cancelled) or an outcome that
@@ -334,11 +377,12 @@ class Idempotency(Middleware):
         run = self._runs.get(storage_key)
         if run is not None:
             run.attached = True
-            remaining = await self._lock_remaining(storage_key)
-            if remaining <= 0:
-                return None
-            done, _ = await asyncio.wait({run.future}, timeout=remaining)
-            if not done or run.future.result() is None:
+            while not run.future.done():
+                remaining = await self._lock_remaining(storage_key)
+                if remaining <= 0:
+                    return None
+                await asyncio.wait({run.future}, timeout=remaining)
+            if run.future.result() is None:
                 return None
             return _Record(record.fingerprint, outcome=run.future.result())
         if self.redis_client is None:
@@ -369,6 +413,13 @@ class Idempotency(Middleware):
         self._runs[storage_key] = run
         return run
 
+    def _renew_in_memory(self, storage_key: str, run: _Run, lock_ttl: float) -> bool:
+        record = self._records.get(storage_key)
+        if record is None or record.owner != run.owner:
+            return False
+        record.expires_at = time.monotonic() + lock_ttl
+        return True
+
     def _finish_in_memory(self, storage_key: str, run: _Run, outcome: _Outcome | None, mode: str) -> None:
         record = self._records.get(storage_key)
         if record is None or record.owner != run.owner:

{dynamicforms_fastapi_viewsets-0.9.1 → dynamicforms_fastapi_viewsets-0.10.0}/pyproject.toml

@@ -49,6 +49,8 @@ dev = [
     "asgiref",
     "PyJWT",
     "muxws[starlette,websockets]>=0.4.1",
+    "ruff",
+    "uvicorn",
 ]
 
 [project.urls]

dynamicforms_fastapi_viewsets-0.9.1/fastapi_viewsets/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.9.1"