marshmallow关系处理

• Nesting Schemas

当模型间拥有关系，比如外键，schema如何处理呢？例如：blog和user之间的关系

class User(object):
    def __init__(self, name, email):
        self.name = name
        self.email = email
        self.created_at = dt.datetime.now()
        self.friends = []
        self.employer = None

class Blog(object):
    def __init__(self, title, author):
        self.title = title
        self.author = author

使用Nested字段来代表关系，并传入相应的schema类

from marshmallow import Schema, fields

class UserSchema(Schema):
    name = fields.String()
    email = fields.Email()
    created_at = fields.DateTime()

class BlogSchema(Schema):
    title = fields.String()
    author = fields.Nested(UserSchema)

序列化blog对象则会嵌入user描述

from marshmallow import Schema, fields, pprint

user = User2(name="Monty", email="monty@python.org")
blog = Blog(title="Something Completely Different", author=user)
pprint(BlogSchema().dump(blog))

{'author': {'created_at': '2019-11-14T15:28:09.212278',
            'email': 'monty@python.org',
            'name': 'Monty'},
 'title': 'Something Completely Different'}

注意：如果field是多个嵌入对象的集合，则必须设置many=True

collaborators = fields.Nested(UserSchema, many=True)

• Specifying Which Fields to Nest

如果想指定序列化时嵌入对象的某几个字段，可以设置only参数

class BlogSchema(Schema):
    title = fields.String()
    author = fields.Nested(UserSchema, only=["email"])

user = User(name="Monty", email="monty@python.org")
blog = Blog(title="Something Completely Different", author=user)
pprint(BlogSchema().dump(blog))

{'author': {'email': 'monty@python.org'},
 'title': 'Something Completely Different'}

如果有更深度的嵌套，可以使用“.”符号连接

class Site(object):
    def __init__(self, blog):
        self.blog = blog

class SiteSchema(Schema):
    blog = fields.Nested(BlogSchema)

user = User(name="Mike", email="mike@python.org")
blog = Blog(title="something is wrong", author=user)
site = Site(blog=blog)
schema = SiteSchema(only=['blog.author.email'])
pprint(schema.dump(site))

{'blog': {'author': {'email': 'mike@python.org'}}}

使用Pluck字段可以用单个值来替换嵌套的数据

class UserSchema(Schema):
    name = fields.String()
    email = fields.Email()
    friends = fields.Pluck("self", "name", many=True)

user1 = User(name="Mike", email="mike@example.com")
user2 = User(name="Tom", email="tom@example.com")
user3 = User(name="Steve", email="steve@example.com")
user3.friends = [user1, user2]
pprint(UserSchema().dump(user3))

{'email': 'steve@example.com', 'friends': ['Mike', 'Tom'], 'name': 'Steve'}

data = {
        "name": "Steve",
        "email": "steve@example.com",
        "friends": [
            "Tom",
            "Mike"
        ]
}
pprint(UserSchema().load(data))

{'email': 'steve@example.com',
 'friends': [{'name': 'Tom'}, {'name': 'Mike'}],
 'name': 'Steve'}

也可以使用exclude参数来排除不要的字段，对于深度嵌套，同样可以使用“.”符号连接

• Partial Loading

反序列化时，嵌套的schemas也可以继承父类的partial参数

class UserSchemaStrict(Schema):
    name = fields.String(required=True)
    email = fields.Email()
    created_at = fields.DateTime(required=True)

class BlogSchemaStrict(Schema):
    title = fields.String(required=True)
    author = fields.Nested(UserSchemaStrict, required=True)

schema = BlogSchemaStrict()
blog = {"title": "Something Completely Different", "author": {}}
result = schema.load(blog, partial=True)
pprint(result)

{'author': {}, 'title': 'Something Completely Different'}

同样可以通过“.”符号连接来指定partial字段的子集

author = {"name": "Monty", "email": "monty@example.com"}
blog = {"title": "Something Completely Different", "author": author}
result = schema.load(blog, partial=("title", "author.created_at"))
pprint(result)

{'author': {'email': 'monty@example.com', 'name': 'Monty'},
 'title': 'Something Completely Different'}

• Two-way Nesting

如果两个对象相互嵌套，则Nested可以传入类名的字符串形式，这允许在未定义该类时定义一个嵌套的schema类

class Author(object):
    def __init__(self, name, email):
        self.name = name
        self.email = email
        self.books = []

class Book(object):
    def __init__(self, title, author):
        self.title = title
        self.author = author

class AuthorSchema(Schema):
    name = fields.Str()
    email = fields.Email()
    # Make sure to use the 'only' or 'exclude' params
    # to avoid infinite recursion
    books = fields.Nested('BookSchema', many=True, exclude=('author',))

    class Meta:
        fields = ('name', 'email', 'books')

class BookSchema(Schema):
    title = fields.Str()
    author = fields.Nested(AuthorSchema, only=('name', 'email'))

    class Meta:
        fields = ('title', 'author')

author = Author(name="Mike", email="mike@yooh.com")
book = Book(title="This is a joke", author=author)
pprint(BookSchema().dump(book))

{'author': {'email': 'mike@yooh.com', 'name': 'Mike'},
 'title': 'This is a joke'}

author.books = [book]
pprint(AuthorSchema().dump(author))

{'books': [{'title': 'This is a joke'}],
 'email': 'mike@yooh.com',
 'name': 'Mike'}

• Nesting A Schema Within Itself

如果需要自引用，则Nested传入‘self’即可

class UserSchema(Schema):
    name = fields.String()
    email = fields.Email()
    friends = fields.Nested("self", many=True)
    # Use the 'exclude' argument to avoid infinite recursion
    employer = fields.Nested("self", exclude=("employer",), default=None)

user = User("Steve", "steve@example.com")
user.friends.append(User("Mike", "mike@example.com"))
user.friends.append(User("Joe", "joe@example.com"))
user.employer = User("Dirk", "dirk@example.com")
result = UserSchema().dump(user)
pprint(result, indent=2)

# {
#     "name": "Steve",
#     "email": "steve@example.com",
#     "friends": [
#         {
#             "name": "Mike",
#             "email": "mike@example.com",
#             "friends": [],
#             "employer": null
#         },
#         {
#             "name": "Joe",
#             "email": "joe@example.com",
#             "friends": [],
#             "employer": null
#         }
#     ],
#     "employer": {
#         "name": "Dirk",
#         "email": "dirk@example.com",
#         "friends": []
#     }
# }