class Schema2(ValidatesSchema): foo = fields.Int(validate=lambda n: n != 42) bar = fields.Int(validate=lambda n: n == 1) @validates("bar") def validate_bar(self, value): if value != 2: raise ValidationError("Must be 2")
class MySchema(Schema): foo = fields.Int() bar = fields.Int() @validates_schema def validate_schema(self, data): if data["foo"] <= 3: raise ValidationError("Must be greater than 3") @validates_schema def validate_bar(self, data): if "bar" in data and data["bar"] < 0: raise ValidationError("bar must not be negative")
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): foo = fields.Int(required=True, validate=lambda n: n == 3) bar = fields.Int(required=True) @validates_schema(skip_on_field_errors=True) def validate_schema(self, data): if data["foo"] != data["bar"]: raise ValidationError("Foo and bar must be equal.") @validates_schema(skip_on_field_errors=True, pass_many=True) def validate_many(self, data, many): if many: assert type(data) is list if len(data) < 2: raise ValidationError("Must provide at least 2 items")
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(), )
class ValidatesSchema(Schema): foo = fields.Int() @validates("foo") def validate_foo(self, value): if value != 42: raise ValidationError( "The answer to life the universe and everything.")
class AuthorSchema(Schema): id = fields.Int(dump_only=True) first = fields.Str() last = fields.Str() formatted_name = fields.Method("format_name", dump_only=True) def format_name(self, author): return "{}, {}".format(author.last, author.first)
class NestedSchema(Schema): foo = fields.Int(required=True) @validates_schema(pass_many=pass_many, pass_original=True) def validate_schema(self, data, original_data, many=False): assert data == expected_data assert original_data == expected_original_data assert many is pass_many raise ValidationError("Method called")
class MySchema(Schema): foo = fields.Int() bar = fields.Int() @validates_schema def validate_schema(self, data): if data["foo"] <= 3: raise ValidationError("Must be greater than 3") @validates_schema(pass_many=True) def validate_raw(self, data, many): if many: assert type(data) is list if len(data) < 2: raise ValidationError("Must provide at least 2 items") @validates_schema def validate_bar(self, data): if "bar" in data and data["bar"] < 0: raise ValidationError("bar must not be negative", "bar")
class MySchema(Schema): foo = fields.Int() bar = fields.Int() @validates_schema(pass_original=True) def validate_original_foo(self, data, original_data): if isinstance(original_data, dict) and isinstance( original_data["foo"], str): raise ValidationError("foo cannot be a string") @validates_schema(pass_many=True, pass_original=True) def validate_original_bar(self, data, original_data, many): def check(datum): if isinstance(datum, dict) and isinstance( datum["bar"], str): raise ValidationError("bar cannot be a string") if many: for each in original_data: check(each) else: check(original_data)
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.Int(dump_only=True) book_name = fields.Str() page_number = fields.Float() line_number = fields.Float() col_number = fields.Float() # 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
class AuthorSchema(Schema): id = fields.Int(dump_only=True) first = fields.Str() last = fields.Str() book_count = fields.Float() age = fields.Float() address = fields.Str() full_name = fields.Method("full_name") def full_name(self, obj): return obj.first + " " + obj.last def format_name(self, author): return "{}, {}".format(author.last, author.first)
class OrderedMetaSchema(Schema): id = fields.Int(allow_none=True) email = fields.Email(allow_none=True) class Meta: fields = ( "name", "email", "age", "created", "id", "homepage", "birthdate", ) ordered = True
class NestedSchema(Schema): foo = fields.Int(required=True) @post_load(pass_many=False, pass_original=True) def check_pass_original_when_pass_many_false(self, data, original_data): assert data == expected_data assert original_data == expected_original_data return data @post_load(pass_many=True, pass_original=True) def check_pass_original_when_pass_many_true(self, data, many, original_data): assert many is True assert data == [expected_data] assert original_data == [expected_original_data] return data
class UserSchema(Schema): id = fields.Int(dump_only=True) email = fields.Str( required=True, validate=validate.Email(error="Not a valid email address"), ) password = fields.Str( required=True, validate=[validate.Length(min=6, max=36)], load_only=True, ) joined_on = fields.DateTime(dump_only=True) # Clean up data @pre_load def process_input(self, data): data["email"] = data["email"].lower().strip() return data # We add a post_dump hook to add an envelope to responses @post_dump(pass_many=True) def wrap(self, data, many): key = "users" if many else "user" return {key: data}
class NestedSchema(Schema): foo = fields.Int() bar = fields.Int()
class MySchema(Schema): foo = fields.Dict(keys=fields.Str(), values=fields.Int())
class MySchema(Schema): foo = fields.Field() bar = fields.List(fields.Str()) baz = fields.Tuple([fields.Str(), fields.Int()])
class ASchema(Schema): id = fields.Int()
class ExampleSchema(Schema): foo = fields.Int() bar = fields.Int() @pre_load() def pre_load_error1(self, item): if item["foo"] != 0: return item errors = { "foo": ["preloadmsg1"], "bar": ["preloadmsg2", "preloadmsg3"], } raise ValidationError(errors) @pre_load() def pre_load_error2(self, item): if item["foo"] != 4: return item raise ValidationError("preloadmsg1", "foo") @pre_load() def pre_load_error3(self, item): if item["foo"] != 8: return item raise ValidationError("preloadmsg1") @post_load() def post_load_error1(self, item): if item["foo"] != 1: return item errors = { "foo": ["postloadmsg1"], "bar": ["postloadmsg2", "postloadmsg3"], } raise ValidationError(errors) @post_load() def post_load_error2(self, item): if item["foo"] != 5: return item raise ValidationError("postloadmsg1", "foo") @pre_dump() def pre_dump_error1(self, item): if item["foo"] != 2: return item errors = { "foo": ["predumpmsg1"], "bar": ["predumpmsg2", "predumpmsg3"], } raise ValidationError(errors) @pre_dump() def pre_dump_error2(self, item): if item["foo"] != 6: return item raise ValidationError("predumpmsg1", "foo") @post_dump() def post_dump_error1(self, item): if item["foo"] != 3: return item errors = { "foo": ["postdumpmsg1"], "bar": ["postdumpmsg2", "postdumpmsg3"], } raise ValidationError(errors) @post_dump() def post_dump_error2(self, item): if item["foo"] != 7: return item raise ValidationError("postdumpmsg1", "foo")
class ValueSchema(Schema): value = fields.Int()
class NestedSchema(Schema): baz = fields.Int(required=True)
class NestedSchema(Schema): foo = fields.Int(required=True) @validates_schema def validate_schema(self, data): raise ValidationError("This will never work.", "foo")