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