Inconsistent None items serialization between Nested(…, many=True) and List(Nested(…)) fields

[Aeron]

At this point, a Nested field with the many=True parameter and a Nested field wrapped in the List will serialize None items differently: the first one will return a list of empty dictionaries, the latter one will return a list of None.

It’s unclear if it’s intentional or not, but it’s frustrating to say at least because these two concepts presumably imply to be interchangeable. Of course, #779 exists not without reason, but it’s a more complicated matter, and it’ll celebrate its second birthday in a few days.

So the main question here is: should it stay inconsistent by design or one approach is provenly false, and needs to be fixed.

Just in case, it’s easy to reproduce with the following example:

from marshmallow import Schema, fields


class N(Schema):
    a = fields.String()
    b = fields.String()


class S1(Schema):
    nested = fields.Nested(N, many=True)


class S2(Schema):
    nested = fields.List(fields.Nested(N))


schema1 = S1()
schema2 = S2()

data = {
    "nested": [None],
}

result1 = schema1.dump(data)
result2 = schema2.dump(data)

assert result1.get("nested") == [{}]
assert result2.get("nested") == [None]

[Aeron]

Ah, I completely overlooked #1497, so it’s a kinda-duplicate, but that issue already closed and has no explicit resolution on the question above. It would be great to have a more distinct view on this subject, if possible. Please, correct me if I missed something.

[deckar01]

While working on #1498, @Meallia uncovered that Nested(many) does not support enabling allow_none for list items. Schema.load() has no concept of allow_none, so it will always implicitly be true.

#779 (comment)

I think the issue is that changing this behavior for Nested(many) would require a major version bump, but there is a desire to just deprecate Nested(many) instead. Either way the discussion for this should probably continue on #779.