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

marshmallow/__init__.py

@@ -68,14 +68,14 @@ __all__ = [
     "RAISE",
     "Schema",
     "SchemaOpts",
+    "ValidationError",
     "fields",
-    "validates",
-    "validates_schema",
-    "pre_dump",
+    "missing",
     "post_dump",
-    "pre_load",
     "post_load",
     "pprint",
-    "ValidationError",
-    "missing",
+    "pre_dump",
+    "pre_load",
+    "validates",
+    "validates_schema",
 ]

marshmallow/class_registry.py

@@ -7,6 +7,7 @@ class:`fields.Nested <marshmallow.fields.Nested>`.
     This module is treated as private API.
     Users should not need to use this module directly.
 """
+# ruff: noqa: ERA001
 
 from __future__ import annotations
 
@@ -49,7 +50,7 @@ def register(classname: str, cls: SchemaType) -> None:
     module = cls.__module__
     # Full module path to the class
     # e.g. user.schemas.UserSchema
-    fullpath = ".".join([module, classname])
+    fullpath = f"{module}.{classname}"
     # If the class is already registered; need to check if the entries are
     # in the same module as cls to avoid having multiple instances of the same
     # class in the registry
@@ -66,18 +67,19 @@ def register(classname: str, cls: SchemaType) -> None:
     else:
         # If fullpath does exist, replace existing entry
         _registry[fullpath] = [cls]
-    return None
 
 
 @typing.overload
-def get_class(classname: str, all: typing.Literal[False] = ...) -> SchemaType: ...
+def get_class(classname: str, *, all: typing.Literal[False] = ...) -> SchemaType: ...
 
 
 @typing.overload
-def get_class(classname: str, all: typing.Literal[True] = ...) -> list[SchemaType]: ...
+def get_class(
+    classname: str, *, all: typing.Literal[True] = ...
+) -> list[SchemaType]: ...
 
 
-def get_class(classname: str, all: bool = False) -> list[SchemaType] | SchemaType:
+def get_class(classname: str, *, all: bool = False) -> list[SchemaType] | SchemaType:  # noqa: A002
     """Retrieve a class from the registry.
 
     :raises: `marshmallow.exceptions.RegistryError` if the class cannot be found
@@ -98,5 +100,4 @@ def get_class(classname: str, all: bool = False) -> list[SchemaType] | SchemaTyp
             "were found. Please use the full, "
             "module-qualified path."
         )
-    else:
-        return _registry[classname][0]
+    return _registry[classname][0]

marshmallow/decorators.py

@@ -93,9 +93,9 @@ def validates(field_name: str) -> Callable[..., Any]:
 
 def validates_schema(
     fn: Callable[..., Any] | None = None,
-    pass_many: bool = False,
-    pass_original: bool = False,
-    skip_on_field_errors: bool = True,
+    pass_many: bool = False,  # noqa: FBT001, FBT002
+    pass_original: bool = False,  # noqa: FBT001, FBT002
+    skip_on_field_errors: bool = True,  # noqa: FBT001, FBT002
 ) -> Callable[..., Any]:
     """Register a schema-level validator.
 
@@ -126,7 +126,8 @@ def validates_schema(
 
 
 def pre_dump(
-    fn: Callable[..., Any] | None = None, pass_many: bool = False
+    fn: Callable[..., Any] | None = None,
+    pass_many: bool = False,  # noqa: FBT001, FBT002
 ) -> Callable[..., Any]:
     """Register a method to invoke before serializing an object. The method
     receives the object to be serialized and returns the processed object.
@@ -143,8 +144,8 @@ def pre_dump(
 
 def post_dump(
     fn: Callable[..., Any] | None = None,
-    pass_many: bool = False,
-    pass_original: bool = False,
+    pass_many: bool = False,  # noqa: FBT001, FBT002
+    pass_original: bool = False,  # noqa: FBT001, FBT002
 ) -> Callable[..., Any]:
     """Register a method to invoke after serializing an object. The method
     receives the serialized object and returns the processed object.
@@ -163,7 +164,8 @@ def post_dump(
 
 
 def pre_load(
-    fn: Callable[..., Any] | None = None, pass_many: bool = False
+    fn: Callable[..., Any] | None = None,
+    pass_many: bool = False,  # noqa: FBT001, FBT002
 ) -> Callable[..., Any]:
     """Register a method to invoke before deserializing an object. The method
     receives the data to be deserialized and returns the processed data.
@@ -181,8 +183,8 @@ def pre_load(
 
 def post_load(
     fn: Callable[..., Any] | None = None,
-    pass_many: bool = False,
-    pass_original: bool = False,
+    pass_many: bool = False,  # noqa: FBT001, FBT002
+    pass_original: bool = False,  # noqa: FBT001, FBT002
 ) -> Callable[..., Any]:
     """Register a method to invoke after deserializing an object. The method
     receives the deserialized data and returns the processed data.
@@ -202,7 +204,10 @@ def post_load(
 
 
 def set_hook(
-    fn: Callable[..., Any] | None, tag: str, many: bool = False, **kwargs: Any
+    fn: Callable[..., Any] | None,
+    tag: str,
+    many: bool = False,  # noqa: FBT001, FBT002
+    **kwargs: Any,
 ) -> Callable[..., Any]:
     """Mark decorated function as a hook to be picked up later.
     You should not need to use this method directly.

marshmallow/error_store.py

@@ -25,7 +25,7 @@ class ErrorStore:
         self.errors = merge_errors(self.errors, messages)
 
 
-def merge_errors(errors1, errors2):
+def merge_errors(errors1, errors2):  # noqa: PLR0911
     """Deeply merge two error messages.
 
     The format of ``errors1`` and ``errors2`` matches the ``message``
@@ -40,7 +40,7 @@ def merge_errors(errors1, errors2):
             return errors1 + errors2
         if isinstance(errors2, dict):
             return dict(errors2, **{SCHEMA: merge_errors(errors1, errors2.get(SCHEMA))})
-        return errors1 + [errors2]
+        return [*errors1, errors2]
     if isinstance(errors1, dict):
         if isinstance(errors2, list):
             return dict(errors1, **{SCHEMA: merge_errors(errors1.get(SCHEMA), errors2)})
@@ -54,7 +54,7 @@ def merge_errors(errors1, errors2):
             return errors
         return dict(errors1, **{SCHEMA: merge_errors(errors1.get(SCHEMA), errors2)})
     if isinstance(errors2, list):
-        return [errors1] + errors2
+        return [errors1, *errors2]
     if isinstance(errors2, dict):
         return dict(errors2, **{SCHEMA: merge_errors(errors1, errors2.get(SCHEMA))})
     return [errors1, errors2]

marshmallow/fields.py

@@ -1,3 +1,4 @@
+# ruff: noqa: F841, SLF001
 from __future__ import annotations
 
 import collections
@@ -11,7 +12,6 @@ import typing
 import uuid
 import warnings
 from collections.abc import Mapping as _Mapping
-from enum import Enum as EnumType
 
 from marshmallow import class_registry, types, utils, validate
 from marshmallow.base import FieldABC
@@ -35,47 +35,49 @@ from marshmallow.warnings import (
 )
 
 if typing.TYPE_CHECKING:
+    from enum import Enum as EnumType
+
     from marshmallow.schema import Schema, SchemaMeta
 
 
 __all__ = [
-    "Field",
-    "Raw",
-    "Nested",
-    "Mapping",
-    "Dict",
-    "List",
-    "Tuple",
-    "String",
+    "IP",
+    "URL",
     "UUID",
-    "Number",
-    "Integer",
-    "Decimal",
-    "Boolean",
-    "Float",
-    "DateTime",
-    "NaiveDateTime",
     "AwareDateTime",
-    "Time",
+    "Bool",
+    "Boolean",
+    "Constant",
     "Date",
-    "TimeDelta",
-    "Url",
-    "URL",
+    "DateTime",
+    "Decimal",
+    "Dict",
     "Email",
-    "IP",
-    "IPv4",
-    "IPv6",
+    "Enum",
+    "Field",
+    "Float",
+    "Function",
     "IPInterface",
+    "IPv4",
     "IPv4Interface",
+    "IPv6",
     "IPv6Interface",
-    "Enum",
-    "Method",
-    "Function",
-    "Str",
-    "Bool",
     "Int",
-    "Constant",
+    "Integer",
+    "List",
+    "Mapping",
+    "Method",
+    "NaiveDateTime",
+    "Nested",
+    "Number",
     "Pluck",
+    "Raw",
+    "Str",
+    "String",
+    "Time",
+    "TimeDelta",
+    "Tuple",
+    "Url",
 ]
 
 
@@ -498,7 +500,9 @@ class Nested(Field):
             name = fields.Str()
             # Use lambda functions when you need two-way nesting or self-nesting
             parent = fields.Nested(lambda: ParentSchema(only=("id",)), dump_only=True)
-            siblings = fields.List(fields.Nested(lambda: ChildSchema(only=("id", "name"))))
+            siblings = fields.List(
+                fields.Nested(lambda: ChildSchema(only=("id", "name")))
+            )
 
 
         class ParentSchema(Schema):
@@ -843,7 +847,7 @@ class Tuple(Field):
         super().__init__(**kwargs)
         if not utils.is_collection(tuple_fields):
             raise ValueError(
-                "tuple_fields must be an iterable of Field classes or " "instances."
+                "tuple_fields must be an iterable of Field classes or instances."
             )
 
         try:
@@ -863,9 +867,9 @@ class Tuple(Field):
         super()._bind_to_schema(field_name, schema)
         new_tuple_fields = []
         for field in self.tuple_fields:
-            field = copy.deepcopy(field)
-            field._bind_to_schema(field_name, self)
-            new_tuple_fields.append(field)
+            new_field = copy.deepcopy(field)
+            new_field._bind_to_schema(field_name, self)
+            new_tuple_fields.append(new_field)
 
         self.tuple_fields = new_tuple_fields
 
@@ -1294,7 +1298,7 @@ class DateTime(Field):
         "format": '"{input}" cannot be formatted as a {obj_type}.',
     }
 
-    def __init__(self, format: str | None = None, **kwargs) -> None:
+    def __init__(self, format: str | None = None, **kwargs) -> None:  # noqa: A002
         super().__init__(**kwargs)
         # Allow this to be None. It may be set later in the ``_serialize``
         # or ``_deserialize`` methods. This allows a Schema to dynamically set the
@@ -1352,7 +1356,7 @@ class NaiveDateTime(DateTime):
 
     def __init__(
         self,
-        format: str | None = None,
+        format: str | None = None,  # noqa: A002
         *,
         timezone: dt.timezone | None = None,
         **kwargs,
@@ -1389,7 +1393,7 @@ class AwareDateTime(DateTime):
 
     def __init__(
         self,
-        format: str | None = None,
+        format: str | None = None,  # noqa: A002
         *,
         default_timezone: dt.tzinfo | None = None,
         **kwargs,
@@ -1548,7 +1552,7 @@ class TimeDelta(Field):
             delta = utils.timedelta_to_microseconds(value)
             unit = utils.timedelta_to_microseconds(base_unit)
             return delta // unit
-        assert self.serialization_type is float
+        assert self.serialization_type is float  # noqa: S101
         return value.total_seconds() / base_unit.total_seconds()
 
     def _deserialize(self, value, attr, data, **kwargs):
@@ -1643,16 +1647,15 @@ class Mapping(Field):
         if not self.value_field and not self.key_field:
             return self.mapping_type(value)
 
-        #  Serialize keys
+        # Serialize keys
         if self.key_field is None:
-            keys = {k: k for k in value.keys()}
+            keys = {k: k for k in value}
         else:
             keys = {
-                k: self.key_field._serialize(k, None, None, **kwargs)
-                for k in value.keys()
+                k: self.key_field._serialize(k, None, None, **kwargs) for k in value
             }
 
-        #  Serialize values
+        # Serialize values
         result = self.mapping_type()
         if self.value_field is None:
             for k, v in value.items():
@@ -1672,18 +1675,18 @@ class Mapping(Field):
 
         errors = collections.defaultdict(dict)
 
-        #  Deserialize keys
+        # Deserialize keys
         if self.key_field is None:
-            keys = {k: k for k in value.keys()}
+            keys = {k: k for k in value}
         else:
             keys = {}
-            for key in value.keys():
+            for key in value:
                 try:
                     keys[key] = self.key_field.deserialize(key, **kwargs)
                 except ValidationError as error:
                     errors[key]["key"] = error.messages
 
-        #  Deserialize values
+        # Deserialize values
         result = self.mapping_type()
         if self.value_field is None:
             for k, v in value.items():

marshmallow/orderedset.py

@@ -45,7 +45,7 @@ class OrderedSet(MutableSet):
 
     def discard(self, key):
         if key in self.map:
-            key, prev, next = self.map.pop(key)
+            key, prev, next = self.map.pop(key)  # noqa: A001
             prev[2] = next
             next[1] = prev
 

marshmallow/schema.py

@@ -1,18 +1,21 @@
-"""The `Schema <marshmallow.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
@@ -63,8 +69,11 @@ def _get_fields_by_mro(klass: SchemaMeta):
     :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 `Schema <marshmallow.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]:
@@ -450,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 #####
 
@@ -468,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.
@@ -720,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
@@ -752,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)
@@ -768,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,
@@ -1016,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
@@ -1044,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(
@@ -1059,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,
@@ -1083,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,
@@ -1091,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]:
@@ -1123,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]
@@ -1202,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

@@ -14,3 +14,27 @@ 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: ...

marshmallow/utils.py

@@ -1,5 +1,6 @@
 """Utility methods for marshmallow."""
 
+# ruff: noqa: T201, T203
 from __future__ import annotations
 
 import collections
@@ -137,7 +138,7 @@ _iso8601_time_re = re.compile(
 )
 
 
-def get_fixed_timezone(offset: int | float | dt.timedelta) -> dt.timezone:
+def get_fixed_timezone(offset: float | dt.timedelta) -> dt.timezone:
     """Return a tzinfo instance with a fixed offset from UTC."""
     if isinstance(offset, dt.timedelta):
         offset = offset.total_seconds() // 60
@@ -169,7 +170,7 @@ def from_iso_datetime(value):
         tzinfo = get_fixed_timezone(offset)
     kw = {k: int(v) for k, v in kw.items() if v is not None}
     kw["tzinfo"] = tzinfo
-    return dt.datetime(**kw)
+    return dt.datetime(**kw)  # noqa: DTZ001
 
 
 def from_iso_time(value):
@@ -279,17 +280,15 @@ def get_value(obj, key: int | str, default=missing):
     """
     if not isinstance(key, int) and "." in key:
         return _get_value_for_keys(obj, key.split("."), default)
-    else:
-        return _get_value_for_key(obj, key, default)
+    return _get_value_for_key(obj, key, default)
 
 
 def _get_value_for_keys(obj, keys, default):
     if len(keys) == 1:
         return _get_value_for_key(obj, keys[0], default)
-    else:
-        return _get_value_for_keys(
-            _get_value_for_key(obj, keys[0], default), keys[1:], default
-        )
+    return _get_value_for_keys(
+        _get_value_for_key(obj, keys[0], default), keys[1:], default
+    )
 
 
 def _get_value_for_key(obj, key, default):
@@ -318,7 +317,7 @@ def set_value(dct: dict[str, typing.Any], key: str, value: typing.Any):
         target = dct.setdefault(head, {})
         if not isinstance(target, dict):
             raise ValueError(
-                f"Cannot set {key} in {head} " f"due to existing value: {target}"
+                f"Cannot set {key} in {head} due to existing value: {target}"
             )
         set_value(target, rest, value)
     else:
@@ -360,10 +359,9 @@ def resolve_field_instance(cls_or_instance: type[Field] | Field) -> Field:
         if not issubclass(cls_or_instance, FieldABC):
             raise FieldInstanceResolutionError
         return cls_or_instance()
-    else:
-        if not isinstance(cls_or_instance, FieldABC):
-            raise FieldInstanceResolutionError
-        return cls_or_instance
+    if not isinstance(cls_or_instance, FieldABC):
+        raise FieldInstanceResolutionError
+    return cls_or_instance
 
 
 def timedelta_to_microseconds(value: dt.timedelta) -> int:

marshmallow/validate.py

@@ -9,10 +9,12 @@ from abc import ABC, abstractmethod
 from itertools import zip_longest
 from operator import attrgetter
 
-from marshmallow import types
 from marshmallow.exceptions import ValidationError
 from marshmallow.warnings import ChangedInMarshmallow4Warning
 
+if typing.TYPE_CHECKING:
+    from marshmallow import types
+
 _T = typing.TypeVar("_T")
 
 
@@ -73,8 +75,8 @@ class And(Validator):
         return f"validators={self.validators!r}"
 
     def __call__(self, value: typing.Any) -> typing.Any:
-        errors = []
-        kwargs = {}
+        errors: list[str | dict] = []
+        kwargs: dict[str, typing.Any] = {}
         for validator in self.validators:
             try:
                 r = validator(value)
@@ -85,14 +87,13 @@ class And(Validator):
                         ChangedInMarshmallow4Warning,
                         stacklevel=2,
                     )
-                    raise ValidationError(self.error)
+                    raise ValidationError(self.error)  # noqa: TRY301
             except ValidationError as err:
                 kwargs.update(err.kwargs)
                 if isinstance(err.messages, dict):
                     errors.append(err.messages)
                 else:
-                    # FIXME : Get rid of cast
-                    errors.extend(typing.cast(list, err.messages))
+                    errors.extend(err.messages)
         if errors:
             raise ValidationError(errors, **kwargs)
         return value
@@ -115,7 +116,7 @@ class URL(Validator):
             self._memoized = {}
 
         def _regex_generator(
-            self, relative: bool, absolute: bool, require_tld: bool
+            self, *, relative: bool, absolute: bool, require_tld: bool
         ) -> typing.Pattern:
             hostname_variants = [
                 # a normal domain name, expressed in [A-Z0-9] chars with hyphens allowed only in the middle
@@ -169,12 +170,12 @@ class URL(Validator):
             return re.compile("".join(parts), re.IGNORECASE)
 
         def __call__(
-            self, relative: bool, absolute: bool, require_tld: bool
+            self, *, relative: bool, absolute: bool, require_tld: bool
         ) -> typing.Pattern:
             key = (relative, absolute, require_tld)
             if key not in self._memoized:
                 self._memoized[key] = self._regex_generator(
-                    relative, absolute, require_tld
+                    relative=relative, absolute=absolute, require_tld=require_tld
                 )
 
             return self._memoized[key]
@@ -215,14 +216,24 @@ class URL(Validator):
             raise ValidationError(message)
 
         # Check first if the scheme is valid
+        scheme = None
         if "://" in value:
             scheme = value.split("://")[0].lower()
             if scheme not in self.schemes:
                 raise ValidationError(message)
 
-        regex = self._regex(self.relative, self.absolute, self.require_tld)
+        regex = self._regex(
+            relative=self.relative, absolute=self.absolute, require_tld=self.require_tld
+        )
+
+        # Hostname is optional for file URLS. If absent it means `localhost`.
+        # Fill it in for the validation if needed
+        if scheme == "file" and value.startswith("file:///"):
+            matched = regex.search(value.replace("file:///", "file://localhost/", 1))
+        else:
+            matched = regex.search(value)
 
-        if not regex.search(value):
+        if not matched:
             raise ValidationError(message)
 
         return value
@@ -318,8 +329,8 @@ class Range(Validator):
 
     def __init__(
         self,
-        min=None,
-        max=None,
+        min=None,  # noqa: A002
+        max=None,  # noqa: A002
         *,
         min_inclusive: bool = True,
         max_inclusive: bool = True,
@@ -365,6 +376,9 @@ class Range(Validator):
         return value
 
 
+_SizedT = typing.TypeVar("_SizedT", bound=typing.Sized)
+
+
 class Length(Validator):
     """Validator which succeeds if the value passed to it has a
     length between a minimum and maximum. Uses len(), so it
@@ -387,8 +401,8 @@ class Length(Validator):
 
     def __init__(
         self,
-        min: int | None = None,
-        max: int | None = None,
+        min: int | None = None,  # noqa: A002
+        max: int | None = None,  # noqa: A002
         *,
         equal: int | None = None,
         error: str | None = None,
@@ -407,12 +421,12 @@ class Length(Validator):
     def _repr_args(self) -> str:
         return f"min={self.min!r}, max={self.max!r}, equal={self.equal!r}"
 
-    def _format_error(self, value: typing.Sized, message: str) -> str:
+    def _format_error(self, value: _SizedT, message: str) -> str:
         return (self.error or message).format(
             input=value, min=self.min, max=self.max, equal=self.equal
         )
 
-    def __call__(self, value: typing.Sized) -> typing.Sized:
+    def __call__(self, value: _SizedT) -> _SizedT:
         length = len(value)
 
         if self.equal is not None:
@@ -531,7 +545,7 @@ class Predicate(Validator):
     def _format_error(self, value: typing.Any) -> str:
         return self.error.format(input=value, method=self.method)
 
-    def __call__(self, value: typing.Any) -> typing.Any:
+    def __call__(self, value: _T) -> _T:
         method = getattr(value, self.method)
 
         if not method(**self.kwargs):

{marshmallow-3.25.1.dist-info → marshmallow-3.26.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: marshmallow
-Version: 3.25.1
+Version: 3.26.0
 Summary: A lightweight library for converting complex datatypes to and from native Python datatypes.
 Author-email: Steven Loria <sloria1@gmail.com>
 Maintainer-email: Steven Loria <sloria1@gmail.com>, Jérôme Lafréchoux <jerome@jolimont.fr>, Jared Deckard <jared@shademaps.com>

marshmallow-3.26.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+marshmallow/__init__.py,sha256=TU1arjtOLs87YDfW4Z35YVbaY2CUXK-VgylcuL8LaQg,2387
+marshmallow/base.py,sha256=39W78-rnuzzx5T95YWBEECzjtqxdUA8XzYJNHd39VLg,1362
+marshmallow/class_registry.py,sha256=HTC9srCEaRsiy5L_vUKQso7IQfeZeRXxZfz4_2NitoM,3029
+marshmallow/decorators.py,sha256=pMjGPaXBZCRfAdQS3Bz5ieTZGA3BOv61FdTPsLwCtMQ,8749
+marshmallow/error_store.py,sha256=iCPSdw8nJGiS4fjWuIAY1aSI_Hhckcdo3l_g-7pjaMw,2240
+marshmallow/exceptions.py,sha256=DuARdOcirCdJxmlp16V97hQKAXOokvdW12jXtYOlGyk,2326
+marshmallow/fields.py,sha256=DjjL5m5YZbwMVHE97MQDNfoFf_e75qMR3eIs17UuVMc,74763
+marshmallow/orderedset.py,sha256=-Lq83AWIIFs2bxptDwkHtfQ63ebX3WD3R6N3B5rRnVI,2936
+marshmallow/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+marshmallow/schema.py,sha256=bSBynndwixq1zcOOPdoZkX7DmpVSpHBaNEh1zqiD888,52128
+marshmallow/types.py,sha256=VY0_D-Xou7nKjcvWB1iccm8cZtxI3rkis1nhNelNn5Q,979
+marshmallow/utils.py,sha256=tLzu9FDL3Ph51qKsoqWIyPSwg8dZ8rzjeXXGLUndHFE,11943
+marshmallow/validate.py,sha256=Fx3F8F20dBGg-Wrv84Chx5SYedX9E0l592hR4MxS0kQ,24652
+marshmallow/warnings.py,sha256=YHC0kQQBbTKCiA1FuwnbnXqrph7oKuU9BjTV4cxwnzE,192
+marshmallow-3.26.0.dist-info/LICENSE,sha256=kGtdkFHkJhRMsXOtkRZnuOvQWpxYTCwmwTWzKj7RIAE,1064
+marshmallow-3.26.0.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+marshmallow-3.26.0.dist-info/METADATA,sha256=Scbh6z8NMiWGVQ3EYrwo6H9-PNczOrepN_tFFZu_A9k,7310
+marshmallow-3.26.0.dist-info/RECORD,,

marshmallow-3.25.1.dist-info/RECORD

@@ -1,18 +0,0 @@
-marshmallow/__init__.py,sha256=C-zbaQJ9dlJLJxotIqTa5OOaD6ojGNRqW8moGrMsGr8,2387
-marshmallow/base.py,sha256=39W78-rnuzzx5T95YWBEECzjtqxdUA8XzYJNHd39VLg,1362
-marshmallow/class_registry.py,sha256=JaA2tJo53ZNzTVoJM_MuN_WKaadEskIcxjOrLKy76iQ,3015
-marshmallow/decorators.py,sha256=3U7gLAmiotqoVC8O2j_7kwUS2ceoJUdkAcuk8SuH9oQ,8486
-marshmallow/error_store.py,sha256=A7AxgLMw9ffSmaxRH4x3wcBWibx-DuGH4LwSDpVn50I,2223
-marshmallow/exceptions.py,sha256=DuARdOcirCdJxmlp16V97hQKAXOokvdW12jXtYOlGyk,2326
-marshmallow/fields.py,sha256=WgtoWGZR3WLkqEf056NTUlHurLVlfCho3TQQ5zSlMqc,74688
-marshmallow/orderedset.py,sha256=C2aAG6w1faIL1phinbAltbe3AUAnF5MN6n7fzESNDhI,2922
-marshmallow/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-marshmallow/schema.py,sha256=w81gPdm9L4_NaloLb8Z04U5shzUbuDOtDPeJL8uMHH0,48653
-marshmallow/types.py,sha256=csTzHJh-tbNs9t9eDRG6HjJMNawSVNw27mmor6w4ztM,423
-marshmallow/utils.py,sha256=Xvpd7h3IdB8tRKfa-u95DbOXjLgDzWRNJIwjsTNI9n0,11970
-marshmallow/validate.py,sha256=D9CbPe2vywalBcTa3iuwCqIK6mNhDn5pQaJ_kn_6_y4,24116
-marshmallow/warnings.py,sha256=YHC0kQQBbTKCiA1FuwnbnXqrph7oKuU9BjTV4cxwnzE,192
-marshmallow-3.25.1.dist-info/LICENSE,sha256=kGtdkFHkJhRMsXOtkRZnuOvQWpxYTCwmwTWzKj7RIAE,1064
-marshmallow-3.25.1.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
-marshmallow-3.25.1.dist-info/METADATA,sha256=aBxXuzqfK0y4iUwJb9zVGHq9vcndAyUzCRZRVVTLmf8,7310
-marshmallow-3.25.1.dist-info/RECORD,,