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