lafrech: +32 −454 :heart_eyes:
That's just great.
sloria: Speeds up `tox -e benchmark` by ~15%.
sloria: Once https://github.com/deckar01/marshmallow/pull/1 is merged in and this is brought up to date with `dev`, I think this is good to merge.

We can probably get rid of `ErrorStore` at this point, but that can happen in a follow-up PR.
sloria: Feel free to squash my commits into yours if you want; I don't care about the git creds =).
sloria: @deckar01 Are you working on this, or should I pick up where you left off?
deckar01: I haven't made any changes locally that haven't been pushed. Feel free to pick it up and push on it. I think some tests started failing after merging deckar01#1. Not sure if it was that or the merge conflicts I resolved. There are also new merge conflicts I haven't looked into.
sloria: OK, I can look into the conflicts this week. Mind if I squash and merge after all is said and done?
diff --git a/CHANGELOG.rst b/CHANGELOG.rst
index 5a0a27a4..2512ff20 100644
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -6,6 +6,8 @@ Changelog
 
 Features:
 
+- *Backwards-incompatible*: Validation does not occur on serialization (:issue:`1132`).
+  This significantly improves serialization performance.
 - *Backwards-incompatible*: ``DateTime`` does not affect timezone information
   on serialization and deserialization (:issue:`1234`, :pr:`1287`).
 - Add ``NaiveDateTime`` and ``AwareDateTime`` to enforce timezone awareness
diff --git a/docs/extending.rst b/docs/extending.rst
index 067415f9..07e88307 100644
--- a/docs/extending.rst
+++ b/docs/extending.rst
@@ -216,9 +216,9 @@ The pipeline for serialization is similar, except that the "pass_many" processor
 Handling Errors
 ---------------
 
-By default, :meth:`Schema.dump` and :meth:`Schema.load` will raise a :exc:`ValidationError <marshmallow.exceptions.ValidationError>`.
+By default, :meth:`Schema.load` will raise a :exc:`ValidationError <marshmallow.exceptions.ValidationError>` if passed invalid data.
 
-You can specify a custom error-handling function for a :class:`Schema` by overriding the `handle_error <marshmallow.Schema.handle_error>`  method. The method receives the :exc:`ValidationError <marshmallow.exceptions.ValidationError>` and the original object (or input data if deserializing) to be (de)serialized.
+You can specify a custom error-handling function for a :class:`Schema` by overriding the `handle_error <marshmallow.Schema.handle_error>`  method. The method receives the :exc:`ValidationError <marshmallow.exceptions.ValidationError>` and the original input data to be deserialized.
 
 .. code-block:: python
 
diff --git a/docs/quickstart.rst b/docs/quickstart.rst
index 605c0ab3..8eb14628 100644
--- a/docs/quickstart.rst
+++ b/docs/quickstart.rst
@@ -45,7 +45,7 @@ Create a schema by defining a class with variables mapping attribute names to :c
 Serializing Objects ("Dumping")
 -------------------------------
 
-Serialize objects by passing them to your schema's :meth:`dump <marshmallow.Schema.dump>` method, which returns the formatted result (or raises a :exc:`ValidationError <marshmallow.exceptions.ValidationError>` with a dictionary of validation errors, which we'll :ref:`revisit later <validation>`).
+Serialize objects by passing them to your schema's :meth:`dump <marshmallow.Schema.dump>` method, which returns the formatted result.
 
 .. code-block:: python
 
@@ -84,9 +84,11 @@ You can also exclude fields by passing in the ``exclude`` parameter.
 Deserializing Objects ("Loading")
 ---------------------------------
 
-The opposite of the :meth:`dump <Schema.dump>` method is the :meth:`load <Schema.load>` method, which deserializes an input dictionary to an application-level data structure.
+The reverse of the `dump <Schema.dump>` method is `load <Schema.load>`, which validates and deserializes 
+an input dictionary to an application-level data structure. 
 
-By default, :meth:`load <Schema.load>` will return a dictionary of field names mapped to the deserialized values.
+By default, :meth:`load <Schema.load>` will return a dictionary of field names mapped to deserialized values (or raise a :exc:`ValidationError <marshmallow.exceptions.ValidationError>` 
+with a dictionary of validation errors, which we'll :ref:`revisit later <validation>`).
 
 .. code-block:: python
 
@@ -160,7 +162,7 @@ Iterable collections of objects are also serializable and deserializable. Just s
 Validation
 ----------
 
-:meth:`Schema.load` (and its JSON-decoding counterpart, :meth:`Schema.loads`) raises a :exc:`ValidationError <marshmallow.exceptions.ValidationError>` error when invalid data are passed in. You can access the dictionary of validation errors from the `ValidationError.messages <marshmallow.exceptions.ValidationError.messages>` attribute. The data that was correctly serialized / deserialized is accessible in `ValidationError.valid_data <marshmallow.exceptions.ValidationError.valid_data>`. Some fields, such as the :class:`Email <fields.Email>` and :class:`URL <fields.URL>` fields, have built-in validation.
+:meth:`Schema.load` (and its JSON-decoding counterpart, :meth:`Schema.loads`) raises a :exc:`ValidationError <marshmallow.exceptions.ValidationError>` error when invalid data are passed in. You can access the dictionary of validation errors from the `ValidationError.messages <marshmallow.exceptions.ValidationError.messages>` attribute. The data that were correctly deserialized are accessible in `ValidationError.valid_data <marshmallow.exceptions.ValidationError.valid_data>`. Some fields, such as the :class:`Email <fields.Email>` and :class:`URL <fields.URL>` fields, have built-in validation.
 
 .. code-block:: python
 
@@ -169,8 +171,8 @@ Validation
     try:
         result = UserSchema().load({"name": "John", "email": "foo"})
     except ValidationError as err:
-        err.messages  # => {'email': ['"foo" is not a valid email address.']}
-        valid_data = err.valid_data  # => {'name': 'John'}
+        err.messages  # => {"email": ['"foo" is not a valid email address.']}
+        valid_data = err.valid_data  # => {"name": "John"}
 
 
 When validating a collection, the errors dictionary will be keyed on the indices of invalid items.
@@ -243,13 +245,11 @@ If validation fails, validation functions raise a :exc:`ValidationError <marshma
     except ValidationError as err:
         err.messages  # => {'quantity': ['Quantity must not be greater than 30.']}
 
-.. note::
-
-    If you have multiple validations to perform, you may also pass a collection (list, tuple, generator) of callables.
+You may also pass a collection (list, tuple, generator) of callables to ``validate``.
 
-.. note::
+.. warning::
 
-    :meth:`Schema.dump` also returns a dictionary of errors, which will include any ``ValidationErrors`` raised during serialization. However, ``required``, ``allow_none``, ``validate``, `@validates <marshmallow.decorators.validates>`, and `@validates_schema <marshmallow.decorators.validates_schema>` only apply during deserialization.
+    Validation only happens on deserialization, not serialization. To improve serialization performance, data passed to :meth:`Schema.dump` are considered valid.
 
 .. seealso::
 
diff --git a/docs/upgrading.rst b/docs/upgrading.rst
index b577d6ae..4e364f90 100644
--- a/docs/upgrading.rst
+++ b/docs/upgrading.rst
@@ -54,7 +54,7 @@ along with the valid data from the `ValidationError.valid_data
         errors = err.messages
         valid_data = err.valid_data
 
-:meth:`Schema().validate <marshmallow.Schema.validate>` always returns a dictionary of validation errors (same as 2.x with ``strict=False``).
+:meth:`Schema.validate() <marshmallow.Schema.validate>` always returns a dictionary of validation errors (same as 2.x with ``strict=False``).
 
 .. code-block:: python
 
@@ -113,6 +113,7 @@ and `validates_schema <marshmallow.decorators.validates_schema>` receive
             in_data["slug"] = in_data["slug"].lower().strip().replace(" ", "-")
             return in_data
 
+
 `Schema.handle_error <marshmallow.Schema.handle_error>` also receives ``many`` and ``partial`` as keyword arguments.
 
 .. code-block:: python
@@ -129,6 +130,41 @@ and `validates_schema <marshmallow.decorators.validates_schema>` receive
             raise AppError("An error occurred with input: {0}".format(data))
 
 
+Validation does not occur on serialization
+******************************************
+
+:meth:`Schema.dump() <marshmallow.Schema.dump>` will no longer validate and collect error messages. You *must* validate
+your data before serializing it.
+
+.. code-block:: python
+
+    from marshmallow import Schema, fields, ValidationError
+
+    invalid_data = dict(created_at="invalid")
+
+
+    class WidgetSchema(Schema):
+        created_at = fields.DateTime()
+
+
+    # 2.x
+    WidgetSchema(strict=True).dump(invalid_data)
+    # marshmallow.exceptions.ValidationError: {'created_at': ['"invalid" cannot be formatted as a datetime.']}
+
+    # 3.x
+    WidgetSchema().dump(invalid_data)
+    # AttributeError: 'str' object has no attribute 'isoformat'
+
+    # Instead, validate before dumping
+    schema = WidgetSchema()
+    try:
+        widget = schema.load(invalid_data)
+    except ValidationError:
+        print("handle errors...")
+    else:
+        dumped = schema.dump(widget)
+
+
 Deserializing invalid types raises a ``ValidationError``
 ********************************************************
 
diff --git a/src/marshmallow/fields.py b/src/marshmallow/fields.py
index c279af8b..10d029f0 100644
--- a/src/marshmallow/fields.py
+++ b/src/marshmallow/fields.py
@@ -276,7 +276,6 @@ class Field(FieldABC):
         :param str obj: The object to pull the key from.
         :param callable accessor: Function used to pull values from ``obj``.
         :param dict kwargs': Field-specific keyword arguments.
-        :raise ValidationError: In case of formatting problem
         """
         if self._CHECK_ATTRIBUTE:
             value = self.get_value(obj, attr, accessor=accessor)
@@ -339,7 +338,6 @@ class Field(FieldABC):
         :param str attr: The attribute or key on the object to be serialized.
         :param object obj: The object the value was pulled from.
         :param dict kwargs': Field-specific keyword arguments.
-        :raise ValidationError: In case of formatting or validation failure.
         :return: The serialized value
         """
         return value
@@ -493,12 +491,7 @@ class Nested(Field):
         schema = self.schema
         if nested_obj is None:
             return None
-        try:
-            return schema.dump(nested_obj, many=self.many)
-        except ValidationError as error:
-            raise ValidationError(
-                error.messages, valid_data=error.valid_data
-            ) from error
+        return schema.dump(nested_obj, many=self.many)
 
     def _test_collection(self, value):
         if self.many and not utils.is_collection(value):
@@ -794,15 +787,15 @@ class Number(Field):
 
     def _format_num(self, value):
         """Return the number value for value, given this field's `num_type`."""
-        # (value is True or value is False) is ~5x faster than isinstance(value, bool)
-        if value is True or value is False:
-            raise TypeError("value must be a Number, not a boolean.")
         return self.num_type(value)
 
     def _validated(self, value):
         """Format the value or raise a :exc:`ValidationError` if an error occurs."""
         if value is None:
             return None
+        # (value is True or value is False) is ~5x faster than isinstance(value, bool)
+        if value is True or value is False:
+            self.fail("invalid", input=value)
         try:
             return self._format_num(value)
         except (TypeError, ValueError) as error:
@@ -815,12 +808,10 @@ class Number(Field):
 
     def _serialize(self, value, attr, obj, **kwargs):
         """Return a string if `self.as_string=True`, otherwise return this field's `num_type`."""
-        ret = self._validated(value)
-        return (
-            self._to_string(ret)
-            if (self.as_string and ret not in (None, missing_))
-            else ret
-        )
+        if value is None:
+            return None
+        ret = self._format_num(value)
+        return self._to_string(ret) if self.as_string else ret
 
     def _deserialize(self, value, attr, data, **kwargs):
         return self._validated(value)
@@ -835,20 +826,19 @@ class Integer(Number):
     num_type = int
     default_error_messages = {"invalid": "Not a valid integer."}
 
-    # override Number
     def __init__(self, *, strict=False, **kwargs):
         self.strict = strict
         super().__init__(**kwargs)
 
     # override Number
-    def _format_num(self, value):
+    def _validated(self, value):
         if self.strict:
             if isinstance(value, numbers.Number) and isinstance(
                 value, numbers.Integral
             ):
-                return super()._format_num(value)
+                return super()._validated(value)
             self.fail("invalid", input=value)
-        return super()._format_num(value)
+        return super()._validated(value)
 
 
 class Float(Number):
@@ -870,8 +860,8 @@ class Float(Number):
         self.allow_nan = allow_nan
         super().__init__(as_string=as_string, **kwargs)
 
-    def _format_num(self, value):
-        num = super()._format_num(value)
+    def _validated(self, value):
+        num = super()._validated(value)
         if self.allow_nan is False:
             if math.isnan(num) or num == float("inf") or num == float("-inf"):
                 self.fail("special")
@@ -934,25 +924,22 @@ class Decimal(Number):
     # override Number
     def _format_num(self, value):
         num = decimal.Decimal(str(value))
-
         if self.allow_nan:
             if num.is_nan():
                 return decimal.Decimal("NaN")  # avoid sNaN, -sNaN and -NaN
-        else:
-            if num.is_nan() or num.is_infinite():
-                self.fail("special")
-
         if self.places is not None and num.is_finite():
             num = num.quantize(self.places, rounding=self.rounding)
-
         return num
 
     # override Number
     def _validated(self, value):
         try:
-            return super()._validated(value)
+            num = super()._validated(value)
         except decimal.InvalidOperation as error:
             raise self.make_error("invalid") from error
+        if not self.allow_nan and (num.is_nan() or num.is_infinite()):
+            raise self.make_error("special")
+        return num
 
     # override Number
     def _to_string(self, value):
@@ -1101,12 +1088,7 @@ class DateTime(Field):
         data_format = self.format or self.DEFAULT_FORMAT
         format_func = self.SERIALIZATION_FUNCS.get(data_format)
         if format_func:
-            try:
-                return format_func(value)
-            except (TypeError, AttributeError, ValueError) as error:
-                raise self.make_error(
-                    "format", input=value, obj_type=self.OBJ_TYPE
-                ) from error
+            return format_func(value)
         else:
             return value.strftime(data_format)
 
@@ -1208,10 +1190,7 @@ class Time(Field):
     def _serialize(self, value, attr, obj, **kwargs):
         if value is None:
             return None
-        try:
-            ret = value.isoformat()
-        except AttributeError as error:
-            raise self.make_error("format", input=value) from error
+        ret = value.isoformat()
         if value.microsecond:
             return ret[:15]
         return ret
@@ -1306,11 +1285,8 @@ class TimeDelta(Field):
     def _serialize(self, value, attr, obj, **kwargs):
         if value is None:
             return None
-        try:
-            base_unit = dt.timedelta(**{self.precision: 1})
-            return int(value.total_seconds() / base_unit.total_seconds())
-        except AttributeError as error:
-            raise self.make_error("format", input=value) from error
+        base_unit = dt.timedelta(**{self.precision: 1})
+        return int(value.total_seconds() / base_unit.total_seconds())
 
     def _deserialize(self, value, attr, data, **kwargs):
         try:
@@ -1387,8 +1363,6 @@ class Mapping(Field):
             return None
         if not self.value_field and not self.key_field:
             return value
-        if not isinstance(value, _Mapping):
-            self.fail("invalid")
 
         #  Serialize keys
         if self.key_field is None:
diff --git a/src/marshmallow/schema.py b/src/marshmallow/schema.py
index 12342c5a..58d888ba 100644
--- a/src/marshmallow/schema.py
+++ b/src/marshmallow/schema.py
@@ -450,51 +450,29 @@ class BaseSchema(base.SchemaABC):
         return value
 
     def _serialize(
-        self,
-        obj,
-        fields_dict,
-        *,
-        error_store,
-        many=False,
-        accessor=None,
-        dict_class=dict,
-        index_errors=True,
-        index=None
+        self, obj, fields_dict, *, many=False, accessor=None, dict_class=dict
     ):
         """Takes raw data (a dict, list, or other object) and a dict of
         fields to output and serializes the data based on those fields.
 
         :param obj: The actual object(s) from which the fields are taken from
         :param dict fields_dict: Mapping of field names to :class:`Field` objects.
-        :param ErrorStore error_store: Structure to store errors.
         :param bool many: Set to `True` if ``data`` should be serialized as
             a collection.
         :param callable accessor: Function to use for getting values from ``obj``.
         :param type dict_class: Dictionary class used to construct the output.
-        :param bool index_errors: Whether to store the index of invalid items in
-            ``self.errors`` when ``many=True``.
-        :param int index: Index of the item being serialized (for storing errors) if
-            serializing a collection, otherwise `None`.
         :return: A dictionary of the marshalled data
 
         .. versionchanged:: 1.0.0
             Renamed from ``marshal``.
         """
-        index = index if index_errors else None
         if many and obj is not None:
             self._pending = True
             ret = [
                 self._serialize(
-                    d,
-                    fields_dict,
-                    error_store=error_store,
-                    many=False,
-                    dict_class=dict_class,
-                    accessor=accessor,
-                    index=idx,
-                    index_errors=index_errors,
+                    d, fields_dict, many=False, dict_class=dict_class, accessor=accessor
                 )
-                for idx, d in enumerate(obj)
+                for d in obj
             ]
             self._pending = False
             return ret
@@ -502,17 +480,10 @@ class BaseSchema(base.SchemaABC):
         for attr_name, field_obj in fields_dict.items():
             if getattr(field_obj, "load_only", False):
                 continue
-            key = field_obj.data_key or attr_name
-            getter = lambda d: field_obj.serialize(attr_name, d, accessor=accessor)
-            value = self._call_and_store(
-                getter_func=getter,
-                data=obj,
-                field_name=key,
-                error_store=error_store,
-                index=index,
-            )
+            value = field_obj.serialize(attr_name, obj, accessor=accessor)
             if value is missing:
                 continue
+            key = field_obj.data_key or attr_name
             ret[key] = value
         return ret
 
@@ -532,47 +503,29 @@ class BaseSchema(base.SchemaABC):
             A :exc:`ValidationError <marshmallow.exceptions.ValidationError>` is raised
             if ``obj`` is invalid.
         """
-        error_store = ErrorStore()
-        errors = {}
         many = self.many if many is None else bool(many)
         if many and is_iterable_but_not_string(obj):
             obj = list(obj)
 
         if self._has_processors(PRE_DUMP):
-            try:
-                processed_obj = self._invoke_dump_processors(
-                    PRE_DUMP, obj, many=many, original_data=obj
-                )
-            except ValidationError as error:
-                errors = error.normalized_messages()
-                result = None
+            processed_obj = self._invoke_dump_processors(
+                PRE_DUMP, obj, many=many, original_data=obj
+            )
         else:
             processed_obj = obj
 
-        if not errors:
-            result = self._serialize(
-                processed_obj,
-                fields_dict=self.fields,
-                error_store=error_store,
-                many=many,
-                accessor=self.get_attribute,
-                dict_class=self.dict_class,
-                index_errors=self.opts.index_errors,
-            )
-            errors = error_store.errors
+        result = self._serialize(
+            processed_obj,
+            fields_dict=self.fields,
+            many=many,
+            accessor=self.get_attribute,
+            dict_class=self.dict_class,
+        )
 
-        if not errors and self._has_processors(POST_DUMP):
-            try:
-                result = self._invoke_dump_processors(
-                    POST_DUMP, result, many=many, original_data=obj
-                )
-            except ValidationError as error:
-                errors = error.normalized_messages()
-        if errors:
-            exc = ValidationError(errors, data=obj, valid_data=result)
-            # User-defined error handler
-            self.handle_error(exc, obj, many=many)
-            raise exc
+        if self._has_processors(POST_DUMP):
+            result = self._invoke_dump_processors(
+                POST_DUMP, result, many=many, original_data=obj
+            )
 
         return result
 

Remove validation on serialization
When using `Dict(values=Nested())` I expect errors in dictionary values to be nested in such a way that I can locate exactly what element is causing the problem. This seems to work as expected for `load()`, but not for `dump()`.

Minimal example:

- Marshmallow version: 3.0.0rc4
- Python version: 3.7.2

```python
from marshmallow import Schema, ValidationError, fields


class InnerSchema(Schema):
    x = fields.Int()


class OuterSchema(Schema):
    inner = fields.Dict(keys=fields.Str(), values=fields.Nested(InnerSchema))


foo = {"inner": {"some-key": {"x": "abc"}}}

try:
    OuterSchema().load(foo)
except ValidationError as e:
    print(e)
    # >>> {'inner': defaultdict(<class 'dict'>, {'some-key': {'value': {'x': ['Not a valid integer.']}}})}
    # Very helpful - and what I expect

class Inner:
    def __init__(self, x):
        self.x = x


class Outer:
    def __init__(self, inner):
        self.inner = inner


bar = Outer(inner={"some-key": Inner(x="abc")})

try:
    OuterSchema().dump(bar)
except ValidationError as e:
    print(e)
    # >>> {'inner': {'x': ['Not a valid integer.']}}
    # Surprisingly - 'some-key' and 'value' are not present here,
    # which makes it harder to pinpoint the problem in large objects
```
diff --git a/tests/test_decorators.py b/tests/test_decorators.py
index 44a543de..0d2ffc6b 100644
--- a/tests/test_decorators.py
+++ b/tests/test_decorators.py
@@ -724,32 +724,6 @@ def test_decorator_error_handling():  # noqa: C901
                 return item
             raise ValidationError("postloadmsg1", "foo")
 
-        @pre_dump()
-        def pre_dump_error1(self, item, **kwargs):
-            if item["foo"] != 2:
-                return item
-            errors = {"foo": ["predumpmsg1"], "bar": ["predumpmsg2", "predumpmsg3"]}
-            raise ValidationError(errors)
-
-        @pre_dump()
-        def pre_dump_error2(self, item, **kwargs):
-            if item["foo"] != 6:
-                return item
-            raise ValidationError("predumpmsg1", "foo")
-
-        @post_dump()
-        def post_dump_error1(self, item, **kwargs):
-            if item["foo"] != 3:
-                return item
-            errors = {"foo": ["postdumpmsg1"], "bar": ["postdumpmsg2", "postdumpmsg3"]}
-            raise ValidationError(errors)
-
-        @post_dump()
-        def post_dump_error2(self, item, **kwargs):
-            if item["foo"] != 7:
-                return item
-            raise ValidationError("postdumpmsg1", "foo")
-
     def make_item(foo, bar):
         data = schema.load({"foo": foo, "bar": bar})
         assert data is not None
@@ -776,26 +750,6 @@ def test_decorator_error_handling():  # noqa: C901
     assert len(errors["bar"]) == 2
     assert "postloadmsg2" in errors["bar"]
     assert "postloadmsg3" in errors["bar"]
-    with pytest.raises(ValidationError) as excinfo:
-        schema.dump(make_item(2, 1))
-    errors = excinfo.value.messages
-    assert "foo" in errors
-    assert len(errors["foo"]) == 1
-    assert errors["foo"][0] == "predumpmsg1"
-    assert "bar" in errors
-    assert len(errors["bar"]) == 2
-    assert "predumpmsg2" in errors["bar"]
-    assert "predumpmsg3" in errors["bar"]
-    with pytest.raises(ValidationError) as excinfo:
-        schema.dump(make_item(3, 1))
-    errors = excinfo.value.messages
-    assert "foo" in errors
-    assert len(errors["foo"]) == 1
-    assert errors["foo"][0] == "postdumpmsg1"
-    assert "bar" in errors
-    assert len(errors["bar"]) == 2
-    assert "postdumpmsg2" in errors["bar"]
-    assert "postdumpmsg3" in errors["bar"]
     with pytest.raises(ValidationError) as excinfo:
         schema.load({"foo": 4, "bar": 1})
     errors = excinfo.value.messages
@@ -810,18 +764,6 @@ def test_decorator_error_handling():  # noqa: C901
     assert "foo" in errors
     assert len(errors["foo"]) == 1
     assert errors["foo"][0] == "postloadmsg1"
-    with pytest.raises(ValidationError) as excinfo:
-        schema.dump(make_item(6, 1))
-    errors = excinfo.value.messages
-    assert "foo" in errors
-    assert len(errors["foo"]) == 1
-    assert errors["foo"][0] == "predumpmsg1"
-    with pytest.raises(ValidationError) as excinfo:
-        schema.dump(make_item(7, 1))
-    errors = excinfo.value.messages
-    assert "foo" in errors
-    assert len(errors["foo"]) == 1
-    assert errors["foo"][0] == "postdumpmsg1"
     with pytest.raises(ValidationError) as excinfo:
         schema.load({"foo": 8, "bar": 1})
     errors = excinfo.value.messages
@@ -873,20 +815,6 @@ def test_decorator_error_handling_with_dump(decorator):
     schema.load({})
 
 
-@pytest.mark.parametrize("decorator", [pre_dump, post_dump])
-def test_decorator_error_handling_with_dump_dict_error(decorator):
-    class ExampleSchema(Schema):
-        @decorator
-        def raise_value_error(self, item, **kwargs):
-            raise ValidationError({"foo": "error"}, "nested")
-
-    schema = ExampleSchema()
-    with pytest.raises(ValidationError) as exc:
-        schema.dump(object())
-    assert exc.value.messages == {"nested": {"foo": "error"}}
-    schema.load({})
-
-
 class Nested:
     def __init__(self, foo):
         self.foo = foo
diff --git a/tests/test_deserialization.py b/tests/test_deserialization.py
index 3f03231f..7536cf75 100644
--- a/tests/test_deserialization.py
+++ b/tests/test_deserialization.py
@@ -45,7 +45,7 @@ class TestFieldDeserialization:
         assert math.isclose(field.deserialize("12.3"), 12.3)
         assert math.isclose(field.deserialize(12.3), 12.3)
 
-    @pytest.mark.parametrize("in_val", ["bad", "", {}])
+    @pytest.mark.parametrize("in_val", ["bad", "", {}, True, False])
     def test_invalid_float_field_deserialization(self, in_val):
         field = fields.Float()
         with pytest.raises(ValidationError) as excinfo:
diff --git a/tests/test_fields.py b/tests/test_fields.py
index 6fda5e5b..5364b83c 100644
--- a/tests/test_fields.py
+++ b/tests/test_fields.py
@@ -92,15 +92,6 @@ class TestField:
         result = MySchema().dump({"name": "Monty", "foo": 42})
         assert result == {"_NaMe": "Monty"}
 
-    def test_number_fields_prohbits_boolean(self):
-        strict_field = fields.Float()
-        with pytest.raises(ValidationError) as excinfo:
-            strict_field.serialize("value", {"value": False})
-        assert excinfo.value.args[0] == "Not a valid number."
-        with pytest.raises(ValidationError) as excinfo:
-            strict_field.serialize("value", {"value": True})
-        assert excinfo.value.args[0] == "Not a valid number."
-
 
 class TestParentAndName:
     class MySchema(Schema):
diff --git a/tests/test_schema.py b/tests/test_schema.py
index a7f2c305..dde4d8ef 100644
--- a/tests/test_schema.py
+++ b/tests/test_schema.py
@@ -58,48 +58,6 @@ def test_serializer_dump(user):
     s = UserSchema()
     result = s.dump(user)
     assert result["name"] == user.name
-    bad_user = User(name="Monty", age="badage")
-    with pytest.raises(ValidationError):
-        s.dump(bad_user)
-
-
-def test_dump_raises_with_dict_of_errors():
-    s = UserSchema()
-    bad_user = User(name="Monty", age="badage")
-    with pytest.raises(ValidationError) as excinfo:
-        s.dump(bad_user)
-    errors = excinfo.value.messages
-    assert "age" in errors
-
-
-@pytest.mark.parametrize("SchemaClass", [UserSchema, UserMetaSchema])
-def test_dump_mode_raises_error(SchemaClass):
-    s = SchemaClass()
-    bad_user = User(name="Monty", homepage="http://www.foo.bar", balance="dummy")
-    with pytest.raises(ValidationError) as excinfo:
-        s.dump(bad_user)
-    exc = excinfo.value
-    assert list(exc.messages.keys()) == ["balance"]
-
-    assert type(exc.messages) == dict
-    assert exc.messages == {"balance": ["Not a valid number."]}
-
-
-def test_dump_resets_errors():
-    class MySchema(Schema):
-        age = fields.Int()
-
-    schema = MySchema()
-    with pytest.raises(ValidationError) as excinfo:
-        schema.dump(User("Joe", age="dummy"))
-    errors = excinfo.value.messages
-    assert len(errors["age"]) == 1
-    assert "Not a valid integer." in errors["age"][0]
-    with pytest.raises(ValidationError) as excinfo:
-        schema.dump(User("Steve", age="__dummy"))
-    errors = excinfo.value.messages
-    assert len(errors["age"]) == 1
-    assert "Not a valid integer." in errors["age"][0]
 
 
 def test_load_resets_errors():
@@ -143,47 +101,6 @@ def test_load_validation_error_stores_input_data_and_valid_data():
         pytest.fail("Data is invalid. Expected a ValidationError to be raised.")
 
 
-def test_dump_validation_error_stores_partially_valid_data():
-    class FailOnDump(fields.Field):
-        def _serialize(self, *args, **kwargs):
-            raise ValidationError("fail")
-
-    class MySchema(Schema):
-        always_valid = fields.DateTime()
-        always_invalid = FailOnDump()
-
-    schema = MySchema()
-    input_data = {"always_valid": dt.datetime.utcnow(), "always_invalid": 24}
-    try:
-        schema.dump(input_data)
-    except ValidationError as err:
-        # err.data is the raw input data
-        assert err.data == input_data
-        assert "always_valid" in err.valid_data
-        # err.valid_data contains valid, serialized data
-        assert isinstance(err.valid_data["always_valid"], str)
-        # excludes invalid data
-        assert "always_invalid" not in err.valid_data
-    else:
-        pytest.fail("Data is invalid. Expected a ValidationError to be raised.")
-
-
-def test_dump_resets_error_fields():
-    class MySchema(Schema):
-        age = fields.Int()
-
-    schema = MySchema()
-    with pytest.raises(ValidationError) as excinfo:
-        schema.dump(User("Joe", age="dummy"))
-    exc = excinfo.value
-    assert len(exc.messages.keys()) == 1
-
-    with pytest.raises(ValidationError) as excinfo:
-        schema.dump(User("Joe", age="__dummy"))
-    exc = excinfo.value
-    assert len(exc.messages.keys()) == 1
-
-
 def test_load_resets_error_fields():
     class MySchema(Schema):
         email = fields.Email()
@@ -217,13 +134,6 @@ def test_errored_fields_do_not_appear_in_output():
     assert "foo" in errors
     assert "foo" not in data
 
-    with pytest.raises(ValidationError) as excinfo:
-        sch.dump({"foo": 2})
-    data, errors = excinfo.value.valid_data, excinfo.value.messages
-
-    assert "foo" in errors
-    assert "foo" not in data
-
 
 def test_load_many_stores_error_indices():
     s = UserSchema()
@@ -264,36 +174,6 @@ def test_multiple_errors_can_be_stored_for_a_given_index():
     assert "bar" in errors[1]
 
 
-def test_dump_many_stores_error_indices():
-    s = UserSchema()
-    u1, u2 = User("Mick", balance=42), User("Keith", balance="dummy")
-
-    with pytest.raises(ValidationError) as excinfo:
-        s.dump([u1, u2], many=True)
-    errors = excinfo.value.messages
-    assert 1 in errors
-    assert len(errors[1]) == 1
-
-    assert "balance" in errors[1]
-
-
-def test_dump_many_doesnt_stores_error_indices_when_index_errors_is_false():
-    class NoIndex(Schema):
-        age = fields.Int()
-
-        class Meta:
-            index_errors = False
-
-    s = NoIndex()
-    u1, u2 = User("Mick", age=42), User("Keith", age="dummy")
-
-    with pytest.raises(ValidationError) as excinfo:
-        s.dump([u1, u2], many=True)
-    errors = excinfo.value.messages
-    assert 1 not in errors
-    assert "age" in errors
-
-
 def test_dump_returns_a_dict(user):
     s = UserSchema()
     result = s.dump(user)
@@ -684,15 +564,12 @@ def test_serializing_dict():
     user = {
         "name": "foo",
         "email": "foo@bar.com",
-        "age": "badage",
+        "age": 42,
         "various_data": {"foo": "bar"},
     }
-    with pytest.raises(ValidationError) as excinfo:
-        UserSchema().dump(user)
-    data, errors = excinfo.value.valid_data, excinfo.value.messages
+    data = UserSchema().dump(user)
     assert data["name"] == "foo"
-    assert "age" in errors
-    assert "age" not in data
+    assert data["age"] == 42
     assert data["various_data"] == {"foo": "bar"}
 
 
@@ -738,22 +615,6 @@ def test_can_serialize_time(user, serialized_user):
     assert serialized_user["time_registered"] == expected
 
 
-def test_invalid_time():
-    u = User("Joe", time_registered="foo")
-    with pytest.raises(ValidationError) as excinfo:
-        UserSchema().dump(u)
-    errors = excinfo.value.messages
-    assert '"foo" cannot be formatted as a time.' in errors["time_registered"]
-
-
-def test_invalid_date():
-    u = User("Joe", birthdate="foo")
-    with pytest.raises(ValidationError) as excinfo:
-        UserSchema().dump(u)
-    errors = excinfo.value.messages
-    assert '"foo" cannot be formatted as a date.' in errors["birthdate"]
-
-
 def test_invalid_dict_but_okay():
     u = User("Joe", various_data="baddict")
     UserSchema().dump(u)
@@ -1792,13 +1653,6 @@ class MySchema(Schema):
     def handle_error(self, errors, obj, **kwargs):
         raise CustomError("Something bad happened")
 
-
-class TestHandleError:
-    def test_dump_with_custom_error_handler(self, user):
-        user.age = "notavalidage"
-        with pytest.raises(CustomError):
-            MySchema().dump(user)
-
     def test_load_with_custom_error_handler(self):
         in_data = {"email": "invalid"}
 
@@ -2083,22 +1937,6 @@ class TestNestedSchema:
         # No problems with collaborators
         assert "collaborators" not in errors
 
-    def test_nested_dump_errors(self, blog):
-        blog.user.age = "foo"
-        with pytest.raises(ValidationError) as excinfo:
-            BlogSchema().dump(blog)
-        errors = excinfo.value.messages
-        assert "age" in errors["user"]
-        assert len(errors["user"]["age"]) == 1
-        assert "Not a valid number." in errors["user"]["age"][0]
-        # No problems with collaborators
-        assert "collaborators" not in errors
-
-    def test_nested_dump(self, blog):
-        blog.user.age = "foo"
-        with pytest.raises(ValidationError, match="age"):
-            BlogSchema().dump(blog)
-
     def test_nested_method_field(self, blog):
         data = BlogSchema().dump(blog)
         assert data["user"]["is_old"]
@@ -2110,13 +1948,6 @@ class TestNestedSchema:
         expected = blog.collaborators[0].name.lower()
         assert data["collaborators"][0]["lowername"] == expected
 
-    def test_invalid_float_field(self):
-        user = User("Joe", age="1b2")
-        with pytest.raises(ValidationError) as excinfo:
-            UserSchema().dump(user)
-        errors = excinfo.value.messages
-        assert "age" in errors
-
     def test_serializer_meta_with_nested_fields(self, blog, user):
         data = BlogSchemaMeta().dump(blog)
         assert data["title"] == blog.title
@@ -2184,35 +2015,6 @@ class TestNestedSchema:
         assert "inner" in errors
         assert "_schema" in errors["inner"]
 
-    def test_dump_validation_error(self):
-        class Child:
-            def __init__(self, foo, bar):
-                self.foo = foo
-                self.bar = bar
-
-        class Parent:
-            def __init__(self, foo, bar):
-                self.foo = foo
-                self.bar = bar
-
-        class ChildSchema(Schema):
-            foo = fields.Int()
-            bar = fields.Int()
-
-        class ParentSchema(Schema):
-            foo = fields.Nested(ChildSchema)
-            bar = fields.Int()
-
-        child = Child(foo="dummy", bar=42)
-        parent = Parent(foo=child, bar=42)
-
-        with pytest.raises(ValidationError) as excinfo:
-            ParentSchema().dump(parent)
-        errors = excinfo.value.messages
-        data = excinfo.value.valid_data
-        assert data == {"foo": {"bar": 42}, "bar": 42}
-        assert errors == {"foo": {"foo": ["Not a valid integer."]}}
-
     @pytest.mark.parametrize("unknown", (None, RAISE, INCLUDE, EXCLUDE))
     def test_nested_unknown_validation(self, unknown):
         class ChildSchema(Schema):
diff --git a/tests/test_serialization.py b/tests/test_serialization.py
index db7b141f..a1953b84 100644
--- a/tests/test_serialization.py
+++ b/tests/test_serialization.py
@@ -4,12 +4,10 @@ import datetime as dt
 import itertools
 import decimal
 import uuid
-import math
 
 import pytest
 
 from marshmallow import Schema, fields, missing as missing_
-from marshmallow.exceptions import ValidationError
 
 from tests.base import User, ALL_FIELDS, central
 
@@ -121,9 +119,6 @@ class TestFieldSerialization:
         user.uuid1 = "{12345678-1234-5678-1234-567812345678}"
         user.uuid2 = uuid.UUID("12345678123456781234567812345678")
         user.uuid3 = None
-        user.uuid4 = "this is not a UUID"
-        user.uuid5 = 42
-        user.uuid6 = {}
 
         field = fields.UUID()
         assert isinstance(field.serialize("uuid1", user), str)
@@ -131,20 +126,12 @@ class TestFieldSerialization:
         assert isinstance(field.serialize("uuid2", user), str)
         assert field.serialize("uuid2", user) == "12345678-1234-5678-1234-567812345678"
         assert field.serialize("uuid3", user) is None
-        with pytest.raises(ValidationError):
-            field.serialize("uuid4", user)
-        with pytest.raises(ValidationError):
-            field.serialize("uuid5", user)
-        with pytest.raises(ValidationError):
-            field.serialize("uuid6", user)
 
     def test_decimal_field(self, user):
         user.m1 = 12
         user.m2 = "12.355"
         user.m3 = decimal.Decimal(1)
         user.m4 = None
-        user.m5 = "abc"
-        user.m6 = [1, 2]
 
         field = fields.Decimal()
         assert isinstance(field.serialize("m1", user), decimal.Decimal)
@@ -154,10 +141,6 @@ class TestFieldSerialization:
         assert isinstance(field.serialize("m3", user), decimal.Decimal)
         assert field.serialize("m3", user) == decimal.Decimal(1)
         assert field.serialize("m4", user) is None
-        with pytest.raises(ValidationError):
-            field.serialize("m5", user)
-        with pytest.raises(ValidationError):
-            field.serialize("m6", user)
 
         field = fields.Decimal(1)
         assert isinstance(field.serialize("m1", user), decimal.Decimal)
@@ -167,10 +150,6 @@ class TestFieldSerialization:
         assert isinstance(field.serialize("m3", user), decimal.Decimal)
         assert field.serialize("m3", user) == decimal.Decimal(1)
         assert field.serialize("m4", user) is None
-        with pytest.raises(ValidationError):
-            field.serialize("m5", user)
-        with pytest.raises(ValidationError):
-            field.serialize("m6", user)
 
         field = fields.Decimal(1, decimal.ROUND_DOWN)
         assert isinstance(field.serialize("m1", user), decimal.Decimal)
@@ -180,18 +159,12 @@ class TestFieldSerialization:
         assert isinstance(field.serialize("m3", user), decimal.Decimal)
         assert field.serialize("m3", user) == decimal.Decimal(1)
         assert field.serialize("m4", user) is None
-        with pytest.raises(ValidationError):
-            field.serialize("m5", user)
-        with pytest.raises(ValidationError):
-            field.serialize("m6", user)
 
     def test_decimal_field_string(self, user):
         user.m1 = 12
         user.m2 = "12.355"
         user.m3 = decimal.Decimal(1)
         user.m4 = None
-        user.m5 = "abc"
-        user.m6 = [1, 2]
 
         field = fields.Decimal(as_string=True)
         assert isinstance(field.serialize("m1", user), str)
@@ -201,10 +174,6 @@ class TestFieldSerialization:
         assert isinstance(field.serialize("m3", user), str)
         assert field.serialize("m3", user) == "1"
         assert field.serialize("m4", user) is None
-        with pytest.raises(ValidationError):
-            field.serialize("m5", user)
-        with pytest.raises(ValidationError):
-            field.serialize("m6", user)
 
         field = fields.Decimal(1, as_string=True)
         assert isinstance(field.serialize("m1", user), str)
@@ -214,10 +183,6 @@ class TestFieldSerialization:
         assert isinstance(field.serialize("m3", user), str)
         assert field.serialize("m3", user) == "1.0"
         assert field.serialize("m4", user) is None
-        with pytest.raises(ValidationError):
-            field.serialize("m5", user)
-        with pytest.raises(ValidationError):
-            field.serialize("m6", user)
 
         field = fields.Decimal(1, decimal.ROUND_DOWN, as_string=True)
         assert isinstance(field.serialize("m1", user), str)
@@ -227,10 +192,6 @@ class TestFieldSerialization:
         assert isinstance(field.serialize("m3", user), str)
         assert field.serialize("m3", user) == "1.0"
         assert field.serialize("m4", user) is None
-        with pytest.raises(ValidationError):
-            field.serialize("m5", user)
-        with pytest.raises(ValidationError):
-            field.serialize("m6", user)
 
     def test_decimal_field_special_values(self, user):
         user.m1 = "-NaN"
@@ -286,59 +247,14 @@ class TestFieldSerialization:
         assert m6s == user.m6
 
     def test_decimal_field_special_values_not_permitted(self, user):
-        user.m1 = "-NaN"
-        user.m2 = "NaN"
-        user.m3 = "-sNaN"
-        user.m4 = "sNaN"
-        user.m5 = "-Infinity"
-        user.m6 = "Infinity"
         user.m7 = "-0"
 
         field = fields.Decimal(places=2)
 
-        with pytest.raises(ValidationError):
-            field.serialize("m1", user)
-        with pytest.raises(ValidationError):
-            field.serialize("m2", user)
-        with pytest.raises(ValidationError):
-            field.serialize("m3", user)
-        with pytest.raises(ValidationError):
-            field.serialize("m4", user)
-        with pytest.raises(ValidationError):
-            field.serialize("m5", user)
-        with pytest.raises(ValidationError):
-            field.serialize("m6", user)
-
         m7s = field.serialize("m7", user)
         assert isinstance(m7s, decimal.Decimal)
         assert m7s.is_zero() and m7s.is_signed()
 
-    @pytest.mark.parametrize("allow_nan", (None, False, True))
-    @pytest.mark.parametrize("value", ("nan", "-nan", "inf", "-inf"))
-    def test_float_field_allow_nan(self, value, allow_nan, user):
-
-        user.key = value
-
-        if allow_nan is None:
-            # Test default case is False
-            field = fields.Float()
-        else:
-            field = fields.Float(allow_nan=allow_nan)
-
-        if allow_nan is True:
-            res = field.serialize("key", user)
-            assert isinstance(res, float)
-            if value.endswith("nan"):
-                assert math.isnan(res)
-            else:
-                assert res == float(value)
-        else:
-            with pytest.raises(ValidationError) as excinfo:
-                field.serialize("key", user)
-            assert str(excinfo.value.args[0]) == (
-                "Special numeric values (nan or infinity) are not permitted."
-            )
-
     def test_decimal_field_fixed_point_representation(self, user):
         """
         Test we get fixed-point string representation for a Decimal number that would normally
@@ -419,12 +335,6 @@ class TestFieldSerialization:
         field = fields.Dict(keys=fields.Str, values=fields.Decimal)
         assert field.serialize("various_data", user) == {"1": 1}
 
-    def test_structured_dict_validates(self, user):
-        user.various_data = {"foo": "bar"}
-        field = fields.Dict(values=fields.Decimal)
-        with pytest.raises(ValidationError):
-            field.serialize("various_data", user)
-
     def test_url_field_serialize_none(self, user):
         user.homepage = None
         field = fields.Url()
@@ -498,17 +408,6 @@ class TestFieldSerialization:
             "Years": 999,
         }
 
-    @pytest.mark.parametrize("value", ["invalid", [], 24])
-    def test_datetime_invalid_serialization(self, value, user):
-        field = fields.DateTime()
-        user.created = value
-
-        with pytest.raises(ValidationError) as excinfo:
-            field.serialize("created", user)
-        assert excinfo.value.args[
-            0
-        ] == '"{}" cannot be formatted as a datetime.'.format(value)
-
     @pytest.mark.parametrize("fmt", ["rfc", "rfc822"])
     @pytest.mark.parametrize(
         ("value", "expected"),
@@ -580,15 +479,6 @@ class TestFieldSerialization:
         user.time_registered = None
         assert field.serialize("time_registered", user) is None
 
-    @pytest.mark.parametrize("in_data", ["badvalue", "", [], 42])
-    def test_invalid_time_field_serialization(self, in_data, user):
-        field = fields.Time()
-        user.time_registered = in_data
-        with pytest.raises(ValidationError) as excinfo:
-            field.serialize("time_registered", user)
-        msg = '"{}" cannot be formatted as a time.'.format(in_data)
-        assert excinfo.value.args[0] == msg
-
     def test_date_field(self, user):
         field = fields.Date()
         assert field.serialize("birthdate", user) == user.birthdate.isoformat()
@@ -596,15 +486,6 @@ class TestFieldSerialization:
         user.birthdate = None
         assert field.serialize("birthdate", user) is None
 
-    @pytest.mark.parametrize("in_data", ["badvalue", "", [], 42])
-    def test_invalid_date_field_serialization(self, in_data, user):
-        field = fields.Date()
-        user.birthdate = in_data
-        with pytest.raises(ValidationError) as excinfo:
-            field.serialize("birthdate", user)
-        msg = '"{}" cannot be formatted as a date.'.format(in_data)
-        assert excinfo.value.args[0] == msg
-
     def test_timedelta_field(self, user):
         user.d1 = dt.timedelta(days=1, seconds=1, microseconds=1)
         user.d2 = dt.timedelta(days=0, seconds=86401, microseconds=1)
@@ -689,12 +570,6 @@ class TestFieldSerialization:
         result = field.serialize("dtimes", obj)
         assert all([type(each) == str for each in result])
 
-    def test_list_field_with_error(self):
-        obj = DateTimeList(["invaliddate"])
-        field = fields.List(fields.DateTime)
-        with pytest.raises(ValidationError):
-            field.serialize("dtimes", obj)
-
     def test_list_field_serialize_none_returns_none(self):
         obj = DateTimeList(None)
         field = fields.List(fields.DateTime)
@@ -719,16 +594,6 @@ class TestFieldSerialization:
         result = field.serialize("dtimes", obj)
         assert len(result) == 2
 
-    def test_list_field_work_with_generators_error(self):
-        def custom_generator():
-            for dtime in [dt.datetime.utcnow(), "m", dt.datetime.now()]:
-                yield dtime
-
-        obj = DateTimeList(custom_generator())
-        field = fields.List(fields.DateTime)
-        with pytest.raises(ValidationError):
-            field.serialize("dtimes", obj)
-
     def test_list_field_work_with_generators_empty_generator_returns_none_for_every_non_returning_yield_statement(  # noqa: B950
         self
     ):
@@ -790,19 +655,6 @@ class TestFieldSerialization:
         assert type(result[0]) == str
         assert type(result[1]) == int
 
-    @pytest.mark.parametrize(
-        "obj",
-        [
-            DateTimeIntegerTuple(("invaliddate", 42)),
-            DateTimeIntegerTuple((dt.datetime.utcnow(), "invalidint")),
-            DateTimeIntegerTuple(("invaliddate", "invalidint")),
-        ],
-    )
-    def test_tuple_field_with_error(self, obj):
-        field = fields.Tuple([fields.DateTime, fields.Integer])
-        with pytest.raises(ValidationError):
-            field.serialize("dtime_int", obj)
-
     def test_tuple_field_serialize_none_returns_none(self):
         obj = DateTimeIntegerTuple(None)
         field = fields.Tuple([fields.DateTime, fields.Integer])

pip install -e .[dev]
parse_log_pytest
requirements.txt
pytest pytest-cov pytest-xdist pytest-mock pytest-asyncio
3.9
requirements/base.txt
pytest --no-header -rA --tb=line --color=no -p no:cacheprovider -W ignore::DeprecationWarning
aspy.yaml==1.3.0
attrs==25.3.0
cachetools==5.5.2
cfgv==3.4.0
chardet==5.2.0
colorama==0.4.6
coverage==7.8.0
distlib==0.3.9
entrypoints==0.3
exceptiongroup==1.2.2
execnet==2.1.1
filelock==3.18.0
flake8==3.7.8
flake8-bugbear==19.3.0
identify==2.6.9
iniconfig==2.1.0
-e git+https://github.com/marshmallow-code/marshmallow.git@70d95e1c44b9838ed4042f636ac71ad65ad9e522#egg=marshmallow
mccabe==0.6.1
nodeenv==1.9.1
packaging==24.2
platformdirs==4.3.7
pluggy==1.5.0
pre-commit==1.21.0
pycodestyle==2.5.0
pyflakes==2.1.1
pyproject-api==1.9.0
pytest==8.3.5
pytest-asyncio==0.26.0
pytest-cov==6.0.0
pytest-mock==3.14.0
pytest-xdist==3.6.1
pytz==2025.2
PyYAML==6.0.2
simplejson==3.20.1
six==1.17.0
toml==0.10.2
tomli==2.2.1
tox==4.25.0
typing_extensions==4.13.0
virtualenv==20.29.3

name: marshmallow
channels:
  - defaults
  - https://repo.anaconda.com/pkgs/main
  - https://repo.anaconda.com/pkgs/r
  - conda-forge
dependencies:
  - _libgcc_mutex=0.1=main
  - _openmp_mutex=5.1=1_gnu
  - ca-certificates=2025.2.25=h06a4308_0
  - ld_impl_linux-64=2.40=h12ee557_0
  - libffi=3.4.4=h6a678d5_1
  - libgcc-ng=11.2.0=h1234567_1
  - libgomp=11.2.0=h1234567_1
  - libstdcxx-ng=11.2.0=h1234567_1
  - ncurses=6.4=h6a678d5_0
  - openssl=3.0.16=h5eee18b_0
  - pip=25.0=py39h06a4308_0
  - python=3.9.21=he870216_1
  - readline=8.2=h5eee18b_0
  - setuptools=75.8.0=py39h06a4308_0
  - sqlite=3.45.3=h5eee18b_0
  - tk=8.6.14=h39e8969_0
  - tzdata=2025a=h04d1e81_0
  - wheel=0.45.1=py39h06a4308_0
  - xz=5.6.4=h5eee18b_1
  - zlib=1.2.13=h5eee18b_1
  - pip:
      - aspy-yaml==1.3.0
      - attrs==25.3.0
      - cachetools==5.5.2
      - cfgv==3.4.0
      - chardet==5.2.0
      - colorama==0.4.6
      - coverage==7.8.0
      - distlib==0.3.9
      - entrypoints==0.3
      - exceptiongroup==1.2.2
      - execnet==2.1.1
      - filelock==3.18.0
      - flake8==3.7.8
      - flake8-bugbear==19.3.0
      - identify==2.6.9
      - iniconfig==2.1.0
      - mccabe==0.6.1
      - nodeenv==1.9.1
      - packaging==24.2
      - platformdirs==4.3.7
      - pluggy==1.5.0
      - pre-commit==1.21.0
      - pycodestyle==2.5.0
      - pyflakes==2.1.1
      - pyproject-api==1.9.0
      - pytest==8.3.5
      - pytest-asyncio==0.26.0
      - pytest-cov==6.0.0
      - pytest-mock==3.14.0
      - pytest-xdist==3.6.1
      - pytz==2025.2
      - pyyaml==6.0.2
      - simplejson==3.20.1
      - six==1.17.0
      - toml==0.10.2
      - tomli==2.2.1
      - tox==4.25.0
      - typing-extensions==4.13.0
      - virtualenv==20.29.3
prefix: /opt/conda/envs/marshmallow

tests/test_deserialization.py::TestFieldDeserialization::test_invalid_datetime_deserialization[10:33:25
tests/test_decorators.py::test_decorated_processors[True] tests/test_decorators.py::test_decorated_processors[False] tests/test_decorators.py::test_decorated_processor_returning_none[exclude] tests/test_decorators.py::test_decorated_processor_returning_none[include] tests/test_decorators.py::test_decorated_processor_returning_none[raise] tests/test_decorators.py::TestPassOriginal::test_pass_original_single tests/test_decorators.py::TestPassOriginal::test_pass_original_many tests/test_decorators.py::test_decorated_processor_inheritance tests/test_decorators.py::test_pre_dump_is_invoked_before_implicit_field_generation tests/test_decorators.py::TestValidatesDecorator::test_validates tests/test_decorators.py::TestValidatesDecorator::test_validates_with_attribute tests/test_decorators.py::TestValidatesDecorator::test_validates_decorator tests/test_decorators.py::TestValidatesDecorator::test_field_not_present tests/test_decorators.py::TestValidatesDecorator::test_precedence tests/test_decorators.py::TestValidatesDecorator::test_validates_with_data_key tests/test_decorators.py::TestValidatesSchemaDecorator::test_validator_nested_many_invalid_data tests/test_decorators.py::TestValidatesSchemaDecorator::test_validator_nested_many_schema_error tests/test_decorators.py::TestValidatesSchemaDecorator::test_validator_nested_many_field_error tests/test_decorators.py::TestValidatesSchemaDecorator::test_validator_nested_many_pass_original_and_pass_many[True-expected_data0-expected_original_data0-data0] tests/test_decorators.py::TestValidatesSchemaDecorator::test_validator_nested_many_pass_original_and_pass_many[False-expected_data1-expected_original_data1-data0] tests/test_decorators.py::TestValidatesSchemaDecorator::test_decorated_validators tests/test_decorators.py::TestValidatesSchemaDecorator::test_multiple_validators tests/test_decorators.py::TestValidatesSchemaDecorator::test_multiple_validators_merge_dict_errors tests/test_decorators.py::TestValidatesSchemaDecorator::test_passing_original_data tests/test_decorators.py::TestValidatesSchemaDecorator::test_allow_reporting_field_errors_in_schema_validator tests/test_decorators.py::TestValidatesSchemaDecorator::test_allow_arbitrary_field_names_in_error tests/test_decorators.py::TestValidatesSchemaDecorator::test_skip_on_field_errors tests/test_decorators.py::test_decorator_error_handling tests/test_decorators.py::test_decorator_error_handling_with_load[pre_load] tests/test_decorators.py::test_decorator_error_handling_with_load[post_load] tests/test_decorators.py::test_decorator_error_handling_with_load_dict_error[pre_load] tests/test_decorators.py::test_decorator_error_handling_with_load_dict_error[post_load] tests/test_decorators.py::test_decorator_error_handling_with_dump[pre_dump] tests/test_decorators.py::test_decorator_error_handling_with_dump[post_dump] tests/test_decorators.py::test_decorator_post_dump_with_nested_original_and_pass_many[data0-expected_data0-expected_original_data0] tests/test_decorators.py::test_decorator_post_load_with_nested_original_and_pass_many[data0-expected_data0-expected_original_data0] tests/test_deserialization.py::TestDeserializingNone::test_fields_allow_none_deserialize_to_none[String] tests/test_deserialization.py::TestDeserializingNone::test_fields_allow_none_deserialize_to_none[Integer] tests/test_deserialization.py::TestDeserializingNone::test_fields_allow_none_deserialize_to_none[Boolean] tests/test_deserialization.py::TestDeserializingNone::test_fields_allow_none_deserialize_to_none[Float] tests/test_deserialization.py::TestDeserializingNone::test_fields_allow_none_deserialize_to_none[Number] tests/test_deserialization.py::TestDeserializingNone::test_fields_allow_none_deserialize_to_none[DateTime] tests/test_deserialization.py::TestDeserializingNone::test_fields_allow_none_deserialize_to_none[Time] tests/test_deserialization.py::TestDeserializingNone::test_fields_allow_none_deserialize_to_none[Date] tests/test_deserialization.py::TestDeserializingNone::test_fields_allow_none_deserialize_to_none[TimeDelta] tests/test_deserialization.py::TestDeserializingNone::test_fields_allow_none_deserialize_to_none[Dict] tests/test_deserialization.py::TestDeserializingNone::test_fields_allow_none_deserialize_to_none[Url] tests/test_deserialization.py::TestDeserializingNone::test_fields_allow_none_deserialize_to_none[Email] tests/test_deserialization.py::TestDeserializingNone::test_fields_allow_none_deserialize_to_none[UUID] tests/test_deserialization.py::TestDeserializingNone::test_fields_allow_none_deserialize_to_none[Decimal] tests/test_deserialization.py::TestDeserializingNone::test_fields_dont_allow_none_by_default[String] tests/test_deserialization.py::TestDeserializingNone::test_fields_dont_allow_none_by_default[Integer] tests/test_deserialization.py::TestDeserializingNone::test_fields_dont_allow_none_by_default[Boolean] tests/test_deserialization.py::TestDeserializingNone::test_fields_dont_allow_none_by_default[Float] tests/test_deserialization.py::TestDeserializingNone::test_fields_dont_allow_none_by_default[Number] tests/test_deserialization.py::TestDeserializingNone::test_fields_dont_allow_none_by_default[DateTime] tests/test_deserialization.py::TestDeserializingNone::test_fields_dont_allow_none_by_default[Time] tests/test_deserialization.py::TestDeserializingNone::test_fields_dont_allow_none_by_default[Date] tests/test_deserialization.py::TestDeserializingNone::test_fields_dont_allow_none_by_default[TimeDelta] tests/test_deserialization.py::TestDeserializingNone::test_fields_dont_allow_none_by_default[Dict] tests/test_deserialization.py::TestDeserializingNone::test_fields_dont_allow_none_by_default[Url] tests/test_deserialization.py::TestDeserializingNone::test_fields_dont_allow_none_by_default[Email] tests/test_deserialization.py::TestDeserializingNone::test_fields_dont_allow_none_by_default[UUID] tests/test_deserialization.py::TestDeserializingNone::test_fields_dont_allow_none_by_default[Decimal] tests/test_deserialization.py::TestDeserializingNone::test_allow_none_is_true_if_missing_is_true tests/test_deserialization.py::TestDeserializingNone::test_list_field_deserialize_none_to_none tests/test_deserialization.py::TestDeserializingNone::test_tuple_field_deserialize_none_to_none tests/test_deserialization.py::TestFieldDeserialization::test_float_field_deserialization tests/test_deserialization.py::TestFieldDeserialization::test_invalid_float_field_deserialization[bad] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_float_field_deserialization[] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_float_field_deserialization[in_val2] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_float_field_deserialization[True] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_float_field_deserialization[False] tests/test_deserialization.py::TestFieldDeserialization::test_float_field_overflow tests/test_deserialization.py::TestFieldDeserialization::test_integer_field_deserialization tests/test_deserialization.py::TestFieldDeserialization::test_strict_integer_field_deserialization tests/test_deserialization.py::TestFieldDeserialization::test_decimal_field_deserialization tests/test_deserialization.py::TestFieldDeserialization::test_decimal_field_with_places tests/test_deserialization.py::TestFieldDeserialization::test_decimal_field_with_places_and_rounding tests/test_deserialization.py::TestFieldDeserialization::test_decimal_field_deserialization_string tests/test_deserialization.py::TestFieldDeserialization::test_decimal_field_special_values tests/test_deserialization.py::TestFieldDeserialization::test_decimal_field_special_values_not_permitted tests/test_deserialization.py::TestFieldDeserialization::test_float_field_allow_nan[nan-None] tests/test_deserialization.py::TestFieldDeserialization::test_float_field_allow_nan[nan-False] tests/test_deserialization.py::TestFieldDeserialization::test_float_field_allow_nan[nan-True] tests/test_deserialization.py::TestFieldDeserialization::test_float_field_allow_nan[-nan-None] tests/test_deserialization.py::TestFieldDeserialization::test_float_field_allow_nan[-nan-False] tests/test_deserialization.py::TestFieldDeserialization::test_float_field_allow_nan[-nan-True] tests/test_deserialization.py::TestFieldDeserialization::test_float_field_allow_nan[inf-None] tests/test_deserialization.py::TestFieldDeserialization::test_float_field_allow_nan[inf-False] tests/test_deserialization.py::TestFieldDeserialization::test_float_field_allow_nan[inf-True] tests/test_deserialization.py::TestFieldDeserialization::test_float_field_allow_nan[-inf-None] tests/test_deserialization.py::TestFieldDeserialization::test_float_field_allow_nan[-inf-False] tests/test_deserialization.py::TestFieldDeserialization::test_float_field_allow_nan[-inf-True] tests/test_deserialization.py::TestFieldDeserialization::test_string_field_deserialization tests/test_deserialization.py::TestFieldDeserialization::test_boolean_field_deserialization tests/test_deserialization.py::TestFieldDeserialization::test_boolean_field_deserialization_with_custom_truthy_values tests/test_deserialization.py::TestFieldDeserialization::test_boolean_field_deserialization_with_custom_truthy_values_invalid[notvalid] tests/test_deserialization.py::TestFieldDeserialization::test_boolean_field_deserialization_with_custom_truthy_values_invalid[123] tests/test_deserialization.py::TestFieldDeserialization::test_boolean_field_deserialization_with_empty_truthy tests/test_deserialization.py::TestFieldDeserialization::test_boolean_field_deserialization_with_custom_falsy_values tests/test_deserialization.py::TestFieldDeserialization::test_field_toggle_show_invalid_value_in_error_message tests/test_deserialization.py::TestFieldDeserialization::test_invalid_datetime_deserialization[not-a-datetime] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_datetime_deserialization[42] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_datetime_deserialization[] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_datetime_deserialization[in_value3] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_datetime_deserialization[2018] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_datetime_deserialization[2018-01-01] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_datetime_deserialization[03-31-2025 tests/test_deserialization.py::TestFieldDeserialization::test_custom_date_format_datetime_field_deserialization tests/test_deserialization.py::TestFieldDeserialization::test_rfc_datetime_field_deserialization[Sun, tests/test_deserialization.py::TestFieldDeserialization::test_iso_datetime_field_deserialization[2013-11-10T01:23:45-expected0-False-iso] tests/test_deserialization.py::TestFieldDeserialization::test_iso_datetime_field_deserialization[2013-11-10T01:23:45-expected0-False-iso8601] tests/test_deserialization.py::TestFieldDeserialization::test_iso_datetime_field_deserialization[2013-11-10T01:23:45+00:00-expected1-True-iso] tests/test_deserialization.py::TestFieldDeserialization::test_iso_datetime_field_deserialization[2013-11-10T01:23:45+00:00-expected1-True-iso8601] tests/test_deserialization.py::TestFieldDeserialization::test_iso_datetime_field_deserialization[2013-11-10T01:23:45.123+00:00-expected2-True-iso] tests/test_deserialization.py::TestFieldDeserialization::test_iso_datetime_field_deserialization[2013-11-10T01:23:45.123+00:00-expected2-True-iso8601] tests/test_deserialization.py::TestFieldDeserialization::test_iso_datetime_field_deserialization[2013-11-10T01:23:45.123456+00:00-expected3-True-iso] tests/test_deserialization.py::TestFieldDeserialization::test_iso_datetime_field_deserialization[2013-11-10T01:23:45.123456+00:00-expected3-True-iso8601] tests/test_deserialization.py::TestFieldDeserialization::test_iso_datetime_field_deserialization[2013-11-10T01:23:45-06:00-expected4-True-iso] tests/test_deserialization.py::TestFieldDeserialization::test_iso_datetime_field_deserialization[2013-11-10T01:23:45-06:00-expected4-True-iso8601] tests/test_deserialization.py::TestFieldDeserialization::test_naive_datetime_with_timezone[iso-None-2013-11-10T01:23:45-expected0] tests/test_deserialization.py::TestFieldDeserialization::test_naive_datetime_with_timezone[iso-timezone1-2013-11-10T01:23:45+00:00-expected1] tests/test_deserialization.py::TestFieldDeserialization::test_naive_datetime_with_timezone[iso-timezone2-2013-11-10T01:23:45-03:00-expected2] tests/test_deserialization.py::TestFieldDeserialization::test_naive_datetime_with_timezone[rfc-None-Sun, tests/test_deserialization.py::TestFieldDeserialization::test_naive_datetime_with_timezone[rfc-timezone4-Sun, tests/test_deserialization.py::TestFieldDeserialization::test_naive_datetime_with_timezone[rfc-timezone5-Sun, tests/test_deserialization.py::TestFieldDeserialization::test_aware_datetime_default_timezone[iso-2013-11-10T01:23:45-timezone0] tests/test_deserialization.py::TestFieldDeserialization::test_aware_datetime_default_timezone[iso-2013-11-10T01:23:45-timezone1] tests/test_deserialization.py::TestFieldDeserialization::test_aware_datetime_default_timezone[rfc-Sun, tests/test_deserialization.py::TestFieldDeserialization::test_time_field_deserialization tests/test_deserialization.py::TestFieldDeserialization::test_invalid_time_field_deserialization[badvalue] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_time_field_deserialization[] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_time_field_deserialization[in_data2] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_time_field_deserialization[42] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_timedelta_precision tests/test_deserialization.py::TestFieldDeserialization::test_timedelta_field_deserialization tests/test_deserialization.py::TestFieldDeserialization::test_invalid_timedelta_field_deserialization[] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_timedelta_field_deserialization[badvalue] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_timedelta_field_deserialization[in_value2] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_timedelta_field_deserialization[9999999999] tests/test_deserialization.py::TestFieldDeserialization::test_date_field_deserialization[None] tests/test_deserialization.py::TestFieldDeserialization::test_date_field_deserialization[%Y-%m-%d] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_date_field_deserialization[] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_date_field_deserialization[123] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_date_field_deserialization[in_value2] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_date_field_deserialization[21-08-2014] tests/test_deserialization.py::TestFieldDeserialization::test_dict_field_deserialization tests/test_deserialization.py::TestFieldDeserialization::test_structured_dict_value_deserialization tests/test_deserialization.py::TestFieldDeserialization::test_structured_dict_key_deserialization tests/test_deserialization.py::TestFieldDeserialization::test_structured_dict_key_value_deserialization tests/test_deserialization.py::TestFieldDeserialization::test_url_field_deserialization tests/test_deserialization.py::TestFieldDeserialization::test_relative_url_field_deserialization tests/test_deserialization.py::TestFieldDeserialization::test_url_field_schemes_argument tests/test_deserialization.py::TestFieldDeserialization::test_email_field_deserialization tests/test_deserialization.py::TestFieldDeserialization::test_function_field_deserialization_is_noop_by_default tests/test_deserialization.py::TestFieldDeserialization::test_function_field_deserialization_with_callable tests/test_deserialization.py::TestFieldDeserialization::test_function_field_deserialization_with_context tests/test_deserialization.py::TestFieldDeserialization::test_function_field_passed_deserialize_only_is_load_only tests/test_deserialization.py::TestFieldDeserialization::test_function_field_passed_deserialize_and_serialize_is_not_load_only tests/test_deserialization.py::TestFieldDeserialization::test_uuid_field_deserialization tests/test_deserialization.py::TestFieldDeserialization::test_invalid_uuid_deserialization[malformed] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_uuid_deserialization[123] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_uuid_deserialization[in_value2] tests/test_deserialization.py::TestFieldDeserialization::test_invalid_uuid_deserialization[tooshort] tests/test_deserialization.py::TestFieldDeserialization::test_deserialization_function_must_be_callable tests/test_deserialization.py::TestFieldDeserialization::test_method_field_deserialization_is_noop_by_default tests/test_deserialization.py::TestFieldDeserialization::test_deserialization_method tests/test_deserialization.py::TestFieldDeserialization::test_deserialization_method_must_be_a_method tests/test_deserialization.py::TestFieldDeserialization::test_method_field_deserialize_only tests/test_deserialization.py::TestFieldDeserialization::test_datetime_list_field_deserialization tests/test_deserialization.py::TestFieldDeserialization::test_list_field_deserialize_invalid_item tests/test_deserialization.py::TestFieldDeserialization::test_list_field_deserialize_multiple_invalid_items tests/test_deserialization.py::TestFieldDeserialization::test_list_field_deserialize_value_that_is_not_a_list[notalist] tests/test_deserialization.py::TestFieldDeserialization::test_list_field_deserialize_value_that_is_not_a_list[42] tests/test_deserialization.py::TestFieldDeserialization::test_list_field_deserialize_value_that_is_not_a_list[value2] tests/test_deserialization.py::TestFieldDeserialization::test_datetime_int_tuple_field_deserialization tests/test_deserialization.py::TestFieldDeserialization::test_tuple_field_deserialize_invalid_item tests/test_deserialization.py::TestFieldDeserialization::test_tuple_field_deserialize_multiple_invalid_items tests/test_deserialization.py::TestFieldDeserialization::test_tuple_field_deserialize_value_that_is_not_a_collection[notalist] tests/test_deserialization.py::TestFieldDeserialization::test_tuple_field_deserialize_value_that_is_not_a_collection[42] tests/test_deserialization.py::TestFieldDeserialization::test_tuple_field_deserialize_value_that_is_not_a_collection[value2] tests/test_deserialization.py::TestFieldDeserialization::test_tuple_field_deserialize_invalid_length tests/test_deserialization.py::TestFieldDeserialization::test_constant_field_deserialization tests/test_deserialization.py::TestFieldDeserialization::test_constant_is_always_included_in_deserialized_data tests/test_deserialization.py::TestFieldDeserialization::test_field_deserialization_with_user_validator_function tests/test_deserialization.py::TestFieldDeserialization::test_field_deserialization_with_user_validator_class_that_returns_bool tests/test_deserialization.py::TestFieldDeserialization::test_field_deserialization_with_user_validator_that_raises_error_with_list tests/test_deserialization.py::TestFieldDeserialization::test_validator_must_return_false_to_raise_error tests/test_deserialization.py::TestFieldDeserialization::test_field_deserialization_with_validator_with_nonascii_input tests/test_deserialization.py::TestFieldDeserialization::test_field_deserialization_with_user_validators tests/test_deserialization.py::TestFieldDeserialization::test_field_deserialization_with_custom_error_message tests/test_deserialization.py::TestSchemaDeserialization::test_deserialize_to_dict tests/test_deserialization.py::TestSchemaDeserialization::test_deserialize_with_missing_values tests/test_deserialization.py::TestSchemaDeserialization::test_deserialize_many tests/test_deserialization.py::TestSchemaDeserialization::test_exclude tests/test_deserialization.py::TestSchemaDeserialization::test_nested_single_deserialization_to_dict tests/test_deserialization.py::TestSchemaDeserialization::test_nested_list_deserialization_to_dict tests/test_deserialization.py::TestSchemaDeserialization::test_nested_single_none_not_allowed tests/test_deserialization.py::TestSchemaDeserialization::test_nested_many_non_not_allowed tests/test_deserialization.py::TestSchemaDeserialization::test_nested_single_required_missing tests/test_deserialization.py::TestSchemaDeserialization::test_nested_many_required_missing tests/test_deserialization.py::TestSchemaDeserialization::test_nested_only_basestring tests/test_deserialization.py::TestSchemaDeserialization::test_nested_only_basestring_with_list_data tests/test_deserialization.py::TestSchemaDeserialization::test_nested_none_deserialization tests/test_deserialization.py::TestSchemaDeserialization::test_deserialize_with_attribute_param tests/test_deserialization.py::TestSchemaDeserialization::test_deserialize_with_attribute_param_symmetry tests/test_deserialization.py::TestSchemaDeserialization::test_deserialize_with_attribute_param_error_returns_field_name_not_attribute_name tests/test_deserialization.py::TestSchemaDeserialization::test_deserialize_with_attribute_param_error_returns_data_key_not_attribute_name tests/test_deserialization.py::TestSchemaDeserialization::test_deserialize_with_data_key_param tests/test_deserialization.py::TestSchemaDeserialization::test_deserialize_with_dump_only_param tests/test_deserialization.py::TestSchemaDeserialization::test_deserialize_with_missing_param_value tests/test_deserialization.py::TestSchemaDeserialization::test_deserialize_with_missing_param_callable tests/test_deserialization.py::TestSchemaDeserialization::test_deserialize_with_missing_param_none tests/test_deserialization.py::TestSchemaDeserialization::test_deserialization_raises_with_errors tests/test_deserialization.py::TestSchemaDeserialization::test_deserialization_raises_with_errors_with_multiple_validators tests/test_deserialization.py::TestSchemaDeserialization::test_deserialization_many_raises_errors tests/test_deserialization.py::TestSchemaDeserialization::test_validation_errors_are_stored tests/test_deserialization.py::TestSchemaDeserialization::test_multiple_errors_can_be_stored_for_a_field tests/test_deserialization.py::TestSchemaDeserialization::test_multiple_errors_can_be_stored_for_an_email_field tests/test_deserialization.py::TestSchemaDeserialization::test_multiple_errors_can_be_stored_for_a_url_field tests/test_deserialization.py::TestSchemaDeserialization::test_required_value_only_passed_to_validators_if_provided tests/test_deserialization.py::TestSchemaDeserialization::test_partial_deserialization[True] tests/test_deserialization.py::TestSchemaDeserialization::test_partial_deserialization[False] tests/test_deserialization.py::TestSchemaDeserialization::test_partial_fields_deserialization tests/test_deserialization.py::TestSchemaDeserialization::test_partial_fields_validation tests/test_deserialization.py::TestSchemaDeserialization::test_unknown_fields_deserialization tests/test_deserialization.py::TestSchemaDeserialization::test_unknown_fields_deserialization_precedence tests/test_deserialization.py::TestSchemaDeserialization::test_unknown_fields_deserialization_with_data_key tests/test_deserialization.py::TestSchemaDeserialization::test_unknown_fields_deserialization_with_index_errors_false tests/test_deserialization.py::TestSchemaDeserialization::test_dump_only_fields_considered_unknown tests/test_deserialization.py::TestValidation::test_integer_with_validator tests/test_deserialization.py::TestValidation::test_integer_with_validators[field0] tests/test_deserialization.py::TestValidation::test_integer_with_validators[field1] tests/test_deserialization.py::TestValidation::test_integer_with_validators[field2] tests/test_deserialization.py::TestValidation::test_float_with_validators[field0] tests/test_deserialization.py::TestValidation::test_float_with_validators[field1] tests/test_deserialization.py::TestValidation::test_float_with_validators[field2] tests/test_deserialization.py::TestValidation::test_string_validator tests/test_deserialization.py::TestValidation::test_function_validator tests/test_deserialization.py::TestValidation::test_function_validators[field0] tests/test_deserialization.py::TestValidation::test_function_validators[field1] tests/test_deserialization.py::TestValidation::test_function_validators[field2] tests/test_deserialization.py::TestValidation::test_method_validator tests/test_deserialization.py::TestValidation::test_nested_data_is_stored_when_validation_fails tests/test_deserialization.py::TestValidation::test_false_value_validation tests/test_deserialization.py::TestValidation::test_nested_partial_load tests/test_deserialization.py::TestValidation::test_deeply_nested_partial_load tests/test_deserialization.py::TestValidation::test_nested_partial_tuple tests/test_deserialization.py::test_required_field_failure[String] tests/test_deserialization.py::test_required_field_failure[Integer] tests/test_deserialization.py::test_required_field_failure[Boolean] tests/test_deserialization.py::test_required_field_failure[Float] tests/test_deserialization.py::test_required_field_failure[Number] tests/test_deserialization.py::test_required_field_failure[DateTime] tests/test_deserialization.py::test_required_field_failure[Time] tests/test_deserialization.py::test_required_field_failure[Date] tests/test_deserialization.py::test_required_field_failure[TimeDelta] tests/test_deserialization.py::test_required_field_failure[Dict] tests/test_deserialization.py::test_required_field_failure[Url] tests/test_deserialization.py::test_required_field_failure[Email] tests/test_deserialization.py::test_required_field_failure[UUID] tests/test_deserialization.py::test_required_field_failure[Decimal] tests/test_deserialization.py::test_required_message_can_be_changed[My tests/test_deserialization.py::test_required_message_can_be_changed[message1] tests/test_deserialization.py::test_required_message_can_be_changed[message2] tests/test_deserialization.py::test_deserialize_raises_exception_if_input_type_is_incorrect[True-exclude] tests/test_deserialization.py::test_deserialize_raises_exception_if_input_type_is_incorrect[True-include] tests/test_deserialization.py::test_deserialize_raises_exception_if_input_type_is_incorrect[True-raise] tests/test_deserialization.py::test_deserialize_raises_exception_if_input_type_is_incorrect[False-exclude] tests/test_deserialization.py::test_deserialize_raises_exception_if_input_type_is_incorrect[False-include] tests/test_deserialization.py::test_deserialize_raises_exception_if_input_type_is_incorrect[False-raise] tests/test_deserialization.py::test_deserialize_raises_exception_if_input_type_is_incorrect[42-exclude] tests/test_deserialization.py::test_deserialize_raises_exception_if_input_type_is_incorrect[42-include] tests/test_deserialization.py::test_deserialize_raises_exception_if_input_type_is_incorrect[42-raise] tests/test_deserialization.py::test_deserialize_raises_exception_if_input_type_is_incorrect[None-exclude] tests/test_deserialization.py::test_deserialize_raises_exception_if_input_type_is_incorrect[None-include] tests/test_deserialization.py::test_deserialize_raises_exception_if_input_type_is_incorrect[None-raise] tests/test_deserialization.py::test_deserialize_raises_exception_if_input_type_is_incorrect[data4-exclude] tests/test_deserialization.py::test_deserialize_raises_exception_if_input_type_is_incorrect[data4-include] tests/test_deserialization.py::test_deserialize_raises_exception_if_input_type_is_incorrect[data4-raise] tests/test_fields.py::test_field_aliases[Integer-Integer] tests/test_fields.py::test_field_aliases[String-String] tests/test_fields.py::test_field_aliases[Boolean-Boolean] tests/test_fields.py::test_field_aliases[Url-Url] tests/test_fields.py::TestField::test_repr tests/test_fields.py::TestField::test_error_raised_if_uncallable_validator_passed tests/test_fields.py::TestField::test_error_raised_if_missing_is_set_on_required_field tests/test_fields.py::TestField::test_custom_field_receives_attr_and_obj tests/test_fields.py::TestField::test_custom_field_receives_data_key_if_set tests/test_fields.py::TestField::test_custom_field_follows_data_key_if_set tests/test_fields.py::TestParentAndName::test_simple_field_parent_and_name tests/test_fields.py::TestParentAndName::test_unbound_field_root_returns_none tests/test_fields.py::TestParentAndName::test_list_field_inner_parent_and_name tests/test_fields.py::TestParentAndName::test_tuple_field_inner_parent_and_name tests/test_fields.py::TestParentAndName::test_mapping_field_inner_parent_and_name tests/test_fields.py::TestParentAndName::test_simple_field_root tests/test_fields.py::TestParentAndName::test_list_field_inner_root tests/test_fields.py::TestParentAndName::test_tuple_field_inner_root tests/test_fields.py::TestParentAndName::test_list_root_inheritance tests/test_fields.py::TestParentAndName::test_dict_root_inheritance tests/test_fields.py::TestMetadata::test_extra_metadata_may_be_added_to_field[String] tests/test_fields.py::TestMetadata::test_extra_metadata_may_be_added_to_field[Integer] tests/test_fields.py::TestMetadata::test_extra_metadata_may_be_added_to_field[Boolean] tests/test_fields.py::TestMetadata::test_extra_metadata_may_be_added_to_field[Float] tests/test_fields.py::TestMetadata::test_extra_metadata_may_be_added_to_field[Number] tests/test_fields.py::TestMetadata::test_extra_metadata_may_be_added_to_field[DateTime] tests/test_fields.py::TestMetadata::test_extra_metadata_may_be_added_to_field[Time] tests/test_fields.py::TestMetadata::test_extra_metadata_may_be_added_to_field[Date] tests/test_fields.py::TestMetadata::test_extra_metadata_may_be_added_to_field[TimeDelta] tests/test_fields.py::TestMetadata::test_extra_metadata_may_be_added_to_field[Dict] tests/test_fields.py::TestMetadata::test_extra_metadata_may_be_added_to_field[Url] tests/test_fields.py::TestMetadata::test_extra_metadata_may_be_added_to_field[Email] tests/test_fields.py::TestMetadata::test_extra_metadata_may_be_added_to_field[UUID] tests/test_fields.py::TestMetadata::test_extra_metadata_may_be_added_to_field[Decimal] tests/test_fields.py::TestErrorMessages::test_default_error_messages_get_merged_with_parent_error_messages_cstm_msg tests/test_fields.py::TestErrorMessages::test_default_error_messages_get_merged_with_parent_error_messages tests/test_fields.py::TestErrorMessages::test_fail tests/test_fields.py::TestNestedField::test_nested_only_and_exclude_as_string[only] tests/test_fields.py::TestNestedField::test_nested_only_and_exclude_as_string[exclude] tests/test_fields.py::TestNestedField::test_nested_unknown_override[None-exclude] tests/test_fields.py::TestNestedField::test_nested_unknown_override[None-include] tests/test_fields.py::TestNestedField::test_nested_unknown_override[None-raise] tests/test_fields.py::TestNestedField::test_nested_unknown_override[exclude-exclude] tests/test_fields.py::TestNestedField::test_nested_unknown_override[exclude-include] tests/test_fields.py::TestNestedField::test_nested_unknown_override[exclude-raise] tests/test_fields.py::TestNestedField::test_nested_unknown_override[include-exclude] tests/test_fields.py::TestNestedField::test_nested_unknown_override[include-include] tests/test_fields.py::TestNestedField::test_nested_unknown_override[include-raise] tests/test_fields.py::TestNestedField::test_nested_unknown_override[raise-exclude] tests/test_fields.py::TestNestedField::test_nested_unknown_override[raise-include] tests/test_fields.py::TestNestedField::test_nested_unknown_override[raise-raise] tests/test_fields.py::TestListNested::test_list_nested_only_exclude_dump_only_load_only_propagated_to_nested[only] tests/test_fields.py::TestListNested::test_list_nested_only_exclude_dump_only_load_only_propagated_to_nested[exclude] tests/test_fields.py::TestListNested::test_list_nested_only_exclude_dump_only_load_only_propagated_to_nested[dump_only] tests/test_fields.py::TestListNested::test_list_nested_only_exclude_dump_only_load_only_propagated_to_nested[load_only] tests/test_fields.py::TestListNested::test_list_nested_only_and_exclude_merged_with_nested[only-expected0] tests/test_fields.py::TestListNested::test_list_nested_only_and_exclude_merged_with_nested[exclude-expected1] tests/test_fields.py::TestListNested::test_list_nested_partial_propagated_to_nested tests/test_fields.py::TestTupleNested::test_tuple_nested_only_exclude_dump_only_load_only_propagated_to_nested[dump_only] tests/test_fields.py::TestTupleNested::test_tuple_nested_only_exclude_dump_only_load_only_propagated_to_nested[load_only] tests/test_fields.py::TestTupleNested::test_tuple_nested_partial_propagated_to_nested tests/test_fields.py::TestDictNested::test_dict_nested_only_exclude_dump_only_load_only_propagated_to_nested[only] tests/test_fields.py::TestDictNested::test_dict_nested_only_exclude_dump_only_load_only_propagated_to_nested[exclude] tests/test_fields.py::TestDictNested::test_dict_nested_only_exclude_dump_only_load_only_propagated_to_nested[dump_only] tests/test_fields.py::TestDictNested::test_dict_nested_only_exclude_dump_only_load_only_propagated_to_nested[load_only] tests/test_fields.py::TestDictNested::test_dict_nested_only_and_exclude_merged_with_nested[only-expected0] tests/test_fields.py::TestDictNested::test_dict_nested_only_and_exclude_merged_with_nested[exclude-expected1] tests/test_fields.py::TestDictNested::test_dict_nested_partial_propagated_to_nested tests/test_schema.py::test_serializing_basic_object[UserSchema] tests/test_schema.py::test_serializing_basic_object[UserMetaSchema] tests/test_schema.py::test_serializer_dump tests/test_schema.py::test_load_resets_errors tests/test_schema.py::test_load_validation_error_stores_input_data_and_valid_data tests/test_schema.py::test_load_resets_error_fields tests/test_schema.py::test_errored_fields_do_not_appear_in_output tests/test_schema.py::test_load_many_stores_error_indices tests/test_schema.py::test_dump_many tests/test_schema.py::test_multiple_errors_can_be_stored_for_a_given_index tests/test_schema.py::test_dump_returns_a_dict tests/test_schema.py::test_dumps_returns_a_string tests/test_schema.py::test_dumping_single_object_with_collection_schema tests/test_schema.py::test_loading_single_object_with_collection_schema tests/test_schema.py::test_dumps_many tests/test_schema.py::test_load_returns_an_object tests/test_schema.py::test_load_many tests/test_schema.py::test_load_invalid_input_type[None] tests/test_schema.py::test_load_invalid_input_type[False] tests/test_schema.py::test_load_invalid_input_type[1] tests/test_schema.py::test_load_invalid_input_type[1.2] tests/test_schema.py::test_load_invalid_input_type[val4] tests/test_schema.py::test_load_invalid_input_type[val5] tests/test_schema.py::test_load_invalid_input_type[val6] tests/test_schema.py::test_load_invalid_input_type[lol] tests/test_schema.py::test_load_many_invalid_input_type[None] tests/test_schema.py::test_load_many_invalid_input_type[False] tests/test_schema.py::test_load_many_invalid_input_type[1] tests/test_schema.py::test_load_many_invalid_input_type[1.2] tests/test_schema.py::test_load_many_invalid_input_type[val4] tests/test_schema.py::test_load_many_invalid_input_type[val5] tests/test_schema.py::test_load_many_invalid_input_type[val6] tests/test_schema.py::test_load_many_invalid_input_type[lol] tests/test_schema.py::test_load_many_empty_collection[val0] tests/test_schema.py::test_load_many_empty_collection[val1] tests/test_schema.py::test_load_many_in_nested_invalid_input_type[False] tests/test_schema.py::test_load_many_in_nested_invalid_input_type[1] tests/test_schema.py::test_load_many_in_nested_invalid_input_type[1.2] tests/test_schema.py::test_load_many_in_nested_invalid_input_type[val3] tests/test_schema.py::test_load_many_in_nested_invalid_input_type[val4] tests/test_schema.py::test_load_many_in_nested_invalid_input_type[val5] tests/test_schema.py::test_load_many_in_nested_invalid_input_type[lol] tests/test_schema.py::test_load_many_in_nested_empty_collection[val0] tests/test_schema.py::test_load_many_in_nested_empty_collection[val1] tests/test_schema.py::test_loads_returns_a_user tests/test_schema.py::test_loads_many tests/test_schema.py::test_loads_deserializes_from_json tests/test_schema.py::test_serializing_none tests/test_schema.py::test_default_many_symmetry tests/test_schema.py::test_on_bind_field_hook tests/test_schema.py::test_nested_on_bind_field_hook tests/test_schema.py::TestValidate::test_validate_raises_with_errors_dict tests/test_schema.py::TestValidate::test_validate_many tests/test_schema.py::TestValidate::test_validate_many_doesnt_store_index_if_index_errors_option_is_false tests/test_schema.py::TestValidate::test_validate tests/test_schema.py::TestValidate::test_validate_required tests/test_schema.py::test_fields_are_not_copies[UserSchema] tests/test_schema.py::test_fields_are_not_copies[UserMetaSchema] tests/test_schema.py::test_dumps_returns_json tests/test_schema.py::test_naive_datetime_field tests/test_schema.py::test_datetime_formatted_field tests/test_schema.py::test_datetime_iso_field tests/test_schema.py::test_tz_datetime_field tests/test_schema.py::test_class_variable tests/test_schema.py::test_serialize_many[UserSchema] tests/test_schema.py::test_serialize_many[UserMetaSchema] tests/test_schema.py::test_inheriting_schema tests/test_schema.py::test_custom_field tests/test_schema.py::test_url_field tests/test_schema.py::test_relative_url_field tests/test_schema.py::test_stores_invalid_url_error[UserSchema] tests/test_schema.py::test_stores_invalid_url_error[UserMetaSchema] tests/test_schema.py::test_email_field[UserSchema] tests/test_schema.py::test_email_field[UserMetaSchema] tests/test_schema.py::test_stored_invalid_email tests/test_schema.py::test_integer_field tests/test_schema.py::test_as_string tests/test_schema.py::test_method_field[UserSchema] tests/test_schema.py::test_method_field[UserMetaSchema] tests/test_schema.py::test_function_field tests/test_schema.py::test_fields_must_be_declared_as_instances tests/test_schema.py::test_serializing_generator[UserSchema] tests/test_schema.py::test_serializing_generator[UserMetaSchema] tests/test_schema.py::test_serializing_empty_list_returns_empty_list tests/test_schema.py::test_serializing_dict tests/test_schema.py::test_serializing_dict_with_meta_fields tests/test_schema.py::test_exclude_in_init[UserSchema] tests/test_schema.py::test_exclude_in_init[UserMetaSchema] tests/test_schema.py::test_only_in_init[UserSchema] tests/test_schema.py::test_only_in_init[UserMetaSchema] tests/test_schema.py::test_invalid_only_param tests/test_schema.py::test_can_serialize_uuid tests/test_schema.py::test_can_serialize_time tests/test_schema.py::test_invalid_dict_but_okay tests/test_schema.py::test_json_module_is_deprecated tests/test_schema.py::test_render_module tests/test_schema.py::test_custom_error_message tests/test_schema.py::test_custom_unknown_error_message tests/test_schema.py::test_custom_type_error_message tests/test_schema.py::test_custom_type_error_message_with_many tests/test_schema.py::test_custom_error_messages_with_inheritance tests/test_schema.py::test_load_errors_with_many tests/test_schema.py::test_error_raised_if_fields_option_is_not_list tests/test_schema.py::test_error_raised_if_additional_option_is_not_list tests/test_schema.py::test_nested_custom_set_in_exclude_reusing_schema tests/test_schema.py::test_nested_only tests/test_schema.py::test_nested_only_inheritance tests/test_schema.py::test_nested_only_empty_inheritance tests/test_schema.py::test_nested_exclude tests/test_schema.py::test_nested_exclude_inheritance tests/test_schema.py::test_nested_only_and_exclude tests/test_schema.py::test_nested_only_then_exclude_inheritance tests/test_schema.py::test_nested_exclude_then_only_inheritance tests/test_schema.py::test_nested_exclude_and_only_inheritance tests/test_schema.py::test_meta_nested_exclude tests/test_schema.py::test_nested_custom_set_not_implementing_getitem tests/test_schema.py::test_deeply_nested_only_and_exclude tests/test_schema.py::test_data_key_collision[f1] tests/test_schema.py::test_data_key_collision[f5] tests/test_schema.py::test_data_key_collision[None] tests/test_schema.py::test_attribute_collision[f1] tests/test_schema.py::test_attribute_collision[f5] tests/test_schema.py::test_attribute_collision[None] tests/test_schema.py::TestDeeplyNestedLoadOnly::test_load_only tests/test_schema.py::TestDeeplyNestedLoadOnly::test_dump_only tests/test_schema.py::TestDeeplyNestedListLoadOnly::test_load_only tests/test_schema.py::TestDeeplyNestedListLoadOnly::test_dump_only tests/test_schema.py::test_nested_constructor_only_and_exclude tests/test_schema.py::test_only_and_exclude tests/test_schema.py::test_only_and_exclude_with_fields tests/test_schema.py::test_invalid_only_and_exclude_with_fields tests/test_schema.py::test_only_and_exclude_with_additional tests/test_schema.py::test_invalid_only_and_exclude_with_additional tests/test_schema.py::test_exclude_invalid_attribute tests/test_schema.py::test_only_bounded_by_fields tests/test_schema.py::test_only_bounded_by_additional tests/test_schema.py::test_only_empty tests/test_schema.py::test_only_and_exclude_as_string[only] tests/test_schema.py::test_only_and_exclude_as_string[exclude] tests/test_schema.py::test_nested_with_sets tests/test_schema.py::test_meta_serializer_fields tests/test_schema.py::test_meta_fields_mapping tests/test_schema.py::test_meta_field_not_on_obj_raises_attribute_error tests/test_schema.py::test_exclude_fields tests/test_schema.py::test_fields_option_must_be_list_or_tuple tests/test_schema.py::test_exclude_option_must_be_list_or_tuple tests/test_schema.py::test_datetimeformat_option tests/test_schema.py::test_dateformat_option tests/test_schema.py::test_default_dateformat tests/test_schema.py::test_inherit_meta tests/test_schema.py::test_inherit_meta_override tests/test_schema.py::test_additional tests/test_schema.py::test_cant_set_both_additional_and_fields tests/test_schema.py::test_serializing_none_meta tests/test_schema.py::TestFieldValidation::test_errors_are_cleared_after_loading_collection tests/test_schema.py::TestFieldValidation::test_raises_error_with_list tests/test_schema.py::TestFieldValidation::test_raises_error_with_dict tests/test_schema.py::TestFieldValidation::test_ignored_if_not_in_only tests/test_schema.py::test_schema_repr tests/test_schema.py::TestNestedSchema::test_nested_many_with_missing_attribute tests/test_schema.py::TestNestedSchema::test_nested_with_attribute_none tests/test_schema.py::TestNestedSchema::test_nested_field_does_not_validate_required tests/test_schema.py::TestNestedSchema::test_nested_none tests/test_schema.py::TestNestedSchema::test_nested tests/test_schema.py::TestNestedSchema::test_nested_many_fields tests/test_schema.py::TestNestedSchema::test_nested_meta_many tests/test_schema.py::TestNestedSchema::test_nested_only tests/test_schema.py::TestNestedSchema::test_exclude tests/test_schema.py::TestNestedSchema::test_list_field tests/test_schema.py::TestNestedSchema::test_nested_load_many tests/test_schema.py::TestNestedSchema::test_nested_errors tests/test_schema.py::TestNestedSchema::test_nested_method_field tests/test_schema.py::TestNestedSchema::test_nested_function_field tests/test_schema.py::TestNestedSchema::test_serializer_meta_with_nested_fields tests/test_schema.py::TestNestedSchema::test_serializer_with_nested_meta_fields tests/test_schema.py::TestNestedSchema::test_nested_fields_must_be_passed_a_serializer tests/test_schema.py::TestNestedSchema::test_invalid_type_passed_to_nested_field tests/test_schema.py::TestNestedSchema::test_all_errors_on_many_nested_field_with_validates_decorator tests/test_schema.py::TestNestedSchema::test_nested_unknown_validation[None] tests/test_schema.py::TestNestedSchema::test_nested_unknown_validation[raise] tests/test_schema.py::TestNestedSchema::test_nested_unknown_validation[include] tests/test_schema.py::TestNestedSchema::test_nested_unknown_validation[exclude] tests/test_schema.py::TestPluckSchema::test_pluck tests/test_schema.py::TestPluckSchema::test_pluck_none tests/test_schema.py::TestPluckSchema::test_pluck_with_data_key tests/test_schema.py::TestSelfReference::test_nesting_schema_within_itself tests/test_schema.py::TestSelfReference::test_nesting_schema_by_passing_class_name tests/test_schema.py::TestSelfReference::test_nesting_within_itself_meta tests/test_schema.py::TestSelfReference::test_nested_self_with_only_param tests/test_schema.py::TestSelfReference::test_multiple_pluck_self_field tests/test_schema.py::TestSelfReference::test_nested_self_many tests/test_schema.py::TestSelfReference::test_nested_self_list tests/test_schema.py::test_serialization_with_required_field tests/test_schema.py::test_deserialization_with_required_field tests/test_schema.py::test_deserialization_with_required_field_and_custom_validator tests/test_schema.py::TestContext::test_context_method tests/test_schema.py::TestContext::test_context_method_function tests/test_schema.py::TestContext::test_function_field_raises_error_when_context_not_available tests/test_schema.py::TestContext::test_function_field_handles_bound_serializer tests/test_schema.py::TestContext::test_fields_context tests/test_schema.py::TestContext::test_nested_fields_inherit_context tests/test_schema.py::TestContext::test_nested_list_fields_inherit_context tests/test_schema.py::TestContext::test_nested_dict_fields_inherit_context tests/test_schema.py::test_serializer_can_specify_nested_object_as_attribute tests/test_schema.py::TestFieldInheritance::test_inherit_fields_from_schema_subclass tests/test_schema.py::TestFieldInheritance::test_inherit_fields_from_non_schema_subclass tests/test_schema.py::TestFieldInheritance::test_inheritance_follows_mro tests/test_schema.py::TestGetAttribute::test_get_attribute_is_used tests/test_schema.py::TestGetAttribute::test_get_attribute_with_many tests/test_schema.py::TestRequiredFields::test_required_string_field_missing tests/test_schema.py::TestRequiredFields::test_required_string_field_failure tests/test_schema.py::TestRequiredFields::test_allow_none_param tests/test_schema.py::TestRequiredFields::test_allow_none_custom_message tests/test_schema.py::TestDefaults::test_missing_inputs_are_excluded_from_dump_output tests/test_schema.py::TestDefaults::test_none_is_serialized_to_none tests/test_schema.py::TestDefaults::test_default_and_value_missing tests/test_schema.py::TestDefaults::test_loading_none tests/test_schema.py::TestDefaults::test_missing_inputs_are_excluded_from_load_output tests/test_schema.py::TestLoadOnly::test_load_only tests/test_schema.py::TestLoadOnly::test_dump_only tests/test_schema.py::TestLoadOnly::test_url_field_requre_tld_false tests/test_serialization.py::TestFieldSerialization::test_number[42-42.0] tests/test_serialization.py::TestFieldSerialization::test_number[0-0.0] tests/test_serialization.py::TestFieldSerialization::test_number[None-None] tests/test_serialization.py::TestFieldSerialization::test_number_as_string tests/test_serialization.py::TestFieldSerialization::test_number_as_string_passed_none tests/test_serialization.py::TestFieldSerialization::test_function_field_passed_func tests/test_serialization.py::TestFieldSerialization::test_function_field_passed_serialize_only_is_dump_only tests/test_serialization.py::TestFieldSerialization::test_function_field_passed_deserialize_and_serialize_is_not_dump_only tests/test_serialization.py::TestFieldSerialization::test_function_field_passed_serialize tests/test_serialization.py::TestFieldSerialization::test_function_field_does_not_swallow_attribute_error tests/test_serialization.py::TestFieldSerialization::test_function_field_load_only tests/test_serialization.py::TestFieldSerialization::test_function_field_passed_serialize_with_context tests/test_serialization.py::TestFieldSerialization::test_function_field_passed_uncallable_object tests/test_serialization.py::TestFieldSerialization::test_integer_field tests/test_serialization.py::TestFieldSerialization::test_integer_as_string_field tests/test_serialization.py::TestFieldSerialization::test_integer_field_default tests/test_serialization.py::TestFieldSerialization::test_integer_field_default_set_to_none tests/test_serialization.py::TestFieldSerialization::test_uuid_field tests/test_serialization.py::TestFieldSerialization::test_decimal_field tests/test_serialization.py::TestFieldSerialization::test_decimal_field_string tests/test_serialization.py::TestFieldSerialization::test_decimal_field_special_values tests/test_serialization.py::TestFieldSerialization::test_decimal_field_special_values_not_permitted tests/test_serialization.py::TestFieldSerialization::test_decimal_field_fixed_point_representation tests/test_serialization.py::TestFieldSerialization::test_boolean_field_serialization tests/test_serialization.py::TestFieldSerialization::test_function_with_uncallable_param tests/test_serialization.py::TestFieldSerialization::test_email_field_serialize_none tests/test_serialization.py::TestFieldSerialization::test_dict_field_serialize_none tests/test_serialization.py::TestFieldSerialization::test_dict_field_invalid_dict_but_okay tests/test_serialization.py::TestFieldSerialization::test_dict_field_serialize tests/test_serialization.py::TestFieldSerialization::test_dict_field_serialize_ordereddict tests/test_serialization.py::TestFieldSerialization::test_structured_dict_value_serialize tests/test_serialization.py::TestFieldSerialization::test_structured_dict_key_serialize tests/test_serialization.py::TestFieldSerialization::test_structured_dict_key_value_serialize tests/test_serialization.py::TestFieldSerialization::test_url_field_serialize_none tests/test_serialization.py::TestFieldSerialization::test_method_field_with_method_missing tests/test_serialization.py::TestFieldSerialization::test_method_field_passed_serialize_only_is_dump_only tests/test_serialization.py::TestFieldSerialization::test_method_field_passed_deserialize_only_is_load_only tests/test_serialization.py::TestFieldSerialization::test_method_field_with_uncallable_attribute tests/test_serialization.py::TestFieldSerialization::test_method_field_does_not_swallow_attribute_error tests/test_serialization.py::TestFieldSerialization::test_method_with_no_serialize_is_missing tests/test_serialization.py::TestFieldSerialization::test_serialize_with_data_key_param tests/test_serialization.py::TestFieldSerialization::test_serialize_with_attribute_and_data_key_uses_data_key tests/test_serialization.py::TestFieldSerialization::test_datetime_field_rfc822[value0-Sun, tests/test_serialization.py::TestFieldSerialization::test_datetime_field_rfc822[value1-Sun, tests/test_serialization.py::TestFieldSerialization::test_datetime_field_rfc822[value2-Sun, tests/test_serialization.py::TestFieldSerialization::test_datetime_field_iso8601[value0-2013-11-10T01:23:45-iso] tests/test_serialization.py::TestFieldSerialization::test_datetime_field_iso8601[value0-2013-11-10T01:23:45-iso8601] tests/test_serialization.py::TestFieldSerialization::test_datetime_field_iso8601[value0-2013-11-10T01:23:45-None] tests/test_serialization.py::TestFieldSerialization::test_datetime_field_iso8601[value1-2013-11-10T01:23:45.123456+00:00-iso] tests/test_serialization.py::TestFieldSerialization::test_datetime_field_iso8601[value1-2013-11-10T01:23:45.123456+00:00-iso8601] tests/test_serialization.py::TestFieldSerialization::test_datetime_field_iso8601[value1-2013-11-10T01:23:45.123456+00:00-None] tests/test_serialization.py::TestFieldSerialization::test_datetime_field_iso8601[value2-2013-11-10T01:23:45+00:00-iso] tests/test_serialization.py::TestFieldSerialization::test_datetime_field_iso8601[value2-2013-11-10T01:23:45+00:00-iso8601] tests/test_serialization.py::TestFieldSerialization::test_datetime_field_iso8601[value2-2013-11-10T01:23:45+00:00-None] tests/test_serialization.py::TestFieldSerialization::test_datetime_field_iso8601[value3-2013-11-10T01:23:45-06:00-iso] tests/test_serialization.py::TestFieldSerialization::test_datetime_field_iso8601[value3-2013-11-10T01:23:45-06:00-iso8601] tests/test_serialization.py::TestFieldSerialization::test_datetime_field_iso8601[value3-2013-11-10T01:23:45-06:00-None] tests/test_serialization.py::TestFieldSerialization::test_datetime_field_format tests/test_serialization.py::TestFieldSerialization::test_string_field tests/test_serialization.py::TestFieldSerialization::test_string_field_default_to_empty_string tests/test_serialization.py::TestFieldSerialization::test_time_field tests/test_serialization.py::TestFieldSerialization::test_date_field tests/test_serialization.py::TestFieldSerialization::test_timedelta_field tests/test_serialization.py::TestFieldSerialization::test_datetime_list_field tests/test_serialization.py::TestFieldSerialization::test_list_field_serialize_none_returns_none tests/test_serialization.py::TestFieldSerialization::test_list_field_work_with_generator_single_value tests/test_serialization.py::TestFieldSerialization::test_list_field_work_with_generators_multiple_values tests/test_serialization.py::TestFieldSerialization::test_list_field_work_with_generators_empty_generator_returns_none_for_every_non_returning_yield_statement tests/test_serialization.py::TestFieldSerialization::test_list_field_work_with_set tests/test_serialization.py::TestFieldSerialization::test_list_field_work_with_custom_class_with_iterator_protocol tests/test_serialization.py::TestFieldSerialization::test_bad_list_field tests/test_serialization.py::TestFieldSerialization::test_datetime_integer_tuple_field tests/test_serialization.py::TestFieldSerialization::test_tuple_field_serialize_none_returns_none tests/test_serialization.py::TestFieldSerialization::test_bad_tuple_field tests/test_serialization.py::TestFieldSerialization::test_serialize_does_not_apply_validators tests/test_serialization.py::TestFieldSerialization::test_constant_field_serialization tests/test_serialization.py::TestFieldSerialization::test_constant_is_always_included_in_serialized_data tests/test_serialization.py::TestFieldSerialization::test_constant_field_serialize_when_omitted tests/test_serialization.py::TestFieldSerialization::test_all_fields_serialize_none_to_none[String] tests/test_serialization.py::TestFieldSerialization::test_all_fields_serialize_none_to_none[Integer] tests/test_serialization.py::TestFieldSerialization::test_all_fields_serialize_none_to_none[Boolean] tests/test_serialization.py::TestFieldSerialization::test_all_fields_serialize_none_to_none[Float] tests/test_serialization.py::TestFieldSerialization::test_all_fields_serialize_none_to_none[Number] tests/test_serialization.py::TestFieldSerialization::test_all_fields_serialize_none_to_none[DateTime] tests/test_serialization.py::TestFieldSerialization::test_all_fields_serialize_none_to_none[Time] tests/test_serialization.py::TestFieldSerialization::test_all_fields_serialize_none_to_none[Date] tests/test_serialization.py::TestFieldSerialization::test_all_fields_serialize_none_to_none[TimeDelta] tests/test_serialization.py::TestFieldSerialization::test_all_fields_serialize_none_to_none[Dict] tests/test_serialization.py::TestFieldSerialization::test_all_fields_serialize_none_to_none[Url] tests/test_serialization.py::TestFieldSerialization::test_all_fields_serialize_none_to_none[Email] tests/test_serialization.py::TestFieldSerialization::test_all_fields_serialize_none_to_none[UUID] tests/test_serialization.py::TestFieldSerialization::test_all_fields_serialize_none_to_none[Decimal] tests/test_serialization.py::TestSchemaSerialization::test_serialize_with_missing_param_value tests/test_serialization.py::TestSchemaSerialization::test_serialize_with_missing_param_callable tests/test_serialization.py::test_serializing_named_tuple tests/test_serialization.py::test_serializing_named_tuple_with_meta tests/test_serialization.py::test_serializing_slice tests/test_serialization.py::test_nested_field_many_serializing_generator
docs/quickstart.rst src/marshmallow/schema.py CHANGELOG.rst docs/extending.rst docs/upgrading.rst src/marshmallow/fields.py
docs/quickstart.rst src/marshmallow/schema.py CHANGELOG.rst docs/extending.rst docs/upgrading.rst src/marshmallow/fields.py