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