def create_dataset(self):
"""
Creates a new dataset
:return:
"""
request = self._get_validated_request()
if 'name' not in request:
raise InvalidRequest("Name is required for a new dataset", status_code=400)
name = request['name']
if 'dataset_type' in request:
if request['dataset_type'] not in DATASET_TYPES:
raise InvalidRequest("The specified type of dataset is not valid.")
dataset_type = DATASET_TYPES[request['dataset_type']]
else:
dataset_type = GenericDataset
logging.info("Creating dataset with name {}".format(name))
if self.dataset_factory.create_dataset(name, dataset_type=dataset_type):
logging.info("Dataset with name {} initialized".format(name))
else:
logging.error("Dataset name {} is already taken".format(name))
raise InvalidRequest("Name already taken.", 401)
return ""
def make_web_screenshot(self):
"""
Retrieves the screenshot for the specified page
"""
json_request = request.get_json(force=True, silent=True, cache=False)
try:
url = json_request['url']
except Exception as ex:
raise InvalidRequest("url is missing in the request JSON.")
if not (url.lower().startswith("http://")
or url.lower().startswith("https://")):
raise InvalidRequest(
"Specified URL is not valid, must start with http:// or https://"
)
service = self.available_services['web_screenshoot_processor']
promise = service.queue_request(url)
binary_result = promise.get_result()
img_io = BytesIO(binary_result)
img_io.seek(0)
return send_file(img_io, mimetype='image/jpeg')
def get_batch(self, batch_id):
service = self.available_services['batch_screenshoot_processor']
try:
zip_uri = service.get_batch_zip_uri(batch_id)
percentage, is_zipped = service.get_processed_percentage(batch_id)
except:
raise InvalidRequest(
"Batch ID not valid or not available for cancelling.")
if not is_zipped:
raise InvalidRequest("Batch is not ready yet.")
return send_file(zip_uri)
def batch_web_screenshot(self):
json_request = request.get_json(force=True, silent=True, cache=False)
try:
urls = json_request['urls']
except Exception as ex:
raise InvalidRequest("url is missing in the request JSON.")
service = self.available_services['batch_screenshoot_processor']
if len(urls) == 0:
raise InvalidRequest("Required at least 1 URL in the 'url' list")
batch_id = service.new_batch(urls)
return jsonify({"batch_id": batch_id})
def _validate_float(var_name, float_number):
"""
Checks whether the specified parameter is a number or not. If not, it will raise a exception.
:param var_name: Name of the var to show in the exception (in order to reference the error).
:param number: Number to validate.
"""
try:
float(float_number) # for int, long and float
except ValueError:
raise InvalidRequest(
"The parameter {} is not a valid float.".format(var_name))
def remove_batch(self, batch_id):
service = self.available_services['batch_screenshoot_processor']
try:
service.remove_batch(batch_id)
except Exception as ex:
raise InvalidRequest(
"Batch ID not valid or not available for removing. {}".format(
ex))
return jsonify({'status': "done"})
def _get_raw_content_validated(is_base64=False):
"""
Validates the content of the request to ensure that it is readable and returns it.
Override this method to change or extend the default validation of the incoming request.
:param is_base64: specifies if the content is encoded in base64 or not. In case it is encoded, it will try
to decode it.
:return: the raw content (decoded content in case of base64)
"""
content = request.stream.read()
if len(content) == 0:
raise InvalidRequest("Request without content.")
if is_base64:
try:
content = base64.b64decode(content)
except Exception as ex:
raise InvalidRequest("Content is not valid Base64.")
return content
def _retrieve_result_metadata(resource_result):
"""
Applies the algorithm of the service to the resource and gets the result.
:param resource_result: Result of the process from a service.
:return: the metadata result of the process.
"""
if resource_result.get_uri() == 'error':
raise InvalidRequest("Content of file not valid: {}".format(
resource_result.get_id()))
return resource_result.get_metadata()
def get_batch_status(self, batch_id):
service = self.available_services['batch_screenshoot_processor']
try:
percentage, is_zipped = service.get_processed_percentage(batch_id)
except Exception as ex:
raise InvalidRequest(
"Batch ID not valid or not available for checking.")
return jsonify({
'percentage_completed': percentage,
'is_zipped': is_zipped
})
def _get_common__parameters(self, should_have_uri=False):
"""
Retrieves the common parameters for face ensemble requests.
:param should_have_uri: if the flag is True, the validation of the request will check that an URI is
present inside the request. This is a flag forwarded to _get_validated_request() method.
:return: request, service_face_detection, service_age_estimation,
service_gender_estimation, work_in_gray, limit_estimations,
bounding_box_expansion
"""
face_controller = age_controller = gender_controller = None
request = FaceEnsembleController._get_validated_request(
should_have_uri=should_have_uri)
limit_estimations = int(request.get('limit_estimations', 3))
bounding_box_expansion = float(
request.get('bounding_box_expansion', 0.8))
work_in_gray = request.get('work_in_gray', "true") == "true"
self._validate_number("limit_estimations", limit_estimations)
self._validate_float("bounding_box_expansion", bounding_box_expansion)
service_face_name = request.get('service_face', 'default')
service_age_name = request.get('service_age', 'default')
service_gender_name = request.get('service_gender', 'default')
if 'face_detection_controller' in self.controllers_dict:
face_controller = self.controllers_dict[
'face_detection_controller']
if 'age_estimation_controller' in self.controllers_dict:
age_controller = self.controllers_dict['age_estimation_controller']
if 'gender_estimation_controller' in self.controllers_dict:
gender_controller = self.controllers_dict[
'gender_estimation_controller']
service_face_detection = self._get_most_suitable_service(
service_face_name, face_controller)
service_age_estimation = self._get_most_suitable_service(
service_age_name, age_controller)
service_gender_estimation = self._get_most_suitable_service(
service_gender_name, gender_controller)
if not service_face_detection:
raise InvalidRequest("No services for face detection found.")
return request, service_face_detection, service_age_estimation, \
service_gender_estimation, work_in_gray, limit_estimations, \
bounding_box_expansion
def _get_validated_request(should_have_uri=False):
"""
Validates the request to fit a basic protocol. If the request does not fit the protocol, it will raise
an exception.
Override this method to change or extend the default validation of the incoming request.
:param should_have_uri: flag to specify if the request should contain an URI or not.
:return: the request validated.
"""
request_args = request.args
if should_have_uri and request_args.get("uri", '') == '':
raise InvalidRequest("Request URI is missing.")
return request_args
def _validate_number(var_name, number):
"""
Checks whether the specified parameter is a number or not. If not, it will raise a exception.
:param var_name: Name of the var to show in the exception (in order to reference the error).
:param number: Number to validate.
"""
try:
num = int(number) # for int, long and float
if num < 0:
raise ValueError("Negative integers not allowed.")
except ValueError:
raise InvalidRequest(
"The parameter {} is not a valid natural integer.".format(
var_name))
def _get_most_suitable_service(self, service_name):
"""
Searchs for the most suitable service for the requested service name.
If a service name is provided but no services matches it, it will return an InvalidRequest exception.
:param service_name: name of the service to match. If it is 'default', it will fall back to the
default service for this controller.
:return: the most suitable service for the service name.
"""
if service_name == "default":
service = self.default_service
else:
if service_name not in self.available_services:
raise InvalidRequest(
"Service name '{}' not valid.".format(service_name))
service = self.available_services[service_name]
return service
def _crop_by_bounding_box(image, bounding_box_text=None):
"""
Crops the image by the specified bounding box. If no bounding box is specified, the image
will be returned without any filtering.
:param image: image to crop.
:param bounding_box_text: bounding box to crop by. None to disable cropping.
:return: the image filtered or the original image in case the bounding box is None.
"""
if bounding_box_text is not None:
try:
bounding_box_text = BoundingBox.from_string(bounding_box_text)
bounding_box_text.fit_in_size(image.get_size())
image = image.crop_image(bounding_box_text,
"Cropped by boundingbox")
except Exception as ex:
raise InvalidRequest(
"The bounding box format is not valid. "
"Format must be: bounding_box=x,y,width,height")
return image
def custom_route_exception_example(self):
"""
Retrieves the services available for face detection.
"""
raise InvalidRequest("Raising exception as a test", status_code=505)