class BlogSchemaMeta(Schema):
"""Same as BlogSerializer but using ``fields`` options."""
user = fields.Nested(UserSchema)
collaborators = fields.Nested(UserSchema, many=True)
class Meta:
fields = ("title", "user", "collaborators", "categories", "id")
class TodoSchema(Schema):
id = fields.Int(dump_only=True)
done = fields.Boolean(attribute="is_done", missing=False)
user = fields.Nested(UserSchema,
exclude=("joined_on", "password"),
dump_only=True)
content = fields.Str(required=True)
posted_on = fields.DateTime(dump_only=True)
# Again, add an envelope to responses
@post_dump(pass_many=True)
def wrap(self, data, many):
key = "todos" if many else "todo"
return {key: data}
# We use make_object to create a new Todo from validated data
@post_load
def make_object(self, data):
if not data:
return None
return Todo(
content=data["content"],
is_done=data["is_done"],
posted_on=dt.datetime.utcnow(),
)
def test_unbound_field_root_returns_none(self):
field = fields.Str()
assert field.root is None
inner_field = fields.Nested(self.MySchema())
outer_field = fields.List(inner_field)
assert outer_field.root is None
assert inner_field.root is None
class MySchema(Schema):
foo = fields.Int(required=True)
bar = fields.Nested(NestedSchema, required=True)
bam = fields.Int(required=True)
@validates_schema(skip_on_field_errors=True)
def consistency_validation(self, data):
errors = {}
if data["bar"]["baz"] != data["foo"]:
errors["bar"] = {"baz": "Non-matching value"}
if data["bam"] > data["foo"]:
errors["bam"] = "Value should be less than foo"
if errors:
raise ValidationError(errors)
class MySchema(Schema):
nested = fields.Nested(NestedSchema)
@validates_schema
def validate_nested_foo(self, data):
raise ValidationError({"nested": {"foo": ["Invalid foo"]}})
@validates_schema
def validate_nested_bar_1(self, data):
raise ValidationError({"nested": {"bar": ["Invalid bar 1"]}})
@validates_schema
def validate_nested_bar_2(self, data):
raise ValidationError({"nested": {"bar": ["Invalid bar 2"]}})
class QuoteSchema(Schema):
id = fields.Int(dump_only=True)
author = fields.Nested(AuthorSchema, validate=must_not_be_blank)
content = fields.Str(required=True, validate=must_not_be_blank)
posted_at = fields.DateTime(dump_only=True)
# Allow client to pass author's full name in request body
# e.g. {"author': 'Tim Peters"} rather than {"first": "Tim", "last": "Peters"}
@pre_load
def process_author(self, data):
author_name = data.get("author")
if author_name:
first, last = author_name.split(" ")
author_dict = dict(first=first, last=last)
else:
author_dict = {}
data["author"] = author_dict
return data
def test_nested_only_and_exclude_as_string(self, param):
with pytest.raises(StringNotCollectionError):
fields.Nested(Schema, **{param: "foo"})
class ExampleSchema(Schema):
nested = fields.Nested(NestedSchema, required=True, many=True)
class BlogUserMetaSchema(Schema):
user = fields.Nested(UserMetaSchema())
collaborators = fields.Nested(UserMetaSchema, many=True)
class OrderedNestedOnly(Schema):
class Meta:
ordered = True
user = fields.Nested(KeepOrder)
class HasNestedExclude(Schema):
class Meta:
ordered = True
user = fields.Nested(KeepOrder, exclude=("birthdate", ))
class OtherSchema(Schema):
objects = fields.Nested(MySchema, many=True)
class BlogSchemaOnlyExclude(BlogSchema):
user = fields.Nested(UserSchema,
only=("name", ),
exclude=("name", "species"))
class BlogSchemaExclude(BlogSchema):
user = fields.Nested(UserSchema, exclude=("uppername", "species"))
class BlogOnlySchema(Schema):
title = fields.String()
user = fields.Nested(UserSchema)
collaborators = fields.Nested(UserSchema, only=("id", ), many=True)
class MySchema(Schema):
nested = fields.Nested(NestedSchema, unknown=field_unknown)
class MySchema(Schema):
nested = fields.Nested(NestedSchema,
required=True,
many=True,
unknown=EXCLUDE)
class BlogSchema(Schema):
title = fields.String()
user = fields.Nested(UserSchema)
collaborators = fields.Nested(UserSchema, many=True)
categories = fields.List(fields.String)
id = fields.String()
