class Meta:
include = OrderedDict([
("from", fields.Str()),
("in", fields.Str()),
("@at", fields.Str()),
])
ordered = True
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 AddFieldsOrdered(Schema):
name = fields.Str()
email = fields.Str()
class Meta:
include = OrderedDict([
("from", fields.Str()),
("in", fields.Str()),
("@at", fields.Str()),
])
ordered = True
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 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 PackageSchema(Schema):
name = fields.Str(required=True)
version = Version(required=True)
description = fields.Str(required=True)
main = fields.Str(required=False)
homepage = fields.URL(required=False)
scripts = fields.Dict(keys=fields.Str(), values=fields.Str())
license = fields.Str(required=True)
dependencies = fields.Dict(keys=fields.Str(),
values=fields.Str(),
required=False)
dev_dependencies = fields.Dict(
keys=fields.Str(),
values=fields.Str(),
required=False,
data_key="devDependencies",
)
class Meta:
# Include unknown fields in the
# deserialized output
unknown = INCLUDE
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 UserSchema(Schema):
name = fields.String()
age = fields.Float()
created = fields.DateTime()
created_formatted = fields.DateTime(format="%Y-%m-%d",
attribute="created",
dump_only=True)
created_iso = fields.DateTime(format="iso",
attribute="created",
dump_only=True)
updated = fields.DateTime()
updated_local = fields.LocalDateTime(attribute="updated", dump_only=True)
species = fields.String(attribute="SPECIES")
id = fields.String(default="no-id")
uppername = Uppercased(attribute="name", dump_only=True)
homepage = fields.Url()
email = fields.Email()
balance = fields.Decimal()
is_old = fields.Method("get_is_old")
lowername = fields.Function(get_lowername)
registered = fields.Boolean()
hair_colors = fields.List(fields.Raw)
sex_choices = fields.List(fields.Raw)
finger_count = fields.Integer()
uid = fields.UUID()
time_registered = fields.Time()
birthdate = fields.Date()
activation_date = fields.Date()
since_created = fields.TimeDelta()
sex = fields.Str(validate=validate.OneOf(["male", "female"]))
various_data = fields.Dict()
class Meta:
render_module = simplejson
def get_is_old(self, obj):
if obj is None:
return missing
if isinstance(obj, dict):
age = obj.get("age")
else:
age = obj.age
try:
return age > 80
except TypeError as te:
raise ValidationError(str(te))
@post_load
def make_user(self, data):
return User(**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 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 AddFieldsChild(self.AddFieldsSchema):
email = fields.Str()
class MySchema(Schema):
name = fields.Str()
class UnorderedSchema(Schema):
name = fields.Str()
email = fields.Str()
class Meta:
ordered = False
class Meta:
include = {"from": fields.Str()}
class AddFieldsSchema(Schema):
name = fields.Str()
class Meta:
include = {"from": fields.Str()}
