Setting default on Nested item about marshmallow

[sloria]

The Nested field allows you to pass a default argument to the constructor. You can set the default to an empty collection, like so:

class AuthorSchema(Serializer):
    name = fields.String()
    books = fields.Nested(BookSchema, many=True, allow_null=True, default=tuple())

a = Author(name='Monty', books=None)
a_ser = AuthorSchema(a)
a_ser.data
# OrderedDict([('name', 'Monty'), ('books', ())])

Does that answer your question?

[sloria]

@adregan Can this issue be closed?

[adregan]

I found a work around, but the method above didn't seem to work:

On GET, I'll pass the data to be serialized, what I was able to so was present null values as arrays by checking for instances of fields.Nested and if the data returned from the DB was None, pass an array instead.

This works, but what I was looking for was on POST serializing an empty array (in the same way as serializing "Untitled" as a default string for a title field, let's say).

The desired output for the API was something like this

{
"entries": [
{
"title": "A title",
"body": "Blah blah blah",
"author": [{
  "id": "12345678",
  "name": "Sarah Something"
}],
"category": "Cool Category"
}
]}

where author is a nested field. However, if the author field was empty, I would want the following on POST or GET:

"author": []

but what I would get was:

"author": null

I think it's fine to close if this isn't an issue for others, but the fact that fields.Nested takes a default argument is something that isn't apparent from the documentation.

Thanks for your time.

[sloria]

I'm curious why setting many=True and default=tuple() did not work for you. Is an Entry's author field a many-to-one relationship? Can you please clarify how you implemented your solution?

[miracle2k]

It doesn't work for me either:

class DocumentSchema(Schema): pass

class BatchSchemaLoad(Schema):
    documents = fields.Nested(DocumentSchema, many=True, default=[])

Then::

In [6]: BatchSchemaLoad().load({})
Out[6]: UnmarshalResult(data={}, errors={})

In [7]: BatchSchemaLoad().load({'documents': []})
Out[7]: UnmarshalResult(data={'documents': []}, errors={})

[sloria]

@miracle2k The default parameter is only applied during serialization, not deserialization. See #45 for the discussion and rationale behind this.

Use Schema.preprocessor or make_object if you need to define defaults for deserialization.

[adregan]

Sorry all. Haven't had time to explore this, and I took my serialization in another direction. I don't store nested objects anymore but lists that reference the id and build the nested objects on GET.

It's been more helpful maintaining the current state of the data that way.

[jimmyshen]

@sloria I'm using marshmallow to validate and unmarshal the JSON response from an API that can return null instead of a nested object. I'm representing these in the schema, like so:

class ApiResponse(Schema):
    entity = Nested(EntitySchema)

I believe this was the case discussed in issue #45.

Adding a preprocessor to shove in a default for the fields over and over did not seem like a maintainable solution for me, so I decided to just subclass fields.Nested, as below:

class NullableNested(Nested):
    def _deserialize(self, value):
        if value is None:
            return dict()
        return value

This seems to work, but I wanted to check if there are problems with this workaround.

Thanks

[sloria]

@jimmyshen Once #76 is implemented, you will be able to pass allow_none to a field. In the meantime, I think your solution is fine.

[jimmyshen]

@sloria Great! Thanks :)