class GenreSchema(Schema):
id: int = fields.Integer(missing=None)
name: str = fields.String(missing=None)
genre_id: int = fields.String(missing=None)
movie_match_candidate_id: int = fields.Integer(missing=None)
movie_id: int = fields.String(missing=None)
movie = fields.Inferred()
movie_match_candidate = fields.Inferred()
class Meta:
exclude = ('movie_match_candidate', 'movie')
class AppSchema(Schema):
class Meta:
unknown = EXCLUDE
api_type = 'apps'
url = 'apps'
model = App
id = fields.Int(missing=None)
email = fields.Email(allow_none=True, missing=None)
roles = fields.List(fields.String(), allow_none=True, missing=None)
password = fields.String(missing=None)
salt = fields.String(allow_none=True, missing=None)
username = fields.String(missing=None)
code = fields.String(missing=None)
token = fields.String(missing=None)
name = fields.String(missing=None)
api_keys = fields.List(fields.String(), data_key='apiKeys', missing=None)
timezone = fields.String(missing=None)
google_api_key = fields.String(data_key='googleApiKey',
allow_none=True,
missing=None)
payment_gateway = fields.String(data_key='paymentGateway', missing=None)
venues = fields.List(fields.Inferred(), missing=None) # TODO
sender_email = fields.Email(data_key='senderEmail', missing=None)
deeplink_namespace = fields.String(data_key='deeplinkNamespace',
missing=None)
merchant_accounts = fields.List(fields.Inferred,
data_key='merchantAccounts',
allow_none=True,
missing=None)
title = fields.String(missing=None)
status = fields.String(missing=None)
currency = fields.Nested(CurrencySchema, missing=None)
cohorts = fields.List(fields.Inferred, missing=None)
class SotaRowSchema(Schema):
model_name = fields.String(required=True)
paper_title = fields.String(missing="")
paper_url = fields.String(missing="")
paper_date = fields.Date(format="%Y-%m-%d", allow_none=True, missing=None)
code_links = fields.Nested(LinkSchema, many=True, missing=list)
model_links = fields.Nested(LinkSchema, many=True, missing=list)
metrics = fields.Dict(keys=fields.String(), values=fields.Inferred())
@post_load
def post_load(self, data):
return SotaRow(**data)
class InstanceSchema(Schema):
id = fields.String(required=True)
version = fields.Inferred()
servers = fields.Nested(ServerSchema,
many=True,
validate=validate.Length(
min=0, max=32, error='invalid server count'))
uptime = fields.Int(required=True,
validate=validate.Range(min=0,
max=2147483647,
error='invalid uptime'))
last_heartbeat = fields.Int(required=False)
@post_load
def make_instance(self, data, **kwargs):
return InstanceModel(**data)
def _init_fields(self):
"""Update fields based on schema options."""
if self.opts.fields:
available_field_names = self.set_class(self.opts.fields)
else:
available_field_names = self.set_class(self.declared_fields.keys())
if self.opts.additional:
available_field_names |= self.set_class(self.opts.additional)
invalid_fields = self.set_class()
if self.only is not None:
# Return only fields specified in only option
field_names = self.set_class(self.only)
invalid_fields |= field_names - available_field_names
else:
field_names = available_field_names
# If "exclude" option or param is specified, remove those fields.
exclude_field_names = set(self.opts.exclude) | set(self.exclude)
if exclude_field_names:
# Note that this isn't available_field_names, since we want to
# apply "only" for the actual calculation.
field_names = field_names - exclude_field_names
invalid_fields |= exclude_field_names - available_field_names
if invalid_fields:
message = 'Invalid fields for {0}: {1}.'.format(self, invalid_fields)
raise ValueError(message)
fields_dict = self.dict_class()
for field_name in field_names:
field_obj = self.declared_fields.get(field_name, fields.Inferred())
self._bind_field(field_name, field_obj)
fields_dict[field_name] = field_obj
return fields_dict
def _init_fields(self) -> None:
"""Update self.fields, self.load_fields, and self.dump_fields based on schema options.
This method is private API.
"""
if self.opts.fields:
available_field_names = self.set_class(self.opts.fields)
else:
available_field_names = self.set_class(self.declared_fields.keys())
if self.opts.additional:
available_field_names |= self.set_class(self.opts.additional)
invalid_fields = self.set_class()
if self.only is not None:
# Return only fields specified in only option
field_names = self.set_class(self.only)
invalid_fields |= field_names - available_field_names
else:
field_names = available_field_names
# If "exclude" option or param is specified, remove those fields.
if self.exclude:
# Note that this isn't available_field_names, since we want to
# apply "only" for the actual calculation.
field_names = field_names - self.exclude
invalid_fields |= self.exclude - available_field_names
if invalid_fields:
message = "Invalid fields for {}: {}.".format(self, invalid_fields)
raise ValueError(message)
fields_dict = self.dict_class()
for field_name in field_names:
field_obj = self.declared_fields.get(field_name, ma_fields.Inferred())
self._bind_field(field_name, field_obj)
fields_dict[field_name] = field_obj
load_fields, dump_fields = self.dict_class(), self.dict_class()
for field_name, field_obj in fields_dict.items():
if not field_obj.dump_only:
load_fields[field_name] = field_obj
if not field_obj.load_only:
dump_fields[field_name] = field_obj
dump_data_keys = [
field_obj.data_key if field_obj.data_key is not None else name
for name, field_obj in dump_fields.items()
]
if len(dump_data_keys) != len(set(dump_data_keys)):
data_keys_duplicates = {
x for x in dump_data_keys if dump_data_keys.count(x) > 1
}
raise ValueError(
"The data_key argument for one or more fields collides "
"with another field's name or data_key argument. "
"Check the following field names and "
"data_key arguments: {}".format(list(data_keys_duplicates))
)
load_attributes = [obj.attribute or name for name, obj in load_fields.items()]
if len(load_attributes) != len(set(load_attributes)):
attributes_duplicates = {
x for x in load_attributes if load_attributes.count(x) > 1
}
raise ValueError(
"The attribute argument for one or more fields collides "
"with another field's name or attribute argument. "
"Check the following field names and "
"attribute arguments: {}".format(list(attributes_duplicates))
)
self.fields = fields_dict
self.dump_fields = dump_fields
self.load_fields = load_fields
def _init_fields(self):
"""Update fields based on schema options."""
if self.opts.fields:
available_field_names = self.set_class(self.opts.fields)
else:
available_field_names = self.set_class(self.declared_fields.keys())
if self.opts.additional:
available_field_names |= self.set_class(self.opts.additional)
invalid_fields = self.set_class()
if self.only is not None:
# Return only fields specified in only option
field_names = self.set_class(self.only)
invalid_fields |= field_names - available_field_names
else:
field_names = available_field_names
# If "exclude" option or param is specified, remove those fields.
exclude_field_names = set(self.opts.exclude) | set(self.exclude)
if exclude_field_names:
# Note that this isn't available_field_names, since we want to
# apply "only" for the actual calculation.
field_names = field_names - exclude_field_names
invalid_fields |= exclude_field_names - available_field_names
if invalid_fields:
message = 'Invalid fields for {0}: {1}.'.format(
self, invalid_fields)
raise ValueError(message)
fields_dict = self.dict_class()
for field_name in field_names:
field_obj = self.declared_fields.get(field_name,
ma_fields.Inferred())
self._bind_field(field_name, field_obj)
fields_dict[field_name] = field_obj
dump_data_keys = [
obj.data_key or name for name, obj in iteritems(fields_dict)
if not obj.load_only
]
if len(dump_data_keys) != len(set(dump_data_keys)):
data_keys_duplicates = {
x
for x in dump_data_keys if dump_data_keys.count(x) > 1
}
raise ValueError(
'The data_key argument for one or more fields collides '
"with another field's name or data_key argument. "
'Check the following field names and '
'data_key arguments: {}'.format(list(data_keys_duplicates)), )
load_attributes = [
obj.attribute or name for name, obj in iteritems(fields_dict)
if not obj.dump_only
]
if len(load_attributes) != len(set(load_attributes)):
attributes_duplicates = {
x
for x in load_attributes if load_attributes.count(x) > 1
}
raise ValueError(
'The attribute argument for one or more fields collides '
"with another field's name or attribute argument. "
'Check the following field names and '
'attribute arguments: {}'.format(
list(attributes_duplicates)), )
return fields_dict
