marshmallow 3.25.0__py3-none-any.whl → 3.26.0__py3-none-any.whl

marshmallow/schema.py

@@ -1,18 +1,21 @@
-"""The :class:`Schema` class, including its metaclass and options (class Meta)."""
+"""The `Schema <marshmallow.Schema>` class, including its metaclass and options (`class Meta <marshmallow.Schema.Meta>`)."""
 
 from __future__ import annotations
 
 import copy
 import datetime as dt
 import decimal
+import functools
 import inspect
 import json
+import operator
 import typing
 import uuid
 import warnings
 from abc import ABCMeta
 from collections import OrderedDict, defaultdict
 from collections.abc import Mapping
+from itertools import zip_longest
 
 from marshmallow import base, class_registry, types
 from marshmallow import fields as ma_fields
@@ -25,7 +28,7 @@ from marshmallow.decorators import (
     VALIDATES_SCHEMA,
 )
 from marshmallow.error_store import ErrorStore
-from marshmallow.exceptions import StringNotCollectionError, ValidationError
+from marshmallow.exceptions import SCHEMA, StringNotCollectionError, ValidationError
 from marshmallow.orderedset import OrderedSet
 from marshmallow.utils import (
     EXCLUDE,
@@ -40,8 +43,11 @@ from marshmallow.utils import (
 )
 from marshmallow.warnings import RemovedInMarshmallow4Warning
 
+if typing.TYPE_CHECKING:
+    from marshmallow.fields import Field
 
-def _get_fields(attrs) -> list[tuple[str, ma_fields.Field]]:
+
+def _get_fields(attrs) -> list[tuple[str, Field]]:
     """Get fields from a class
 
     :param attrs: Mapping of class attributes
@@ -60,11 +66,14 @@ def _get_fields_by_mro(klass: SchemaMeta):
     class itself is excluded from the search; only its parents are checked. Get
     fields from ``_declared_fields`` if available, else use ``__dict__``.
 
-    :param type klass: Class whose fields to retrieve
+    :param klass: Class whose fields to retrieve
     """
     mro = inspect.getmro(klass)
+    # Combine fields from all parents
+    # functools.reduce(operator.iadd, list_of_lists) is faster than sum(list_of_lists, [])
     # Loop over mro in reverse to maintain correct order of fields
-    return sum(
+    return functools.reduce(
+        operator.iadd,
         (
             _get_fields(
                 getattr(base, "_declared_fields", base.__dict__),
@@ -79,10 +88,20 @@ class SchemaMeta(ABCMeta):
     """Metaclass for the Schema class. Binds the declared fields to
     a ``_declared_fields`` attribute, which is a dictionary mapping attribute
     names to field objects. Also sets the ``opts`` class attribute, which is
-    the Schema class's ``class Meta`` options.
+    the Schema class's `class Meta <marshmallow.Schema.Meta>` options.
     """
 
-    def __new__(mcs, name, bases, attrs):
+    Meta: type
+    opts: typing.Any
+    OPTIONS_CLASS: type
+    _declared_fields: dict[str, Field]
+
+    def __new__(
+        mcs,  # noqa: N804
+        name: str,
+        bases: tuple[type, ...],
+        attrs: dict[str, typing.Any],
+    ) -> SchemaMeta:
         meta = attrs.get("Meta")
         ordered = getattr(meta, "ordered", False)
         if not ordered:
@@ -112,7 +131,7 @@ class SchemaMeta(ABCMeta):
         cls_fields += list(klass.opts.include.items())
 
         # Assign _declared_fields on class
-        klass._declared_fields = mcs.get_declared_fields(
+        klass._declared_fields = mcs.get_declared_fields(  # noqa: SLF001
             klass=klass,
             cls_fields=cls_fields,
             inherited_fields=inherited_fields,
@@ -122,19 +141,19 @@ class SchemaMeta(ABCMeta):
 
     @classmethod
     def get_declared_fields(
-        mcs,
+        mcs,  # noqa: N804
         klass: SchemaMeta,
-        cls_fields: list[tuple[str, ma_fields.Field]],
-        inherited_fields: list[tuple[str, ma_fields.Field]],
+        cls_fields: list[tuple[str, Field]],
+        inherited_fields: list[tuple[str, Field]],
         dict_cls: type[dict] = dict,
-    ) -> dict[str, ma_fields.Field]:
+    ) -> dict[str, Field]:
         """Returns a dictionary of field_name => `Field` pairs declared on the class.
         This is exposed mainly so that plugins can add additional fields, e.g. fields
-        computed from class Meta options.
+        computed from `class Meta <marshmallow.Schema.Meta>` options.
 
         :param klass: The class object.
         :param cls_fields: The fields declared on the class, including those added
-            by the ``include`` class Meta option.
+            by the ``include`` `class Meta <marshmallow.Schema.Meta>` option.
         :param inherited_fields: Inherited fields.
         :param dict_cls: dict-like class to use for dict output Default to ``dict``.
         """
@@ -191,9 +210,9 @@ class SchemaMeta(ABCMeta):
 
 
 class SchemaOpts:
-    """class Meta options for the :class:`Schema`. Defines defaults."""
+    """Defines defaults for `marshmallow.Schema.Meta`."""
 
-    def __init__(self, meta, ordered: bool = False):
+    def __init__(self, meta: type, ordered: bool = False):  # noqa: FBT001, FBT002
         self.fields = getattr(meta, "fields", ())
         if not isinstance(self.fields, (list, tuple)):
             raise ValueError("`fields` option must be a list or tuple.")
@@ -202,8 +221,7 @@ class SchemaOpts:
             raise ValueError("`additional` option must be a list or tuple.")
         if self.fields and self.additional:
             raise ValueError(
-                "Cannot set both `fields` and `additional` options"
-                " for the same Schema."
+                "Cannot set both `fields` and `additional` options for the same Schema."
             )
         self.exclude = getattr(meta, "exclude", ())
         if not isinstance(self.exclude, (list, tuple)):
@@ -221,6 +239,14 @@ class SchemaOpts:
         else:
             render_module = json
         self.render_module = getattr(meta, "render_module", render_module)
+        if hasattr(meta, "ordered"):
+            warnings.warn(
+                "The `ordered` `class Meta` option is deprecated. "
+                "Field order is already preserved by default. "
+                "Set `Schema.dict_class` to OrderedDict to maintain the previous behavior.",
+                RemovedInMarshmallow4Warning,
+                stacklevel=2,
+            )
         self.ordered = getattr(meta, "ordered", ordered)
         self.index_errors = getattr(meta, "index_errors", True)
         self.include = getattr(meta, "include", {})
@@ -232,7 +258,7 @@ class SchemaOpts:
 
 
 class Schema(base.SchemaABC, metaclass=SchemaMeta):
-    """Base schema class with which to define custom schemas.
+    """Base schema class with which to define schemas.
 
     Example usage:
 
@@ -284,7 +310,7 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
         `prefix` parameter removed.
     """
 
-    TYPE_MAPPING: dict[type, type[ma_fields.Field]] = {
+    TYPE_MAPPING: dict[type, type[Field]] = {
         str: ma_fields.String,
         bytes: ma_fields.String,
         dt.datetime: ma_fields.DateTime,
@@ -314,7 +340,7 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
 
     # These get set by SchemaMeta
     opts: typing.Any
-    _declared_fields: dict[str, ma_fields.Field] = {}
+    _declared_fields: dict[str, Field] = {}
     _hooks: dict[str, list[tuple[str, bool, dict]]] = {}
 
     class Meta:
@@ -322,39 +348,87 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
 
         Example usage: ::
 
-            class Meta:
-                fields = ("id", "email", "date_created")
-                exclude = ("password", "secret_attribute")
-
-        Available options:
-
-        - ``fields``: Tuple or list of fields to include in the serialized result.
-        - ``additional``: Tuple or list of fields to include *in addition* to the
-            explicitly declared fields. ``additional`` and ``fields`` are
-            mutually-exclusive options.
-        - ``include``: Dictionary of additional fields to include in the schema. It is
-            usually better to define fields as class variables, but you may need to
-            use this option, e.g., if your fields are Python keywords. May be an
-            `OrderedDict`.
-        - ``exclude``: Tuple or list of fields to exclude in the serialized result.
-            Nested fields can be represented with dot delimiters.
-        - ``many``: Whether the data is a collection by default.
-        - ``dateformat``: Default format for `Date <fields.Date>` fields.
-        - ``datetimeformat``: Default format for `DateTime <fields.DateTime>` fields.
-        - ``timeformat``: Default format for `Time <fields.Time>` fields.
-        - ``render_module``: Module to use for `loads <Schema.loads>` and `dumps <Schema.dumps>`.
-            Defaults to `json` from the standard library.
-        - ``ordered``: If `True`, output of `Schema.dump <marshmallow.Schema.dump>` will be a `collections.OrderedDict`.
-        - ``index_errors``: If `True`, errors dictionaries will include the index
-            of invalid items in a collection.
-        - ``load_only``: Tuple or list of fields to exclude from serialized results.
-        - ``dump_only``: Tuple or list of fields to exclude from deserialization
-        - ``unknown``: Whether to exclude, include, or raise an error for unknown
-            fields in the data. Use `EXCLUDE`, `INCLUDE` or `RAISE`.
-        - ``register``: Whether to register the `Schema <marshmallow.Schema>` with marshmallow's internal
-            class registry. Must be `True` if you intend to refer to this `Schema <marshmallow.Schema>`
-            by class name in `Nested` fields. Only set this to `False` when memory
-            usage is critical. Defaults to `True`.
+            from marshmallow import Schema
+
+
+            class MySchema(Schema):
+                class Meta:
+                    fields = ("id", "email", "date_created")
+                    exclude = ("password", "secret_attribute")
+
+        .. admonition:: A note on type checking
+
+            Type checkers will only check the attributes of the `Meta <marshmallow.Schema.Meta>`
+            class if you explicitly subclass `marshmallow.Schema.Meta`.
+
+            .. code-block:: python
+
+                from marshmallow import Schema
+
+
+                class MySchema(Schema):
+                    # Not checked by type checkers
+                    class Meta:
+                        additional = True
+
+
+                class MySchema2(Schema):
+                    # Type checkers will check attributes
+                    class Meta(Schema.Opts):
+                        additional = True  # Incompatible types in assignment
+
+        .. versionremoved:: 3.0.0b7 Remove ``strict``.
+        .. versionadded:: 3.0.0b12 Add `unknown`.
+        .. versionchanged:: 3.0.0b17 Rename ``dateformat`` to `datetimeformat`.
+        .. versionadded:: 3.9.0 Add `timeformat`.
+        .. versionchanged:: 3.26.0 Deprecate `ordered`. Field order is preserved by default.
+        """
+
+        fields: typing.ClassVar[tuple[Field] | list[Field]]
+        """Fields to include in the (de)serialized result"""
+        additional: typing.ClassVar[tuple[Field] | list[Field]]
+        """Fields to include in addition to the explicitly declared fields.
+        `additional <marshmallow.Schema.Meta.additional>` and `fields <marshmallow.Schema.Meta.fields>`
+        are mutually-exclusive options.
+        """
+        include: typing.ClassVar[dict[str, Field]]
+        """Dictionary of additional fields to include in the schema. It is
+        usually better to define fields as class variables, but you may need to
+        use this option, e.g., if your fields are Python keywords.
+        """
+        exclude: typing.ClassVar[tuple[Field] | list[Field]]
+        """Fields to exclude in the serialized result.
+        Nested fields can be represented with dot delimiters.
+        """
+        many: typing.ClassVar[bool]
+        """Whether data should be (de)serialized as a collection by default."""
+        dateformat: typing.ClassVar[str]
+        """Default format for `Date <marshmallow.fields.Date>` fields."""
+        datetimeformat: typing.ClassVar[str]
+        """Default format for `DateTime <marshmallow.fields.DateTime>` fields."""
+        timeformat: typing.ClassVar[str]
+        """Default format for `Time <marshmallow.fields.Time>` fields."""
+        render_module: typing.ClassVar[types.RenderModule]
+        """ Module to use for `loads <marshmallow.Schema.loads>` and `dumps <marshmallow.Schema.dumps>`.
+        Defaults to `json` from the standard library.
+        """
+        ordered: typing.ClassVar[bool]
+        """If `True`, `Schema.dump <marshmallow.Schema.dump>` is a `collections.OrderedDict`."""
+        index_errors: typing.ClassVar[bool]
+        """If `True`, errors dictionaries will include the index of invalid items in a collection."""
+        load_only: typing.ClassVar[tuple[Field] | list[Field]]
+        """Fields to exclude from serialized results"""
+        dump_only: typing.ClassVar[tuple[Field] | list[Field]]
+        """Fields to exclude from serialized results"""
+        unknown: typing.ClassVar[str]
+        """Whether to exclude, include, or raise an error for unknown fields in the data.
+        Use `EXCLUDE`, `INCLUDE` or `RAISE`.
+        """
+        register: typing.ClassVar[bool]
+        """Whether to register the `Schema <marshmallow.Schema>` with marshmallow's internal
+        class registry. Must be `True` if you intend to refer to this `Schema <marshmallow.Schema>`
+        by class name in `Nested` fields. Only set this to `False` when memory
+        usage is critical. Defaults to `True`.
         """
 
     def __init__(
@@ -400,9 +474,9 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
         self.context = context or {}
         self._normalize_nested_options()
         #: Dictionary mapping field_names -> :class:`Field` objects
-        self.fields: dict[str, ma_fields.Field] = {}
-        self.load_fields: dict[str, ma_fields.Field] = {}
-        self.dump_fields: dict[str, ma_fields.Field] = {}
+        self.fields: dict[str, Field] = {}
+        self.load_fields: dict[str, Field] = {}
+        self.dump_fields: dict[str, Field] = {}
         self._init_fields()
         messages = {}
         messages.update(self._default_error_messages)
@@ -416,15 +490,15 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
 
     @property
     def dict_class(self) -> type[dict]:
+        """`dict` type to return when serializing."""
         if self.ordered:
             return OrderedDict
-        else:
-            return dict
+        return dict
 
     @classmethod
     def from_dict(
         cls,
-        fields: dict[str, ma_fields.Field],
+        fields: dict[str, Field],
         *,
         name: str = "GeneratedSchema",
     ) -> type[Schema]:
@@ -440,8 +514,9 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
         Generated schemas are not added to the class registry and therefore cannot
         be referred to by name in `Nested` fields.
 
-        :param dict fields: Dictionary mapping field names to field instances.
-        :param str name: Optional name for the class, which will appear in
+
+        :param fields: Dictionary mapping field names to field instances.
+        :param name: Optional name for the class, which will appear in
             the ``repr`` for the class.
 
         .. versionadded:: 3.0.0
@@ -449,8 +524,7 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
         Meta = type(
             "GeneratedMeta", (getattr(cls, "Meta", object),), {"register": False}
         )
-        schema_cls = type(name, (cls,), {**fields.copy(), "Meta": Meta})
-        return schema_cls
+        return type(name, (cls,), {**fields.copy(), "Meta": Meta})
 
     ##### Override-able methods #####
 
@@ -467,7 +541,6 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
         .. versionchanged:: 3.0.0rc9
             Receives `many` and `partial` (on deserialization) as keyword arguments.
         """
-        pass
 
     def get_attribute(self, obj: typing.Any, attr: str, default: typing.Any):
         """Defines how to pull values from an object to serialize.
@@ -483,11 +556,11 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
     def _call_and_store(getter_func, data, *, field_name, error_store, index=None):
         """Call ``getter_func`` with ``data`` as its argument, and store any `ValidationErrors`.
 
-        :param callable getter_func: Function for getting the serialized/deserialized
+        :param getter_func: Function for getting the serialized/deserialized
             value from ``data``.
         :param data: The data passed to ``getter_func``.
-        :param str field_name: Field name.
-        :param int index: Index of the item being validated, if validating a collection,
+        :param field_name: Field name.
+        :param index: Index of the item being validated, if validating a collection,
             otherwise `None`.
         """
         try:
@@ -503,7 +576,7 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
         """Serialize ``obj``.
 
         :param obj: The object(s) to serialize.
-        :param bool many: `True` if ``data`` should be serialized as a collection.
+        :param many: `True` if ``data`` should be serialized as a collection.
         :return: A dictionary of the serialized data
         """
         if many and obj is not None:
@@ -583,16 +656,16 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
     ) -> typing.Any | list[typing.Any]:
         """Deserialize ``data``.
 
-        :param dict data: The data to deserialize.
-        :param ErrorStore error_store: Structure to store errors.
-        :param bool many: `True` if ``data`` should be deserialized as a collection.
-        :param bool|tuple partial: Whether to ignore missing fields and not require
+        :param data: The data to deserialize.
+        :param error_store: Structure to store errors.
+        :param many: `True` if ``data`` should be deserialized as a collection.
+        :param partial: Whether to ignore missing fields and not require
             any fields declared. Propagates down to ``Nested`` fields as well. If
             its value is an iterable, only missing fields listed in that iterable
             will be ignored. Use dot delimiters to specify nested fields.
         :param unknown: Whether to exclude, include, or raise an error for unknown
             fields in the data. Use `EXCLUDE`, `INCLUDE` or `RAISE`.
-        :param int index: Index of the item being serialized (for storing errors) if
+        :param index: Index of the item being serialized (for storing errors) if
             serializing a collection, otherwise `None`.
         :return: The deserialized data as `dict_class` instance or list of `dict_class`
         instances if `many` is `True`.
@@ -719,16 +792,17 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
 
     def loads(
         self,
-        json_data: str,
+        json_data: str | bytes | bytearray,
         *,
         many: bool | None = None,
         partial: bool | types.StrSequenceOrSet | None = None,
         unknown: str | None = None,
         **kwargs,
     ):
-        """Same as :meth:`load`, except it takes a JSON string as input.
+        """Same as :meth:`load`, except it uses `marshmallow.Schema.Meta.render_module` to deserialize
+        the passed string before passing data to :meth:`load`.
 
-        :param json_data: A JSON string of the data to deserialize.
+        :param json_data: A string of the data to deserialize.
         :param many: Whether to deserialize `obj` as a collection. If `None`, the
             value for `self.many` is used.
         :param partial: Whether to ignore missing fields and not require
@@ -751,15 +825,15 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
 
     def _run_validator(
         self,
-        validator_func,
+        validator_func: types.SchemaValidator,
         output,
         *,
         original_data,
-        error_store,
-        many,
-        partial,
-        pass_original,
-        index=None,
+        error_store: ErrorStore,
+        many: bool,
+        partial: bool | types.StrSequenceOrSet | None,
+        pass_original: bool,
+        index: int | None = None,
     ):
         try:
             if pass_original:  # Pass original, raw data (before unmarshalling)
@@ -767,7 +841,26 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
             else:
                 validator_func(output, partial=partial, many=many)
         except ValidationError as err:
-            error_store.store_error(err.messages, err.field_name, index=index)
+            field_name = err.field_name
+            data_key: str
+            if field_name == SCHEMA:
+                data_key = SCHEMA
+            else:
+                field_obj: Field | None = None
+                try:
+                    field_obj = self.fields[field_name]
+                except KeyError:
+                    if field_name in self.declared_fields:
+                        field_obj = self.declared_fields[field_name]
+                if field_obj:
+                    data_key = (
+                        field_obj.data_key
+                        if field_obj.data_key is not None
+                        else field_name
+                    )
+                else:
+                    data_key = field_name
+            error_store.store_error(err.messages, data_key, index=index)
 
     def validate(
         self,
@@ -1015,26 +1108,26 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
         self.dump_fields = dump_fields
         self.load_fields = load_fields
 
-    def on_bind_field(self, field_name: str, field_obj: ma_fields.Field) -> None:
+    def on_bind_field(self, field_name: str, field_obj: Field) -> None:
         """Hook to modify a field when it is bound to the `Schema <marshmallow.Schema>`.
 
         No-op by default.
         """
-        return None
+        return
 
-    def _bind_field(self, field_name: str, field_obj: ma_fields.Field) -> None:
+    def _bind_field(self, field_name: str, field_obj: Field) -> None:
         """Bind field to the schema, setting any necessary attributes on the
         field (e.g. parent and name).
 
         Also set field load_only and dump_only values if field_name was
-        specified in ``class Meta``.
+        specified in `class Meta <marshmallow.Schema.Meta>`.
         """
         if field_name in self.load_only:
             field_obj.load_only = True
         if field_name in self.dump_only:
             field_obj.dump_only = True
         try:
-            field_obj._bind_to_schema(field_name, self)
+            field_obj._bind_to_schema(field_name, self)  # noqa: SLF001
         except TypeError as error:
             # Field declared as a class, not an instance. Ignore type checking because
             # we handle unsupported arg types, i.e. this is dead code from
@@ -1043,10 +1136,10 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
                 msg = (
                     f'Field for "{field_name}" must be declared as a '
                     "Field instance, not a class. "
-                    f'Did you mean "fields.{field_obj.__name__}()"?'  # type: ignore
+                    f'Did you mean "fields.{field_obj.__name__}()"?'  # type: ignore[attr-defined]
                 )
                 raise TypeError(msg) from error
-            raise error
+            raise
         self.on_bind_field(field_name, field_obj)
 
     def _invoke_dump_processors(
@@ -1058,10 +1151,9 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
         data = self._invoke_processors(
             tag, pass_many=False, data=data, many=many, original_data=original_data
         )
-        data = self._invoke_processors(
+        return self._invoke_processors(
             tag, pass_many=True, data=data, many=many, original_data=original_data
         )
-        return data
 
     def _invoke_load_processors(
         self,
@@ -1082,7 +1174,7 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
             original_data=original_data,
             partial=partial,
         )
-        data = self._invoke_processors(
+        return self._invoke_processors(
             tag,
             pass_many=False,
             data=data,
@@ -1090,7 +1182,6 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
             original_data=original_data,
             partial=partial,
         )
-        return data
 
     def _invoke_field_validators(self, *, error_store: ErrorStore, data, many: bool):
         for attr_name, _, validator_kwargs in self._hooks[VALIDATES]:
@@ -1122,7 +1213,7 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
                             index=(idx if self.opts.index_errors else None),
                         )
                         if validated_value is missing:
-                            data[idx].pop(field_name, None)
+                            item.pop(field_name, None)
             else:
                 try:
                     value = data[field_obj.attribute or field_name]
@@ -1201,15 +1292,14 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
                 if pass_original:
                     data = [
                         processor(item, original, many=many, **kwargs)
-                        for item, original in zip(data, original_data)
+                        for item, original in zip_longest(data, original_data)
                     ]
                 else:
                     data = [processor(item, many=many, **kwargs) for item in data]
+            elif pass_original:
+                data = processor(data, original_data, many=many, **kwargs)
             else:
-                if pass_original:
-                    data = processor(data, original_data, many=many, **kwargs)
-                else:
-                    data = processor(data, many=many, **kwargs)
+                data = processor(data, many=many, **kwargs)
         return data
 
 

marshmallow/types.py

@@ -5,7 +5,36 @@
     This module is provisional. Types may be modified, added, and removed between minor releases.
 """
 
+from __future__ import annotations
+
 import typing
 
+#: A type that can be either a sequence of strings or a set of strings
 StrSequenceOrSet = typing.Union[typing.Sequence[str], typing.AbstractSet[str]]
+
+#: Type for validator functions
 Validator = typing.Callable[[typing.Any], typing.Any]
+
+
+class SchemaValidator(typing.Protocol):
+    def __call__(
+        self,
+        output: typing.Any,
+        original_data: typing.Any = ...,
+        *,
+        partial: bool | StrSequenceOrSet | None = None,
+        many: bool = False,
+    ) -> None: ...
+
+
+class RenderModule(typing.Protocol):
+    def dumps(
+        self, obj: typing.Any, *args: typing.Any, **kwargs: typing.Any
+    ) -> str: ...
+
+    def loads(
+        self,
+        json_data: str | bytes | bytearray,
+        *args: typing.Any,
+        **kwargs: typing.Any,
+    ) -> typing.Any: ...