Пример #1
0
    def post(self):
        logger.info('In ClusterText post()')
        args = parsers.cluster_parser.parse_args()

        if not allowed_file(args['file'].filename, settings.TEXT_ALLOWED_EXTENSIONS):
            logger.error('Invalid file name ' + args['file'].filename)
            error = BadRequest()
            error.data = ['This filetype is not allowed. Please contact admin.']
            raise error

        n = args['n']
        if n < 2 or n > 6:
            logger.error('Invalid n-gram size: %d' % n)
            error = BadRequest()
            error.data = ['n value must be between 2 and 6. Please try again.']
            raise error

        try:
            coverage = True if 'true' in args['coverage'] else False
            logger.info('Coverage value is ' + str(coverage))
            mem_file = BytesIO()
            args['file'].save(mem_file)

            logger.info('Finding cluster labels...')
            clusters, coverage = find_labels(mem_file.getvalue().decode('UTF-8'), n, coverage)
            output = {'coverage': coverage, 'clusters': clusters}

        except:
            logger.error('Some exception occurred.')
            error = InternalServerError()
            error.data = ['Some error. Please contact admin.']
            raise error

        return output, 200
Пример #2
0
    def post(self):
        """Predict audio classes from input data"""
        result = {'status': 'error'}

        args = input_parser.parse_args()
        audio_data = args['audio'].read()

        # clean up from earlier runs
        if os.path.exists("/audio.wav"):
            os.remove("/audio.wav")

        if '.wav' in str(args['audio']):
            file = open("/audio.wav", "wb")
            file.write(audio_data)
            file.close()
        else:
            e = BadRequest()
            e.data = {
                'status': 'error',
                'message': 'Invalid file type/extension'
            }
            raise e

        # Getting the predictions
        try:
            preds = self.model_wrapper._predict("/audio.wav",
                                                args['start_time'])
        except ValueError:
            e = BadRequest()
            e.data = {
                'status': 'error',
                'message': 'Invalid start time: value outside audio clip'
            }
            raise e

        # Aligning the predictions to the required API format
        label_preds = [{
            'label_id': p[0],
            'label': p[1],
            'probability': p[2]
        } for p in preds]

        # Filter list
        if args['filter'] is not None and any(x.strip() != ''
                                              for x in args['filter']):
            label_preds = [
                x for x in label_preds if x['label'] in args['filter']
            ]

        result['predictions'] = label_preds
        result['status'] = 'ok'

        os.remove("/audio.wav")

        return result
Пример #3
0
    def post(self):
        """Predict audio classes from input data"""
        result = {'status': 'error'}

        args = input_parser.parse_args()

        if not re.match("audio/.*wav", str(args['audio'].mimetype)):
            e = BadRequest()
            e.data = {
                'status':
                'error',
                'message':
                'Invalid file type/extension: ' + str(args['audio'].mimetype)
            }
            raise e

        audio_data = args['audio'].read()
        # sliced_audio = audio_slice.slice(audio_data, 10)

        # Getting the predictions
        try:
            preds = self.model_wrapper._predict(audio_data, args['start_time'])
        except ValueError:
            e = BadRequest()
            e.data = {
                'status': 'error',
                'message': 'Invalid start time: value outside audio clip'
            }
            raise e

        # Aligning the predictions to the required API format
        label_preds = [{
            'label_id': p[0],
            'label': p[1],
            'probability': p[2]
        } for p in preds]
        # label_preds = [{'label_id': p[0], 'probability': p[2]} for p in preds]

        # Filter list
        if args['filter'] is not None and any(x.strip() != ''
                                              for x in args['filter']):
            label_preds = [
                x for x in label_preds if x['label'] in args['filter']
            ]

        result['predictions'] = label_preds
        result['status'] = 'ok'

        return result
    def post(self):
        """Generate audio embedding from input data"""
        result = {'status': 'error'}

        args = input_parser.parse_args()
        audio_data = args['audio'].read()

        # clean up from earlier runs
        if os.path.exists("/audio.wav"):
            os.remove("/audio.wav")

        if '.wav' in str(args['audio']):
            file = open("/audio.wav", "wb")
            file.write(audio_data)
            file.close()
        else:
            e = BadRequest()
            e.data = {
                'status': 'error',
                'message': 'Invalid file type/extension'
            }
            raise e

        # Getting the predictions
        preds = self.model_wrapper.predict("/audio.wav")

        # Aligning the predictions to the required API format
        result['embedding'] = preds.tolist()
        result['status'] = 'ok'

        os.remove("/audio.wav")

        return result
Пример #5
0
    def post(self):
        """Predict audio classes from input data"""
        result = {'status': 'error'}

        args = audio_parser.parse_args()
        audio_data = args['audio'].read()

        # clean up from earlier runs
        if os.path.exists("/audio.wav"):
            os.remove("/audio.wav")
        
        if '.wav' in str(args['audio']):
            file = open("/audio.wav", "wb")
            file.write(audio_data)
            file.close()
        else:
            e = BadRequest()
            e.data = {'status': 'error', 'message': 'Invalid file type/extension'}
            raise e

        # Getting the predictions
        preds = self.mw.predict("/audio.wav")
        
        # Aligning the predictions to the required API format
        label_preds = [{'label_id': p[0], 'label': p[1], 'probability': p[2]} for p in preds]
        result['predictions'] = label_preds
        result['status'] = 'ok'
        
        os.remove("/audio.wav")

        return result
Пример #6
0
def authorizeRequest():
    bearer = request.headers.get('Authorization')
    e = BadRequest(
        'No Authorization provided in headers. Attach a valid bearer token.')
    e.data = {'Access': 'Denied', 'CODE': 'Unauthorized'}
    if bearer is None or 'Bearer' not in bearer:
        raise e
Пример #7
0
def validate(self, req=None, strict=False):
    if req is None:
        req = request

    result = self.result_class()

    # A record of arguments not yet parsed; as each is found among self.args, it will be popped out
    req.unparsed_arguments = dict(
        self.argument_class('').source(req)) if strict else {}
    errors = {}
    for arg in self.args:
        value, found = arg.parse(req, self.bundle_errors)
        if isinstance(value, ValueError):
            errors.update(found)
            found = None
        if found or arg.store_missing:
            result[arg.dest or arg.name] = value
    if errors:
        data = {
            "errors": errors,
            "message": "Invalid data",
        }
        bad_request = BadRequest()
        bad_request.data = data

        raise bad_request

    if strict and req.unparsed_arguments:
        arguments = ', '.join(req.unparsed_arguments.keys())
        msg = 'Unknown arguments: {0}'.format(arguments)
        raise BadRequest(msg)

    return result
Пример #8
0
    def get(self, filename):
        logger.info('In DownloadFile get(), filename:' + filename)

        if not allowed_file(filename, settings.EVENT_ALLOWED_EXTENSIONS):
            logger.error('Invalid file name:' + filename)
            error = BadRequest()
            error.data = ['This file type is not allowed. Please contact admin.']
            raise error

        logger.info('Sending file from directory...')
        root_dir = os.getcwd()
        return send_from_directory(os.path.join(root_dir, settings.UPLOAD_FOLDER), filename)
Пример #9
0
def validate_payload(payload, api_model):
    # check if any reqd fields are missing in payload
    for key in api_model:
        if api_model[key].required and key not in payload:
            e = BadRequest('My custom message')
            e.data = {'custom': 'Required field \'%s\' missing' % key}
            raise e
    # check payload
    for key in payload:
        field = api_model[key]
        if isinstance(field, fields.List):
            field = field.container
            data = payload[key]
        else:
            data = [payload[key]]
        if isinstance(field, custom_fields.CustomField) and hasattr(field, 'validate'):
            for i in data:
                if not field.validate(i):
                    e = BadRequest('My custom message')
                    e.data = {'custom': 'Validation of \'%s\' field failed' % key}
                    raise e
Пример #10
0
def raise_validation_error(message):
    """
    Raises validation error

    Args:
        message (str): error message
    Raises:
        (ValidationError): raise an exception
    """

    error = BadRequest()
    error.data = {'status': 'error', 'message': message}
    raise error
Пример #11
0
    def read_image(self, image_data):
        try:
            image = Image.open(io.BytesIO(image_data))
        except IOError as img_exception:
            logger.error(str(img_exception))
            e = BadRequest()
            e.data = {
                'status': 'error',
                'message': 'The provided input is not a valid image.'
            }
            raise e

        return image
Пример #12
0
    def post(self):
        data = request.json
        holder = data.get('holder')
        number = data.get('number')
        cvv = data.get('cvv')

        try:
            decrypted_data = decrypt_card_data(holder, number, cvv)
        except ValueError as error:
            error_dict = ast.literal_eval(str(error))
            err = BadRequest(error_dict.get("message", "Internal Error"))
            err.data = error_dict
            raise err
        return decrypted_data, 200
Пример #13
0
    def post(self):
        logger.info('In ClusterEvent post()')
        args = parsers.event_parser.parse_args()

        if not allowed_file(args['file'].filename, settings.EVENT_ALLOWED_EXTENSIONS):
            logger.error('Invalid file name ' + args['file'].filename)
            error = BadRequest()
            error.data = ['This file type is not allowed. Please contact admin.']
            raise error

        try:
            comments_field = args['comments']
            action_field = args['action']
            filename = secure_filename(args['file'].filename)
            filename = get_uuid_filename(filename)
            file_path = os.path.join(settings.UPLOAD_FOLDER, filename)

            if not os.path.exists(settings.UPLOAD_FOLDER):
                logger.info('Creating upload folder: ' + settings.UPLOAD_FOLDER)
                os.makedirs(settings.UPLOAD_FOLDER)

            logger.info('Saving file to ' + file_path)
            args['file'].save(file_path)

            logger.info('Running event_cluster.run_e2e()')
            derived_filename = utils.event_cluster.run_e2e(file_path, comments_field, action_field)
            logger.info('Created new file at %s' % derived_filename)
            output = {'download_url': url_for('download_file', filename=os.path.basename(derived_filename))}

        except:
            logger.error('Some error occurred.\n' + traceback.format_exc())
            error = InternalServerError()
            error.data = ['Some error. Please contact admin.']
            raise error

        return output, 200
Пример #14
0
def raise_bad_request_error(errors):
    """
    Raises bad request error

    Args:
        errors (list): list of errors
    Raises:
        (ValidationError): raise an exception
    """

    error = BadRequest()
    error.data = {
        'status': 'error',
        'errors': errors
    }
    raise error
Пример #15
0
    def get(self):
        parse = reqparse.RequestParser(bundle_errors=True)
        parse.add_argument('file',
                           type=werkzeug.datastructures.FileStorage,
                           required=True,
                           location='files',
                           help="File must be image.")
        parse.add_argument(
            'candidates',
            type=int,
            default=0,
            choices=list(range(11)),
            help='Number of candidate captions ranges from 0 to 10.')

        args = parse.parse_args()

        app.logger.info((f"Processing /caption request with "
                         f"{args['candidates']} candidates"))

        file = args['file']

        if file.filename == '':
            app.logger.debug("File not selected in /caption request")
        elif not str(file.filename).split('.')[-1] in ALLOWED_EXTENSIONS:
            app.logger.debug(
                f"File with invalid extension"
                f"{str(file.filename).split('.')[-1]} in /caption request")
            e = BadRequest('Input payload validation failed.')
            e.data = {
                'errors': {
                    'file':
                    f"File has invalid extension ."
                    f"{str(file.filename).split('.')[-1]}",
                },
            }
            raise e
        else:
            image_name = f"{uuid.uuid4()}.jpg"
            image_path = os.path.join('static', image_name)
            file.save(image_path)

            captions = model_driver.get_prediction(image_path, mt.ckpt,
                                                   args['candidates'])

            result = {'captions': captions}

            return result
Пример #16
0
 def get(self, id):
     '''Get user item from database'''
     try:
         my_user = User.fetch_by_id(id)
         user = user_schema.dump(my_user)
         if len(user) == 0:
             e = BadRequest('User item does not exist')
             e.data = {'status': '404'}
             raise e
         return {'status': 'Match retrieved', 'user': user}, 200
     except KeyError as e:
         api.abort(500,
                   e.__doc__,
                   status="Could not retrieve information",
                   statusCode="500")
     except Exception as e:
         api.abort(404,
                   e.__doc__,
                   status="User item does not exist",
                   statusCode="404")
Пример #17
0
 def get(self, id):
     '''Get todo item from database'''
     try:
         my_todo = Todo.fetch_by_id(id)
         todo = todo_schema.dump(my_todo)
         if len(todo) == 0:
             e = BadRequest('Todo item does not exist')
             e.data = {'status': '404'}
             raise e
         return {'status': 'Match retrieved', 'todo': todo}, 200
     except KeyError as e:
         api.abort(500,
                   e.__doc__,
                   status="Could not retrieve information",
                   statusCode="500")
     except Exception as e:
         api.abort(404,
                   e.__doc__,
                   status="Todo item does not exist",
                   statusCode="404")
Пример #18
0
 def delete(self, id):
     '''Delete user item from database'''
     try:
         my_user = User.fetch_by_id(id)
         user = user_schema.dump(my_user)
         if len(user) == 0:
             e = BadRequest('User item does not exist')
             e.data = {'status': '404'}
             raise e
         User.delete_by_id(id)
         return {'status': 'User item has been deleted'}
     except KeyError as e:
         api.abort(500,
                   e.__doc__,
                   status="Could not perform this action",
                   statusCode="500")
     except Exception as e:
         api.abort(400,
                   e.__doc__,
                   status="Could perform this action",
                   statusCode="400")
Пример #19
0
def get_verified_data(request, schema):
    """
    :param
        request: request object
        schema: json schema to validate against

    :return: dict
        data is verified against a JSON schema and errors are raised accordingly
        data is decoded from JSON to a dict and returned
    """
    try:
        data = json.loads(request.data.decode('utf-8'))
    except ValueError:
        raise BadRequest("Unable to read JSON payload")
    try:
        validate(data, schema, format_checker=FormatChecker())
    except ValidationError as e:
        xcpt = BadRequest(e.message)
        xcpt.data = {"source": {"path": schema_validation_error_path(e)}}
        raise xcpt
    return data
    def post(self):
        """Generate audio embedding from input data"""
        result = {'status': 'error'}

        args = input_parser.parse_args()

        if not re.match("audio/.*wav", str(args['audio'].mimetype)):
            e = BadRequest()
            e.data = {
                'status': 'error',
                'message': 'Invalid file type/extension'
            }
            raise e

        audio_data = args['audio'].read()

        # Getting the predictions
        preds = self.model_wrapper.predict(audio_data)

        # Aligning the predictions to the required API format
        result['embedding'] = preds.tolist()
        result['status'] = 'ok'

        return result
Пример #21
0
def handle_error(error, error_code):
    print(error)
    bad_request = BadRequest()
    bad_request.data = {'detail': str(error), 'error_code': error_code}
    raise bad_request
Пример #22
0
file_parser = token_parser.copy()
file_parser.add_argument('xml_file',
                         required=True,
                         help=upload_file_help,
                         type=werkzeug.datastructures.FileStorage,
                         location='files')

page_parser = token_parser.copy()
page_parser.add_argument('limit', help=limit_help, type=int, location='args')
page_parser.add_argument('offset', help=offset_help, type=int, location='args')

date_parser = token_parser.copy()
date_parser.add_argument('from_date',
                         type=str,
                         help=date_help,
                         location='args')
date_parser.add_argument('to_date', type=str, help=date_help, location='args')

e401 = BadRequest('Unauthorized')
e401.code = 401
e401.data = {
    'message': 'Autentication token is not authorized to do this action'
}

e404 = BadRequest('Not Found')
e404.code = 404

e500 = BadRequest('Internal Server Error')
e500.code = 500
Пример #23
0
Файл: cgtd.py Проект: ga4gh/CGT
def bad_request(message):
    e = BadRequest(message)
    e.data = {'error': message}
    return e
Пример #24
0
def failure(errors=None, message=None):
    from werkzeug.exceptions import BadRequest
    e = BadRequest('My custom message')
    e.data = ({'errors': errors, 'message': message, 'status': 'Failed'})
    raise e
Пример #25
0
def getLastLocation(token_auth, visitor_id):
    try:
        config = {
            'user': app.config.MATOMO_DATABASE_USER,
            'password': app.config.MATOMO_DATABASE_PASS,
            'host': app.config.MATOMO_DATABASE_HOST,
            'port': app.config.MATOMO_DATABASE_PORT,
            'database': app.config.MATOMO_DATABASE_NAME,
            'connection_timeout': 5,
        }
        query = 'SELECT ' \
                'lv.visit_last_action_time, ' \
                'lv.idsite, inet_ntoa(conv(hex(location_ip), 16, 10)) AS location_ip, ' \
                'lv.location_browser_lang, lv.location_country, lv.location_region, lv.location_city, ' \
                'lv.location_latitude, lv.location_longitude ' \
                'FROM `' + app.config.MATOMO_DATABASE_NAME + '`.`log_visit` lv  ' \
                'WHERE lv.idvisitor = UNHEX(\''+visitor_id+'\') ' \
                'AND idsite IN (SELECT idsite FROM ' \
                '`' + app.config.MATOMO_DATABASE_NAME + '`.`access` da, ' \
                '`' + app.config.MATOMO_DATABASE_NAME + '`.`user` du ' \
                ' WHERE da.login = du.login ' \
                'AND du.superuser_access = 0 AND du.token_auth=\''+token_auth+'\') ' \
                'ORDER BY lv.idvisit'
        cnx = mysql.connector.connect(**config)
        cur = cnx.cursor(buffered=True)
        cur.execute(query)

        # fetch all of the rows from the query
        data = cur.fetchall()

        value = {
            'visitor_id': visitor_id,
            'site_id': None,
            'location_ip': None,
            'location_browser_lang': None,
            'location_country': None,
            'location_region': None,
            'location_city': None,
            'location_latitude': None,
            'location_longitude': None,
            'visit_last_action_time': None
        }

        if len(data) > 0:
            for row in data:
                value = {
                    'visitor_id': visitor_id,
                    'site_id': str(row[1]),
                    'location_ip': str(row[2]),
                    'location_browser_lang': str(row[3]),
                    'location_country': str(row[4]),
                    'location_region': str(row[5]),
                    'location_city': str(row[6]),
                    'location_latitude': str(row[7]),
                    'location_longitude': str(row[8]),
                    'visit_last_action_time': str(row[0])
                }
        cur.close()
        cnx.close()
        rtrn = json.dumps(value)
        return json.loads(rtrn)

    except mysql.connector.Error:
        e = BadRequest('Connection Error')
        e.code = 503
        e.data = {'visitorid': visitor_id, 'value': 'Connection Error'}
        raise e
    except:
        e = BadRequest('Service Unavailable')
        e.code = 503
        e.data = {'id': visitor_id, 'value': 'Error'}
        raise e
Пример #26
0
def bad_request(message):
    e = BadRequest(message)
    e.data = {'error': message}
    return e
Пример #27
0
def throw(server_error, status_code):
    # abort(status_code, server_error=server_error)
    b = BadRequest()
    b.data = {'server_error': server_error}
    raise b
    def post(self):
        """Generate audio embedding from input data"""
        result = {'status': 'error'}

        true_start = time.time()

        args = input_parser.parse_args()

        if args['audio'] is None and args['url'] is None:
            e = BadRequest()
            e.data = {
                'status': 'error',
                'message': 'Need to provide either an audio or url argument'
            }
            raise e

        audio_data = {}
        uuid_map = {}
        if args['url'] is not None:
            url_splt = args['url'].split(',')
            for url in url_splt:
                audio_data[url] = urllib.request.urlopen(url).read()
        else:
            audio_data[args['audio'].filename] = args['audio'].read()

        print(f"audio_data: {audio_data.keys()}")
        for filestring in audio_data.keys():
            uuid_map[filestring] = uuid.uuid1()
            if 'mp3' in filestring:
                print(f"Creating file: /{uuid_map[filestring]}.mp3")
                file = open(f"/{uuid_map[filestring]}.mp3", "wb+")
                file.write(audio_data[filestring])
                file.close()
            elif 'wav' in filestring:
                print(f"Creating file: /{uuid_map[filestring]}.wav")
                file = open(f"/{uuid_map[filestring]}.wav", "wb+")
                file.write(audio_data[filestring])
                file.close()
            else:
                e = BadRequest()
                e.data = {
                    'status': 'error',
                    'message': 'Invalid file type/extension'
                }
                raise e

        start = time.time()

        commands = [
            f"ffmpeg -i /{uuid_map[x]}.mp3 /{uuid_map[x]}.wav"
            if 'mp3' in x else "" for x in uuid_map.keys()
        ]
        threads = []
        for command in commands:
            if command != "":
                print(f" Running command: {command}")
                threads.append(
                    threading.Thread(target=run_sys, args=(command, )))
        for thread in threads:
            thread.start()
        for thread in threads:
            thread.join()

        print(f'Converted mp3 files in {time.time() - start}s')

        start = time.time()
        for filestring in uuid_map.keys():
            audio_data[filestring] = open(f"/{uuid_map[filestring]}.wav",
                                          "rb").read()
            os.remove(f"/{uuid_map[filestring]}.wav")
            if 'mp3' in filestring:
                os.remove(f"/{uuid_map[filestring]}.mp3")
        print(f'Deleted files in {time.time() - start}s')

        # Getting the predictions
        res = {}
        threads = []
        for filestring in audio_data.keys():
            threads.append(
                threading.Thread(target=run_model,
                                 args=(self.model_wrapper.predict, filestring,
                                       audio_data[filestring], res)))
        for thread in threads:
            thread.start()
        for thread in threads:
            thread.join()

        # Aligning the predictions to the required API format
        result['embedding'] = res
        result['status'] = 'ok'

        print(f'Completed processing in {time.time() - true_start}s')
        return result