def update_status(self, data):
if self.status == 'deleted':
raise errors.ForbiddenStatusError(self._id)
status = data.pop('status')
if data:
raise DataError({'status': "This is the only field that can be updated with this endpoint"})
if not isinstance(status, str):
raise DataError({'status': f"Value must be string, but found {type(status).__name__}"})
self.import_data({'status': status})
def update_car(self, data):
if self.status == 'deleted':
raise errors.ForbiddenStatusError(self._id)
if 'status' in data:
raise DataError({'status': "Can not be set with this endpoint. "
"Please use /api/cars/:obj_id/status"})
if 'vin' in data:
raise DataError({'vin': "Can not be set with this endpoint. "
"Please use /api/cars/:obj_id/vin"})
self.import_data(data)
def validate_body_schematic(self):
if self._request_model.request_schematic_validation is None:
return True
# If the HTTP Response Validation Schematic has been set
else:
try:
# The last part to test is does the Parsed JSON match the schematic validation
self._request_model.request_schematic_validation(self._request_model.body) \
.validate()
return True
except DataError as e:
message = """The request was unable to conform to the validation schematic.
The error provided by the schematic validation is {0}
To fix this you can either modify the schematic validation or remove it entirely
""".format(str(e))
raise DataError(message)
except TypeError as e:
message = """The request was unable to conform to the validation schematic. The
schematic applied was {0}
The error provided by the schematic validation is {1}
To fix this you can either modify the schematic validation or remove it entirely
""".format(str(self._request_model.request_schematic_validation), e)
raise TypeError(message)
def validate_auth(auth_type, auth_data):
"""
Functionality:
Validate the state of the two auth objects that will be used to apply authentication
Test if the auth_schematic passed
We also do a second test to make sure the auth_schematic.value is also a model
"""
if auth_type is None and auth_data is None:
return True
if auth_type in authentication_choices and auth_type == "basic":
if auth_data.get('username') is None or auth_data.get('password') is None:
message = """For the Basic Authentication a username and password is required. The
current authentication data passed to this function is incorrect. The authentication
data is {0}""".format(str(auth_data))
raise DataError(message)
HTTPBasicAuth(auth_data.get('username'),
auth_data.get('password'))
return True
else:
message = """We are unable to find the authentication defined within the http_method_choices var.
Please verify if the authentication type {0} exists within the http_method_choices
variable. If it does not then you need to either change the authentication type
or add the authentication variable inside the http_method_choices var""" \
.format(str(auth_type))
raise NotImplementedError(message)
def import_data(self, raw_value, strict=False):
if not self._schema.compare_tag_name(raw_value['tag']):
raise DataError({raw_value['tag']: 'Mismatched tag name'})
self._import_attributes(raw_value.get('attrib', {}), strict)
self._import_children(raw_value.get('children', []), strict)
self._import_content(raw_value.get('text'), strict)
return self
def _on_production_year_set(self, value):
if not value:
return
try:
datetime.strptime(value, '%Y')
except ValueError:
raise DataError({'production_year': "productionYear should match pattern '%Y'"})
def _import_content(self, content, strict=False):
if content is not None:
for field_name, v in self._schema.content.items():
self._data[field_name] = v.from_content(content)
break
else:
if strict:
raise DataError({'text': 'Rogue content'})
def validate(self, partial=False, convert=True, app_data=None, **kwargs):
"""Validate model."""
super().validate(partial, convert, app_data, **kwargs)
# role list checks
if not isinstance(self.roles, list):
raise DataError({'roles': 'Value is not a list'})
# pylint: disable=not-an-iterable
for role in self.roles:
if role not in ROLES:
raise DataError({'roles': 'Unknown role "%s"' % role})
if len(self.roles) != len(set(self.roles)):
raise DataError({'roles': 'Duplicate roles'})
# pylint: disable=unsupported-membership-test
if 'none' in self.roles and len(self.roles) > 1:
raise DataError(
{'roles': 'Role "none" can\'t be used with orher roles'})
def _validate_post_request(self):
"""Load the post request into the validation class and perform validations."""
if "audio" not in self.request.files:
raise DataError(dict(audio="No audio file included in request"))
if "metadata" not in self.request.files:
raise DataError(
dict(metadata="No metadata file included in request"))
metadata = json.loads(self.request.files["metadata"].read().decode())
upload_request = UploadRequest(
dict(
wake_word=metadata.get("wake_word"),
engine=metadata.get("engine"),
timestamp=metadata.get("timestamp"),
model=metadata.get("model"),
))
upload_request.validate()
self.request_data = upload_request.to_native()
def _import_attributes(self, attrib, strict=False):
for attrib_name, attrib_value in attrib.items():
for field_name, v in self._schema.attributes.items():
if v.matches(field_name, attrib_name):
self._data[field_name] = v.from_attr(
field_name, attrib_value)
break
else:
if strict:
raise DataError({attrib_name: 'Rogue attribute'})
def _get_skill(self):
"""Retrieve the skill associated with the request."""
skill_repo = SkillRepository(self.db)
self.skill = skill_repo.get_skill_by_global_id(
self.request.json['skill_gid'])
if self.skill is None:
err_msg = ('No skill on database for skill ' +
self.request.json['skill_gid'])
_log.error(err_msg)
raise DataError(dict(skill_gid=[err_msg]))
def validate_bar(cls, data, value):
errors = {}
if 'a' not in value:
errors['a'] = ValidationError('Key a must be set.')
if 'b' not in value:
errors['b'] = ValidationError('Key b must be set.')
if errors:
raise DataError(errors)
def validate(self, partial=False, convert=True, app_data=None, **kwargs):
"""Validate model."""
super().validate(partial, convert, app_data, **kwargs)
choices = []
for district_choices in self.choices.values():
for choice in district_choices.values():
for choice_id in choice.keys():
if choice_id in choices:
raise DataError(
{'choices': f'Duplicate choice ID: {choice_id}'})
choices.append(choice_id)
def _import_children(self, children, strict=False):
for child in children:
for field_name, v in self._schema.children.items():
match_result = v.matches(field_name, child)
if match_result:
self._data[field_name] = v.incorporate_child(
match_result, self._data.get(field_name, Undefined),
child)
break
else:
if strict:
raise DataError({child['tag']: 'Rogue child'})
def _get_device_skill(self, device_id):
"""Retrieve the device's skill entry from the database."""
device_skill = self.device_skill_repo.get_skill_settings_for_device(
device_id, self.skill.id)
if device_skill is None:
error_msg = (
'Received skill setting definition before manifest for '
'skill ' + self.skill.skill_gid)
_log.error(error_msg)
raise DataError(dict(skill_gid=[error_msg]))
return device_skill
def _validate_post_request(self):
"""Load the post request into the validation class and perform validations."""
upload_request = UploadRequest(
dict(
wake_word=self.request.form.get("wake_word"),
engine=self.request.form.get("engine"),
timestamp=self.request.form.get("timestamp"),
model=self.request.form.get("model"),
))
upload_request.validate()
self.request_data = upload_request.to_native()
if "audio_file" not in self.request.files:
raise DataError(
dict(audio_file="No audio file included in request"))
def validate_body_schematic(self, json_decoded_response):
if self._response_model.response_schematic_validation is None or \
self._response_model.response is None:
return True
if issubclass(self._response_model.response_schematic_validation, Model) is True:
try:
if isinstance(json_decoded_response, dict) is False:
raise ValueError()
# The last part to test is does the Parsed JSON match the schematic validation
self._response_model.response_schematic_validation(json_decoded_response) \
.validate()
return True
except DataError as e:
message = """The response was unable to conform to the validation schematic.
The error provided by the schematic validation is {0}
To fix this you can either modify the schematic validation or remove it entirely
""".format(str(e))
raise DataError(message)
except ValueError as e:
message = """Unable to parse the response as JSON.
The response received was {0}.
Full error from the JSON parse attempt {1}
""".format(str(self._response_model.response.content), e)
raise ValueError(message)
else:
message = """The proxy schematic does not contain the correct type.
The provided type is {0}. The function requires a valid schematic as a argument
This allows a response object to be tested against the schematic""" \
.format(str(type(self._response_model.response_schematic_validation)))
raise TypeError(message)
def test_handle_data_error(self):
e = DataError({"A1": "A1 Data Error"})
resp = baseapp.handle_data_error(e)
assert resp.status_code == 400
def get_figure(
data, # type: DataFrame
filters=[], # type: List[dict]
group=None, # type: Optional[dict]
pivot=None, # type: Optional[dict]
kind='bar', # type: str
color_scheme={}, # type: Dict[str, str]
x_axis=None, # type: Optional[str]
y_axis=None, # type: Optional[str]
title=None, # type: Optional[str]
x_title=None, # type: Optional[str]
y_title=None, # type: Optional[str]
bins=50, # type: int
bar_mode='stack', # type: str
):
'''
Generates a plotly figure dictionary from given data and manipulations.
Args:
data (DataFrame): Data.
filters (list[dict], optional): List of filters for data. Default: [].
group (dict, optional): Grouping operation. Default: None.
pivot (dict, optional): Pivot operation. Default: None.
kind (str, optional): Kind of plot. Default: bar.
color_scheme (dict[str, str], optional): Color scheme. Default: {}.
x_axis (str): Column to use as x axis: Default: None.
y_axis (str): Column to use as y axis: Default: None.
title (str, optional): Title of plot. Default: None.
x_title (str, optional): Title of x axis. Default: None.
y_title (str, optional): Title of y axis. Default: None.
bins (int, optional): Number of bins if histogram. Default: 50.
bar_mode (str, optional): How bars in bar graph are presented.
Default: stack.
Raises:
DataError: If any filter in filters is invalid.
DataError: If group is invalid.
DataError: If pivot is invalid.
Returns:
dict: Plotly Figure as dictionary.
'''
data = data.copy()
# filter
for f in filters:
f = cfg.FilterAction(f)
try:
f.validate()
except DataError as e:
raise DataError({'Invalid filter': e.to_primitive()})
f = f.to_primitive()
if len(data) == 0:
break
data = filter_data(data, f['column'], f['comparator'], f['value'])
# group
if group is not None:
grp = group # type: Any
grp = cfg.GroupAction(grp)
try:
grp.validate()
except DataError as e:
raise DataError({'Invalid group': e.to_primitive()})
grp = grp.to_primitive()
data = group_data(
data,
grp['columns'],
grp['metric'],
datetime_column=grp['datetime_column'],
)
# pivot
if pivot is not None:
pvt = pivot # type: Any
pvt = cfg.PivotAction(pvt)
try:
pvt.validate()
except DataError as e:
raise DataError({'Invalid pivot': e.to_primitive()})
pvt = pvt.to_primitive()
data = pivot_data(data,
pvt['columns'],
values=pvt['values'],
index=pvt['index'])
# create figure
figure = data.iplot(kind=kind,
asFigure=True,
theme='henanigans',
colorscale='henanigans',
x=x_axis,
y=y_axis,
title=title,
xTitle=x_title,
yTitle=y_title,
barmode=bar_mode,
bins=bins).to_dict() # type: dict
figure['layout']['title']['font']['color'] = '#F4F4F4'
figure['layout']['xaxis']['title']['font']['color'] = '#F4F4F4'
figure['layout']['yaxis']['title']['font']['color'] = '#F4F4F4'
if color_scheme != {}:
figure = conform_figure(figure, color_scheme)
# makes area traces stackable
if kind == 'area':
for trace in figure['data']:
trace['stackgroup'] = 1
return figure
dict(
name='config',
type='string',
description='Database configuration as JSON string.',
required=True,
default='',
)
],
responses={
200:
dict(
description='Shekels database successfully initialized.',
content='application/json',
),
400:
dict(description='Invalid configuration.',
example=dict(
error='''
DataError(
{'data_path': ValidationError([ErrorMessage("/foo.bar is not in a valid CSV file.", None)])}
)'''[1:],
success=False,
))
}))
def initialize():
# type: () -> flask.Response
'''
Initialize database with given config.
Raises:
RuntimeError: If config is invalid.
def _on_make_set(self, value):
if not value:
return
if not value.isupper():
raise DataError({'make': 'make should be uppercase'})
def _on_model_set(self, value):
if not value:
return
if not value.isupper():
raise DataError({'model': 'model should be uppercase'})
def post(self, team_id):
"""
Message all team members
---
tags:
- teams
produces:
- application/json
parameters:
- in: header
name: Authorization
description: Base64 encoded session token
required: true
type: string
default: Token sessionTokenHere==
- name: team_id
in: path
description: Unique team ID
required: true
type: integer
default: 1
- in: body
name: body
required: true
description: JSON object for creating message
schema:
properties:
subject:
type: string
default: Thanks
required: true
message:
type: string
default: Thanks for your contribution
required: true
responses:
200:
description: Message sent successfully
401:
description: Unauthorized - Invalid credentials
403:
description: Forbidden
500:
description: Internal Server Error
"""
try:
authenticated_user_id = token_auth.current_user()
team_id = request.view_args["team_id"]
message_dto = MessageDTO(request.get_json())
# Validate if team is present
try:
team = TeamService.get_team_by_id(team_id)
except NotFound:
return {"Error": "Team not found"}, 404
is_manager = TeamService.is_user_team_manager(
team_id, authenticated_user_id)
if not is_manager:
raise ValueError
message_dto.from_user_id = authenticated_user_id
message_dto.validate()
if not message_dto.message.strip(
) or not message_dto.subject.strip():
raise DataError({"Validation": "Empty message not allowed"})
except DataError as e:
current_app.logger.error(f"Error validating request: {str(e)}")
return {"Error": "Request payload did not match validation"}, 400
except ValueError:
return {
"Error": "Unauthorised to send message to team members"
}, 403
try:
threading.Thread(
target=TeamService.send_message_to_all_team_members,
args=(team_id, team.name, message_dto),
).start()
return {"Success": "Message sent successfully"}, 200
except ValueError as e:
return {"Error": str(e)}, 403
except Exception as e:
error_msg = f"Send message all - unhandled error: {str(e)}"
current_app.logger.critical(error_msg)
return {"Error": "Unable to send messages to team members"}, 500
name='write_mode',
type='string',
description='How assets will be extracted to hidebound/data directory.',
required=False,
default='copy',
enum=['copy', 'move'],
)
],
responses={
200: dict(
description='Hidebound database successfully initialized.',
content='application/json',
),
400: dict(
description='Invalid configuration.',
example=dict(
error='''
DataError(
{'write_mode': ValidationError([ErrorMessage("foo is not in ['copy', 'move'].", None)])}
)'''[1:],
success=False,
)
)
}
))
def initialize():
# type: () -> flask.Response
'''
Initialize database with given config.
Returns:
Response: Flask Response instance.
