def create_note(session: Session, data: NoteCreate, auth: Auth): """ This endpoint created note """ instance = Note( user_id=auth.user.id, title=data['title'], text=data['text'], device_token=data['device_token'] ) if data.get('reminder_date'): try: instance.reminder_date = datetime.strptime( data['reminder_date'], '%Y/%m/%d %H:%M' ) except ValueError: raise ValidationError({ 'message': 'invalid reminder date' }) if data.get('category'): category = session.query(Category).filter( Category.id == data['category'], Category.user_id == auth.user.id ).first() if not category: raise ValidationError({'message': 'Invalid category'}) instance.category_id = category.id session.add(instance) session.flush() return NoteList(instance)
def __init__(self, *args, **kwargs): definitions = None allow_coerce = False if args: assert len(args) == 1 definitions = kwargs.pop("definitions", definitions) allow_coerce = kwargs.pop("allow_coerce", allow_coerce) assert not kwargs if args[0] is None or isinstance(args[0], (bool, int, float, list)): raise ValidationError("Must be an object.") elif isinstance(args[0], dict): # Instantiated with a dict. value = args[0] else: # Instantiated with an object instance. value = { key: getattr(args[0], key) for key in self.validator.properties.keys() } else: # Instantiated with keyword arguments. value = kwargs value = self.validator.validate(value) object.__setattr__(self, "_dict", value)
def validate(self, value): match = DATE_REGEX.match(value) if not match: raise ValidationError('Must be a valid date.') kwargs = {k: int(v) for k, v in match.groupdict().items()} return datetime.date(**kwargs)
def __init__(self, *args, **kwargs): definitions = None allow_coerce = False force_format = False if args: assert len(args) == 1 definitions = kwargs.pop('definitions', definitions) allow_coerce = kwargs.pop('allow_coerce', allow_coerce) force_format = kwargs.pop('force_format', force_format) assert not kwargs if args[0] is None or isinstance( args[0], (str, bytes, bool, int, float, list)): raise ValidationError('Must be an object.') elif isinstance(args[0], Mapping): # Instantiated with a dict. value = args[0] else: # Instantiated with an object instance. value = {} for key, val in self.validator.properties.items(): v = getattr(args[0], key, validators.NO_DEFAULT) if v != validators.NO_DEFAULT: value[key] = v else: # Instantiated with keyword arguments. value = kwargs object.__setattr__(self, 'allow_coerce', allow_coerce) object.__setattr__(self, '_dict', dict(value)) object.__setattr__(self, 'formatted', False) if force_format: self.format(self.allow_coerce)
def validate(schema: type, value: Any, key=None): try: return schema(value) except SchemaError as exc: if key is None: detail = exc.detail else: detail = {key: exc.detail} raise ValidationError(detail=detail)
def __setattr__(self, key, value): if key not in self.validator.properties: raise AttributeError('Invalid attribute "%s"' % key) validator = self.validator.properties[key] try: value = validator.validate(value) except ValidationError as ex: raise ValidationError({validator.title or key: ex.detail}) self._dict[key] = value
def validate(self, value): match = TIME_REGEX.match(value) if not match: raise ValidationError('Must be a valid time.') kwargs = match.groupdict() kwargs['microsecond'] = kwargs['microsecond'] and kwargs['microsecond'].ljust(6, '0') kwargs = {k: int(v) for k, v in kwargs.items() if v is not None} return datetime.time(**kwargs)
def reformat(self, field_name, value=None, allow_coerce=False): if value is None: value = self._dict.get(field_name) validator = self.__class__.validator.properties[field_name] try: val = validator.validate(value, allow_coerce=allow_coerce) except ValidationError as ex: raise ValidationError({validator.title or field_name: ex.detail}) setattr(self, field_name, val) return val
def reformat(self, field_name, value=None, allow_coerce=False): if value is None: value = self._dict.get(field_name) try: val = self.__class__.validator.properties[field_name].validate( value, allow_coerce=allow_coerce) except ValidationError as ex: raise ValidationError(f"Field: {field_name} is {ex}") setattr(self, field_name, val) return val
def update_note(session: Session, note: int, auth: Auth, data: NoteCreate): """ This endpoint updates note """ instance = session.query(Note).filter( Note.id == note, Note.user_id == auth.user.id ).first() if not instance: raise NotFound({'message': 'Note not found'}) instance.title = data['title'] instance.text = data['text'] instance.device_token = data['device_token'] if data.get('reminder_date'): try: instance.reminder_date = datetime.strptime( data['reminder_date'], '%Y/%m/%d %H:%M' ) except ValueError: raise ValidationError({ 'message': 'invalid reminder date' }) if data.get('category'): category = session.query(Category).filter( Category.id == data['category'], Note.user_id == auth.user.id ).first() if not category: raise ValidationError({'message': 'Invalid category'}) instance.category_id = category.id session.commit() return NoteList(session.query(Note).filter(Note.id == note).first())
def instant_answer(q: Query) -> Result: """ Check if the query should display a map """ if q is None: # value is None if the query param is absent in request raise ValidationError({'q': '"q" is required'}) postal_response = postal.predict(q) ft_response = fasttext.predict(q) # for the moment we decide that it's an address if fasttext and postal agree on it is_addr = postal_response and ft_response return Result(q=q, is_address=is_addr)
async def reservation_create(session: Session, reservation: ReservationType) -> ReservationType: already_booked = session.query(Reservation).filter( Reservation.room == reservation['room'], Reservation.start_date >= arrow.get(reservation['start_date']).datetime, Reservation.end_date <= arrow.get(reservation['end_date']).datetime, ).count() if already_booked: raise ValidationError('this room is already booked for the same dates') obj = Reservation(**ReservationSerializer().load(reservation).data) session.add(obj) session.commit() return ReservationType(ReservationSerializer().dump(obj).data)
def django_get_token(session: DjangoSession, settings: Settings, data: Login): from django.contrib.auth import authenticate user_settings = get_settings(settings) user = authenticate( username=data['username'], password=data['password'] ) if not user: raise ValidationError(detail='Username or password invalid') TokenModel = getattr(session, user_settings['TOKEN_MODEL']) instance = TokenModel.objects.create( user=user, token=generate_key() ) return {'token': instance.token}
def validate(self, value): match = DATETIME_REGEX.match(value) if not match: raise ValidationError('Must be a valid datetime.') kwargs = match.groupdict() kwargs['microsecond'] = kwargs['microsecond'] and kwargs['microsecond'].ljust(6, '0') tzinfo = kwargs.pop('tzinfo') if tzinfo == 'Z': tzinfo = datetime.timezone.utc elif tzinfo is not None: offset_mins = int(tzinfo[-2:]) if len(tzinfo) > 3 else 0 offset_hours = int(tzinfo[1:3]) delta = datetime.timedelta(hours=offset_hours, minutes=offset_mins) if tzinfo[0] == '-': delta = -delta tzinfo = datetime.timezone(delta) kwargs = {k: int(v) for k, v in kwargs.items() if v is not None} kwargs['tzinfo'] = tzinfo return datetime.datetime(**kwargs)
def update_profile(session: Session, auth: Auth, data: ProfileUpdate, settings: Settings): """ This endpoint updates current user profile """ user = session.query(User).filter(User.id == auth.user.id).first() if data['username'] != user.username and session.query(User).filter( User.username == data['username']).count() != 0: raise ValidationError({'message': 'Username already in use'}) user.username = data['username'] if data.get('password'): user.password = hash_password(data['password'], settings) session.commit() return { 'username': user.username, 'id': user.id }
def parse(content, encoding=None, validator=None): if encoding not in (None, "json", "yaml"): raise ValueError('encoding must be either "json" or "yaml"') if encoding is None: if INFER_YAML.match(content): encoding = "yaml" elif INFER_JSON.match(content): encoding = "json" else: message = ErrorMessage( text= "Unable to guess if encoding is JSON or YAML. Use the 'encoding' argument.", code="unknown_encoding") raise ValidationError(messages=[message]) if encoding == "json": token = tokenize_json(content) else: token = tokenize_yaml(content) value = token.get_value() if validator is not None: try: value = validator.validate(value) except ValidationError as exc: for message in exc.messages: if message.code == 'required': message.position = token.lookup_position( message.index[:-1]) elif message.code in ['invalid_property', 'invalid_key']: message.position = token.lookup_key_position(message.index) else: message.position = token.lookup_position(message.index) exc.messages = sorted(exc.messages, key=lambda x: x.position.index) raise exc return (value, token)
def __init__(self, *args, **kwargs): if args: assert len(args) == 1 assert not kwargs if args[0] is None or isinstance(args[0], (bool, int, float, list)): raise ValidationError('Must be an object.') elif isinstance(args[0], dict): # Instantiated with a dict. value = args[0] else: # Instantiated with an object instance. value = { key: getattr(args[0], key) for key in self.validator.properties.keys() } else: # Instantiated with keyword arguments. value = kwargs value = self.validate(value) object.__setattr__(self, '_dict', value)
def sqlalcamy_get_token(session: SqlalchemySession, settings: Settings, data: Login): user_settings = get_settings(settings) username = data['username'] password = user_settings['ENCRYPTION_FUNCTION'](data['password'], settings) UserModel = user_settings['USER_MODEL'] TokenModel = user_settings['TOKEN_MODEL'] filters = { user_settings['USERNAME_FIELD']: username, user_settings['PASSWORD_FIELD']: password } user = session.query(UserModel).filter_by(**filters).first() if not user: raise ValidationError(detail='Username or password invalid') token = TokenModel( token=generate_key(), user_id=user.id ) session.add(token) return {'token': token.token}
def facets_for(field_name, size): """Return a dict for the aggregation (facet) for the given field Arguments: - size: Number of buckets per aggregation, where applicable. Ignored for geo_distance and date facets. """ if field_name.startswith('sourceResource.spatial.coordinates'): parts = field_name.partition(':') field, coords_part = parts[0], parts[2] origin = coords_part.replace(':', ',') ranges = \ [{'from': i, 'to': i + 99} for i in range(0, 2100, 100)] \ + [{'from': 2100}] return { 'geo_distance': { 'field': field, 'origin': origin, 'unit': 'mi', 'ranges': ranges } } else: try: actual_field, facet_type = facets[field_name] except KeyError: raise ValidationError("%s is not a facetable field" % field_name) if facet_type == 'date_histogram': interval = date_facet_interval(field_name) if interval in ['month', 'year']: return date_histogram_agg(field_name, actual_field, interval, size) else: return {'terms': {'field': actual_field, 'size': size}}
def validate(self, value, definitions=None, allow_coerce=False): if value is None and self.allow_null: return None elif value is None: self.error('null') elif not isinstance(value, (dict, typing.Mapping)): self.error('type') definitions = self.get_definitions(definitions) validated = dict_type() # Ensure all property keys are strings. errors = {} if any(not isinstance(key, str) for key in value.keys()): self.error('invalid_key') # Min/Max properties if self.min_properties is not None: if len(value) < self.min_properties: if self.min_properties == 1: self.error('empty') else: self.error('min_properties') if self.max_properties is not None: if len(value) > self.max_properties: self.error('max_properties') # Required properties for key in self.required: if key not in value: errors[key] = self.error_message('required') # Properties for key, child_schema in self.properties.items(): if key not in value: if child_schema.has_default(): validated[key] = child_schema.default continue item = value[key] try: validated[key] = child_schema.validate( item, definitions=definitions, allow_coerce=allow_coerce ) except ValidationError as exc: errors[key] = exc.detail # Pattern properties if self.pattern_properties: for key in list(value.keys()): for pattern, child_schema in self.pattern_properties.items(): if re.search(pattern, key): item = value[key] try: validated[key] = child_schema.validate( item, definitions=definitions, allow_coerce=allow_coerce ) except ValidationError as exc: errors[key] = exc.detail # Additional properties remaining = [ key for key in value.keys() if key not in set(validated.keys()) ] if self.additional_properties is True: for key in remaining: validated[key] = value[key] elif self.additional_properties is False: for key in remaining: errors[key] = self.error_message('no_additional_properties') elif self.additional_properties is not None: child_schema = self.additional_properties for key in remaining: item = value[key] try: validated[key] = child_schema.validate( item, definitions=definitions, allow_coerce=allow_coerce ) except ValidationError as exc: errors[key] = exc.detail if errors: raise ValidationError(errors) return validated
def mock_validation_failure(*args, **kwargs): raise ValidationError('x is not a valid parameter')
def error(self, code, **context): message = self.error_message(code, **context) raise ValidationError(messages=[message])
def validate(self, value, definitions=None, allow_coerce=False): if value is None and self.allow_null: return None elif value is None: self.error('null') elif not isinstance(value, (dict, typing.Mapping)): self.error('type') definitions = self.get_definitions(definitions) validated = dict_type() # Ensure all property keys are strings. errors = {} for key in value.keys(): if not isinstance(key, str): errors[key] = [self.error_message('invalid_key')] # Min/Max properties if self.min_properties is not None: if len(value) < self.min_properties: if self.min_properties == 1: self.error('empty') else: self.error('min_properties') if self.max_properties is not None: if len(value) > self.max_properties: self.error('max_properties') # Required properties for key in self.required: if key not in value: errors[key] = [self.error_message('required', field_name=key)] # Properties for key, child_schema in self.properties.items(): if key not in value: if child_schema.has_default(): validated[key] = child_schema.default continue item = value[key] try: validated[key] = child_schema.validate( item, definitions=definitions, allow_coerce=allow_coerce ) except ValidationError as exc: errors[key] = exc.messages # Pattern properties if self.pattern_properties: for key in list(value.keys()): for pattern, child_schema in self.pattern_properties.items(): if isinstance(key, str) and re.search(pattern, key): item = value[key] try: validated[key] = child_schema.validate( item, definitions=definitions, allow_coerce=allow_coerce ) except ValidationError as exc: errors[key] = exc.messages # Additional properties remaining = [ key for key in value.keys() if key not in set(validated.keys()) | set(errors.keys()) ] if self.additional_properties is True: for key in remaining: validated[key] = value[key] elif self.additional_properties is False: for key in remaining: errors[key] = [self.error_message('invalid_property')] elif self.additional_properties is not None: child_schema = self.additional_properties for key in remaining: item = value[key] try: validated[key] = child_schema.validate( item, definitions=definitions, allow_coerce=allow_coerce ) except ValidationError as exc: errors[key] = exc.messages if errors: error_messages = [] for key, messages in errors.items(): for message in messages: index = [key] if message.index is None else [key] + message.index error_message = ErrorMessage(message.text, message.code, index) error_messages.append(error_message) raise ValidationError(error_messages) return validated
def validate(schema, value): try: return schema(value) except SchemaError as exc: raise ValidationError(message=str(exc))
def validate(self, value, definitions=None, allow_coerce=False): if value is None and self.allow_null: return None elif value is None: self.error('null') elif not isinstance(value, list): self.error('type') definitions = self.get_definitions(definitions) validated = [] if self.min_items is not None and self.min_items == self.max_items and len(value) != self.min_items: self.error('exact_items') if self.min_items is not None and len(value) < self.min_items: if self.min_items == 1: self.error('empty') self.error('min_items') elif self.max_items is not None and len(value) > self.max_items: self.error('max_items') elif isinstance(self.items, list) and (self.additional_items is False) and len(value) > len(self.items): self.error('additional_items') # Ensure all items are of the right type. errors = {} if self.unique_items: seen_items = Uniqueness() for pos, item in enumerate(value): try: if isinstance(self.items, list): if pos < len(self.items): item = self.items[pos].validate( item, definitions=definitions, allow_coerce=allow_coerce ) elif isinstance(self.additional_items, Validator): item = self.additional_items.validate( item, definitions=definitions, allow_coerce=allow_coerce ) elif self.items is not None: item = self.items.validate( item, definitions=definitions, allow_coerce=allow_coerce ) if self.unique_items: if item in seen_items: self.error('unique_items') else: seen_items.add(item) validated.append(item) except ValidationError as exc: errors[pos] = exc.detail if errors: raise ValidationError(errors) return validated
def badinit(*args, **kwargs): raise ValidationError('no good')
def validate(self, value): try: return self.type(value) except Exception as ex: raise ValidationError(str(ex))
def validate(self, value): try: return datetime.datetime.strptime(value, self.format) except Exception as e: raise ValidationError(str(e))
def error(self, code): message = self.error_message(code) raise ValidationError(message)
def validate(schema, format=None, encoding=None): if format not in FORMAT_CHOICES: raise ValueError('format must be one of %s' % FORMAT_CHOICES) if isinstance(schema, (str, bytes)): value, token = parse(schema, encoding) elif isinstance(schema, dict): if encoding is not None: raise ValueError('encoding must be `None`.') value, token = schema, None else: raise ValueError( 'schema must either be a dict, or a string/bytestring.') if format is None: if isinstance(value, dict) and "openapi" in value and "swagger" not in value: format = "openapi" elif isinstance( value, dict) and "swagger" in value and "openapi" not in value: format = "swagger" else: message = ErrorMessage( text= "Unable to determine schema format. Use the 'format' argument.", code='unknown_format') raise ValidationError(messages=[message]) validator = { 'config': APISTAR_CONFIG, 'jsonschema': JSON_SCHEMA, 'openapi': OPEN_API, 'swagger': SWAGGER }[format] if validator is not None: try: value = validator.validate(value) except ValidationError as exc: exc.summary = { 'config': 'Invalid configuration file.', 'jsonschema': 'Invalid JSONSchema document.', 'openapi': 'Invalid OpenAPI schema.', 'swagger': 'Invalid Swagger schema.', }[format] if token is not None: for message in exc.messages: if message.code == 'required': message.position = token.lookup_position( message.index[:-1]) elif message.code in ['invalid_property', 'invalid_key']: message.position = token.lookup_key_position( message.index) else: message.position = token.lookup_position(message.index) exc.messages = sorted(exc.messages, key=lambda x: x.position.index) raise exc if format in ['openapi', 'swagger']: decoder = {'openapi': OpenAPI, 'swagger': Swagger}[format] value = decoder().load(value) return value