In marshmallow, fields.List will send the inner object to fields.String as value(see marshmallow.fields.List._serialize), while fields.String will simply convert the input value to string(see marshmallow.fields.String._serialize).
class List(Field):
def _serialize(
self, value, attr, obj, **kwargs
) -> typing.Optional[typing.List[typing.Any]]:
if value is None:
return None
return [self.inner._serialize(each, attr, obj, **kwargs) for each in value]
class String(Field):
def _serialize(self, value, attr, obj, **kwargs) -> typing.Optional[str]:
if value is None:
return None
return utils.ensure_text_type(value)
This is why your objects in translated_languages shown as "<api.models.Language object at 0x000002598642C8E0>".
In order to dump as expect, we can use a custom field which is inherited from fields.List and override it's _serialize function.
There is an example for you. CustomInnerSerializerListField is the custom field, and in the dump results the inner_names to inner_names6 are all my failed attempts, inner_names_expected is the exatily result I want.
import typing
from flask_marshmallow import Marshmallow
from marshmallow import fields
ma = Marshmallow()
class SelfNestedModule:
def __init__(self, name, outer_id=0, inner_list=None):
self.name = name
assert not (outer_id and inner_list)
self.outer_id = outer_id
self.id = id(self)
# define self-referential relationship in sqlalchemy
self.outer: SelfNestedModule = None # relationship
self.inner_list = inner_list or [] # backref
@property
def role(self):
assert not (self.outer_id and self.inner_list)
if self.outer_id:
return 'Inner'
return 'Outer'
def add_inner(self, inner: 'SelfNestedModule'):
assert self.role == 'Outer'
self.inner_list.append(inner)
def save_to_outer(self, outer_obj: 'SelfNestedModule'):
# self.role: Outer -> Inner
self.outer_id = outer_obj.id
outer_obj.add_inner(self)
self.outer = outer_obj
return self
def __repr__(self):
new_line = '\n' if self.role == 'Outer' else ''
return (
f'{self.role}({new_line}'
f' name="{self.name}", {new_line}'
f' outer_name="{self.outer.name if self.outer else ""}", {new_line}'
f' inner_list=[%s]{new_line}'
f') # id={self.id}'
) % (('\n' + '\n'.join(map(lambda o: ' ' + repr(o), self.inner_list)) + '\n') if self.inner_list else '')
def __str__(self):
return f'<SelfNestedModule object at {id(self)}>'
outer = SelfNestedModule("outer_obj")
inner1 = SelfNestedModule("inner_obj1").save_to_outer(outer)
inner2 = SelfNestedModule("inner_obj2").save_to_outer(outer)
another_outer = SelfNestedModule("another_outer_obj")
print(repr(outer))
print(repr(another_outer))
"""
Outer(
name="outer_obj",
outer_name="",
inner_list=[
Inner( name="inner_obj1", outer_name="outer_obj", inner_list=[]) # id=140663262984120
Inner( name="inner_obj2", outer_name="outer_obj", inner_list=[]) # id=140663262986024
]
) # id=140663262985576
Outer(
name="another_outer_obj",
outer_name="",
inner_list=[]
) # id=140663263074680
"""
"""
We need rows in table be dumped as:
{
{
'id': 140663262985576,
'name': 'outer_obj',
'inner_names': [
'inner_obj1',
'inner_obj2',
]
},
{
'id': 140663262984120,
'name': 'inner_obj1',
'outer_name': 'outer_obj',
'inner_names': []
},
{
'id': 140663262986024,
'name': 'inner_obj2',
'outer_name': 'outer_obj',
'inner_names': []
},
{
'id': 140663263074680,
'name': 'another_outer_obj',
'inner_names': []
},
}
"""
class CustomInnerSerializerListField(fields.List):
def __init__(self, cls_or_instance: typing.Union[fields.Field, type], inner_serializer=None, **kwargs):
super().__init__(cls_or_instance, **kwargs)
import functools
self.inner_serializer_fun = functools.partial(inner_serializer, self) if inner_serializer else self.inner._serialize
def _nested_inner_serializer(self, inner_value, outer_attr, outer_obj, accessor=None, **kwargs):
attr = self.inner.attribute or outer_attr
return self.inner.serialize(attr, inner_value, accessor=accessor, **kwargs)
def _serialize(
self, value, attr, obj, **kwargs
) -> typing.Optional[typing.List[typing.Any]]:
if value is None:
return None
return [self.inner_serializer_fun(each, attr, obj, **kwargs) for each in value]
class MySchema(ma.SQLAlchemyAutoSchema):
class Meta:
model = None
id = ma.Int(dump_only=True)
name = ma.Str(attribute='name')
outer_name = ma.Str(attribute='outer.name')
inner_names = ma.List(ma.Str(attribute='name'), dump_only=True, attribute='inner_list')
inner_names2 = ma.List(ma.Nested('self', only=('name', )), dump_only=True, attribute='inner_list')
inner_names3 = ma.List(ma.Str(attribute='name'), dump_only=True, attribute='inner_list.name')
inner_names4 = ma.List(ma.Str(attribute='inner_list.name'), dump_only=True, attribute='inner_list')
inner_names5 = ma.List(ma.Str(accessor=lambda obj: obj.name), dump_only=True, attribute='inner_list')
inner_names6 = ma.List(ma.Str(accessor=lambda obj: obj.name), dump_only=True, attribute='inner_list')
inner_names_expected = CustomInnerSerializerListField(ma.Str(attribute='name'), dump_only=True, attribute='inner_list', inner_serializer=CustomInnerSerializerListField._nested_inner_serializer)
inner_names_original = CustomInnerSerializerListField(ma.Str(attribute='name'), dump_only=True, attribute='inner_list')
# outer = ma.Nested('self', exclude=('outer', ))
# inner_list = ma.List(ma.Nested('self', exclude=('outer', )))
schema = MySchema()
schema.dump(outer)
schema.dump(another_outer)
schema.dump(inner1)
"""
schema.dump(outer)
{'id': 140663262985576, 'inner_names5': ['<SelfNestedModule object at 140663262984120>', '<SelfNestedModule object at 140663262986024>'], 'inner_names_expected': ['inner_obj1', 'inner_obj2'], 'name': 'outer_obj', 'inner_names_original': ['<SelfNestedModule object at 140663262984120>', '<SelfNestedModule object at 140663262986024>'], 'inner_names6': ['<SelfNestedModule object at 140663262984120>', '<SelfNestedModule object at 140663262986024>'], 'inner_names4': ['<SelfNestedModule object at 140663262984120>', '<SelfNestedModule object at 140663262986024>'], 'inner_names2': [{'name': 'inner_obj1'}, {'name': 'inner_obj2'}], 'inner_names': ['<SelfNestedModule object at 140663262984120>', '<SelfNestedModule object at 140663262986024>']}
schema.dump(another_outer)
{'id': 140663263074680, 'inner_names5': [], 'inner_names_expected': [], 'name': 'another_outer_obj', 'inner_names_original': [], 'inner_names6': [], 'inner_names4': [], 'inner_names2': [], 'inner_names': []}
schema.dump(inner1)
{'id': 140663262984120, 'outer_name': 'outer_obj', 'inner_names5': [], 'inner_names_expected': [], 'name': 'inner_obj1', 'inner_names_original': [], 'inner_names6': [], 'inner_names4': [], 'inner_names2': [], 'inner_names': []}
"""
