dynamicforms-fastapi-viewsets 0.13.0__tar.gz → 0.14.0__tar.gz

{dynamicforms_fastapi_viewsets-0.13.0 → dynamicforms_fastapi_viewsets-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: dynamicforms-fastapi-viewsets
-Version: 0.13.0
+Version: 0.14.0
 Summary: Django REST Framework-style viewsets for FastAPI, with optional Celery-backed async execution and a Vue/TypeScript client counterpart.
 Project-URL: Homepage, https://github.com/dynamicforms/fastapi-viewsets
 Project-URL: Repository, https://github.com/dynamicforms/fastapi-viewsets
@@ -40,6 +40,7 @@ Requires-Dist: pyjwt; extra == 'dev'
 Requires-Dist: pytest; extra == 'dev'
 Requires-Dist: pytest-asyncio; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: python-multipart; extra == 'dev'
 Requires-Dist: redis; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'
 Requires-Dist: uvicorn; extra == 'dev'
@@ -60,6 +61,8 @@ Celery-backed async execution and a matching Vue/TypeScript client counterpart.
 - **Python mixins for FastAPI** — compose CRUD and bulk endpoints from small, focused mixin classes.
 - **`route_viewset` decorator** — register a viewset on a FastAPI router with a single decorator call.
   Handles type resolution, lifecycle management and OpenAPI schema automatically.
+- **Nested viewsets** — mount a viewset under another one's path (`/accounts/members`) with
+  `ViewSetRouter.sub_viewset`; a request to it passes the parent's checks and its own.
 - **`CollectionViewSet`** — zero-boilerplate in-memory viewset backed by any Python list, set or dict.
   Great for prototyping and testing.
 - **`DjangoORMViewSet`** — back a viewset with a Django QuerySet. The filters it can compile, the

{dynamicforms_fastapi_viewsets-0.13.0 → dynamicforms_fastapi_viewsets-0.14.0}/README.md

@@ -6,6 +6,8 @@ Celery-backed async execution and a matching Vue/TypeScript client counterpart.
 - **Python mixins for FastAPI** — compose CRUD and bulk endpoints from small, focused mixin classes.
 - **`route_viewset` decorator** — register a viewset on a FastAPI router with a single decorator call.
   Handles type resolution, lifecycle management and OpenAPI schema automatically.
+- **Nested viewsets** — mount a viewset under another one's path (`/accounts/members`) with
+  `ViewSetRouter.sub_viewset`; a request to it passes the parent's checks and its own.
 - **`CollectionViewSet`** — zero-boilerplate in-memory viewset backed by any Python list, set or dict.
   Great for prototyping and testing.
 - **`DjangoORMViewSet`** — back a viewset with a Django QuerySet. The filters it can compile, the

{dynamicforms_fastapi_viewsets-0.13.0 → dynamicforms_fastapi_viewsets-0.14.0}/fastapi_viewsets/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.13.0"
+__version__ = "0.14.0"
 
 from .error_namespace import ERROR_NAMESPACE, ERROR_NAMESPACE_PYDANTIC
 

{dynamicforms_fastapi_viewsets-0.13.0 → dynamicforms_fastapi_viewsets-0.14.0}/fastapi_viewsets/context/__init__.py

@@ -43,10 +43,13 @@ def _resolve_config_value(value: Any, action_name: "str | None") -> Any:
 
 class SerializableObject(ABC):
     """
-    Base class for context values that need custom (de)serialization across the Celery/Redis
-    boundary - e.g. because reconstructing them requires domain-specific logic, not just decoding
-    a JSON literal (see settings.viewsets_context_json_encoder/decoder for the simpler case of
-    normalising a plain value type like datetime).
+    Base class for context values, and `celery_viewset` action arguments and results, that need
+    custom (de)serialization across the Celery/Redis boundary - e.g. because reconstructing them
+    requires domain-specific logic, not just decoding a JSON literal (see
+    settings.viewsets_context_json_encoder/decoder for the simpler case of normalising a plain
+    value type like datetime in context). An action argument or result crosses as its tagged
+    payload at any depth of lists and dicts, whatever its annotation (see
+    decorators/celery_viewset/transport.py).
 
     `value` holds the actual wrapped value. Subclasses implement the "magic" __serialize__/
     __deserialize__ methods; serialize_context()/deserialize_context() detect instances of this
@@ -349,8 +352,8 @@ def to_jsonable(value: Any) -> Any:
     list/tuple element-wise, and any other value goes through pydantic_core.to_jsonable_python()
     (datetime, Decimal, UUID, Enum, set, dataclass, ...) - the encoding FastAPI's response
     serialization applies to the same value on REST/muxws. Shared by ViewSetResult's own
-    serialization and celery_viewset's worker/client payloads. from_jsonable() is its inverse for
-    tagged objects.
+    serialization and celery_viewset's encoding of a value its type hint does not type (see
+    decorators/celery_viewset/transport.py). from_jsonable() is its inverse for tagged objects.
     """
     if isinstance(value, SerializableObject):
         return serialize_value(value)

{dynamicforms_fastapi_viewsets-0.13.0 → dynamicforms_fastapi_viewsets-0.14.0}/fastapi_viewsets/decorators/__init__.py

@@ -5,6 +5,7 @@ from .celery_viewset import (
     set_is_celery_worker,
 )
 from .route_viewset import route_viewset
+from .sub_viewsets import SubViewSet, ViewSetRouter
 
 __all__ = [
     "celery_viewset",
@@ -12,4 +13,6 @@ __all__ = [
     "celery_viewset_server",
     "route_viewset",
     "set_is_celery_worker",
+    "SubViewSet",
+    "ViewSetRouter",
 ]

{dynamicforms_fastapi_viewsets-0.13.0 → dynamicforms_fastapi_viewsets-0.14.0}/fastapi_viewsets/decorators/build_schema.py

@@ -1,9 +1,11 @@
+import inspect
 import warnings
 
 from typing import get_args, TypeVar
 
 from fastapi import APIRouter, FastAPI
 from fastapi.routing import APIRoute
+from starlette.responses import Response
 
 from ..endpoint_docs import docs_for, viewset_tags
 from ..middleware import unwrap_viewset_result_type
@@ -104,9 +106,10 @@ 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 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).
+    and attaches them to the class. If get_wrapper is None, only __router is built (no FastAPI app,
+    no endpoint wrapping), and only when `cls` itself has none yet. With get_wrapper the routes are
+    built on every call, so each routing of a class wraps its endpoints for its own base path and
+    instance; a subclass of a class it was called for gets routes of its own.
 
     disable_response_model: pass True when a configured command middleware declares
     modifies_response_shape=True (see Middleware.modifies_response_shape and
@@ -119,7 +122,7 @@ def build_schema(cls, base_path: str = "", default_tags=None, get_wrapper=None,
     FastAPI's own response validation.
     """
     own = vars(cls)
-    if "__router" in own and (get_wrapper is None or own.get("__router_full", False)):
+    if "__router" in own and get_wrapper is None:
         return
 
     celery_mode = get_wrapper is None
@@ -185,6 +188,10 @@ def build_schema(cls, base_path: str = "", default_tags=None, get_wrapper=None,
                 # unwrapped here too, or an endpoint declared this way would document/validate as the
                 # wrapper instead of the wire body whenever use_resolved is False.
                 response_model = unwrap_viewset_result_type(response_model)
+                # an endpoint returning a Response answers with it as it is, as FastAPI does for an
+                # endpoint annotated with a Response class
+                if inspect.isclass(response_model) and issubclass(response_model, Response):
+                    response_model = 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
@@ -212,8 +219,6 @@ def build_schema(cls, base_path: str = "", default_tags=None, get_wrapper=None,
             class_router.routes.append(route)
 
     cls.__router = class_router
-    if not celery_mode:
-        cls.__router_full = True
 
 
 def route_sort_key(route: APIRoute):

{dynamicforms_fastapi_viewsets-0.13.0 → dynamicforms_fastapi_viewsets-0.14.0}/fastapi_viewsets/decorators/celery_viewset/client.py

@@ -10,14 +10,15 @@ from pydantic import BaseModel
 
 from ...action_configuration import resolve_action_configuration, TimeLimits
 from ...context import _Deferred, Context, SerializableObject, serialize_context, to_jsonable
-from ...exceptions import ActionDispatchError, ResultTimeoutError
+from ...exceptions import ActionDispatchError, ActionFailedError, ResultTimeoutError
 from ...middleware import ActionTransition, run_transition_listeners
 from ..build_schema import build_schema
 from ..lifecycle_runner import current_call, DEFERRED_ACTIONS_ATTRIBUTE, effective_middlewares
 from ..primary_key_model_helper import PARTIAL_UPDATE_ACTIONS
 from . import result_reader
-from .payload import CONTEXT_KWARG, PARENT_KWARG, REQUEST_KWARG, request_to_jsonable
+from .payload import CONTEXT_KWARG, PARENT_KWARG, REQUEST_KWARG, request_to_jsonable, UNTYPED_KWARG
 from .result_reader import get_process_queue_key, get_result_queue_key
+from .transport import ActionCodec, EncodedResult
 
 if TYPE_CHECKING:
     import redis
@@ -51,7 +52,8 @@ def celery_viewset_client(
     send Celery tasks and await results via a Redis result queue.
 
     A call whose result does not arrive within result_timeout seconds raises ResultTimeoutError (504).
-    None waits without a limit.
+    None waits without a limit. Arguments and results are encoded by the action's type hints (see
+    `transport`).
     """
     queue_key = get_result_queue_key(task_prefix)
 
@@ -99,6 +101,33 @@ async def _serialize_value(value, partial: bool = False):
     return to_jsonable(value)
 
 
+async def _encode_arguments(
+    codec: ActionCodec, positional: tuple, named: dict, partial: bool
+) -> tuple[list, dict, list[str]]:
+    """The Celery args and kwargs of a call's arguments, and the names of the kwargs that crossed
+    untyped (see `transport`). An argument that holds an `UploadFile` is encoded in a worker thread,
+    which reads the file."""
+
+    async def encode(name: str, value):
+        kind = codec.params[name].kind if name in codec.params else "untyped"
+        if kind in ("model", "partial"):
+            return await _serialize_value(value, partial), True
+        if isinstance(value, Context):
+            return await _serialize_value(value), False
+        if codec.reads_uploads:
+            return await asyncio.to_thread(codec.encode_argument, name, value)
+        return codec.encode_argument(name, value)
+
+    encoded_args = [await _serialize_value(value) for value in positional]
+    encoded_kwargs: dict = {}
+    untyped: list[str] = []
+    for name, value in named.items():
+        encoded_kwargs[name], typed = await encode(name, value)
+        if not typed:
+            untyped.append(name)
+    return encoded_args, encoded_kwargs, untyped
+
+
 def _time_limit_options(context: Context) -> dict:
     """The `send_task` time limit options of the call's `TimeLimits` configuration."""
     limits = context.configuration_for(TimeLimits)
@@ -118,15 +147,21 @@ def _patch_method(
     """Replace the method on cls with an async version that sends a Celery task and awaits the result.
 
     The task carries the call's context, request and parent execution (see `payload`) from
-    `current_call()`; a `context` the caller passes replaces the call's. The action's `TimeLimits`
+    `current_call()`; a `context` the caller passes replaces the call's. Positional arguments are
+    sent as the keyword arguments of their parameters, each encoded by its parameter's type hint
+    (see `transport`); the names of those that crossed untyped are sent under `UNTYPED_KWARG`, and
+    the result is decoded by the return annotation. 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`.
+    `ActionDispatchError` (reason `serialization`), a send that fails raises it with reason `send`,
+    and a result that cannot be decoded raises `ActionFailedError` (reason `result`).
     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__
     declares_request = "request" in inspect.signature(original_endpoint).parameters
+    codec = ActionCodec(cls, original_endpoint)
+    partial = method_name in PARTIAL_UPDATE_ACTIONS
 
     @wraps(original_endpoint)
     async def async_client_wrapper(_self, *args, **kwargs):
@@ -148,13 +183,12 @@ def _patch_method(
             for value in list(context.raw().values()):
                 if isinstance(value, _Deferred):
                     await value
+            positional, named = codec.bind(args, kwargs)
             try:
-                serializable_args = [await _serialize_value(v) for v in args]
-                serializable_kwargs = {
-                    k: await _serialize_value(v, method_name in PARTIAL_UPDATE_ACTIONS) for k, v in kwargs.items()
-                }
+                encoded_args, encoded_kwargs, untyped = await _encode_arguments(codec, positional, named, partial)
                 task_kwargs = {
-                    **serializable_kwargs,
+                    **encoded_kwargs,
+                    **({UNTYPED_KWARG: untyped} if untyped else {}),
                     CONTEXT_KWARG: await serialize_context(context.raw()),
                     REQUEST_KWARG: request_to_jsonable(call.request if call is not None else None),
                     PARENT_KWARG: parent.to_jsonable() if parent is not None else None,
@@ -163,7 +197,10 @@ def _patch_method(
                 }
             except Exception as error:
                 logger.error(
-                    "Celery task arguments not serializable: %s (correlation_id=%s)", task_name, correlation_id
+                    "Celery task arguments not serializable: %s (correlation_id=%s): %s",
+                    task_name,
+                    correlation_id,
+                    error,
                 )
                 raise ActionDispatchError(task_name, "serialization") from error
             logger.info("Celery task scheduling: %s (correlation_id=%s)", task_name, correlation_id)
@@ -172,7 +209,7 @@ def _patch_method(
                 await asyncio.to_thread(
                     celery_app.send_task,
                     task_name,
-                    args=serializable_args,
+                    args=encoded_args,
                     kwargs=task_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
@@ -189,10 +226,17 @@ def _patch_method(
                 ActionTransition("dispatched", cls, method_name, bound_context, parent, None),
             )
             try:
-                return await asyncio.wait_for(future, result_timeout)
+                result = await asyncio.wait_for(future, result_timeout)
             except asyncio.TimeoutError:
                 logger.error("Celery task timed out: %s (correlation_id=%s)", task_name, correlation_id)
                 raise ResultTimeoutError(task_name, result_timeout) from None
+            if not isinstance(result, EncodedResult):
+                return result
+            try:
+                return codec.decode_result(result)
+            except Exception as error:
+                logger.exception("Result of %s (correlation_id=%s) cannot be read", task_name, correlation_id)
+                raise ActionFailedError(task_name, "result") from error
         finally:
             result_reader.unregister_future(correlation_id)
 

{dynamicforms_fastapi_viewsets-0.13.0 → dynamicforms_fastapi_viewsets-0.14.0}/fastapi_viewsets/decorators/celery_viewset/payload.py

@@ -1,7 +1,8 @@
 """
 The call data a `celery_viewset` task carries beside the action's own arguments: the call's context,
-its request and the execution it was dispatched in. `celery_viewset_client` writes them under the
-reserved kwargs below, and `celery_viewset_server` consumes them before the action is called.
+its request, the execution it was dispatched in and the arguments that crossed untyped.
+`celery_viewset_client` writes them under the reserved kwargs below, and `celery_viewset_server`
+consumes them before the action is called.
 """
 
 from typing import Any
@@ -13,6 +14,9 @@ CONTEXT_KWARG = "_context"
 """The call's context, as `serialize_context` encodes it."""
 REQUEST_KWARG = "_request"
 """The call's request, as `request_to_jsonable` encodes it; None without one."""
+UNTYPED_KWARG = "_untyped"
+"""The names of the arguments that crossed untyped (see `transport`); absent when every argument
+crossed by its type hint."""
 PARENT_KWARG = "_parent"
 """The `ExecutionRef` the call was dispatched in, as `ExecutionRef.to_jsonable` encodes it; None
 for a call a request made."""

{dynamicforms_fastapi_viewsets-0.13.0 → dynamicforms_fastapi_viewsets-0.14.0}/fastapi_viewsets/decorators/celery_viewset/result_reader.py

@@ -11,6 +11,7 @@ from fastapi.exceptions import RequestValidationError
 
 from ...context import from_jsonable
 from ...exceptions import _error_from_jsonable, _error_to_jsonable, ActionFailedError, ResultReaderStoppedError
+from .transport import EncodedResult
 
 if TYPE_CHECKING:
     import redis
@@ -111,9 +112,11 @@ def _resolve(future: asyncio.Future, data: dict) -> None:
     try:
         if data.get("error") is not None:
             future.set_exception(_payload_error(data))
+        elif "result_encoding" in data:
+            # decoded by the caller, which knows the action's return annotation (see transport.py)
+            future.set_result(EncodedResult(data.get("result"), data["result_encoding"]))
         else:
-            # Undoes _to_jsonable's SerializableObject tagging (see server.py) at any depth - an
-            # untagged value passes through unchanged.
+            # a result pushed by push_result(): every SerializableObject in it is rebuilt, at any depth
             future.set_result(from_jsonable(data.get("result")))
     except Exception as error:
         logger.exception("Result of %s (correlation_id=%s) cannot be read", task, data.get("correlation_id"))
@@ -172,7 +175,8 @@ def push_result(
     of a class `fastapi_viewsets.exceptions` defines keeps its class), and so does a
     `RequestValidationError`; any other error reaches it as `ActionFailedError`. `task` names the
     call's task in that error. The FastAPI process answers each as `fastapi_viewsets.error_responses`
-    answers it.
+    answers it. A `result` reaches the caller in its JSON form, with every `SerializableObject` in it
+    rebuilt; it is not decoded by the action's return annotation.
     """
     if error is not None:
         data = error_payload(correlation_id, task, error)

{dynamicforms_fastapi_viewsets-0.13.0 → dynamicforms_fastapi_viewsets-0.14.0}/fastapi_viewsets/decorators/celery_viewset/server.py

@@ -17,7 +17,7 @@ from collections import OrderedDict
 from collections.abc import Callable
 from dataclasses import dataclass
 from functools import wraps
-from typing import Any, get_args, get_origin, get_type_hints, TYPE_CHECKING, TypeVar, Union
+from typing import Any, get_args, get_origin, TYPE_CHECKING, TypeVar, Union
 
 from fastapi import HTTPException
 from fastapi.exceptions import RequestValidationError
@@ -25,7 +25,7 @@ from pydantic import BaseModel, TypeAdapter, ValidationError
 
 from ...action_configuration import resolve_action_configuration
 from ...conf import settings
-from ...context import Context, deserialize_context, to_jsonable
+from ...context import Context, deserialize_context, from_jsonable
 from ...exceptions import ActionDispatchError, ActionFailedError, ActionInterruptedError, DfViewSetError
 from ...middleware import ActionTransition, ExecutionRef, run_executor_started, run_transition_listeners
 from ..build_schema import build_schema
@@ -34,12 +34,11 @@ from ..primary_key_model_helper import (
     create_model_without_pk,
     from_partial_body,
     partial_body_annotation,
-    PARTIAL_UPDATE_ACTIONS,
     typecast_to_original_model,
 )
-from ..route_viewset import build_type_map, resolve_typevars
-from .payload import CONTEXT_KWARG, PARENT_KWARG, request_from_jsonable, REQUEST_KWARG
+from .payload import CONTEXT_KWARG, PARENT_KWARG, request_from_jsonable, REQUEST_KWARG, UNTYPED_KWARG
 from .result_reader import error_payload, push_payload
+from .transport import ActionCodec
 
 if TYPE_CHECKING:
     import redis
@@ -62,12 +61,6 @@ def _unwrap_optional(hint):
     return hint
 
 
-# `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
-
-
 def _reconstruct_value(hint, value):
     """Rebuild a dict (or list/tuple of dicts) back into BaseModel instance(s) per `hint`.
 
@@ -116,35 +109,31 @@ def _sole_missing_field(model: type[BaseModel], error: ValidationError) -> str |
 _model_without_pk = functools.lru_cache(create_model_without_pk)
 
 
-def _reconstruct_kwargs(original_endpoint, kwargs: dict, cls: type = None) -> dict:
-    """Reconstruct dict values back into Pydantic BaseModel instances based on endpoint type hints.
+def _reconstruct_kwargs(
+    original_endpoint, kwargs: dict, cls: type = None, untyped=(), codec: ActionCodec | None = None
+) -> dict:
+    """The action's keyword arguments from the task's kwargs, each decoded by its parameter's kind
+    (see `transport`): a model validated as its model, a partial update body as the partial model the
+    FastAPI side validated it with, a typed value validated by its hint, and a value named in
+    `untyped` (or of an untyped parameter) with every `SerializableObject` in it rebuilt.
 
     The call's context, request and parent arrive under the reserved kwargs of `payload`, which the
     task consumes before this runs.
     """
+    codec = codec or ActionCodec(cls, original_endpoint)
     result = {}
-    remaining = dict(kwargs)
-
-    try:
-        hints = get_type_hints(original_endpoint)
-    except Exception:
-        result.update(remaining)
-        return result
-
-    type_map = build_type_map(cls) if cls is not None else {}
-
-    partial = original_endpoint.__name__ in PARTIAL_UPDATE_ACTIONS
-    for key, value in remaining.items():
-        hint = hints.get(key)
-        if hint is not None:
-            hint = resolve_typevars(type_map, hint)
-        partial_annotation = partial_body_annotation(hint, None) if partial else None
-        if partial_annotation is not None:
+    for key, value in kwargs.items():
+        param = codec.params.get(key)
+        kind = param.kind if param is not None else "untyped"
+        if kind == "partial":
             # validated as the partial model the FastAPI side validated it with, so the model holds
             # the fields the request stated and no others
-            result[key] = from_partial_body(TypeAdapter(partial_annotation).validate_python(value, by_name=True), hint)
+            annotation = partial_body_annotation(param.hint, None)
+            result[key] = from_partial_body(TypeAdapter(annotation).validate_python(value, by_name=True), param.hint)
+        elif kind == "model":
+            result[key] = _reconstruct_value(param.hint, value)
         else:
-            result[key] = _reconstruct_value(hint, value)
+            result[key] = codec.decode_argument(key, value, kind == "typed" and key not in untyped)
     return result
 
 
@@ -561,7 +550,9 @@ def celery_viewset_server(
     """
     Decorator for the Celery worker side. Registers a task per route of the viewset that executes
     the action and pushes its result or error to the caller's result queue through `redis_client`
-    (a synchronous `redis.Redis`, required).
+    (a synchronous `redis.Redis`, required). The action's arguments are decoded, and its result
+    encoded, by its type hints (see `transport`); a result that cannot be encoded fails the call
+    with `ActionFailedError` (reason `result`).
 
     The tasks are registered with `ignore_result=True`, `acks_late=False`,
     `reject_on_worker_lost=False` and `store_errors_even_if_ignored=False`, overriding the
@@ -585,6 +576,7 @@ def celery_viewset_server(
 
         def get_sync_wrapper(original_endpoint, task_name: str):
             parameters = inspect.signature(original_endpoint).parameters
+            codec = ActionCodec(cls, original_endpoint)
 
             @wraps(original_endpoint)
             def sync_wrapper(*args, **kwargs):
@@ -602,7 +594,9 @@ def celery_viewset_server(
                     context = Context(deserialize_context(kwargs.pop(CONTEXT_KWARG, None) or {}))
                     request = request_from_jsonable(kwargs.pop(REQUEST_KWARG, None))
                     parent = ExecutionRef.from_jsonable(kwargs.pop(PARENT_KWARG, None))
-                    kwargs = _reconstruct_kwargs(original_endpoint, kwargs, cls)
+                    untyped = kwargs.pop(UNTYPED_KWARG, None) or ()
+                    args = tuple(from_jsonable(arg) for arg in args)
+                    kwargs = _reconstruct_kwargs(original_endpoint, kwargs, cls, untyped, codec)
                     marker = execution_translator.set(run.translate)
                     try:
                         with _soft_limit_raises(task_name):
@@ -628,10 +622,12 @@ def celery_viewset_server(
                     logger.info("Celery task completed: %s (correlation_id=%s)", task_name, correlation_id)
                     if correlation_id and result_queue_key:
                         try:
+                            data, encoding = codec.encode_result(result)
                             payload = {
                                 "correlation_id": correlation_id,
                                 "task": task_name,
-                                "result": _to_jsonable(result),
+                                "result": data,
+                                "result_encoding": encoding,
                             }
                         except Exception as error:
                             raise ActionFailedError(task_name, "result") from error