dynamicforms-fastapi-viewsets 0.11.2__tar.gz → 0.11.4__tar.gz

{dynamicforms_fastapi_viewsets-0.11.2 → dynamicforms_fastapi_viewsets-0.11.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: dynamicforms-fastapi-viewsets
-Version: 0.11.2
+Version: 0.11.4
 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
@@ -35,7 +35,7 @@ Requires-Dist: coverage; extra == 'dev'
 Requires-Dist: django; extra == 'dev'
 Requires-Dist: gevent; extra == 'dev'
 Requires-Dist: httpx2; extra == 'dev'
-Requires-Dist: muxws[starlette,websockets]>=0.4.1; extra == 'dev'
+Requires-Dist: muxws[starlette,websockets]>=0.4.2; extra == 'dev'
 Requires-Dist: pyjwt; extra == 'dev'
 Requires-Dist: pytest; extra == 'dev'
 Requires-Dist: pytest-asyncio; extra == 'dev'
@@ -49,7 +49,7 @@ Requires-Dist: django>=4.2; extra == 'django'
 Provides-Extra: jwt
 Requires-Dist: pyjwt>=2.8; extra == 'jwt'
 Provides-Extra: muxws
-Requires-Dist: muxws[starlette]>=0.4.1; extra == 'muxws'
+Requires-Dist: muxws[starlette]>=0.4.2; extra == 'muxws'
 Description-Content-Type: text/markdown
 
 # DynamicForms FastAPI Viewsets
@@ -72,8 +72,7 @@ Celery-backed async execution and a matching Vue/TypeScript client counterpart.
 - **Bulk operations** — first-class support for bulk create, update, partial update and destroy.
 - **muxws transport** — reach the same viewsets over a single WebSocket instead of one HTTP request
   per call. A command goes through your application as an HTTP request does - its middleware,
-  exception handlers, router dependencies and state - so both transports behave identically. In the
-  demo, a burst of 100 requests takes 156 ms over REST and 37 ms over muxws.
+  exception handlers, router dependencies and state - so both transports behave identically.
 - **Events** — publish an event to a topic and every frontend following it learns of it, as a muxws
   push or on its next poll. `ChangeEvents` publishes every create, update and destroy of a viewset to
   its routed base path; custom events are declared with `source()`. Every event is recorded before it
@@ -139,7 +138,7 @@ app.include_router(router)
 
 See the [full documentation](https://docs.velis.si/dynamicforms/fastapi-viewsets/) for guides on
 the mixin system, `route_viewset`, `CollectionViewSet`, `DjangoORMViewSet`, `celery_viewset`, the
-list pipeline and pagination, the muxws transport, and the Vue client.
+list pipeline and pagination, the muxws transport, events, and the Vue client.
 
 ## Demo
 

{dynamicforms_fastapi_viewsets-0.11.2 → dynamicforms_fastapi_viewsets-0.11.4}/README.md

@@ -18,8 +18,7 @@ Celery-backed async execution and a matching Vue/TypeScript client counterpart.
 - **Bulk operations** — first-class support for bulk create, update, partial update and destroy.
 - **muxws transport** — reach the same viewsets over a single WebSocket instead of one HTTP request
   per call. A command goes through your application as an HTTP request does - its middleware,
-  exception handlers, router dependencies and state - so both transports behave identically. In the
-  demo, a burst of 100 requests takes 156 ms over REST and 37 ms over muxws.
+  exception handlers, router dependencies and state - so both transports behave identically.
 - **Events** — publish an event to a topic and every frontend following it learns of it, as a muxws
   push or on its next poll. `ChangeEvents` publishes every create, update and destroy of a viewset to
   its routed base path; custom events are declared with `source()`. Every event is recorded before it
@@ -85,7 +84,7 @@ app.include_router(router)
 
 See the [full documentation](https://docs.velis.si/dynamicforms/fastapi-viewsets/) for guides on
 the mixin system, `route_viewset`, `CollectionViewSet`, `DjangoORMViewSet`, `celery_viewset`, the
-list pipeline and pagination, the muxws transport, and the Vue client.
+list pipeline and pagination, the muxws transport, events, and the Vue client.
 
 ## Demo
 

dynamicforms_fastapi_viewsets-0.11.4/fastapi_viewsets/__init__.py

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

{dynamicforms_fastapi_viewsets-0.11.2 → dynamicforms_fastapi_viewsets-0.11.4}/fastapi_viewsets/collection_viewset.py

@@ -211,8 +211,7 @@ class CollectionViewSet(AsyncCollectionViewSet[K, T]):
 
         for field_name, field_info in data.__class__.model_fields.items():
             if field_info.json_schema_extra and field_info.json_schema_extra.get("autoinc_int"):
-                # If the field is already set and is not 0 or None, we leave it (unless this is the desired behavior)
-                # However, we usually want autoinc only if the value is not yet set
+                # a truthy value is kept; 0 or None gets the next value after the container's maximum
                 current_val = getattr(data, field_name, None)
                 if current_val:
                     continue

{dynamicforms_fastapi_viewsets-0.11.2 → dynamicforms_fastapi_viewsets-0.11.4}/fastapi_viewsets/conf.py

@@ -9,7 +9,7 @@ if TYPE_CHECKING:
 
     from .context.auth import AuthBackend
     from .events.authorizers import EventAuthorizer
-    from .events.delivery import DeliveryFilter
+    from .events.delivery import DeliveryFilter, EventListener
     from .events.store import EventStore
     from .middleware import CommandMiddleware
 
@@ -40,8 +40,9 @@ class Settings:
         """
         self.viewsets_idempotency_lock_ttl: float = 600
         """
-        Seconds a running record of `Idempotency` is kept after it was written, unless the action
-        finishes first. Once it expires, a repeat runs the action again.
+        Seconds a running record of `Idempotency` is kept after it was last extended; the process
+        running the call extends it every third of this time. Once it expires, a repeat runs the
+        action again.
         """
         self.viewsets_auth_processors: list[AuthBackend] = []
         self.default_action_configuration: dict[Any, Any] = {}
@@ -82,8 +83,15 @@ class Settings:
         """
         self.viewsets_event_delivery_filters: list[DeliveryFilter] = []
         """
-        The functions that decide, per subscription and per event, whether a push is sent. A filter
-        that answers False skips that socket; a filter that raises counts as True.
+        The functions that decide, per subscription and per event, whether a push is sent, and per
+        poll and per event whether the poll answers the event. A filter that answers False skips that
+        socket or leaves the event out of the poll answer; a filter that raises counts as True.
+        """
+        self.viewsets_event_listeners: list[EventListener] = []
+        """
+        The functions called with every event in every process whose store is started, before its
+        pushes, whether or not the process holds a subscription of its topic. A listener that raises is
+        logged and the next one runs.
         """
         self.viewsets_event_log_size: int = 32
         """

{dynamicforms_fastapi_viewsets-0.11.2 → dynamicforms_fastapi_viewsets-0.11.4}/fastapi_viewsets/decorators/celery_viewset/client.py

@@ -27,6 +27,7 @@ if TYPE_CHECKING:
 T = TypeVar("T")
 logger = logging.getLogger(__name__)
 
+# Seconds a `celery_viewset_client` call waits for its result when `result_timeout` is not given.
 DEFAULT_RESULT_TIMEOUT = 3600.0
 
 # queue_keys registered by celery_viewset_client so far - populated at decoration (import) time,

{dynamicforms_fastapi_viewsets-0.11.2 → dynamicforms_fastapi_viewsets-0.11.4}/fastapi_viewsets/decorators/celery_viewset/result_reader.py

@@ -136,8 +136,9 @@ def _payload_error(data: dict) -> Exception:
 def error_payload(correlation_id: str, task: str | None, error: BaseException) -> dict:
     """
     The payload that fails one call with `error`: an `HTTPException` (a `DfViewSetError` with its
-    class), any other error as `ActionFailedError`. `http_status_code` and `http_detail` repeat the
-    status and detail for a reader that does not decode `error`.
+    class), a `RequestValidationError` as a 422 with its errors as `detail`, any other error as
+    `ActionFailedError`. `http_status_code` and `http_detail` repeat the status and detail for a
+    reader that does not decode `error`.
     """
     if not isinstance(error, (HTTPException, RequestValidationError)):
         error = ActionFailedError(task)
@@ -168,8 +169,9 @@ def push_result(
     """
     Push a result or an error for one call. queue_key is the `_result_queue_key` the client sent with
     the task. An `error` that is an `HTTPException` reaches the caller as it is (a `DfViewSetError`
-    of a class `fastapi_viewsets.exceptions` defines keeps its class); any other error reaches it
-    as `ActionFailedError`. `task` names the call's task in that error.
+    of a class `fastapi_viewsets.exceptions` defines keeps its class); a `RequestValidationError`
+    reaches it as an `HTTPException` 422 with its errors as `detail`; any other error reaches it as
+    `ActionFailedError`. `task` names the call's task in that error.
     """
     if error is not None:
         data = error_payload(correlation_id, task, error)

{dynamicforms_fastapi_viewsets-0.11.2 → dynamicforms_fastapi_viewsets-0.11.4}/fastapi_viewsets/decorators/celery_viewset/server.py

@@ -63,11 +63,9 @@ def _unwrap_optional(hint):
     return hint
 
 
-# Alias, not a re-implementation: the actual conversion (Pydantic models, dicts, lists/tuples,
-# SerializableObject values - e.g. a ViewSetResult a worker-side action returned directly, see
-# fastapi_viewsets.middleware) lives in fastapi_viewsets.context.to_jsonable, shared with
-# ViewSetResult's own (de)serialization. Kept under this name since call sites/tests here already
-# import it as `_to_jsonable`.
+# `fastapi_viewsets.context.to_jsonable`: converts Pydantic models, dicts, lists/tuples and
+# SerializableObject values (e.g. a ViewSetResult a worker-side action returned directly); also used
+# by ViewSetResult's own (de)serialization.
 _to_jsonable = to_jsonable
 
 

{dynamicforms_fastapi_viewsets-0.11.2 → dynamicforms_fastapi_viewsets-0.11.4}/fastapi_viewsets/events/__init__.py

@@ -32,6 +32,7 @@ from .delivery import (
     DeliveryFilter,
     drop_peer,
     drop_subscriptions,
+    EventListener,
     passes_filters,
     reset_subscriptions,
     subscribe,
@@ -80,6 +81,7 @@ __all__ = [
     "ChangeEvents",
     "DeclaredSources",
     "DeliveryFilter",
+    "EventListener",
     "Event",
     "EventAuthorizer",
     "EventScope",

{dynamicforms_fastapi_viewsets-0.11.2 → dynamicforms_fastapi_viewsets-0.11.4}/fastapi_viewsets/events/conftest.py

@@ -19,6 +19,7 @@ EVENT_SETTINGS = (
     "viewsets_event_store",
     "viewsets_event_authorizers",
     "viewsets_event_delivery_filters",
+    "viewsets_event_listeners",
     "viewsets_event_log_size",
     "viewsets_event_log_ttl",
     "viewsets_event_push_timeout",
@@ -33,6 +34,7 @@ def _reset_events():
     saved = {name: getattr(settings, name) for name in EVENT_SETTINGS}
     settings.viewsets_event_authorizers = []
     settings.viewsets_event_delivery_filters = []
+    settings.viewsets_event_listeners = []
     reset_subscriptions()
     reset_sources()
     reset_event_scopes()

{dynamicforms_fastapi_viewsets-0.11.2 → dynamicforms_fastapi_viewsets-0.11.4}/fastapi_viewsets/events/delivery.py

@@ -62,6 +62,14 @@ None for a poll over REST. `topic` is the client topic; `subscription.store_topi
 `subscription.scope` name the scope of a scoped topic.
 """
 
+EventListener = Callable[[str, int, int, str, Any, int], "None | Awaitable[None]"]
+"""
+`listener(topic, rev, prev, event_name, payload, version)`, sync or async; `topic` is the store
+topic. `deliver()` calls the listeners with every event, in every process whose store is started,
+whether or not the process holds a subscription of the topic, before it pushes the event; a listener
+that removes subscriptions (`drop_subscriptions`) removes them before the push.
+"""
+
 # store topic -> (id(peer), client topic) -> Subscription
 _by_topic: dict[str, dict[tuple[int, str], Subscription]] = {}
 # id(peer) -> client topic -> Subscription
@@ -316,8 +324,10 @@ async def _push(
 
 async def deliver(topic: str, rev: int, prev: int, name: str, payload: Any, version: int) -> None:
     """
-    Pushes one event of the store topic `topic` to every subscription delivered under it in this
-    process, each push in a task of its own, and returns without waiting for them. A push runs the
+    Calls `settings.viewsets_event_listeners` in list order with the event, awaiting each; a listener
+    that raises is logged and the next one runs. Then pushes the event of the store topic `topic` to
+    every subscription delivered under it in this process, each push in a task of its own, and
+    returns without waiting for them. A push runs the
     subscription's reauthorization when it is due (see `settings.viewsets_event_reauthorize_after`),
     the delivery filters with the client topic, and then `peer.notify(payload, headers={":event":
     name, ":version": version, ":topic": subscription.topic, ":rev": rev, ":prev": prev})`, with
@@ -325,6 +335,13 @@ async def deliver(topic: str, rev: int, prev: int, name: str, payload: Any, vers
     `settings.viewsets_event_push_timeout` seconds. A push that raises a `ConnectionLost` drops
     every subscription of its socket; any other failure is logged at debug level.
     """
+    for listener in settings.viewsets_event_listeners:
+        try:
+            result = listener(topic, rev, prev, name, payload, version)
+            if inspect.isawaitable(result):
+                await result
+        except Exception:
+            logger.exception("events: a listener raised for topic %s rev %s", topic, rev)
     for subscription in subscriptions(topic):
         _spawn(_push(subscription, topic, rev, prev, name, payload, version))
 

{dynamicforms_fastapi_viewsets-0.11.2 → dynamicforms_fastapi_viewsets-0.11.4}/fastapi_viewsets/events/redis.py

@@ -1,13 +1,16 @@
 """
 `RedisEventStore`: the event store shared by every process that reaches one Redis.
 
-The only module of `fastapi_viewsets.events` that uses `redis`. It takes a `redis.asyncio.Redis`
-client the application constructs, and imports the `redis` package for type checking only.
+The only module of `fastapi_viewsets.events` that uses `redis`. `RedisEventStore` takes a
+`redis.asyncio.Redis` client the application constructs, or builds one client per event loop from a
+URL (`RedisEventStore.from_url`, `PerLoopRedis`); the `redis` package is imported by `PerLoopRedis`
+only.
 """
 
 import asyncio
 import json
 import logging
+import threading
 
 from typing import Any, TYPE_CHECKING
 
@@ -47,10 +50,78 @@ 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
+DEFAULT_READ_TIMEOUT = 1.0
 
 # Seconds `start` waits for Redis to confirm the SUBSCRIBE of the events channel.
-_SUBSCRIBE_TIMEOUT = 5.0
+DEFAULT_SUBSCRIBE_TIMEOUT = 5.0
+
+# The `redis.asyncio.Redis.from_url` options `PerLoopRedis` sets unless given: seconds a connect and
+# a single command may take.
+DEFAULT_CLIENT_OPTIONS: dict[str, Any] = {"socket_connect_timeout": 2.0, "socket_timeout": 5.0}
+
+
+class PerLoopRedis:
+    """
+    Stands in for a `redis.asyncio.Redis`: every attribute whose name does not start with `_` is
+    read off the client of the running event loop, created with
+    `Redis.from_url(url, **(DEFAULT_CLIENT_OPTIONS | options))` on its first use in that loop. A
+    `redis.asyncio` connection belongs to the loop it was opened on, and one process runs the store
+    on several loops: the server's, the loops of a Celery worker's executions, and the loop
+    `asgiref`'s `async_to_sync()` opens for a call without a running loop to hand it to (WSGI,
+    management commands, plain threads).
+
+    A loop's client is closed and forgotten when the loop's tasks are cancelled at its end, as
+    `asyncio.run()` does. A client used on that loop by another task's cancellation cleanup may be
+    closed already. The client of a loop closed without that, and of a loop alive at process exit, is
+    not closed: it is forgotten by the next call that creates a client, and its connections close
+    when it is garbage-collected.
+    """
+
+    def __init__(self, url: str, **options: Any):
+        from redis.asyncio import Redis
+
+        self.url = url
+        self.options = DEFAULT_CLIENT_OPTIONS | options
+        self._redis_class = Redis
+        self._clients: dict[asyncio.AbstractEventLoop, Redis] = {}
+        self._lock = threading.Lock()
+
+    def client(self) -> "Redis":
+        """The client of the running loop. Raises `RuntimeError` outside a running loop."""
+        loop = asyncio.get_running_loop()
+        with self._lock:
+            client = self._clients.get(loop)
+            if client is not None:
+                return client
+            for closed in [held for held in self._clients if held.is_closed()]:
+                del self._clients[closed]
+            client = self._clients[loop] = self._redis_class.from_url(self.url, **self.options)
+        closer = loop.create_task(self._close_with_loop(loop, client), name="PerLoopRedis: close with the loop")
+        # A loop that ends without cancelling its tasks destroys this one without a warning.
+        closer._log_destroy_pending = False  # type: ignore[attr-defined]
+        return client
+
+    async def _close_with_loop(self, loop: asyncio.AbstractEventLoop, client: "Redis") -> None:
+        try:
+            await loop.create_future()
+        except asyncio.CancelledError:
+            self._forget(loop, client)
+            await client.aclose()
+            raise
+        except GeneratorExit:
+            # The task is destroyed with its loop: there is no loop to close the client on.
+            self._forget(loop, client)
+            raise
+
+    def _forget(self, loop: asyncio.AbstractEventLoop, client: "Redis") -> None:
+        with self._lock:
+            if self._clients.get(loop) is client:
+                del self._clients[loop]
+
+    def __getattr__(self, name: str) -> Any:
+        if name.startswith("_"):
+            raise AttributeError(name)
+        return getattr(self.client(), name)
 
 
 class RedisEventStore:
@@ -67,19 +138,52 @@ class RedisEventStore:
     `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.
+    leaves out a topic without one. `stop()` closes the connection. `start()` and `stop()` run on
+    one loop, the loop the reader runs on.
+
+    `subscribe_timeout` is the seconds `start()` waits for Redis to confirm the SUBSCRIBE;
+    `read_timeout` the seconds the reader waits for a message before it checks again, and waits after
+    a failed read.
 
     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:"):
+    def __init__(
+        self,
+        redis_client: "Redis | PerLoopRedis",
+        key_prefix: str = "events:",
+        *,
+        subscribe_timeout: float = DEFAULT_SUBSCRIBE_TIMEOUT,
+        read_timeout: float = DEFAULT_READ_TIMEOUT,
+    ):
         self.redis_client = redis_client
         self.key_prefix = key_prefix
+        self.subscribe_timeout = subscribe_timeout
+        self.read_timeout = read_timeout
         self._pubsub: Any = None
         self._reader: asyncio.Task | None = None
 
+    @classmethod
+    def from_url(
+        cls,
+        url: str,
+        key_prefix: str = "events:",
+        *,
+        subscribe_timeout: float = DEFAULT_SUBSCRIBE_TIMEOUT,
+        read_timeout: float = DEFAULT_READ_TIMEOUT,
+        **options: Any,
+    ) -> "RedisEventStore":
+        """A store on `PerLoopRedis(url, **options)`: one client per event loop. `options` are
+        `redis.asyncio.Redis.from_url` options over `DEFAULT_CLIENT_OPTIONS`."""
+        return cls(
+            PerLoopRedis(url, **options),
+            key_prefix,
+            subscribe_timeout=subscribe_timeout,
+            read_timeout=read_timeout,
+        )
+
     def rev_key(self, topic: str) -> str:
         return f"{self.key_prefix}rev:{topic}"
 
@@ -99,25 +203,24 @@ class RedisEventStore:
     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.
+        Raises `asyncio.TimeoutError` when the confirmation does not arrive within `subscribe_timeout`
+        seconds, and the error of the connection when it fails; the store is then not started.
         """
         if self.reader_running:
             return
         pubsub = self.redis_client.pubsub()
         try:
             await pubsub.subscribe(self.channel)
-            await asyncio.wait_for(self._confirmed(pubsub), _SUBSCRIBE_TIMEOUT)
+            await asyncio.wait_for(self._confirmed(pubsub), self.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:
+    async def _confirmed(self, pubsub: Any) -> None:
         while True:
-            message = await pubsub.get_message(ignore_subscribe_messages=False, timeout=_READ_TIMEOUT)
+            message = await pubsub.get_message(ignore_subscribe_messages=False, timeout=self.read_timeout)
             if message is not None and message.get("type") == "subscribe":
                 return
 
@@ -185,12 +288,12 @@ class RedisEventStore:
     async def _read(self) -> None:
         while True:
             try:
-                message = await self._pubsub.get_message(ignore_subscribe_messages=True, timeout=_READ_TIMEOUT)
+                message = await self._pubsub.get_message(ignore_subscribe_messages=True, timeout=self.read_timeout)
             except asyncio.CancelledError:
                 raise
             except Exception:
                 logger.exception("events: reading the events channel failed")
-                await asyncio.sleep(_READ_TIMEOUT)
+                await asyncio.sleep(self.read_timeout)
                 continue
             if message is None or message.get("type") != "message":
                 continue

{dynamicforms_fastapi_viewsets-0.11.2 → dynamicforms_fastapi_viewsets-0.11.4}/fastapi_viewsets/middleware/__init__.py

@@ -216,16 +216,14 @@ class Middleware(ABC):
         the onion chain below, exactly as if this method didn't exist.
 
         `cls` is always the viewset *class*, never an instance - for `per-request`/`instance-key`
-        lifecycles no instance exists yet this early (uniform across all 3 lifecycle modes, rather
-        than sometimes a real instance and sometimes not, depending on which one). `context` is
-        real and usable here (see `fastapi_viewsets.context.get_shared_context`) - built as early as
-        this method can possibly run, which for `per-request`/`instance-key` lifecycles is *before*
-        `load_state()`; no shipped context processor reads viewset instance state.
-
-        Put here *only* logic that might actually reject - there's no benefit to running
-        unconditional work (e.g. enriching context with no reject path - see
-        `middleware.auth.authorization.Authorization`, which splits across both methods for exactly
-        this reason) before body parsing, so that kind of work stays in `__call__` as it does today.
+        lifecycles no instance exists yet this early. `context` is real and usable here (see
+        `fastapi_viewsets.context.get_shared_context`) - built as early as this method can possibly
+        run, which for `per-request`/`instance-key` lifecycles is *before* `load_state()`; no shipped
+        context processor reads viewset instance state.
+
+        Put here *only* logic that may reject. Unconditional work (e.g. enriching context with no
+        reject path) belongs in `__call__`; `middleware.auth.authorization.Authorization` splits
+        across both methods this way.
         For middleware whose entire job is reject-or-allow with nothing unconditional (`Session`,
         `RateLimiter`), `__call__` is `return await call_next()`: `depends()` makes the only
         decision, and if it rejects, `__call__`/the onion chain is not reached (the exception

{dynamicforms_fastapi_viewsets-0.11.2 → dynamicforms_fastapi_viewsets-0.11.4}/fastapi_viewsets/mux_ws/__init__.py

@@ -16,18 +16,14 @@ Server side:
     from fastapi import FastAPI, WebSocket
     from muxws import accept
 
-    from fastapi_viewsets.mux_ws import origin_allowed, process_command
+    from fastapi_viewsets.mux_ws import process_command
 
     @app.websocket("/ws")
     async def muxws_endpoint(websocket: WebSocket) -> None:
-        # A cookie-authenticated WebSocket has no CSRF protection: refuse a foreign Origin before
-        # accept(), which the server answers with HTTP 403.
-        if not origin_allowed(websocket):
-            await websocket.close(code=1008)
-            return
         # Do not call websocket.accept() yourself - muxws performs the upgrade, because only it
-        # knows which muxws.v1.<codec> subprotocol to select.
-        peer = await accept(websocket)
+        # knows which muxws.v1.<codec> subprotocol to select. A cookie-authenticated WebSocket has
+        # no CSRF protection: allowed_origins refuses a foreign Origin with HTTP 403.
+        peer = await accept(websocket, allowed_origins=["https://app.example"])
         peer.on_stream(
             lambda payload, stream: process_command(payload, stream, connection=websocket, peer=peer)
         )
@@ -38,7 +34,6 @@ Which viewsets get registered is decided at three levels, each able to defer to
 `settings.viewsets_register_muxws` globally (default True).
 """
 
-from .origin import origin_allowed
 from .protocol import METHOD_KEY, PATH_KEY, QUERY_KEY, STATUS_KEY
 from .registry import (
     is_registered,
@@ -58,7 +53,6 @@ __all__ = [
     "QUERY_KEY",
     "STATUS_KEY",
     "is_registered",
-    "origin_allowed",
     "process_command",
     "register_viewset",
     "registered_viewsets",

{dynamicforms_fastapi_viewsets-0.11.2 → dynamicforms_fastapi_viewsets-0.11.4}/fastapi_viewsets/mux_ws/asgi.py

@@ -5,9 +5,7 @@ The muxws transport deliberately does not re-implement parameter binding, valida
 resolution or response-model serialisation - it hands the request to the application, the same one
 an HTTP server hands a request to, so the two transports cannot drift apart on anything the
 application declares. The scope marks the request as a muxws one (`fastapi_viewsets.routing`).
-
-What that costs is one synthetic ASGI round trip per call, which is still nothing next to an
-actual HTTP request: no connection setup, no header parsing, no socket at all.
+Each call is one in-process ASGI round trip.
 """
 
 import json
@@ -129,9 +127,8 @@ def payload_to_body(payload: Any) -> bytes:
     """
     Re-encodes an already-decoded muxws payload as the JSON bytes FastAPI expects to parse.
 
-    This decode-then-re-encode round trip is the one real inefficiency of dispatching through
-    ASGI, and it is deliberate: skipping it would mean binding and validating parameters
-    ourselves, which is exactly the duplication this transport exists to avoid. See GAPS.md.
+    FastAPI parses the request body from bytes, so a decoded payload is encoded again as JSON;
+    `bytes` pass through unchanged and an absent or `None` payload is an empty body.
     """
     from muxws.frames import ABSENT
 

{dynamicforms_fastapi_viewsets-0.11.2 → dynamicforms_fastapi_viewsets-0.11.4}/fastapi_viewsets/mux_ws/protocol.py

@@ -1,15 +1,13 @@
 """
 The request/response envelope carried over a muxws stream.
 
-muxws deliberately does no routing of its own - SPEC WSM-AUT-004 forbids it from looking at the
-opening payload to pick a handler - so the addressing has to come from us. Rather than invent a
-vocabulary, we mirror HTTP/2, which muxws already models: an `open` frame carries `headers` plus a
-`payload`, exactly as HTTP/2 carries a HEADERS frame followed by DATA.
-
-Method, path and query string therefore travel as pseudo-headers, `:`-prefixed the way HTTP/2
-prefixes its own. The prefix is not decoration - it is what keeps them from colliding with real
-HTTP headers, since a header field name may not contain a colon. Everything in the open frame's
-headers that is *not* `:`-prefixed is passed through as an ordinary HTTP header.
+muxws does no routing (SPEC WSM-AUT-004: it does not look at the opening payload to pick a
+handler), so the open frame carries the address. The envelope follows HTTP/2: an `open` frame
+carries `headers` plus a `payload`, as HTTP/2 carries a HEADERS frame followed by DATA.
+
+Method, path and query string travel as HTTP/2-style pseudo-headers, `:`-prefixed. They cannot
+collide with HTTP headers, because a header field name may not contain a colon. Every header of
+the open frame that is not `:`-prefixed is passed through as an ordinary HTTP header.
 
     peer.open(
         payload={"title": "Kind of Blue"},          # the request body

{dynamicforms_fastapi_viewsets-0.11.2 → dynamicforms_fastapi_viewsets-0.11.4}/fastapi_viewsets/mux_ws/server.py

@@ -76,10 +76,7 @@ async def process_command(
 
         @app.websocket("/ws")
         async def endpoint(websocket: WebSocket) -> None:
-            if not origin_allowed(websocket):
-                await websocket.close(code=1008)  # before accept(): the handshake is answered with HTTP 403
-                return
-            peer = await accept(websocket)
+            peer = await accept(websocket, allowed_origins=["https://app.example"])
 
             async def on_stream(payload, stream):
                 if await process_command(payload, stream, connection=websocket, peer=peer):

{dynamicforms_fastapi_viewsets-0.11.2 → dynamicforms_fastapi_viewsets-0.11.4}/pyproject.toml

@@ -34,7 +34,7 @@ dependencies = [
 
 [project.optional-dependencies]
 celery = ["celery>=5.3", "redis>=5.0"]
-muxws = ["muxws[starlette]>=0.4.1"]
+muxws = ["muxws[starlette]>=0.4.2"]
 django = ["django>=4.2", "asgiref>=3.6"]
 jwt = ["PyJWT>=2.8"]
 dev = [
@@ -49,7 +49,7 @@ dev = [
     "django",
     "asgiref",
     "PyJWT",
-    "muxws[starlette,websockets]>=0.4.1",
+    "muxws[starlette,websockets]>=0.4.2",
     "ruff",
     "uvicorn",
 ]

dynamicforms_fastapi_viewsets-0.11.2/fastapi_viewsets/__init__.py

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

dynamicforms_fastapi_viewsets-0.11.2/fastapi_viewsets/mux_ws/origin.py

@@ -1,103 +0,0 @@
-"""
-`origin_allowed`, the `Origin` check of a WebSocket endpoint.
-
-A browser sends the cookies of the endpoint's site with a WebSocket handshake whatever page opened
-it, and a WebSocket has no CSRF protection of its own: an endpoint whose session is a cookie answers
-a handshake from another site's page with that session unless it checks `Origin` before `accept()`.
-"""
-
-from collections.abc import Collection
-from typing import TYPE_CHECKING
-from urllib.parse import urlsplit
-
-if TYPE_CHECKING:
-    from starlette.requests import HTTPConnection
-
-_DEFAULT_PORTS = {"http": 80, "https": 443}
-
-
-def _parse_origin(value: str) -> tuple[str, str, int] | None:
-    """`(scheme, host, port)` of a serialized origin, `scheme://host[:port]` with an optional
-    trailing `/`, scheme and host lower-cased and the port explicit; None for anything else."""
-    text = value.strip()
-    if text.endswith("/"):
-        text = text[:-1]
-    try:
-        parts = urlsplit(text)
-        port = parts.port
-    except ValueError:
-        return None
-    scheme = parts.scheme.lower()
-    if scheme not in _DEFAULT_PORTS or not parts.hostname:
-        return None
-    if parts.path or parts.query or parts.fragment or parts.username is not None or parts.password is not None:
-        return None
-    if "@" in parts.netloc:
-        return None
-    return scheme, parts.hostname.lower(), port if port is not None else _DEFAULT_PORTS[scheme]
-
-
-def _parse_host(value: str, default_port: int) -> tuple[str, int] | None:
-    """`(host, port)` of a `Host` header value, the port `default_port` when it names none."""
-    try:
-        parts = urlsplit(f"//{value.strip()}")
-        port = parts.port
-    except ValueError:
-        return None
-    if not parts.hostname or parts.path or parts.query or parts.fragment or "@" in parts.netloc:
-        return None
-    return parts.hostname.lower(), port if port is not None else default_port
-
-
-def origin_allowed(connection: "HTTPConnection", allowed_origins: Collection[str] | None = None) -> bool:
-    """
-    Whether the `Origin` of `connection` (a `WebSocket` or a `Request`) may open the endpoint.
-
-    - No `Origin` header (a client that is not a browser): True. More than one: False.
-    - `Origin: null`, and an origin that is not `scheme://host[:port]` with the scheme `http` or
-      `https` (a path, a query, userinfo, another scheme): False.
-    - Origins compare as `(scheme, host, port)`, scheme and host lower-cased, the port the scheme's
-      default (80, 443) when the origin names none, a trailing `/` removed.
-    - With `allowed_origins`: True when the origin equals one of its entries. An entry that is not
-      an origin raises `ValueError`.
-    - Without it: True when the origin's `(host, port)` equals that of the request's host, the first
-      item of `X-Forwarded-Host` when the request carries one, else `Host`; a host without a port
-      takes the default port of the origin's scheme. The scheme is not compared, so a TLS proxy in
-      front of the application passes. No host at all: False. A proxy that rewrites `Host` without
-      setting `X-Forwarded-Host` needs `allowed_origins`.
-
-    The endpoint calls it before `accept()` and closes a refused handshake, which the server answers
-    with HTTP 403:
-
-        if not origin_allowed(websocket):
-            await websocket.close(code=1008)
-            return
-        peer = await accept(websocket)
-    """
-    allowed = None
-    if allowed_origins is not None:
-        allowed = set()
-        for entry in allowed_origins:
-            parsed = _parse_origin(entry)
-            if parsed is None:
-                raise ValueError(f"{entry!r} in allowed_origins is not an origin: scheme://host[:port]")
-            allowed.add(parsed)
-
-    values = connection.headers.getlist("origin")
-    if not values:
-        return True
-    if len(values) > 1:
-        return False
-    origin = _parse_origin(values[0])
-    if origin is None:
-        return False
-    if allowed is not None:
-        return origin in allowed
-
-    scheme, host, port = origin
-    forwarded = connection.headers.get("x-forwarded-host")
-    request_host = forwarded.split(",")[0] if forwarded else connection.headers.get("host")
-    if not request_host or not request_host.strip():
-        return False
-    parsed_host = _parse_host(request_host, _DEFAULT_PORTS[scheme])
-    return parsed_host == (host, port)