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()