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

marshmallow/schema.py

@@ -1,5 +1,6 @@
 """The `Schema <marshmallow.Schema>` class, including its metaclass and options (`class Meta <marshmallow.Schema.Meta>`)."""
 
+# ruff: noqa: SLF001
 from __future__ import annotations
 
 import copy
@@ -11,14 +12,14 @@ 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 collections import defaultdict
+from collections.abc import Mapping, Sequence
 from itertools import zip_longest
 
-from marshmallow import base, class_registry, types
+from marshmallow import class_registry, types
 from marshmallow import fields as ma_fields
+from marshmallow.constants import EXCLUDE, INCLUDE, RAISE, missing
 from marshmallow.decorators import (
     POST_DUMP,
     POST_LOAD,
@@ -31,17 +32,11 @@ from marshmallow.error_store import ErrorStore
 from marshmallow.exceptions import SCHEMA, StringNotCollectionError, ValidationError
 from marshmallow.orderedset import OrderedSet
 from marshmallow.utils import (
-    EXCLUDE,
-    INCLUDE,
-    RAISE,
     get_value,
     is_collection,
-    is_instance_or_subclass,
-    missing,
+    is_sequence_but_not_string,
     set_value,
-    validate_unknown_parameter_value,
 )
-from marshmallow.warnings import RemovedInMarshmallow4Warning
 
 if typing.TYPE_CHECKING:
     from marshmallow.fields import Field
@@ -52,11 +47,17 @@ def _get_fields(attrs) -> list[tuple[str, Field]]:
 
     :param attrs: Mapping of class attributes
     """
-    return [
-        (field_name, field_value)
-        for field_name, field_value in attrs.items()
-        if is_instance_or_subclass(field_value, base.FieldABC)
-    ]
+    ret = []
+    for field_name, field_value in attrs.items():
+        if isinstance(field_value, type) and issubclass(field_value, ma_fields.Field):
+            raise TypeError(
+                f'Field for "{field_name}" must be declared as a '
+                "Field instance, not a class. "
+                f'Did you mean "fields.{field_value.__name__}()"?'
+            )
+        if isinstance(field_value, ma_fields.Field):
+            ret.append((field_name, field_value))
+    return ret
 
 
 # This function allows Schemas to inherit from non-Schema classes and ensures
@@ -97,24 +98,12 @@ class SchemaMeta(ABCMeta):
     _declared_fields: dict[str, Field]
 
     def __new__(
-        mcs,  # noqa: N804
+        mcs,
         name: str,
         bases: tuple[type, ...],
         attrs: dict[str, typing.Any],
     ) -> SchemaMeta:
         meta = attrs.get("Meta")
-        ordered = getattr(meta, "ordered", False)
-        if not ordered:
-            # Inherit 'ordered' option
-            # Warning: We loop through bases instead of MRO because we don't
-            # yet have access to the class object
-            # (i.e. can't call super before we have fields)
-            for base_ in bases:
-                if hasattr(base_, "Meta") and hasattr(base_.Meta, "ordered"):
-                    ordered = base_.Meta.ordered
-                    break
-            else:
-                ordered = False
         cls_fields = _get_fields(attrs)
         # Remove fields from list of class attributes to avoid shadowing
         # Schema attributes/methods in case of name conflict
@@ -126,12 +115,12 @@ class SchemaMeta(ABCMeta):
         meta = klass.Meta
         # Set klass.opts in __new__ rather than __init__ so that it is accessible in
         # get_declared_fields
-        klass.opts = klass.OPTIONS_CLASS(meta, ordered=ordered)
+        klass.opts = klass.OPTIONS_CLASS(meta)
         # Add fields specified in the `include` class Meta option
         cls_fields += list(klass.opts.include.items())
 
         # Assign _declared_fields on class
-        klass._declared_fields = mcs.get_declared_fields(  # noqa: SLF001
+        klass._declared_fields = mcs.get_declared_fields(
             klass=klass,
             cls_fields=cls_fields,
             inherited_fields=inherited_fields,
@@ -212,52 +201,27 @@ class SchemaMeta(ABCMeta):
 class SchemaOpts:
     """Defines defaults for `marshmallow.Schema.Meta`."""
 
-    def __init__(self, meta: type, ordered: bool = False):  # noqa: FBT001, FBT002
+    def __init__(self, meta: type):
         self.fields = getattr(meta, "fields", ())
         if not isinstance(self.fields, (list, tuple)):
             raise ValueError("`fields` option must be a list or tuple.")
-        self.additional = getattr(meta, "additional", ())
-        if not isinstance(self.additional, (list, tuple)):
-            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."
-            )
         self.exclude = getattr(meta, "exclude", ())
         if not isinstance(self.exclude, (list, tuple)):
             raise ValueError("`exclude` must be a list or tuple.")
         self.dateformat = getattr(meta, "dateformat", None)
         self.datetimeformat = getattr(meta, "datetimeformat", None)
         self.timeformat = getattr(meta, "timeformat", None)
-        if hasattr(meta, "json_module"):
-            warnings.warn(
-                "The json_module class Meta option is deprecated. Use render_module instead.",
-                RemovedInMarshmallow4Warning,
-                stacklevel=2,
-            )
-            render_module = getattr(meta, "json_module", json)
-        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.render_module = getattr(meta, "render_module", json)
         self.index_errors = getattr(meta, "index_errors", True)
         self.include = getattr(meta, "include", {})
         self.load_only = getattr(meta, "load_only", ())
         self.dump_only = getattr(meta, "dump_only", ())
-        self.unknown = validate_unknown_parameter_value(getattr(meta, "unknown", RAISE))
+        self.unknown = getattr(meta, "unknown", RAISE)
         self.register = getattr(meta, "register", True)
         self.many = getattr(meta, "many", False)
 
 
-class Schema(base.SchemaABC, metaclass=SchemaMeta):
+class Schema(metaclass=SchemaMeta):
     """Base schema class with which to define schemas.
 
     Example usage:
@@ -295,8 +259,6 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
         delimiters.
     :param many: Should be set to `True` if ``obj`` is a collection
         so that the object will be serialized to a list.
-    :param context: Optional context passed to :class:`fields.Method` and
-        :class:`fields.Function` fields.
     :param load_only: Fields to skip during serialization (write-only fields)
     :param dump_only: Fields to skip during deserialization (read-only fields)
     :param partial: Whether to ignore missing fields and not require
@@ -307,7 +269,10 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
         fields in the data. Use `EXCLUDE`, `INCLUDE` or `RAISE`.
 
     .. versionchanged:: 3.0.0
-        `prefix` parameter removed.
+        Remove ``prefix`` parameter.
+
+    .. versionchanged:: 4.0.0
+        Remove ``context`` parameter.
     """
 
     TYPE_MAPPING: dict[type, type[Field]] = {
@@ -337,6 +302,8 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
     OPTIONS_CLASS: type = SchemaOpts
 
     set_class = OrderedSet
+    dict_class: type[dict] = dict
+    """`dict` type to return when serializing."""
 
     # These get set by SchemaMeta
     opts: typing.Any
@@ -381,12 +348,13 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
         .. 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.
+        .. versionchanged:: 3.26.0 Deprecate ``ordered``. Field order is preserved by default.
+        .. versionremoved:: 4.0.0 Remove ``ordered``.
         """
 
-        fields: typing.ClassVar[tuple[Field] | list[Field]]
+        fields: typing.ClassVar[tuple[str, ...] | list[str]]
         """Fields to include in the (de)serialized result"""
-        additional: typing.ClassVar[tuple[Field] | list[Field]]
+        additional: typing.ClassVar[tuple[str, ...] | list[str]]
         """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.
@@ -396,7 +364,7 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
         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]]
+        exclude: typing.ClassVar[tuple[str, ...] | list[str]]
         """Fields to exclude in the serialized result.
         Nested fields can be represented with dot delimiters.
         """
@@ -408,19 +376,20 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
         """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]
+
+        # FIXME: Use a more constrained type here.
+        # ClassVar[RenderModule] doesn't work.
+        render_module: typing.Any
         """ 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]]
+        load_only: typing.ClassVar[tuple[str, ...] | list[str]]
         """Fields to exclude from serialized results"""
-        dump_only: typing.ClassVar[tuple[Field] | list[Field]]
+        dump_only: typing.ClassVar[tuple[str, ...] | list[str]]
         """Fields to exclude from serialized results"""
-        unknown: typing.ClassVar[str]
+        unknown: typing.ClassVar[types.UnknownOption]
         """Whether to exclude, include, or raise an error for unknown fields in the data.
         Use `EXCLUDE`, `INCLUDE` or `RAISE`.
         """
@@ -437,11 +406,10 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
         only: types.StrSequenceOrSet | None = None,
         exclude: types.StrSequenceOrSet = (),
         many: bool | None = None,
-        context: dict | None = None,
         load_only: types.StrSequenceOrSet = (),
         dump_only: types.StrSequenceOrSet = (),
         partial: bool | types.StrSequenceOrSet | None = None,
-        unknown: str | None = None,
+        unknown: types.UnknownOption | None = None,
     ):
         # Raise error if only or exclude is passed as string, not list of strings
         if only is not None and not is_collection(only):
@@ -455,23 +423,12 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
         self.exclude: set[typing.Any] | typing.MutableSet[typing.Any] = set(
             self.opts.exclude
         ) | set(exclude)
-        self.ordered = self.opts.ordered
         self.load_only = set(load_only) or set(self.opts.load_only)
         self.dump_only = set(dump_only) or set(self.opts.dump_only)
         self.partial = partial
-        self.unknown = (
-            self.opts.unknown
-            if unknown is None
-            else validate_unknown_parameter_value(unknown)
+        self.unknown: types.UnknownOption = (
+            self.opts.unknown if unknown is None else unknown
         )
-        if context:
-            warnings.warn(
-                "The `context` parameter is deprecated and will be removed in marshmallow 4.0. "
-                "Use `contextvars.ContextVar` to pass context instead.",
-                RemovedInMarshmallow4Warning,
-                stacklevel=2,
-            )
-        self.context = context or {}
         self._normalize_nested_options()
         #: Dictionary mapping field_names -> :class:`Field` objects
         self.fields: dict[str, Field] = {}
@@ -488,13 +445,6 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
     def __repr__(self) -> str:
         return f"<{self.__class__.__name__}(many={self.many})>"
 
-    @property
-    def dict_class(self) -> type[dict]:
-        """`dict` type to return when serializing."""
-        if self.ordered:
-            return OrderedDict
-        return dict
-
     @classmethod
     def from_dict(
         cls,
@@ -599,7 +549,6 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
             for `self.many` is used.
         :return: Serialized data
 
-        .. versionadded:: 1.0.0
         .. versionchanged:: 3.0.0b7
             This method returns the serialized data rather than a ``(data, errors)`` duple.
             A :exc:`ValidationError <marshmallow.exceptions.ValidationError>` is raised
@@ -632,7 +581,6 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
             for `self.many` is used.
         :return: A ``json`` string
 
-        .. versionadded:: 1.0.0
         .. versionchanged:: 3.0.0b7
             This method returns the serialized data rather than a ``(data, errors)`` duple.
             A :exc:`ValidationError <marshmallow.exceptions.ValidationError>` is raised
@@ -643,15 +591,12 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
 
     def _deserialize(
         self,
-        data: (
-            typing.Mapping[str, typing.Any]
-            | typing.Iterable[typing.Mapping[str, typing.Any]]
-        ),
+        data: Mapping[str, typing.Any] | Sequence[Mapping[str, typing.Any]],
         *,
         error_store: ErrorStore,
         many: bool = False,
         partial=None,
-        unknown=RAISE,
+        unknown: types.UnknownOption = RAISE,
         index=None,
     ) -> typing.Any | list[typing.Any]:
         """Deserialize ``data``.
@@ -673,13 +618,13 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
         index_errors = self.opts.index_errors
         index = index if index_errors else None
         if many:
-            if not is_collection(data):
+            if not is_sequence_but_not_string(data):
                 error_store.store_error([self.error_messages["type"]], index=index)
                 ret_l = []
             else:
                 ret_l = [
                     self._deserialize(
-                        typing.cast(dict, d),
+                        d,
                         error_store=error_store,
                         many=False,
                         partial=partial,
@@ -757,14 +702,11 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
 
     def load(
         self,
-        data: (
-            typing.Mapping[str, typing.Any]
-            | typing.Iterable[typing.Mapping[str, typing.Any]]
-        ),
+        data: Mapping[str, typing.Any] | Sequence[Mapping[str, typing.Any]],
         *,
         many: bool | None = None,
         partial: bool | types.StrSequenceOrSet | None = None,
-        unknown: str | None = None,
+        unknown: types.UnknownOption | None = None,
     ):
         """Deserialize a data structure to an object defined by this Schema's fields.
 
@@ -780,7 +722,6 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
             If `None`, the value for `self.unknown` is used.
         :return: Deserialized data
 
-        .. versionadded:: 1.0.0
         .. versionchanged:: 3.0.0b7
             This method returns the deserialized data rather than a ``(data, errors)`` duple.
             A :exc:`ValidationError <marshmallow.exceptions.ValidationError>` is raised
@@ -792,17 +733,18 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
 
     def loads(
         self,
-        json_data: str | bytes | bytearray,
+        s: str | bytes | bytearray,
+        /,
         *,
         many: bool | None = None,
         partial: bool | types.StrSequenceOrSet | None = None,
-        unknown: str | None = None,
+        unknown: types.UnknownOption | None = None,
         **kwargs,
     ):
         """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 string of the data to deserialize.
+        :param s: 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
@@ -814,13 +756,14 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
             If `None`, the value for `self.unknown` is used.
         :return: Deserialized data
 
-        .. versionadded:: 1.0.0
         .. versionchanged:: 3.0.0b7
             This method returns the deserialized data rather than a ``(data, errors)`` duple.
             A :exc:`ValidationError <marshmallow.exceptions.ValidationError>` is raised
             if invalid data are passed.
+        .. versionchanged:: 4.0.0
+            Rename ``json_module`` parameter to ``s``.
         """
-        data = self.opts.render_module.loads(json_data, **kwargs)
+        data = self.opts.render_module.loads(s, **kwargs)
         return self.load(data, many=many, partial=partial, unknown=unknown)
 
     def _run_validator(
@@ -832,14 +775,17 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
         error_store: ErrorStore,
         many: bool,
         partial: bool | types.StrSequenceOrSet | None,
+        unknown: types.UnknownOption | None,
         pass_original: bool,
         index: int | None = None,
     ):
         try:
             if pass_original:  # Pass original, raw data (before unmarshalling)
-                validator_func(output, original_data, partial=partial, many=many)
+                validator_func(
+                    output, original_data, partial=partial, many=many, unknown=unknown
+                )
             else:
-                validator_func(output, partial=partial, many=many)
+                validator_func(output, partial=partial, many=many, unknown=unknown)
         except ValidationError as err:
             field_name = err.field_name
             data_key: str
@@ -864,10 +810,7 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
 
     def validate(
         self,
-        data: (
-            typing.Mapping[str, typing.Any]
-            | typing.Iterable[typing.Mapping[str, typing.Any]]
-        ),
+        data: Mapping[str, typing.Any] | Sequence[Mapping[str, typing.Any]],
         *,
         many: bool | None = None,
         partial: bool | types.StrSequenceOrSet | None = None,
@@ -883,27 +826,22 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
             its value is an iterable, only missing fields listed in that iterable
             will be ignored. Use dot delimiters to specify nested fields.
         :return: A dictionary of validation errors.
-
-        .. versionadded:: 1.1.0
         """
         try:
             self._do_load(data, many=many, partial=partial, postprocess=False)
         except ValidationError as exc:
-            return typing.cast(dict[str, list[str]], exc.messages)
+            return typing.cast("dict[str, list[str]]", exc.messages)
         return {}
 
     ##### Private Helpers #####
 
     def _do_load(
         self,
-        data: (
-            typing.Mapping[str, typing.Any]
-            | typing.Iterable[typing.Mapping[str, typing.Any]]
-        ),
+        data: (Mapping[str, typing.Any] | Sequence[Mapping[str, typing.Any]]),
         *,
         many: bool | None = None,
         partial: bool | types.StrSequenceOrSet | None = None,
-        unknown: str | None = None,
+        unknown: types.UnknownOption | None = None,
         postprocess: bool = True,
     ):
         """Deserialize `data`, returning the deserialized result.
@@ -925,18 +863,19 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
         error_store = ErrorStore()
         errors: dict[str, list[str]] = {}
         many = self.many if many is None else bool(many)
-        unknown = (
-            self.unknown
-            if unknown is None
-            else validate_unknown_parameter_value(unknown)
-        )
+        unknown = self.unknown if unknown is None else unknown
         if partial is None:
             partial = self.partial
         # Run preprocessors
         if self._hooks[PRE_LOAD]:
             try:
                 processed_data = self._invoke_load_processors(
-                    PRE_LOAD, data, many=many, original_data=data, partial=partial
+                    PRE_LOAD,
+                    data,
+                    many=many,
+                    original_data=data,
+                    partial=partial,
+                    unknown=unknown,
                 )
             except ValidationError as err:
                 errors = err.normalized_messages()
@@ -961,20 +900,22 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
                 field_errors = bool(error_store.errors)
                 self._invoke_schema_validators(
                     error_store=error_store,
-                    pass_many=True,
+                    pass_collection=True,
                     data=result,
                     original_data=data,
                     many=many,
                     partial=partial,
+                    unknown=unknown,
                     field_errors=field_errors,
                 )
                 self._invoke_schema_validators(
                     error_store=error_store,
-                    pass_many=False,
+                    pass_collection=False,
                     data=result,
                     original_data=data,
                     many=many,
                     partial=partial,
+                    unknown=unknown,
                     field_errors=field_errors,
                 )
             errors = error_store.errors
@@ -987,6 +928,7 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
                         many=many,
                         original_data=data,
                         partial=partial,
+                        unknown=unknown,
                     )
                 except ValidationError as err:
                     errors = err.normalized_messages()
@@ -1041,8 +983,6 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
             available_field_names = self.set_class(self.opts.fields)
         else:
             available_field_names = self.set_class(self.declared_fields.keys())
-            if self.opts.additional:
-                available_field_names |= self.set_class(self.opts.additional)
 
         invalid_fields = self.set_class()
 
@@ -1067,7 +1007,7 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
 
         fields_dict = self.dict_class()
         for field_name in field_names:
-            field_obj = self.declared_fields.get(field_name, ma_fields.Inferred())
+            field_obj = self.declared_fields[field_name]
             self._bind_field(field_name, field_obj)
             fields_dict[field_name] = field_obj
 
@@ -1126,129 +1066,128 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
             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)  # 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
-            # the type checker's perspective.
-            if isinstance(field_obj, type) and issubclass(field_obj, base.FieldABC):
-                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[attr-defined]
-                )
-                raise TypeError(msg) from error
-            raise
+        field_obj._bind_to_schema(field_name, self)
         self.on_bind_field(field_name, field_obj)
 
     def _invoke_dump_processors(
         self, tag: str, data, *, many: bool, original_data=None
     ):
-        # The pass_many post-dump processors may do things like add an envelope, so
-        # invoke those after invoking the non-pass_many processors which will expect
+        # The pass_collection post-dump processors may do things like add an envelope, so
+        # invoke those after invoking the non-pass_collection processors which will expect
         # to get a list of items.
         data = self._invoke_processors(
-            tag, pass_many=False, data=data, many=many, original_data=original_data
+            tag,
+            pass_collection=False,
+            data=data,
+            many=many,
+            original_data=original_data,
         )
         return self._invoke_processors(
-            tag, pass_many=True, data=data, many=many, original_data=original_data
+            tag, pass_collection=True, data=data, many=many, original_data=original_data
         )
 
     def _invoke_load_processors(
         self,
         tag: str,
-        data,
+        data: Mapping[str, typing.Any] | Sequence[Mapping[str, typing.Any]],
         *,
         many: bool,
         original_data,
         partial: bool | types.StrSequenceOrSet | None,
+        unknown: types.UnknownOption | None,
     ):
-        # This has to invert the order of the dump processors, so run the pass_many
+        # This has to invert the order of the dump processors, so run the pass_collection
         # processors first.
         data = self._invoke_processors(
             tag,
-            pass_many=True,
+            pass_collection=True,
             data=data,
             many=many,
             original_data=original_data,
             partial=partial,
+            unknown=unknown,
         )
         return self._invoke_processors(
             tag,
-            pass_many=False,
+            pass_collection=False,
             data=data,
             many=many,
             original_data=original_data,
             partial=partial,
+            unknown=unknown,
         )
 
     def _invoke_field_validators(self, *, error_store: ErrorStore, data, many: bool):
         for attr_name, _, validator_kwargs in self._hooks[VALIDATES]:
             validator = getattr(self, attr_name)
-            field_name = validator_kwargs["field_name"]
 
-            try:
-                field_obj = self.fields[field_name]
-            except KeyError as error:
-                if field_name in self.declared_fields:
-                    continue
-                raise ValueError(f'"{field_name}" field does not exist.') from error
+            field_names = validator_kwargs["field_names"]
 
-            data_key = (
-                field_obj.data_key if field_obj.data_key is not None else field_name
-            )
-            if many:
-                for idx, item in enumerate(data):
+            for field_name in field_names:
+                try:
+                    field_obj = self.fields[field_name]
+                except KeyError as error:
+                    if field_name in self.declared_fields:
+                        continue
+                    raise ValueError(f'"{field_name}" field does not exist.') from error
+
+                data_key = (
+                    field_obj.data_key if field_obj.data_key is not None else field_name
+                )
+                do_validate = functools.partial(validator, data_key=data_key)
+
+                if many:
+                    for idx, item in enumerate(data):
+                        try:
+                            value = item[field_obj.attribute or field_name]
+                        except KeyError:
+                            pass
+                        else:
+                            validated_value = self._call_and_store(
+                                getter_func=do_validate,
+                                data=value,
+                                field_name=data_key,
+                                error_store=error_store,
+                                index=(idx if self.opts.index_errors else None),
+                            )
+                            if validated_value is missing:
+                                item.pop(field_name, None)
+                else:
                     try:
-                        value = item[field_obj.attribute or field_name]
+                        value = data[field_obj.attribute or field_name]
                     except KeyError:
                         pass
                     else:
                         validated_value = self._call_and_store(
-                            getter_func=validator,
+                            getter_func=do_validate,
                             data=value,
                             field_name=data_key,
                             error_store=error_store,
-                            index=(idx if self.opts.index_errors else None),
                         )
                         if validated_value is missing:
-                            item.pop(field_name, None)
-            else:
-                try:
-                    value = data[field_obj.attribute or field_name]
-                except KeyError:
-                    pass
-                else:
-                    validated_value = self._call_and_store(
-                        getter_func=validator,
-                        data=value,
-                        field_name=data_key,
-                        error_store=error_store,
-                    )
-                    if validated_value is missing:
-                        data.pop(field_name, None)
+                            data.pop(field_name, None)
 
     def _invoke_schema_validators(
         self,
         *,
         error_store: ErrorStore,
-        pass_many: bool,
+        pass_collection: bool,
         data,
         original_data,
         many: bool,
         partial: bool | types.StrSequenceOrSet | None,
         field_errors: bool = False,
+        unknown: types.UnknownOption | None,
     ):
         for attr_name, hook_many, validator_kwargs in self._hooks[VALIDATES_SCHEMA]:
-            if hook_many != pass_many:
+            if hook_many != pass_collection:
                 continue
             validator = getattr(self, attr_name)
             if field_errors and validator_kwargs["skip_on_field_errors"]:
                 continue
             pass_original = validator_kwargs.get("pass_original", False)
 
-            if many and not pass_many:
+            if many and not pass_collection:
                 for idx, (item, orig) in enumerate(zip(data, original_data)):
                     self._run_validator(
                         validator,
@@ -1257,6 +1196,7 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
                         error_store=error_store,
                         many=many,
                         partial=partial,
+                        unknown=unknown,
                         index=idx,
                         pass_original=pass_original,
                     )
@@ -1269,26 +1209,27 @@ class Schema(base.SchemaABC, metaclass=SchemaMeta):
                     many=many,
                     pass_original=pass_original,
                     partial=partial,
+                    unknown=unknown,
                 )
 
     def _invoke_processors(
         self,
         tag: str,
         *,
-        pass_many: bool,
-        data,
+        pass_collection: bool,
+        data: Mapping[str, typing.Any] | Sequence[Mapping[str, typing.Any]],
         many: bool,
         original_data=None,
         **kwargs,
     ):
         for attr_name, hook_many, processor_kwargs in self._hooks[tag]:
-            if hook_many != pass_many:
+            if hook_many != pass_collection:
                 continue
             # This will be a bound method.
             processor = getattr(self, attr_name)
             pass_original = processor_kwargs.get("pass_original", False)
 
-            if many and not pass_many:
+            if many and not pass_collection:
                 if pass_original:
                     data = [
                         processor(item, original, many=many, **kwargs)