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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: dynamicforms-fastapi-viewsets
-Version: 0.11.0
+Version: 0.11.2
 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

dynamicforms_fastapi_viewsets-0.11.2/fastapi_viewsets/__init__.py

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

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

@@ -107,6 +107,16 @@ class Settings:
         The number of topics one socket may hold; a subscription beyond it raises
         `EventSubscriptionsExceededError` (409). Also the number of cursors one poll may carry.
         """
+        self.viewsets_event_reauthorize_after: float | None = 300.0
+        """
+        Seconds after which a push to a subscription of a scoped viewset topic first runs the
+        topic's gate again with the request the subscription was made with. The push is sent when the
+        gate answers the subscription's store topic; a refusal (an `HTTPException` of a status from
+        400 to 499 other than 429) or another store topic removes the subscription and skips the
+        push; any other failure, a 429 or 5xx included, skips the push and keeps the subscription for
+        the next push to try again. None never runs it. Subscriptions of unscoped topics are not
+        affected.
+        """
         self.viewsets_event_poll_after_ms: int = 0
         """
         `poll_after_ms` of every poll answer: the shortest interval, in milliseconds, at which a

{dynamicforms_fastapi_viewsets-0.11.0 → dynamicforms_fastapi_viewsets-0.11.2}/fastapi_viewsets/context/__init__.py

@@ -184,6 +184,24 @@ class LazyObject(SerializableObject, ABC):
         raise NotImplementedError
 
 
+class _Deferred:
+    """
+    A context value computed once, on its first `await`, by `compute()`. `serialize_context()`
+    awaits it like any bare awaitable; `celery_viewset_client` awaits every `_Deferred` of the
+    call's context before it serializes the arguments, so an exception of `compute()` propagates
+    from the call unchanged.
+    """
+
+    def __init__(self, compute: Any) -> None:
+        self._compute = compute
+        self._future: asyncio.Future | None = None
+
+    def __await__(self):
+        if self._future is None:
+            self._future = asyncio.ensure_future(self._compute())
+        return self._future.__await__()
+
+
 class Context:
     """
     Wraps the per-request context dict produced by running settings.viewsets_context_processors.
@@ -241,6 +259,14 @@ class Context:
     def __len__(self) -> int:
         return len(self._data)
 
+    @property
+    def action_name(self) -> "str | None":
+        """The name of the action this context represents, the name `configuration_for` resolves
+        `ByAction` values against; None for a context built without one. Read-only. As an attribute
+        it takes precedence over a context value named `action_name`, which `context["action_name"]`
+        reads."""
+        return self._action_name
+
     def raw(self) -> dict[str, Any]:
         """The underlying plain dict - for serialize_context()/deserialize_context() to walk."""
         return self._data

{dynamicforms_fastapi_viewsets-0.11.0 → dynamicforms_fastapi_viewsets-0.11.2}/fastapi_viewsets/decorators/build_schema.py

@@ -104,7 +104,8 @@ def action_openapi_extra(action_name: str, openapi_extra: dict | None) -> dict:
 def build_schema(cls, base_path: str = "", default_tags=None, get_wrapper=None, disable_response_model=False):
     """
     Builds __router (APIRouter with all routes from mixins) and __app (FastAPI instance),
-    and attaches them to the class. Idempotent: if already called, returns immediately.
+    and attaches them to the class. Idempotent: if already called for `cls` itself, returns
+    immediately; a subclass of a class it was called for gets routes of its own.
     If get_wrapper is None, only __router is built (no FastAPI app, no endpoint wrapping).
 
     disable_response_model: pass True when a configured command middleware declares
@@ -117,7 +118,8 @@ def build_schema(cls, base_path: str = "", default_tags=None, get_wrapper=None,
     default) leaves the endpoint's declared return type in place, both in the OpenAPI docs and for
     FastAPI's own response validation.
     """
-    if hasattr(cls, "__router") and (get_wrapper is None or getattr(cls, "__router_full", False)):
+    own = vars(cls)
+    if "__router" in own and (get_wrapper is None or own.get("__router_full", False)):
         return
 
     celery_mode = get_wrapper is None

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

@@ -9,7 +9,7 @@ from typing import TYPE_CHECKING, TypeVar
 from pydantic import BaseModel
 
 from ...action_configuration import resolve_action_configuration, TimeLimits
-from ...context import Context, SerializableObject, serialize_context, to_jsonable
+from ...context import _Deferred, Context, SerializableObject, serialize_context, to_jsonable
 from ...exceptions import ActionDispatchError, ResultTimeoutError
 from ...middleware import ActionTransition, run_transition_listeners
 from ..build_schema import build_schema
@@ -120,6 +120,8 @@ def _patch_method(
     `current_call()`; a `context` the caller passes replaces the call's. The action's `TimeLimits`
     configuration is sent as the task's time limits. Arguments that cannot be serialized raise
     `ActionDispatchError` (reason `serialization`), a send that fails raises it with reason `send`.
+    A deferred context value (`ChangeEvents`'s scope of a call) is computed before the arguments
+    are serialized; its exception propagates unchanged and nothing is sent.
     Once the task is sent, `Middleware.on_transition()` of the action's effective middlewares
     receives `dispatched`. The action's name joins the class's `DEFERRED_ACTIONS_ATTRIBUTE`."""
     method_name = original_endpoint.__name__
@@ -142,6 +144,9 @@ def _patch_method(
             parent = call.parent_of_dispatch() if call is not None else None
             action_configuration = resolve_action_configuration(cls, method_name)
             bound_context = Context(context.raw(), action_configuration=action_configuration, action_name=method_name)
+            for value in list(context.raw().values()):
+                if isinstance(value, _Deferred):
+                    await value
             try:
                 serializable_args = [await _serialize_value(v) for v in args]
                 serializable_kwargs = {

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

@@ -200,16 +200,21 @@ class _Run:
     One execution in this process. Maps the exceptions the executor raises into it to this
     package's: a soft time limit and the gevent pool's hard time limit (`gevent.Timeout`) to
     `ActionInterruptedError`, any other celery, billiard or kombu exception to `ActionFailedError`, and
-    the `asyncio.CancelledError` of an execution an interruption cancelled to that interruption.
+    the `asyncio.CancelledError` of an execution an interruption cancelled to that interruption, or
+    to the `SystemExit` / `KeyboardInterrupt` of a process exit.
     """
 
     def __init__(self, task: str):
         self.task = task
-        self.interruption: ActionInterruptedError | None = None
+        self.interruption: BaseException | None = None
         self._interrupting: BaseException | None = None
 
     def interrupted(self, error: BaseException) -> None:
         """Records `error`, which interrupted the loop while the execution was suspended."""
+        if isinstance(error, (KeyboardInterrupt, SystemExit)):
+            self.interruption = error
+            self._interrupting = error
+            return
         translated = self.translate(error)
         if isinstance(translated, ActionInterruptedError):
             self.interruption = translated
@@ -286,6 +291,13 @@ def _event_loop() -> asyncio.AbstractEventLoop:
     return loop
 
 
+def _supervised() -> bool:
+    """Whether this process is a pool child that billiard started, whose supervisor outlives it."""
+    from billiard.process import current_process
+
+    return getattr(current_process(), "_parent_pid", None) is not None
+
+
 _started_pid: int | None = None
 _started_loops: "weakref.WeakSet[asyncio.AbstractEventLoop]" = weakref.WeakSet()
 _started_lock = threading.Lock()
@@ -564,7 +576,8 @@ def celery_viewset_server(
     one as `ActionFailedError`. The
     worker's supervisor reports what ends an execution from outside it (a hard time limit, a
     termination, a lost process) and a call that never runs (revoked, expired, unknown, rejected)
-    to the caller and to `Middleware.on_transition()`.
+    to the caller and to `Middleware.on_transition()`; a process no supervisor outlives (any pool but
+    `prefork`) reports its own exit as `interrupted` with reason `terminated`.
     """
     if redis_client is None:
         raise ValueError("redis_client is required for celery_viewset_server")
@@ -641,6 +654,10 @@ def celery_viewset_server(
             translated error, or a process exit as it is. An `HTTPException` the action raised is its
             answer and is not re-raised.
 
+            A process exit is reported as `interrupted` with reason `terminated` where no supervisor
+            outlives the process (any process but a prefork pool child); a prefork pool child's
+            supervisor reports it.
+
             The gevent pool's hard time limit is reported here as the supervisor reports another
             pool's, as `interrupted` with reason `time_limit`, and its `gevent.Timeout` is re-raised
             as it is: the pool handles the time limit only when that exception reaches it."""
@@ -678,7 +695,9 @@ def celery_viewset_server(
                     pushed.status_code,
                     pushed.detail,
                 )
-            if correlation_id and result_queue_key:
+            if process_exit and not _supervised():
+                _report("interrupted", task_name, call, lambda _t: pushed)
+            elif correlation_id and result_queue_key:
                 push_payload(redis_client, result_queue_key, error_payload(correlation_id, task_name, pushed))
             if process_exit:
                 raise caught

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

@@ -26,11 +26,12 @@ from .authorizers import (
     EventAuthorizer,
     ViewsetTopics,
 )
-from .changes import Change, ChangeEvents, RecordsChanged, routed_base_path, TOPIC_CONTEXT_KEY
+from .changes import Change, ChangeEvents, RecordsChanged, routed_base_path, TOPIC_CONTEXT_KEY, write_topic
 from .delivery import (
     deliver,
     DeliveryFilter,
     drop_peer,
+    drop_subscriptions,
     passes_filters,
     reset_subscriptions,
     subscribe,
@@ -42,13 +43,37 @@ from .delivery import (
 )
 from .event import Event
 from .lifecycle import check_events, start_events, stop_events
+from .scopes import (
+    event_scope,
+    EventScope,
+    GATE_RUN_SCOPE_KEY,
+    reset_event_scopes,
+    resolve_scope,
+    resolve_topic,
+    ResolvedTopic,
+    SCOPE_CONTEXT_KEY,
+    scope_of,
+    ScopeKey,
+    ScopeResolver,
+)
 from .sources import declared_source, publish, reset_sources, Source, source
 from .store import EventStore, get_store, LoggedEvent, MAX_REV, MemoryEventStore
-from .topics import is_valid_topic, is_viewset_topic, SOURCE_NAME_PATTERN, split_custom_topic, validate_topic
+from .topics import (
+    is_scoped_topic,
+    is_valid_topic,
+    is_viewset_topic,
+    scoped_topic,
+    SOURCE_NAME_PATTERN,
+    split_custom_topic,
+    split_scoped_topic,
+    validate_topic,
+)
 from .viewset import EventsViewSet, register_events
 
 __all__ = [
+    "GATE_RUN_SCOPE_KEY",
     "MAX_REV",
+    "SCOPE_CONTEXT_KEY",
     "SOURCE_NAME_PATTERN",
     "TOPIC_CONTEXT_KEY",
     "Change",
@@ -57,11 +82,15 @@ __all__ = [
     "DeliveryFilter",
     "Event",
     "EventAuthorizer",
+    "EventScope",
     "EventStore",
     "EventsViewSet",
     "LoggedEvent",
     "MemoryEventStore",
     "RecordsChanged",
+    "ResolvedTopic",
+    "ScopeKey",
+    "ScopeResolver",
     "Source",
     "Subscription",
     "ViewsetTopics",
@@ -72,17 +101,26 @@ __all__ = [
     "declared_source",
     "deliver",
     "drop_peer",
+    "drop_subscriptions",
+    "event_scope",
     "get_store",
+    "is_scoped_topic",
     "is_valid_topic",
     "is_viewset_topic",
     "passes_filters",
     "publish",
     "register_events",
+    "reset_event_scopes",
     "reset_sources",
     "reset_subscriptions",
+    "resolve_scope",
+    "resolve_topic",
     "routed_base_path",
+    "scope_of",
+    "scoped_topic",
     "source",
     "split_custom_topic",
+    "split_scoped_topic",
     "start_events",
     "stop_events",
     "subscribe",
@@ -91,4 +129,5 @@ __all__ = [
     "unsubscribe",
     "validate_topic",
     "wait_for_pushes",
+    "write_topic",
 ]

{dynamicforms_fastapi_viewsets-0.11.0 → dynamicforms_fastapi_viewsets-0.11.2}/fastapi_viewsets/events/authorizers.py

@@ -129,8 +129,8 @@ def match_viewset(app: Any, topic: str) -> ViewsetMatch | None:
     The first route of `app`, in routing order, whose endpoint carries `__viewset_class__` and, as
     `__viewset_action__`, the class's `list_items`, or `retrieve` for a class without `list_items`,
     and whose path without that action's path in `__viewset_metadata__["paths"]` matches `topic`
-    as Starlette matches a request path, path parameters included: `/clubs/{club_id}/tracks`
-    matches the topic `/clubs/7/tracks`. None when no route matches.
+    as Starlette matches a request path, path parameters included: `/orgs/{org_id}/tracks`
+    matches the topic `/orgs/7/tracks`. None when no route matches.
     """
     for route in _routes(app):
         endpoint = getattr(route, "endpoint", None)
@@ -213,8 +213,11 @@ class ViewsetTopics:
     `retrieve` when it has no `list_items`.
 
     A topic that does not start with `/`, and a topic no viewset on `request.app` has, get None (see
-    `match_viewset`). For the viewset found, the checks a request to that action passes run against
-    the calling request, which carries the path parameters read from the topic as `path_params`:
+    `match_viewset`).
+
+    For a class without `@event_scope`, the checks a request to that action passes before the
+    command chain run against the calling request, which carries the path parameters read from the
+    topic as `path_params`:
 
     1. the route's `dependencies` other than `route_viewset`'s own, those of the application, of
        `include_router`, of the `APIRouter` and of the route itself; a parameter of one that does not
@@ -224,17 +227,30 @@ class ViewsetTopics:
        action_configuration=..., action_name=...)`: `settings.viewsets_command_middleware` followed
        by the middleware instances the configuration adds.
 
+    A check in a middleware's `__call__` or in `perform_*` does not run for such a class. For a class
+    with `@event_scope`, the gate run of `resolve_topic` admits the topic: the route's dependencies,
+    the context processors, `depends()` and `__call__` of every effective middleware and the scope's
+    resolver, against a request of its own (see `fastapi_viewsets.events.scopes`). A viewset that is
+    not split by tenant gets the same checks with a constant resolver,
+    `@event_scope(lambda request, context: "all")`.
+
     An `HTTPException` propagates: `Session` raises 401, `Authorization` 403, `RateLimiter` 429 and
-    counts the call as one call of that action. When none raises, the topic is admitted.
+    counts the call as one call of that action, `EventScopeMissingError` 403 for a resolver that
+    answers None. When none raises, the topic is admitted.
     """
 
     async def __call__(self, request: Request, context: Context, topic: str) -> bool | None:
+        from .scopes import resolve_topic, scope_of
+
         if not is_viewset_topic(topic):
             return None
         found = match_viewset(request.app, topic)
         if found is None:
             return None
         cls, action = found.viewset_class, found.action
+        if scope_of(cls) is not None:
+            await resolve_topic(request, topic)
+            return True
         checked = _with_path_params(request, found.path_params)
         if not await _route_dependencies_admit(checked, found.route):
             return False

{dynamicforms_fastapi_viewsets-0.11.0 → dynamicforms_fastapi_viewsets-0.11.2}/fastapi_viewsets/events/changes.py

@@ -4,6 +4,8 @@ each of its create, update and destroy actions.
 
     settings.viewsets_command_middleware = [Idempotency(...), ChangeEvents(), Session(), ...]
 
+`write_topic` answers the topic of a call for an endpoint that publishes itself.
+
 | `execution.action` | `op` | `changes` |
 |---|---|---|
 | `create` | `created` | the pk of the returned record |
@@ -15,6 +17,7 @@ each of its create, update and destroy actions.
 """
 
 import inspect
+import logging
 
 from collections.abc import Awaitable, Callable, Mapping
 from typing import Any, Literal, TYPE_CHECKING
@@ -22,15 +25,19 @@ from typing import Any, Literal, TYPE_CHECKING
 from pydantic import BaseModel
 
 from ..action_configuration import resolve_action_configuration
-from ..context import Context
+from ..context import _Deferred, Context
+from ..decorators.lifecycle_runner import execution_translator
 from ..middleware import ActionExecution, Middleware, ViewSetResult
 from .event import Event
+from .scopes import EventScope, resolve_scope, SCOPE_CONTEXT_KEY, scope_of
 from .sources import publish
-from .topics import validate_topic
+from .topics import _validate_published_topic, scoped_topic, validate_topic
 
 if TYPE_CHECKING:
     from fastapi import Request
 
+logger = logging.getLogger(__name__)
+
 TOPIC_CONTEXT_KEY = "fastapi_viewsets.events.topic"
 """The context key under which `ChangeEvents.__call__` stores the routed base path of the call's
 viewset. The worker of a `celery_viewset` action a request called reads the topic from the context
@@ -72,8 +79,8 @@ def routed_base_path(request: "Request") -> str | None:
     """
     The routed base path of the viewset whose endpoint `request` was routed to: the `include_router`
     prefixes followed by `base_path`, e.g. `/api/music` for a request to `/api/music/3`, with the
-    values of the request's path parameters in place, e.g. `/clubs/7/tracks` for a viewset at
-    `/clubs/{club_id}/tracks`.
+    values of the request's path parameters in place, e.g. `/orgs/7/tracks` for a viewset at
+    `/orgs/{org_id}/tracks`.
 
     It is the request's path, relative to the application's `root_path`, with as many trailing
     segments removed as the action's relative path (`__viewset_metadata__["paths"][action]`) has.
@@ -107,9 +114,26 @@ class ChangeEvents(Middleware):
     module's table). An action that raises publishes nothing; any other action publishes nothing.
 
     `__call__` runs in the web process and stores `routed_base_path(request)` in the context under
-    `TOPIC_CONTEXT_KEY`, on every action. `execute()` runs where the action executes and publishes
-    after `call_next()` returns. An exception of the publish, `store.append` failing included,
-    propagates from `execute()` after the action has run.
+    `TOPIC_CONTEXT_KEY`, on every action. For every action of a class with `@event_scope` (see
+    `fastapi_viewsets.events.scopes`) but a write action configured `False` or with a `topic`, it
+    also stores under `SCOPE_CONTEXT_KEY` the deferred resolution of the scope's key with the call's
+    request and context. The resolver runs after the whole command chain, wherever `ChangeEvents`
+    sits in it: in the web process, on the first `await` of the entry (`execute()` of a write action,
+    `write_topic()`) for an action that executes there, and before the dispatch for every
+    `celery_viewset` action, which then carries `{"name": ..., "key": ...}`, or None for a key of
+    None, to the worker. An exception of the resolver refuses the call before the action.
+    `execute()` runs where the action executes and publishes after `call_next()` returns. An
+    exception of the publish, `store.append` failing included, propagates from `execute()` after the
+    action has run.
+
+    The topic `execute()` publishes to:
+
+    1. for a class without `@event_scope`, `topic_for(execution)`;
+    2. for a class with `@event_scope`, `topic_for(execution)` of a subclass that overrides it;
+       else, for an execution a request called, `@{name}:{key}` of the key under
+       `SCOPE_CONTEXT_KEY` (resolved there in the web process); else `@{name}:{key}` of the key the
+       resolver answers in `execute()`, with the execution's request and context. A key of None
+       publishes nothing and logs a warning. A `topic` option on a class with `@event_scope` raises `TypeError`.
 
     `@action_configuration` on a class or a `perform_*` method:
 
@@ -132,7 +156,7 @@ class ChangeEvents(Middleware):
     async def __call__(
         self,
         request: "Request | None",
-        viewset: Any,  # noqa: ARG002
+        viewset: Any,
         context: Context,
         call_next: Callable[[], Awaitable[ViewSetResult]],
     ) -> ViewSetResult:
@@ -140,8 +164,20 @@ class ChangeEvents(Middleware):
             topic = routed_base_path(request)
             if topic is not None:
                 context.set(TOPIC_CONTEXT_KEY, topic)
+            cls = viewset if isinstance(viewset, type) else type(viewset)
+            scope = scope_of(cls)
+            if scope is not None and self._carries_scope(context):
+                context.set(SCOPE_CONTEXT_KEY, _Deferred(lambda: _scope_entry(scope, request, context)))
         return await call_next()
 
+    def _carries_scope(self, context: Context) -> bool:
+        """Whether `__call__` stores the scope of the call: for every action but a write action
+        configured `False` or with a `topic`."""
+        if context.action_name not in _OPS:
+            return True
+        options = self.options_for(context)
+        return options is not None and "topic" not in options
+
     def config_from(self, context: Context) -> Any:
         """The value configured under this instance as the key, else under its class."""
         own = context.configuration_for(self)
@@ -182,20 +218,46 @@ class ChangeEvents(Middleware):
         options = self.options_for(execution.context) if op is not None else None
         if options is None or self.replaced_for(execution):
             return await call_next()
-        topic = validate_topic(self.topic_for(execution))
+        topic = await self._resolve_topic(execution)
+        if topic is None:
+            scope = scope_of(execution.viewset_class)
+            logger.warning(
+                "events: %s.%s: the event scope %r answered no key; no %s is published",
+                execution.viewset_class.__qualname__,
+                execution.action,
+                scope.name if scope is not None else None,
+                RecordsChanged.event_name,
+            )
+            return await call_next()
         if op != "deleted":
             self.pk_field_for(execution)
         result = await call_next()
         await publish(topic, RecordsChanged(op=op, changes=self.changes_for(execution, op, result)))
         return result
 
+    async def _resolve_topic(self, execution: ActionExecution) -> str | None:
+        """The topic `execute()` publishes to (see the class's topic order); None for a scope key of
+        None."""
+        scope = scope_of(execution.viewset_class)
+        if scope is None:
+            return validate_topic(self.topic_for(execution))
+        if "topic" in (self.options_for(execution.context) or {}):
+            raise TypeError(
+                f"{execution.viewset_class.__qualname__}: event_scope and the {type(self).__name__} 'topic' "
+                f"option exclude each other"
+            )
+        if type(self).topic_for is not ChangeEvents.topic_for:
+            return _validate_published_topic(self.topic_for(execution))
+        return await _scoped_write_topic(scope, execution.request, execution.context, execution.parent is None)
+
     def topic_for(self, execution: ActionExecution) -> str:
         """
-        The configured `topic` (a callable is called with `execution`); else, for an execution a
-        request called (`execution.parent` None), the routed base path in the context under
-        `TOPIC_CONTEXT_KEY`; else `__viewset_metadata__["base_path"]`, for an execution dispatched
-        outside any call or in the execution of another action, whose context carries the topic of
-        that other action. Raises `TypeError` when there is none of the three.
+        The topic of an execution of a class without `@event_scope`, and the hook a subclass
+        overrides, for any class: the configured `topic` (a callable is called with `execution`);
+        else, for an execution a request called (`execution.parent` None), the routed base path in
+        the context under `TOPIC_CONTEXT_KEY`; else `__viewset_metadata__["base_path"]`, for an
+        execution dispatched outside any call or in the execution of another action, whose context
+        carries the topic of that other action. Raises `TypeError` when there is none of the three.
         """
         topic = (self.options_for(execution.context) or {}).get("topic")
         if callable(topic):
@@ -254,6 +316,70 @@ class ChangeEvents(Middleware):
         return [Change(pk=_read_pk(execution, record, field)) for record in (body if bulk else [body])]
 
 
+async def _scope_entry(scope: EventScope, request: "Request | None", context: Context) -> dict[str, str] | None:
+    key = await resolve_scope(scope, request, context)
+    return None if key is None else {"name": scope.name, "key": key}
+
+
+_NOT_CARRIED = object()
+
+
+async def _carried_topic(scope: EventScope, context: Context) -> Any:
+    """The store topic of the entry under `SCOPE_CONTEXT_KEY` when the context holds one of `scope`
+    (None for an entry of a key of None), else `_NOT_CARRIED`."""
+    raw = context.raw()
+    if SCOPE_CONTEXT_KEY not in raw:
+        return _NOT_CARRIED
+    carried = raw[SCOPE_CONTEXT_KEY]
+    if isinstance(carried, _Deferred):
+        carried = await carried
+    if carried is None:
+        return None
+    if isinstance(carried, dict) and carried.get("name") == scope.name and isinstance(carried.get("key"), str):
+        return scoped_topic(scope.name, carried["key"])
+    return _NOT_CARRIED
+
+
+async def _scoped_write_topic(
+    scope: EventScope, request: "Request | None", context: Context, carries: bool
+) -> str | None:
+    """The store topic of a write of a class with `scope`: from the entry under `SCOPE_CONTEXT_KEY`
+    when `carries` and the context holds one of this scope, else from the key the resolver answers
+    with `request` and `context`; None for a key of None."""
+    if carries:
+        carried = await _carried_topic(scope, context)
+        if carried is not _NOT_CARRIED:
+            return carried
+    key = await resolve_scope(scope, request, context)
+    return None if key is None else scoped_topic(scope.name, key)
+
+
+async def write_topic(viewset: Any, request: "Request | None", context: Context) -> str | None:
+    """
+    The topic a write of the current call of `viewset` (a viewset class or instance) publishes to,
+    for an endpoint that writes outside the eight actions and publishes itself. For a class with
+    `@event_scope`, the store topic `@{name}:{key}` of the key under `SCOPE_CONTEXT_KEY` when the
+    context holds an entry of this scope (`ChangeEvents.__call__` stores one for every action of the
+    class), else of the key the scope's resolver answers with `request` and `context`; None for a key
+    of None; an exception of the resolver propagates. In a `celery_viewset` worker the resolver is
+    never called: the key is the one the web process resolved before the dispatch, and a context
+    without an entry of this scope answers None. For a class without it, the topic under
+    `TOPIC_CONTEXT_KEY`, else `__viewset_metadata__["base_path"]`, else None.
+    """
+    cls = viewset if isinstance(viewset, type) else type(viewset)
+    scope = scope_of(cls)
+    if scope is not None:
+        if execution_translator.get() is not None:
+            carried = await _carried_topic(scope, context)
+            return None if carried is _NOT_CARRIED else carried
+        return await _scoped_write_topic(scope, request, context, True)
+    routed = context.raw().get(TOPIC_CONTEXT_KEY)
+    if routed is not None:
+        return routed
+    metadata = getattr(cls, "__viewset_metadata__", None)
+    return metadata["base_path"] if metadata is not None else None
+
+
 def _argument(execution: ActionExecution, name: str) -> Any:
     """The argument `name` of the action's call, passed by keyword or by position."""
     if name in execution.kwargs:

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

@@ -12,6 +12,7 @@ from ..conf import settings
 from . import store as store_module
 from .delivery import reset_subscriptions
 from .redis import _APPEND_SCRIPT
+from .scopes import reset_event_scopes
 from .sources import reset_sources
 
 EVENT_SETTINGS = (
@@ -23,6 +24,7 @@ EVENT_SETTINGS = (
     "viewsets_event_push_timeout",
     "viewsets_event_max_subscriptions",
     "viewsets_event_poll_after_ms",
+    "viewsets_event_reauthorize_after",
 )
 
 
@@ -33,12 +35,14 @@ def _reset_events():
     settings.viewsets_event_delivery_filters = []
     reset_subscriptions()
     reset_sources()
+    reset_event_scopes()
     store_module._default_store = None
     yield
     for name, value in saved.items():
         setattr(settings, name, value)
     reset_subscriptions()
     reset_sources()
+    reset_event_scopes()
     store_module._default_store = None