dynamicforms-fastapi-viewsets 0.6.2__tar.gz → 0.7.0__tar.gz

{dynamicforms_fastapi_viewsets-0.6.2 → dynamicforms_fastapi_viewsets-0.7.0}/.gitignore

@@ -9,7 +9,6 @@ dist
 /demo/backend/demo.sqlite3
 
 /docs/.vitepress/cache
-/package-lock.json
 
 __pycache__/
 *.py[cod]

{dynamicforms_fastapi_viewsets-0.6.2 → dynamicforms_fastapi_viewsets-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: dynamicforms-fastapi-viewsets
-Version: 0.6.2
+Version: 0.7.0
 Summary: Django REST Framework-style viewsets for FastAPI, with optional Celery-backed async execution and a Vue/TypeScript client counterpart.
 Project-URL: Homepage, https://github.com/dynamicforms/fastapi-viewsets
 Project-URL: Repository, https://github.com/dynamicforms/fastapi-viewsets

dynamicforms_fastapi_viewsets-0.7.0/fastapi_viewsets/__init__.py

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

{dynamicforms_fastapi_viewsets-0.6.2 → dynamicforms_fastapi_viewsets-0.7.0}/fastapi_viewsets/decorators/build_schema.py

@@ -94,12 +94,15 @@ def build_schema(cls, base_path: str = "", default_tags=None, get_wrapper=None,
     and attaches them to the class. Idempotent: if already called, returns immediately.
     If get_wrapper is None, only __router is built (no FastAPI app, no endpoint wrapping).
 
-    disable_response_model: pass True when command middleware is configured (see
-    fastapi_viewsets/middleware.py and route_viewset.py) - middleware can change the shape of what's
-    actually served (e.g. strip an internal-only field via ViewSetResult.body), so FastAPI must not
-    coerce/re-validate the endpoint's return value against the ORIGINAL method's declared return
-    type, which would silently undo those changes (missing fields reappear with their model
-    defaults).
+    disable_response_model: pass True when a configured command middleware declares
+    modifies_response_shape=True (see Middleware.modifies_response_shape and
+    any_modifies_response_shape() in fastapi_viewsets/middleware/__init__.py, and route_viewset.py) -
+    such a middleware can change the shape of what's actually served (e.g. strip an internal-only
+    field via ViewSetResult.body), so FastAPI must not coerce/re-validate the endpoint's return value
+    against the ORIGINAL method's declared return type, which would silently undo those changes
+    (missing fields reappear with their model defaults). Middleware that doesn't declare this (the
+    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)):
         return

{dynamicforms_fastapi_viewsets-0.6.2 → dynamicforms_fastapi_viewsets-0.7.0}/fastapi_viewsets/decorators/celery_viewset/client.py

@@ -126,6 +126,11 @@ def _patch_method(cls: type, original_endpoint, task_name: str, celery_app, queu
                     "_result_queue_key": queue_key,
                     **extra_kwargs,
                 },
+                # send_task() defaults ignore_result to False regardless of what the task was
+                # registered with (celery_viewset_server sets ignore_result=True) - Celery's
+                # per-request value overrides the task's own, so it must be repeated here or the
+                # worker still tries to JSON-encode the raw return value into its result backend.
+                ignore_result=True,
             )
             return await future
         except Exception:

{dynamicforms_fastapi_viewsets-0.6.2 → dynamicforms_fastapi_viewsets-0.7.0}/fastapi_viewsets/decorators/celery_viewset/server.py

@@ -59,6 +59,26 @@ def _to_jsonable(value):
     return value
 
 
+def _reconstruct_value(hint, value):
+    """Rebuild a dict (or list/tuple of dicts) back into BaseModel instance(s) per `hint`.
+
+    `_reconstruct_kwargs` only unwraps `Optional[...]` at the top level, so a hint arriving here
+    may still be `list[Model]` or `Optional[list[Model]]` - handled by recursing into the origin's
+    type args rather than requiring `hint` itself to be a bare BaseModel subclass.
+    """
+    hint = _unwrap_optional(hint)
+    if hint is not None and isinstance(value, dict) and inspect.isclass(hint) and issubclass(hint, BaseModel):
+        try:
+            return hint.model_validate(value)
+        except Exception:
+            return hint.model_construct(**value)
+    if get_origin(hint) in (list, tuple) and isinstance(value, (list, tuple)):
+        args = get_args(hint)
+        if args:
+            return [_reconstruct_value(args[0], item) for item in value]
+    return value
+
+
 def _reconstruct_kwargs(original_endpoint, kwargs: dict, cls: type = None) -> dict:
     """Reconstruct dict values back into Pydantic BaseModel instances based on endpoint type hints.
 
@@ -85,14 +105,8 @@ 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 = _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)
-            except Exception:
-                result[key] = hint.model_construct(**value)
-        else:
-            result[key] = value
+            hint = resolve_typevars(type_map, hint)
+        result[key] = _reconstruct_value(hint, value)
     return result
 
 
@@ -144,6 +158,14 @@ def celery_viewset_server(
                                 }
                             ),
                         )
+                        # celery_viewset_client never reads this task's own retval (only the queue
+                        # entry just pushed above), so returning `result` a second time here would
+                        # hand Celery a raw endpoint return value - e.g. a Pydantic model - to
+                        # encode on its own (result backend, task-succeeded event, ...), which
+                        # isn't JSON-safe. ignore_result=True (set on both task registration and
+                        # send_task) tells Celery to skip that, but a JSON-trivial retval here means
+                        # nothing breaks even where that setting doesn't reach.
+                        return True
                     return result
                 except Exception as e:
                     if isinstance(e, HTTPException):

{dynamicforms_fastapi_viewsets-0.6.2 → dynamicforms_fastapi_viewsets-0.7.0}/fastapi_viewsets/decorators/route_viewset.py

@@ -21,7 +21,7 @@ from fastapi_viewsets.endpoint_docs import (
     register_tag,
     viewset_description,
 )
-from fastapi_viewsets.middleware import Middleware
+from fastapi_viewsets.middleware import any_modifies_response_shape, Middleware
 from fastapi_viewsets.mixins import FilterParam
 from fastapi_viewsets.mux_ws import register_viewset, resolve_register_muxws, resolve_register_rest
 
@@ -342,14 +342,16 @@ def route_viewset(
             return wrapper, new_return_annotation
 
         # Command middleware (see fastapi_viewsets/middleware.py) can reshape the response body via
-        # 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.
+        # ViewSetResult - only middleware that actually declares modifies_response_shape=True
+        # untrusts the endpoint's declared return type as the response_model (same reasoning as the
+        # old finalize_response hook); typical middleware (auth, rate limiting, sessions) only adds
+        # headers/cookies and leaves the declared model - and therefore the OpenAPI docs - in place.
         build_schema(
             cls,
             base_path,
             default_tags,
             get_wrapper,
-            disable_response_model=bool(settings.viewsets_command_middleware),
+            disable_response_model=any_modifies_response_shape(settings.viewsets_command_middleware),
         )
 
         muxws_routes = []

{dynamicforms_fastapi_viewsets-0.6.2 → dynamicforms_fastapi_viewsets-0.7.0}/fastapi_viewsets/middleware/__init__.py

@@ -57,6 +57,20 @@ class Middleware(ABC):
     concrete example) - a bare function would need extra indirection (closures, partials) for that.
     """
 
+    modifies_response_shape: bool = False
+    """
+    Whether this middleware can change the shape of ViewSetResult.body (strip/rename/restructure
+    fields, not just add side-channel headers/cookies or a status code) - see
+    `any_modifies_response_shape()` below. False by default: typical middleware (auth, rate
+    limiting, sessions) only inspects the result or attaches headers/cookies, so the endpoint's
+    declared return type stays a trustworthy response_model. Override to True on a middleware whose
+    __call__ actually reassigns `result.body` to something that no longer matches the original
+    return annotation - otherwise FastAPI's response_model validation will coerce the reshaped body
+    back towards the original model (e.g. reintroducing a stripped field with its default value).
+    A plain function middleware declares this the same way, by setting the attribute on the
+    function object: `my_middleware.modifies_response_shape = True`.
+    """
+
     def config_from(self, context: Context) -> Any:
         """
         This middleware's own @action_configuration value for the current call (see
@@ -104,6 +118,18 @@ class Middleware(ABC):
         raise NotImplementedError
 
 
+def any_modifies_response_shape(middlewares: list) -> bool:
+    """
+    Whether any entry in `middlewares` (a mix of Middleware instances and/or plain functions, as
+    settings.viewsets_command_middleware holds) declares modifies_response_shape=True. A bare
+    function that never set the attribute is treated as False, same default as the Middleware
+    class - see Middleware.modifies_response_shape above. Used by route_viewset/build_schema to
+    decide whether an endpoint's declared response_model can still be trusted for OpenAPI docs and
+    FastAPI's own response validation.
+    """
+    return any(getattr(middleware, "modifies_response_shape", False) for middleware in middlewares)
+
+
 async def run_command_chain(
     middlewares: list[CommandMiddleware],
     request: "Request | None",

dynamicforms_fastapi_viewsets-0.6.2/fastapi_viewsets/__init__.py

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