dynamicforms-fastapi-viewsets 0.5.1__tar.gz → 0.5.4__tar.gz

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/.gitignore

@@ -19,3 +19,4 @@ build/
 .pytest_cache/
 .ruff_cache/
 .coverage
+coverage.json

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/PKG-INFO

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

dynamicforms_fastapi_viewsets-0.5.4/fastapi_viewsets/__init__.py

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

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/fastapi_viewsets/backends/django_orm.py

@@ -180,9 +180,7 @@ class DjangoORMViewSet(ImplMixin[K, T], Generic[K, T]):
             return await super().apply_filter(context, query, records)
 
         concrete = self._concrete_fields()
-        translatable = all(
-            all(name in concrete for name in fltr.fields()) for fltr in filter_set
-        )
+        translatable = all(all(name in concrete for name in fltr.fields()) for fltr in filter_set)
         if not translatable or not can_compile_all(type(self), filter_set):
             return await super().apply_filter(context, query, records)
 
@@ -372,6 +370,7 @@ for _filter_type in _LOOKUPS:
 # Cursor predicate
 # ---------------------------------------------------------------------------
 
+
 class RowValues(Func):
     """`(a, b, c)` - a SQL row constructor."""
 
@@ -414,14 +413,16 @@ def _cursor_condition(viewset: "DjangoORMViewSet", fltr: CursorPredicate) -> Q:
     directly as a condition.
     """
     keys = fltr.keys
-    nullable = {
-        field.name for field in viewset.model._meta.get_fields() if getattr(field, "null", False)
-    }
+    nullable = {field.name for field in viewset.model._meta.get_fields() if getattr(field, "null", False)}
     uniform = len({descending for _, descending in keys}) == 1
     if uniform and not fltr.inclusive and not any(name in nullable for name, _ in keys):
         return _row_value_condition(keys, fltr.position, fltr.backwards)
     return _segment_condition(
-        keys, fltr.position, fltr.backwards, fltr.inclusive, fltr.nulls_first,
+        keys,
+        fltr.position,
+        fltr.backwards,
+        fltr.inclusive,
+        fltr.nulls_first,
     )
 
 

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/fastapi_viewsets/collection_viewset.py

@@ -58,9 +58,7 @@ class AsyncCollectionViewSet(
     async def perform_update(self, _context: Context, pk: K, data: T, partial: bool = True) -> T:
         return await self.container_update(pk, data, partial)
 
-    async def perform_bulk_update(
-        self, _context: Context, records: dict[K, T], partial: bool = True
-    ) -> list[T]:
+    async def perform_bulk_update(self, _context: Context, records: dict[K, T], partial: bool = True) -> list[T]:
         results = []
         for pk, data in records.items():
             results.append(await self.container_update(pk, data, partial))

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/fastapi_viewsets/context/auth/jwt.py

@@ -64,7 +64,7 @@ class JWTAuthBackend(AuthBackend):
         header = request.headers.get(self.header_name, "")
         if not header.lower().startswith("bearer "):
             return None  # not a bearer token - let the next backend try it
-        return _JWTUserLazy(header[len("bearer "):].strip(), self.secret, self.algorithm)
+        return _JWTUserLazy(header[len("bearer ") :].strip(), self.secret, self.algorithm)
 
 
 def encode_jwt(

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/fastapi_viewsets/cursor.py

@@ -135,9 +135,7 @@ def decode_cursor(raw: str, keys: CursorKeys, expected_query: str, annotations:
         raise CursorError("cursor is not readable: no position in it")
 
     if payload.get("q") != expected_query:
-        raise CursorError(
-            "this cursor was issued for a different ordering or filter - start from the first page"
-        )
+        raise CursorError("this cursor was issued for a different ordering or filter - start from the first page")
 
     position = payload["p"]
     missing = [name for name, _ in keys if name not in position]
@@ -214,7 +212,10 @@ class CursorPredicate(Filter):
     def matches(self, record: Any) -> bool:
         for name, descending in self.keys:
             order = compare_in_order(
-                _read(record, name), self.position.get(name), descending, self.nulls_first,
+                _read(record, name),
+                self.position.get(name),
+                descending,
+                self.nulls_first,
             )
             if order != 0:
                 # `order > 0` means the row sorts after the anchor; reading backwards wants before.

dynamicforms_fastapi_viewsets-0.5.4/fastapi_viewsets/decorators/__init__.py

@@ -0,0 +1,19 @@
+from .celery_viewset import (
+    celery_viewset,
+    celery_viewset_client,
+    celery_viewset_server,
+    set_celery_dispatch_hook,
+    set_celery_kwargs_hook,
+    set_is_celery_worker,
+)
+from .route_viewset import route_viewset
+
+__all__ = [
+    "celery_viewset",
+    "celery_viewset_client",
+    "celery_viewset_server",
+    "route_viewset",
+    "set_celery_dispatch_hook",
+    "set_celery_kwargs_hook",
+    "set_is_celery_worker",
+]

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/fastapi_viewsets/decorators/build_schema.py

@@ -167,16 +167,17 @@ def build_schema(cls, base_path: str = "", default_tags=None, get_wrapper=None,
             # Per-viewset wording, applied here because this is where the schema-serving app is
             # built; patching the caller's router afterwards would leave /schema showing the
             # mixin's generic docstring. See endpoint_docs.py.
-            class_router.add_api_route(**route_to_add_api_route_kwargs(
-                route,
-                path=full_path,
-                endpoint=endpoint_wrapper,
-                response_model=response_model,
-                tags=route.tags or default_tags,
-                openapi_extra=getattr(endpoint_wrapper, "__shape_openapi_extra__", None)
-                or route.openapi_extra,
-                **docs_for(cls, route.endpoint.__name__),
-            ))
+            class_router.add_api_route(
+                **route_to_add_api_route_kwargs(
+                    route,
+                    path=full_path,
+                    endpoint=endpoint_wrapper,
+                    response_model=response_model,
+                    tags=route.tags or default_tags,
+                    openapi_extra=getattr(endpoint_wrapper, "__shape_openapi_extra__", None) or route.openapi_extra,
+                    **docs_for(cls, route.endpoint.__name__),
+                )
+            )
 
         app.include_router(class_router)
         cls.__app = app

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/fastapi_viewsets/decorators/celery_viewset/__init__.py

@@ -2,7 +2,7 @@ import logging
 import sys
 
 from ..lifecycle_runner import LifecycleType
-from .client import celery_viewset_client, get_registered_queue_keys
+from .client import celery_viewset_client, get_registered_queue_keys, set_celery_dispatch_hook
 from .result_reader import (
     get_result_queue_key,
     get_running_queue_keys,
@@ -10,7 +10,7 @@ from .result_reader import (
     start_result_reader,
     stop_result_reader,
 )
-from .server import celery_viewset_server
+from .server import celery_viewset_server, set_celery_kwargs_hook
 
 logger = logging.getLogger(__name__)
 
@@ -68,7 +68,8 @@ def check_result_readers() -> frozenset[str]:
             "No result reader is running for queue_key=%s - requests dispatched to this "
             "celery_viewset will hang waiting for a result that never arrives. Call "
             "start_result_reader(redis_client, %r) in your FastAPI lifespan.",
-            queue_key, queue_key,
+            queue_key,
+            queue_key,
         )
     return frozenset(missing)
 
@@ -78,6 +79,8 @@ __all__ = [
     "celery_viewset_client",
     "celery_viewset_server",
     "set_is_celery_worker",
+    "set_celery_kwargs_hook",
+    "set_celery_dispatch_hook",
     "start_result_reader",
     "stop_result_reader",
     "check_result_readers",

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/fastapi_viewsets/decorators/celery_viewset/client.py

@@ -2,6 +2,7 @@ import asyncio
 import logging
 import uuid
 
+from collections.abc import Awaitable, Callable
 from functools import wraps
 from typing import TYPE_CHECKING, TypeVar
 
@@ -20,6 +21,20 @@ if TYPE_CHECKING:
 T = TypeVar("T")
 logger = logging.getLogger(__name__)
 
+_celery_dispatch_hook: Callable[[dict], Awaitable[dict]] | None = None
+
+
+def set_celery_dispatch_hook(hook: Callable[[dict], Awaitable[dict]] | None) -> None:
+    """Register a callable awaited just before send_task; its return dict is merged into kwargs.
+
+    Receives the call's current kwargs (context included, if the action declares one) so a
+    registered hook can read what a context processor already put there instead of needing its own
+    request-level plumbing. Returns {} when there is nothing to add.
+    """
+    global _celery_dispatch_hook
+    _celery_dispatch_hook = hook
+
+
 # queue_keys registered by celery_viewset_client so far - populated at decoration (import) time,
 # used by check_result_readers() to spot a queue_key with no running result reader.
 _registered_queue_keys: set[str] = set()
@@ -97,10 +112,16 @@ def _patch_method(cls: type, original_endpoint, task_name: str, celery_app, queu
                 else:
                     serializable_kwargs[k] = await _serialize_value(v)
             logger.info("Celery task scheduling: %s (correlation_id=%s)", task_name, correlation_id)
+            extra_kwargs = await _celery_dispatch_hook(kwargs) if _celery_dispatch_hook is not None else {}
             celery_app.send_task(
-                    task_name,
-                    args=serializable_args,
-                    kwargs={**serializable_kwargs, "_correlation_id": correlation_id, "_result_queue_key": queue_key},
+                task_name,
+                args=serializable_args,
+                kwargs={
+                    **serializable_kwargs,
+                    "_correlation_id": correlation_id,
+                    "_result_queue_key": queue_key,
+                    **extra_kwargs,
+                },
             )
             return await future
         except Exception:

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/fastapi_viewsets/decorators/celery_viewset/server.py

@@ -2,9 +2,11 @@ import asyncio
 import inspect
 import json
 import logging
+import types
 
+from collections.abc import Callable
 from functools import wraps
-from typing import get_type_hints, TYPE_CHECKING, TypeVar
+from typing import get_args, get_origin, get_type_hints, TYPE_CHECKING, TypeVar, Union
 
 from fastapi import HTTPException
 from pydantic import BaseModel
@@ -23,6 +25,30 @@ logger = logging.getLogger(__name__)
 
 T = TypeVar("T")
 
+_celery_kwargs_hook: Callable[[Callable, dict], tuple[Callable, dict]] | None = None
+
+
+def set_celery_kwargs_hook(hook: Callable[[Callable, dict], tuple[Callable, dict]] | None) -> None:
+    """Register a callable that may wrap the runner and/or consume kwargs before reconstruction.
+
+    Receives (runner, kwargs), must return (runner, kwargs). Called with kwargs still raw - before
+    _reconstruct_kwargs, which passes through any key it has no type hint for, so a key the hook
+    does not consume would otherwise reach the action as an argument it never declared.
+    """
+    global _celery_kwargs_hook
+    _celery_kwargs_hook = hook
+
+
+def _unwrap_optional(hint):
+    """Before Python 3.11, `get_type_hints()` implicitly wraps a None-defaulted parameter's
+    annotation in `Optional[...]`, so a hint that is actually a bare model class arrives as
+    `Union[Model, None]` and the `inspect.isclass` check below sees a `Union`, not a class."""
+    if get_origin(hint) in (Union, types.UnionType):
+        args = [arg for arg in get_args(hint) if arg is not type(None)]
+        if len(args) == 1:
+            return args[0]
+    return hint
+
 
 def _to_jsonable(value):
     """Recursively convert Pydantic models and lists to JSON-serializable structures."""
@@ -59,7 +85,7 @@ def _reconstruct_kwargs(original_endpoint, kwargs: dict, cls: type = None) -> di
     for key, value in remaining.items():
         hint = hints.get(key)
         if hint is not None:
-            hint = resolve_typevars(type_map, hint)
+            hint = _unwrap_optional(resolve_typevars(type_map, hint))
         if hint is not None and isinstance(value, dict) and inspect.isclass(hint) and issubclass(hint, BaseModel):
             try:
                 result[key] = hint.model_validate(value)
@@ -102,16 +128,22 @@ def celery_viewset_server(
 
                 logger.info("Celery task executing: %s (correlation_id=%s)", task_name, correlation_id)
                 try:
+                    run = loop.run_until_complete
+                    if _celery_kwargs_hook is not None:
+                        run, kwargs = _celery_kwargs_hook(run, kwargs)
                     kwargs = _reconstruct_kwargs(original_endpoint, kwargs, cls)
-                    result = loop.run_until_complete(
-                        lifecycle_runner(original_endpoint, instance, cls, lifecycle, *args, **kwargs)
-                    )
+                    result = run(lifecycle_runner(original_endpoint, instance, cls, lifecycle, *args, **kwargs))
                     logger.info("Celery task completed: %s (correlation_id=%s)", task_name, correlation_id)
                     if correlation_id and result_queue_key and redis_client is not None:
-                        redis_client.rpush(result_queue_key, json.dumps({
-                            "correlation_id": correlation_id,
-                            "result": _to_jsonable(result),
-                        }))
+                        redis_client.rpush(
+                            result_queue_key,
+                            json.dumps(
+                                {
+                                    "correlation_id": correlation_id,
+                                    "result": _to_jsonable(result),
+                                }
+                            ),
+                        )
                     return result
                 except Exception as e:
                     if isinstance(e, HTTPException):

dynamicforms_fastapi_viewsets-0.5.4/fastapi_viewsets/decorators/conftest.py

@@ -0,0 +1,14 @@
+def iter_routes(routes):
+    """Flatten a FastAPI route list, recursing into an included router's own .routes.
+
+    fastapi>=0.137 wraps each include_router() call in an internal object exposing
+    .original_router instead of the route directly; older fastapi puts the real route in the
+    list itself. Duck-typed on the .original_router attribute rather than importing fastapi's
+    internal class, so this keeps working if that class is renamed or moved again.
+    """
+    for route in routes:
+        original_router = getattr(route, "original_router", None)
+        if original_router is not None:
+            yield from iter_routes(original_router.routes)
+        else:
+            yield route

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/fastapi_viewsets/decorators/lifecycle_runner.py

@@ -23,7 +23,7 @@ async def lifecycle_runner(
     response: Any = None,
     needs_context: bool = False,
     request: "Request | None" = None,
-    **kwargs
+    **kwargs,
 ):
     """
     `response` is reserved for the command middleware chain (see below) - callers that have no

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/fastapi_viewsets/decorators/primary_key_model_helper.py

@@ -1,9 +1,10 @@
-from typing import Any, get_origin, TypeVar
+from typing import Annotated, Any, get_args, get_origin, TypeVar
 
 from pydantic import BaseModel, create_model
 
 T = TypeVar("T", bound=BaseModel)
 
+
 def create_model_without_pk(model: type[T], pk_field_name: str) -> type[BaseModel]:
     """
     Creates a new Pydantic model based on the given model but without the specified primary key field.
@@ -15,12 +16,16 @@ def create_model_without_pk(model: type[T], pk_field_name: str) -> type[BaseMode
     }
     return create_model(f"{model.__name__}NoPK", **fields)
 
+
 def typecast_to_original_model(value: Any, original_annotation: type[T]) -> T:
     """
     Typecasts a value (usually a Pydantic model without PK) back to the original Pydantic model.
     If validation fails (e.g., due to missing PK that will be auto-incremented), it uses model_construct.
     """
-    origin = get_origin(original_annotation) or original_annotation
+    annotation = original_annotation
+    if get_origin(annotation) is Annotated:
+        annotation = get_args(annotation)[0]
+    origin = get_origin(annotation) or annotation
     if not isinstance(value, BaseModel) or isinstance(value, origin):
         return value
 

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/fastapi_viewsets/decorators/route_viewset.py

@@ -105,6 +105,7 @@ def _make_middleware_depends(cls: type, action_name: str):
     registration time; actual @action_configuration resolution stays fully dynamic; settings can
     still change at runtime between requests.
     """
+
     async def _run(request: Request) -> None:
         action_configuration = resolve_action_configuration(cls, action_name)
         effective_middlewares = settings.viewsets_command_middleware + extra_middlewares_for(
@@ -119,22 +120,25 @@ def _make_middleware_depends(cls: type, action_name: str):
 
     scheme = settings.viewsets_security_scheme
     if scheme is None:
+
         async def middleware_depends(request: Request) -> None:
             await _run(request)
+
         return middleware_depends
 
     async def middleware_depends(request: Request, _credential=Depends(scheme)) -> None:  # noqa: B008
         await _run(request)
+
     return middleware_depends
 
 
 def route_viewset(
-        router: APIRouter,
-        base_path: str,
-        lifecycle: LifecycleType = "singleton",
-        pk_field_name: str = None,
-        register_muxws: bool = None,
-        register_rest: bool = None,
+    router: APIRouter,
+    base_path: str,
+    lifecycle: LifecycleType = "singleton",
+    pk_field_name: str = None,
+    register_muxws: bool = None,
+    register_rest: bool = None,
 ):
     """
     `register_rest` and `register_muxws` decide which transports this viewset is published on.
@@ -146,6 +150,7 @@ def route_viewset(
     replacement is a single mapping - `transports={"rest": False}`, absent key meaning defer -
     rather than a third `register_*`; see GAPS.md for why a set of flags is the worse shape.
     """
+
     def decorator(cls: type[T]):
         instance = cls() if lifecycle == "singleton" else None
 
@@ -154,7 +159,7 @@ def route_viewset(
         # Derive tag from class name: strip "ViewSet" suffix if present
         cls_name = cls.__name__
         if cls_name.endswith("ViewSet"):
-            cls_name = cls_name[:-len("ViewSet")]
+            cls_name = cls_name[: -len("ViewSet")]
         default_tags = [cls_name] if cls_name else None
         # The viewset's own docstring becomes the description of the group its endpoints appear
         # under - the section intro that was otherwise blank however well each endpoint was
@@ -164,9 +169,8 @@ def route_viewset(
 
         def _is_filter_param(annotation) -> bool:
             """Return True when annotation is Annotated[T, FilterParam()]."""
-            return (
-                hasattr(annotation, "__metadata__")
-                and any(isinstance(m, FilterParam) for m in annotation.__metadata__)
+            return hasattr(annotation, "__metadata__") and any(
+                isinstance(m, FilterParam) for m in annotation.__metadata__
             )
 
         def _is_model_query_param(annotation) -> bool:
@@ -208,13 +212,15 @@ def route_viewset(
                 if uses.get(name) is False:
                     continue
                 if name == "x_list_shape":
-                    parameter = parameter.replace(annotation=Annotated[
-                        Literal[(*allowed, None)],
-                        Header(
-                            alias=SHAPE_HEADER,
-                            description=f"Response shape. Omit for this endpoint's default ({default}).",
-                        ),
-                    ])
+                    parameter = parameter.replace(
+                        annotation=Annotated[
+                            Literal[(*allowed, None)],
+                            Header(
+                                alias=SHAPE_HEADER,
+                                description=f"Response shape. Omit for this endpoint's default ({default}).",
+                            ),
+                        ]
+                    )
                 params.append(parameter)
 
             item_type = type_map.get(ItemVar, ItemVar)
@@ -267,10 +273,7 @@ def route_viewset(
                     continue
 
                 # If we have a PK field and this parameter is a model from which we want to exclude PK
-                if (pk_field_name and
-                    inspect.isclass(annotation) and
-                    issubclass(annotation, BaseModel)
-                ):
+                if pk_field_name and inspect.isclass(annotation) and issubclass(annotation, BaseModel):
                     # Check if {pk} is in the path and if the method is one that normally accepts a model in the body
                     # (POST without {pk} or PUT/PATCH with {pk})
                     is_create = "POST" in route_methods and "{pk}" not in route_path
@@ -286,18 +289,14 @@ def route_viewset(
             # (never forwarded to the underlying method itself, see wrapper below). Keyword-only
             # so it can be appended regardless of what defaults precede it. Used by lifecycle_runner
             # to run the command middleware chain and apply headers/cookies onto the real response.
-            new_params.append(
-                inspect.Parameter("response", inspect.Parameter.KEYWORD_ONLY, annotation=Response)
-            )
+            new_params.append(inspect.Parameter("response", inspect.Parameter.KEYWORD_ONLY, annotation=Response))
 
             if needs_context:
                 # Reserved param name, only added for endpoints that declare a `context` param.
                 # FastAPI injects the REAL Request here; lifecycle_runner uses it to build the
                 # context (see fastapi_viewsets/context.py) and injects the result as `context`
                 # right before the endpoint runs - never forwarded to the endpoint itself.
-                new_params.append(
-                    inspect.Parameter("request", inspect.Parameter.KEYWORD_ONLY, annotation=Request)
-                )
+                new_params.append(inspect.Parameter("request", inspect.Parameter.KEYWORD_ONLY, annotation=Request))
 
             new_return_annotation = resolve_typevars(type_map, sig.return_annotation)
             new_sig = sig.replace(parameters=new_params, return_annotation=new_return_annotation)
@@ -325,8 +324,15 @@ def route_viewset(
                         new_kwargs[param_name] = value
 
                 return await lifecycle_runner(
-                    original_endpoint, instance, cls, lifecycle, *args, response=response_obj,
-                    needs_context=needs_context, request=request_obj, **new_kwargs
+                    original_endpoint,
+                    instance,
+                    cls,
+                    lifecycle,
+                    *args,
+                    response=response_obj,
+                    needs_context=needs_context,
+                    request=request_obj,
+                    **new_kwargs,
                 )
 
             wrapper.__signature__ = new_sig
@@ -339,7 +345,10 @@ def route_viewset(
         # ViewSetResult - if any is configured, the endpoint's declared return type can no longer
         # be trusted as the actual response_model, same reasoning as the old finalize_response hook.
         build_schema(
-            cls, base_path, default_tags, get_wrapper,
+            cls,
+            base_path,
+            default_tags,
+            get_wrapper,
             disable_response_model=bool(settings.viewsets_command_middleware),
         )
 
@@ -348,9 +357,7 @@ def route_viewset(
         for route in cls.__router.routes:
             action_name = route.endpoint.__name__  # survives @wraps(original_endpoint) in get_wrapper
             documented.add(action_name)
-            dependencies = list(route.dependencies or []) + [
-                Depends(_make_middleware_depends(cls, action_name))
-            ]
+            dependencies = list(route.dependencies or []) + [Depends(_make_middleware_depends(cls, action_name))]
             route_kwargs = route_to_add_api_route_kwargs(route, dependencies=dependencies)
             # Per-viewset wording for an endpoint the mixin provided - the mixin's own docstring is
             # the same sentence on every viewset in the application. See endpoint_docs.py.
@@ -379,11 +386,7 @@ def route_viewset(
         if muxws_routes:
             register_viewset(cls, base_path, muxws_routes, default_tags)
 
-        cls.__viewset_metadata__ = {
-            "base_path": base_path,
-            "lifecycle": lifecycle,
-            "router": router
-        }
+        cls.__viewset_metadata__ = {"base_path": base_path, "lifecycle": lifecycle, "router": router}
 
         return cls
 

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/fastapi_viewsets/endpoint_docs.py

@@ -63,6 +63,7 @@ def endpoint_docs(docs: dict[str, EndpointDoc]):
     the other way round it would run too late; rather than silently document nothing, that is
     refused with a message saying which way round to put it.
     """
+
     def decorator(cls):
         if getattr(cls, "__viewset_metadata__", None) is not None:
             raise ValueError(

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/fastapi_viewsets/filters/declaration.py

@@ -91,11 +91,7 @@ def make_filter_model(model: type[BaseModel], declaration: FilterDeclaration) ->
                 )
             parameter = field_name if lookup == "exact" else f"{field_name}__{lookup}"
             annotation = _parameter_annotation(field_annotation, lookup)
-            default = (
-                Field(None, description="Comma-separated list of values")
-                if lookup in _LIST_LOOKUPS
-                else None
-            )
+            default = Field(None, description="Comma-separated list of values") if lookup in _LIST_LOOKUPS else None
             fields[parameter] = (annotation, default)
             spec[parameter] = (field_name, lookup, _item_annotation(field_annotation, lookup))
 

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/fastapi_viewsets/filters/registry.py

@@ -31,6 +31,7 @@ def compiles(backend: type, filter_type: type[Filter]) -> Callable[[Compiler], C
         def _(viewset, fltr, queryset):
             return queryset.filter(**{fltr.field: fltr.value})
     """
+
     def decorator(compiler: Compiler) -> Compiler:
         _compilers[(backend, filter_type)] = compiler
         return compiler

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/fastapi_viewsets/list_shapes.py

@@ -56,8 +56,7 @@ def _placeholder(schema: dict, definitions: dict, depth: int = 0) -> Any:
     kind = schema.get("type")
     if kind == "object":
         return {
-            name: _placeholder(field, definitions, depth + 1)
-            for name, field in schema.get("properties", {}).items()
+            name: _placeholder(field, definitions, depth + 1) for name, field in schema.get("properties", {}).items()
         }
     if kind == "array":
         return [_placeholder(schema.get("items", {}), definitions, depth + 1)]

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/fastapi_viewsets/mixins.py

@@ -111,6 +111,7 @@ class CreateMixin(Generic[K, T], ABC):
     """
     Create a model instance.
     """
+
     __router = APIRouter()
 
     @final
@@ -123,6 +124,7 @@ class BulkOnlyCreateMixin(Generic[K, T], ABC):
     """
     Create model instances in bulk.
     """
+
     __router = APIRouter()
 
     @final
@@ -188,6 +190,7 @@ class SortStateColumn(BaseModel):
     Mirrors the FE SortStateColumn interface: one column in the current sort order.
     Python attribute names use snake_case; JSON serialization uses camelCase (columnName).
     """
+
     model_config = ConfigDict(populate_by_name=True, alias_generator=to_camel)
 
     column_name: str
@@ -239,6 +242,7 @@ class ListMixin(Generic[T, TFilter], ABC):
     the response into a union of exactly those models; `route_viewset` computes both from these two
     attributes, so nothing here is written twice.
     """
+
     __router = APIRouter()
 
     list_shape: str | None = None
@@ -333,9 +337,7 @@ class ListMixin(Generic[T, TFilter], ABC):
     list_items.__list_shape_aware__ = True
     """Tells route_viewset to prune this signature and compute its response model per viewset."""
 
-    async def get_list(
-        self: "ImplMixin[Any, T] | ListMixin[T]", context: Context, query: ListQuery
-    ) -> Any:
+    async def get_list(self: "ImplMixin[Any, T] | ListMixin[T]", context: Context, query: ListQuery) -> Any:
         """
         The list pipeline, in one place and overridable as a whole.
 
@@ -405,9 +407,7 @@ class ListMixin(Generic[T, TFilter], ABC):
             return records
         return await self.sort_list(query.sort, await self.land(query, records))
 
-    async def land(
-        self: "ImplMixin[Any, T] | ListMixin[T]", query: ListQuery, records: ListRecords
-    ) -> list:
+    async def land(self: "ImplMixin[Any, T] | ListMixin[T]", query: ListQuery, records: ListRecords) -> list:
         """
         Ends the lazy part: materialises the source and converts it to the response model.
 
@@ -667,6 +667,7 @@ class RetrieveMixin(Generic[K, T], ABC):
     """
     Retrieve a model instance.
     """
+
     __router = APIRouter()
 
     @final
@@ -682,6 +683,7 @@ class UpdateMixin(Generic[K, T], ABC):
     """
     Update a model instance.
     """
+
     __router = APIRouter()
 
     @final
@@ -691,9 +693,7 @@ class UpdateMixin(Generic[K, T], ABC):
 
     @final
     @__router.patch("/{pk}", name="partial_update", responses=NOT_FOUND_RESPONSE)
-    async def partial_update(
-        self: "ImplMixin[K, T] | UpdateMixin[K, T]", context: Context, pk: K, data: T
-    ) -> T:
+    async def partial_update(self: "ImplMixin[K, T] | UpdateMixin[K, T]", context: Context, pk: K, data: T) -> T:
         return await self.perform_update(context, pk, data, partial=True)
 
 
@@ -701,6 +701,7 @@ class BulkOnlyUpdateMixin(Generic[K, T], ABC):
     """
     Update model instances in bulk.
     """
+
     __router = APIRouter()
 
     @final
@@ -731,6 +732,7 @@ class DestroyMixin(Generic[K, T], ABC):
     """
     Destroy a model instance. Return the destroyed key and any additional data about its destruction
     """
+
     __router = APIRouter()
 
     @final
@@ -743,6 +745,7 @@ class BulkOnlyDestroyMixin(Generic[K, T], ABC):
     """
     Destroy model instances in bulk.
     """
+
     __router = APIRouter()
 
     @final
@@ -758,6 +761,7 @@ class BulkDestroyMixin(DestroyMixin[K, T], BulkOnlyDestroyMixin[K, T]):
     Destroy model instances (single or bulk).
     """
 
+
 ###################################################################################################
 # LOOKUP
 ###################################################################################################
@@ -770,6 +774,7 @@ class LookupItem(BaseModel):
 
 class LookupFilter(BaseModel):
     """Default filter model for LookupMixin. Provides case-insensitive title search via q."""
+
     q: str | None = None
 
 
@@ -796,6 +801,7 @@ class LookupMixin(Generic[TLookupFilter], ABC):
        The default implementation filters by fltr.q (case-insensitive title match).
        Override to customise in-memory filtering.
     """
+
     __router = APIRouter()
 
     @abstractmethod
@@ -832,9 +838,7 @@ class LookupMixin(Generic[TLookupFilter], ABC):
         fltr: Annotated[TLookupFilter, Query()] = None,
     ) -> list[LookupItem]:
         has_filter = (
-            fltr is not None
-            and hasattr(fltr, "model_dump")
-            and any(v is not None for v in fltr.model_dump().values())
+            fltr is not None and hasattr(fltr, "model_dump") and any(v is not None for v in fltr.model_dump().values())
         )
         if has_filter:
             await self.setup_lookup_filter(fltr)

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/fastapi_viewsets/mux_ws/protocol.py

@@ -93,11 +93,7 @@ def parse_request(headers: dict[str, Any] | None) -> tuple[str, str, bytes, dict
     else:
         raise EnvelopeError(f"{QUERY_KEY} must be a string or a mapping, got {type(query).__name__}")
 
-    http_headers = {
-        str(key).lower(): str(value)
-        for key, value in headers.items()
-        if not str(key).startswith(":")
-    }
+    http_headers = {str(key).lower(): str(value) for key, value in headers.items() if not str(key).startswith(":")}
     return method.upper(), path, query_string, http_headers
 
 

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/fastapi_viewsets/mux_ws/registry.py

@@ -155,6 +155,7 @@ def _add_schema_route(app: FastAPI, registration: _Registration) -> None:
     built here rather than copied from there, because the REST one closes over the REST app and
     would report the wrong transport's endpoint set.
     """
+
     def schema() -> dict[str, Any]:
         return registration.schema()
 

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/fastapi_viewsets/response_classes.py

@@ -7,7 +7,9 @@ from pydantic import BaseModel
 class NotFoundResponse(BaseModel):
     detail: str = "Item with pk {pk} not found"
 
-NOT_FOUND_RESPONSE= { "404": { "model": NotFoundResponse, "message": NotFoundResponse().detail } }
+
+NOT_FOUND_RESPONSE = {"404": {"model": NotFoundResponse, "message": NotFoundResponse().detail}}
+
 
 class NotFoundError(HTTPException):
     def __init__(self, pk: Any):

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/fastapi_viewsets/save_state/save_state.py

@@ -6,6 +6,7 @@ from .serialize_state import SerializeState
 if TYPE_CHECKING:
     from redis.asyncio import Redis
 
+
 class SaveState(SerializeState, ABC):
     def __init__(self, instance_id: str):
         super().__init__()

dynamicforms_fastapi_viewsets-0.5.1/fastapi_viewsets/__init__.py

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

dynamicforms_fastapi_viewsets-0.5.1/fastapi_viewsets/decorators/__init__.py

@@ -1,10 +0,0 @@
-from .celery_viewset import celery_viewset, celery_viewset_client, celery_viewset_server, set_is_celery_worker
-from .route_viewset import route_viewset
-
-__all__ = [
-    "celery_viewset",
-    "celery_viewset_client",
-    "celery_viewset_server",
-    "route_viewset",
-    "set_is_celery_worker",
-]

{dynamicforms_fastapi_viewsets-0.5.1 → dynamicforms_fastapi_viewsets-0.5.4}/fastapi_viewsets/save_state/serialize_state.py

@@ -16,8 +16,8 @@ class SerializeState(ABC):
     async def deserialize_state(self, state: str):
         pass
 
-class SerializeStateSlots(SerializeState):
 
+class SerializeStateSlots(SerializeState):
     async def serialize_state(self) -> str:  # noqa: B027
         return json.dumps(
             {slot: getattr(self, slot) for slot in self.__slots__},