def get_test_distances(logger): a = request.form.get('a') b = request.form.get('b') c = request.form.get('c') d = request.form.get('d') logger.debug(f"a: {a}") logger.debug(f"b: {b}") logger.debug(f"c: {c}") logger.debug(f"d: {d}") if not a or not b or not c or not d: abort(400) a = float(a) b = float(b) c = float(c) d = float(d) observations = np.array([[a,b],[c,d]]) p = chi2_contingency(observations)[1] logger.debug("p-value "+str(p)) return json.dumps( {"p": float(p)} )
def fetch(conn, sql, values): cursor = conn.cursor(cursor_factory=psycopg2.extras.DictCursor) query = cursor.mogrify(sql, values) logger.debug(query) cursor.execute(query) rows = cursor.fetchall() return rows[:]
def detail(): try: token = flask.request.headers.get("token", None) if token not in util.session: message = { "error": "limited authority", "code": 401, "tips": util.get_tips_dict(10006) } message = json.dumps(message) logger.debug("GET /user/v1/detail - 401") return message, 401 uuid = util.session[token] user_detail = conductor.user.user_detail(uuid) except STPHTTPException as e: message = { "error": e.error_message, "code": e.httpcode, "tips": e.tip } message = json.dumps(message) logger.debug("GET /user/v1/detail - %s" % e.httpcode) logger.error("Get user detail ERROR:\n %s" % traceback.format_exc()) return message, e.httpcode user_detail = json.dumps(user_detail) return user_detail, 200
def post(self): """ Upload a image :return: """ args = image_upload_parser.parse_args() uploaded = args['image_file'] city = args['city'] logger.debug(uploaded) if uploaded.filename == '': # flash('No selected file') # return redirect(request.url) return {'Message': "No file selected"} if not validate_city(city): return {'Message': "Input city is not supported so far."} # city = str(ALLOWED_CITIES[0]).lower() else: city = str(city).lower() if uploaded and self.validate_imagefile(uploaded.filename): temp_image, response = supervisor_ayi_service.ayi_comment(uploaded, city) @after_this_request def after_request_func(res): if application.config['KEEP_UPLOAD_IMAGE']: pass else: logger.debug("Remove temp image file.") if os.path.exists(temp_image): os.remove(temp_image) return res return response
def context_layer_set(self, instance, context_layers): instance.layers.clear() for context_layer in context_layers: layer = context_layer.pop('layer') layer = get_object_or_404(Layer, id=layer['id']) ctx, created = ContextLayer.objects.update_or_create( base_map=instance, layer=layer, defaults=context_layer) logger.debug(ctx)
def after_request_func(res): if application.config['KEEP_UPLOAD_IMAGE']: pass else: logger.debug("Remove temp image file.") if os.path.exists(temp_image): os.remove(temp_image) return res
def upload_regions(logger): print("Uploading regions") logger.debug("Uploading regions.") regions_name = request.form.get('regions_name') regions = request.form.get('regions') if not regions or not regions_name: logger.error("Missing regions or region_name.") abort(400) regions_name = regions_name regions, error_regions = parse_input_regions(regions) id = generateRegionId(regions_name) try: session = db.session #session.execute("set enable_seqscan=false") create_upload_table_full(session, id, createUpload=True, regions=regions) create_upload_table(session, id, create=True) df_regions = pd.DataFrame(regions, columns=['chr', 'start', 'stop']) df_regions["len"] = df_regions["stop"] - df_regions["start"] + 1 avg_len = df_regions["len"].mean().astype("float") max_len = df_regions["len"].max().astype("float") # Add an entry to the user file uf = UserFile(name=id, preloaded=False, count=len(regions), avg_length=avg_len, max_length=max_len) session.add(uf) session.commit() session.close() except Exception as e: logger.error("Error uploading regions.", e) abort(500) result = { "id": id, "name": regions_name, "parsed_lines": len(regions), "avg_len": avg_len, "max_len": max_len, **({ "error": error_regions } if error_regions else {}) } return json.dumps(result)
def init(): """ Populate data """ User.objects.filter(email='*****@*****.**').delete() user = UserFactory(email='*****@*****.**') logger.debug('User %s', user) posts = PostFactory.create_batch(10, author=user) logger.debug('Created posts %s', posts)
def get_users(db): try: ret = db.query(schema.User).options( load_only("username", "first_name", "last_name", "created_at", "updated_at", "email")) logger.debug(ret) return ret.all() except Exception as error: logger.error(f"{str(error)}") return None
def authenticate(db, email, pwd): try: tmpObj = db.query(schema.User).options(load_only( "username", "id")).filter( and_(schema.User.email == email, schema.User.password == pwd)) logger.debug(tmpObj) tmpObj = tmpObj.one() return tmpObj except NoResultFound: return False except Exception as error: logger.error(f"{str(error)}") return False
def get_log(self): """ Logging user command and output. 记录用户的日志 """ tty_log_dir = os.path.join(LOG_DIR, 'tty') date_today = datetime.datetime.now() date_start = date_today.strftime('%Y%m%d') time_start = date_today.strftime('%H%M%S') today_connect_log_dir = os.path.join(tty_log_dir, date_start) log_file_path = os.path.join( today_connect_log_dir, '%s_%s_%s' % (self.username, self.asset_name, time_start)) try: mkdir(os.path.dirname(today_connect_log_dir), mode=777) mkdir(today_connect_log_dir, mode=777) except OSError: logger.debug('创建目录 %s 失败,请修改%s目录权限' % (today_connect_log_dir, tty_log_dir)) raise ServerError('创建目录 %s 失败,请修改%s目录权限' % (today_connect_log_dir, tty_log_dir)) try: log_file_f = open(log_file_path + '.log', 'a') log_time_f = open(log_file_path + '.time', 'a') except IOError: logger.debug('创建tty日志文件失败, 请修改目录%s权限' % today_connect_log_dir) raise ServerError('创建tty日志文件失败, 请修改目录%s权限' % today_connect_log_dir) if self.login_type == 'ssh': # 如果是ssh连接过来,记录connect.py的pid,web terminal记录为日志的id pid = os.getpid() self.remote_ip = remote_ip # 获取远端IP else: pid = 0 log = Log(user=self.username, host=self.asset_name, remote_ip=self.remote_ip, login_type=self.login_type, log_path=log_file_path, start_time=date_today, pid=pid) log.save() if self.login_type == 'web': log.pid = log.id # 设置log id为websocket的id, 然后kill时干掉websocket log.save() log_file_f.write('Start at %s\r\n' % datetime.datetime.now()) return log_file_f, log_time_f, log
def unlock(): try: data = json.loads(flask.request.data) uuid = data.get("uuid", None) params = {"uuid": uuid} util.check_param(**params) token = flask.request.headers.get("token", None) if (token not in util.session) or \ (not conductor.user.is_admin_user(util.session[token])): message = { "error": "limited authority", "code": 401, "tips": util.get_tips_dict(10006) } message = json.dumps(message) logger.debug("POST /user/v1/unlock - 401") logger.warn("unlock user %s WARNING: limited authority." % uuid) return message, 401 conductor.user.unlock(uuid) except DuplicateException as e: message = { "success": e.error_message, "code": e.httpcode } message = json.dumps(message) logger.info(e.error_message) logger.debug("POST /user/v1/unlock - %s" % e.httpcode) return message, e.httpcode except STPHTTPException as e: message = { "error": e.error_message, "code": e.httpcode, "tips": e.tip } message = json.dumps(message) logger.debug("POST /user/v1/unlock - %s" % e.httpcode) logger.error("unlock user ERROR:\n %s" % traceback.format_exc()) return message, e.httpcode except json.decoder.JSONDecodeError: logger.error("unlock user ERROR: JSON decode failed.\n %s" % traceback.format_exc()) logger.debug("POST /user/v1/unlock - 406") message = { "error": "invalid POST request: JSON decode failed.", "code": 406, "tips": util.get_tips_dict(10004) } message = json.dumps(message) return message, 406 logger.info("unlock user %s success." % uuid) message = { "success": "unlock user %s success." % uuid, "code": 200 } message = json.dumps(message) return message, 200
def line_detail(uuid): try: detail = conductor.line.details(uuid) except STPHTTPException as e: message = {"line": None, "error": e.error_message, "code": e.httpcode} message = json.dumps(message) logger.debug("GET /line/v1/detail/%s - %s" % (uuid, e.httpcode)) logger.error("Get subway line %s detail ERROR: %s." % (uuid, e.error_message)) return message, e.httpcode message = {"line": detail, "code": http_code.OK} message = json.dumps(message) logger.debug("GET /line/v1/detail/%s - %s" % (uuid, http_code.OK)) return message, http_code.OK
def get_user(db, user_id): try: res = db.query(schema.User).get(user_id) ret = {} ret['username'] = res.username ret['first_name'] = res.first_name ret['last_name'] = res.last_name ret['email'] = res.email ret['created_at'] = res.created_at ret['updated_at'] = res.updated_at logger.debug(f"Getting user profile {ret}") return ret except Exception as error: logger.error(f"{str(error)}") return False
def update_user(db, user): try: logger.debug(f"Updating user data wth id : {user.id}") tmp_user = db.query(schema.User).get(user.id) tmp_user.username = user.username tmp_user.email = user.email tmp_user.first_name = user.first_name tmp_user.last_name = user.last_name logger.debug(f"Updated user data : {tmp_user}") db.commit() db.refresh(tmp_user) logger.info(f"Updated user data with ID of {tmp_user.id}") return True except Exception as error: logger.error(f"{str(error)}") return False
def send_code_email(): try: data = json.loads(flask.request.data) params = { "receiver": data.get("receiver", None), "header": data.get("header", None), "operate": data.get("operate", None) } util.check_param(**params) verify_code = util.general_verify_code(6) kwargs = { "header": params["header"], "type": "send_code", "receiver": params["receiver"], "operate": params["operate"], "code": verify_code } from main import send_mail send_mail(**kwargs) conductor.user.push_verify_code(kwargs["receiver"], verify_code, kwargs["operate"]) message = { "success": "send to %s success." % kwargs["receiver"], "code": http_code.OK } message = json.dumps(message) except STPHTTPException as e: logger.debug("POST /email/v1/code - %s" % e.httpcode) logger.error("send code email ERROR:\n%s" % traceback.format_exc()) message = {"error": "send mail failed.", "code": e.httpcode} message = json.dumps(message) return message, e.httpcode except json.decoder.JSONDecodeError: logger.error("register user ERROR: JSON decode failed.\n %s" % traceback.format_exc()) logger.debug("POST /user/v1/register - 406") message = { "error": "invalid POST request: JSON decode failed.", "code": http_code.NotAcceptable } message = json.dumps(message) return message, http_code.NotAcceptable return message, http_code.OK
def station_list(): try: token = flask.request.headers.get("token", None) if (token not in util.session) or \ (not conductor.user.is_admin_user(util.session[token])): raise STPHTTPException("limited authority", 401, 10001) stations = conductor.station.get_list() except STPHTTPException as e: message = {"error": e.error_message, "code": e.httpcode, "tips": e.tip} message = json.dumps(message) logger.debug("GET /station/v1/list - %s" % e.httpcode) return message, e.httpcode message = {"stations": stations, "code": 200} message = json.dumps(message) logger.debug("GET /station/v1/list - 200") return message, 200
def create_user(db, user): try: new_user = schema.User(username=user.username, password=user.password, email=user.email, first_name=user.first_name, last_name=user.last_name) db.add(new_user) db.commit() db.refresh(new_user) logger.debug(f"Creating user : {new_user}") logger.info(f"New user created with ID of {new_user.id}") return True except IntegrityError as error: logger.info(f"Email : {user.email} already exists") raise DuplicatedRecordError("Email already exists") except Exception as error: logger.error(f"{str(error)}") return False
def user_list(): token = flask.request.headers.get("token", None) if (token not in util.session) or \ (not conductor.user.is_admin_user(util.session[token])): message = { "users": [], "error": "limited authority", "code": 401, "tips": util.get_tips_dict(10006) } message = json.dumps(message) logger.debug("GET /user/v1/users - 401") logger.warn("Can not get user list info: limited authority.") return message, 401 users = conductor.user.users() message = {"users": users, "code": 200} message = json.dumps(message) logger.debug("GET /user/v1/users - 200") return message, 200
def preprocess_imagefile(filename, city): IMAGE_SIZE = MODELS[city]['MODEL_IMAGE_SIZE'] try: # read file as byte image_string = tf.io.read_file(filename) # decode as string image_decoded = tf.image.decode_jpeg(image_string, channels=3) # image_decoded = tf.image.decode_gif(image_string) ## P.S tf.image.decode_image return shapeless tensor. # image_decoded = tf.image.decode_image(image_string) # resize to given image size image_resized = tf.image.resize(image_decoded, (IMAGE_SIZE, IMAGE_SIZE)) # normalization image_normalized = (tf.cast(image_resized, tf.float32) / 127.5) - 1 return image_normalized except Exception as e: logger.error(e) logger.debug(filename)
def preprocess(self, uploaded_image): if isinstance(uploaded_image, str): image_str = uploaded_image image_file = base64.b64decode(image_str) # logger.debug(image_file) ext = "jpeg" save_filename = str(uuid.uuid4()) + "." + ext destination = application.config['UPLOAD_FOLDER'] if not os.path.exists(destination): os.makedirs(destination) with open(os.path.join(destination, save_filename), "wb") as f: f.write(image_file) else: logger.debug(uploaded_image) filename = uploaded_image.filename ext = filename.rsplit('.', 1)[1].lower() save_filename = str(uuid.uuid4()) + "." + ext destination = application.config['UPLOAD_FOLDER'] if not os.path.exists(destination): os.makedirs(destination) uploaded_image.save(os.path.join(destination, save_filename)) return os.path.join(application.config['UPLOAD_FOLDER'], save_filename)
def update_station(): try: data = json.loads(flask.request.data) token = flask.request.headers.get("token", None) if (token not in util.session) or \ (not conductor.user.is_admin_user(util.session[token])): message = { "error": "limited authority", "code": 401, "tips": util.get_tips_dict(10006) } message = json.dumps(message) logger.warn("update subway station WARNING: limited authority.") logger.debug("PUT /station/v1/update - 401") return message, 401 except json.decoder.JSONDecodeError: logger.error("update subway station ERROR: JSON decode failed.\n %s" % traceback.format_exc()) logger.debug("PUT /station/v1/update - 406") message = { "error": "invalid PUT request: JSON decode failed.", "code": 406, "tips": util.get_tips_dict(10004) } message = json.dumps(message) return message, 406 uuid = data.get("uuid", None) new_name = data.get("name", None) try: params = {"uuid": uuid, "name": new_name} util.check_param(**params) conductor.station.update(uuid, new_name) except STPHTTPException as e: message = {"error": e.error_message, "code": e.httpcode, "tips": e.tip} message = json.dumps(message) logger.error("update subway station %s ERROR:\n%s" % (uuid, traceback.format_exc())) logger.debug("PUT /station/v1/update - %s" % e.httpcode) return message, e.httpcode message = { "success": "update subway station %s success." % uuid, "code": 200 } message = json.dumps(message) logger.debug("PUT /station/v1/update - 200") return message, 200
def upload_photo(): token = flask.request.headers.get("token", None) if (token is None) or (token not in util.session): message = { "error": "limited authority", "code": 401, "tips": util.get_tips_dict(10006) } message = json.dumps(message) logger.debug("POST /user/v1/upload/photo - 401") return message, 401 file = flask.request.files["photo"] filename = file.filename format = filename.rsplit(".", 1)[1] if format not in ["jpg", "jpeg", "png"]: message = { "error": "format not allowed", "code": 400, "tips": util.get_tips_dict(10112) } message = json.dumps(message) logger.debug("POST /user/v1/upload/photo - 400") logger.error("BadRequest: upload photo failed: unsupported photo format %s" % format) return message, 400 uuid = util.session[token] try: conductor.user.save_photo(uuid, format, file) except STPHTTPException as e: message = { "error": e.error_message, "code": e.httpcode, "tips": e.tip } message = json.dumps(message) logger.debug("POST /user/v1/upload/photo - %s" % e.httpcode) return message, e.httpcode logger.debug("POST /user/v1/upload/photo - 200") message = { "success": "upload photo finished" } message = json.dumps(message) return message, 200
def delete(): try: data = json.loads(flask.request.data) except json.decoder.JSONDecodeError: logger.error("delete subway line ERROR: JSON decode failed.\n %s" % traceback.format_exc()) logger.debug("DELETE /line/v1/delete - %s" % http_code.NotAcceptable) message = { "error": "invalid DELETE request: JSON decode failed.", "code": http_code.NotAcceptable, "tips": util.get_tips_dict(10004) } message = json.dumps(message) return message, http_code.NotAcceptable token = flask.request.headers.get("token", None) if (token not in util.session) or \ (not conductor.user.is_admin_user(util.session[token])): message = { "error": "limited authority", "code": http_code.Unauthorized, "tips": util.get_tips_dict(10006) } message = json.dumps(message) logger.warn("delete subway line WARNING: limited authority.") logger.debug("DELETE /line/v1/delete - %s" % http_code.Unauthorized) return message, http_code.Unauthorized uuid = data.get("uuid", None) logger.info("Begin to delete subway line %s." % uuid) try: kwargs = {"uuid": uuid} util.check_param(**kwargs) conductor.line.delete_subway_line(uuid) except STPHTTPException as e: message = {"error": e.error_message, "code": e.httpcode, "tips": e.tip} message = json.dumps(message) logger.error("delete subway line %s ERROR:\n%s" % (uuid, traceback.format_exc())) logger.debug("DELETE /line/v1/delete - %s" % e.httpcode) return message, e.httpcode message = { "success": "delete subway line %s success." % uuid, "code": http_code.OK } message = json.dumps(message) return message, http_code.OK
def add(): try: data = json.loads(flask.request.data) except json.decoder.JSONDecodeError: logger.error("add subway line ERROR: JSON decode failed.\n %s" % traceback.format_exc()) logger.debug("POST /line/v1/add - 406") message = { "error": "invalid POST request: JSON decode failed.", "code": http_code.NotAcceptable, "tips": util.get_tips_dict(10004) } message = json.dumps(message) return message, http_code.NotAcceptable token = flask.request.headers.get("token", None) if (token not in util.session) or \ (not conductor.user.is_admin_user(util.session[token])): message = { "error": "limited authority", "code": http_code.Unauthorized, "tips": util.get_tips_dict(10006) } message = json.dumps(message) logger.warn("add subway line WARNING: limited authority.") logger.debug("POST /line/v1/add - 401") return message, http_code.Unauthorized name = data.get("name", None) try: logger.info("Begin to add subway line %s." % name) util.check_param(name=name) conductor.line.add_subway_line(name) except STPHTTPException as e: message = {"error": e.error_message, "code": e.httpcode, "tips": e.tip} message = json.dumps(message) logger.error("add subway line %s ERROR:\n%s" % (name, traceback.format_exc())) logger.debug("POST /line/v1/add - %s" % e.httpcode) return message, e.httpcode message = { "success": "add subway line %s success." % name, "code": http_code.OK } message = json.dumps(message) return message, http_code.OK
def register_user(): try: data = json.loads(flask.request.data) except json.decoder.JSONDecodeError: logger.error("register user ERROR: JSON decode failed.\n %s" % traceback.format_exc()) logger.debug("POST /user/v1/register - 406") message = { "error": "invalid POST request: JSON decode failed.", "code": 406, "tips": util.get_tips_dict(10004) } message = json.dumps(message) return message, 406 try: email = data.get("email", None) kwargs = { "username": data.get("username", None), "password": data.get("password", None), "email": email, "user_type": conductor.user.normal_user } util.check_param(**kwargs) conductor.user.check_email(email) conductor.user.register(**kwargs) except STPHTTPException as e: message = { "error": e.error_message, "code": e.httpcode, "tips": e.tip } message = json.dumps(message) logger.error("register user ERROR: %s\n%s." % (e.error_message, traceback.format_exc())) logger.debug("POST /user/v1/register - %s" % e.httpcode) return message, e.httpcode message = {"success": "registered user %s success" % email, "code": 200} message = json.dumps(message) logger.info("register user %s success." % email) logger.debug("POST /user/v1/register - 200") return message, 200
def find_user(): try: data = json.loads(flask.request.data) email = data.get("email", None) kwargs = { "email": email } util.check_param(**kwargs) conductor.user.check_email(email) except STPHTTPException as e: logger.debug("POST /user/v1/exist - %s" % e.httpcode) message = { "error": e.error_message, "code": e.httpcode, "tips": e.tip } message = json.dumps(message) return message, e.httpcode except json.decoder.JSONDecodeError: logger.error("exist user ERROR: JSON decode failed.\n %s" % traceback.format_exc()) logger.debug("POST /user/v1/exist - 406") message = { "error": "invalid POST request: JSON decode failed.", "code": 406, "tips": util.get_tips_dict(10004) } message = json.dumps(message) return message, 406 exit_detail = conductor.user.is_user_exist(email) message = exit_detail message["code"] = 200 message = json.dumps(message) logger.debug("POST /user/v1/exist - 200") return message, 200
def update(): try: data = json.loads(flask.request.data) uuid = data.get("uuid", None) email = data.get("email", None) kwargs = { "uuid": uuid, "email": email, "username": '', "verify_code": data.get("verify_code", None) } util.check_param(**kwargs) conductor.user.check_verify_code(**kwargs) if "new_email" in data: kwargs["new_email"] = data["new_email"] if "new_username" in data: kwargs["new_username"] = data["new_username"] if "new_password" in data: kwargs["new_password"] = data["new_password"] conductor.user.update(**kwargs) except json.decoder.JSONDecodeError: logger.error("modify user ERROR: JSON decode failed.\n %s" % traceback.format_exc()) logger.debug("PUT /user/v1/modify - 406") message = { "error": "invalid PUT request: JSON decode failed.", "code": 406, "tips": util.get_tips_dict(10004) } message = json.dumps(message) return message, 406 except STPHTTPException as e: message = { "error": e.error_message, "code": e.httpcode, "tips": e.tip } message = json.dumps(message) logger.debug("PUT /user/v1/modify - %s" % e.httpcode) logger.error("modify user ERROR:\n %s" % traceback.format_exc()) return message, e.httpcode except DBError as e: message = { "error": e.error_message, "code": e.error_code, "tips": util.get_tips_dict(10108) } message = json.dumps(message) logger.debug("PUT /user/v1/modify - %s" % e.error_code) logger.error("modify user ERROR:\n %s" % traceback.format_exc()) return message, e.error_code message = { "success": "update user %s success." % uuid, "code": 200 } message = json.dumps(message) logger.info("update user %s success." % uuid) logger.debug("PUT /user/v1/modify - 200") return message, 200
def results_by_area(event_type, year, area, area_id=None): """ Return results for the specified area, with links to available parent areas where applicable. """ # validate endpoints event_type = validate_event_type(event_type) year = validate_year(year) area = validate_area(area) # validate filter parameters filter_area = None filter_id = None for tmp_area in reversed(areas): if request.args.get(tmp_area): filter_area = tmp_area filter_id = request.args.get(tmp_area) # throw an exception, if this is not a viable filter for the specified area if areas.index(filter_area) >= areas.index(area): raise ApiException(422, "The specified filter parameter cannot be used in this query.") break # validate paging parameters page = 0 per_page = 50 if request.args.get('page'): try: page = int(request.args.get('page')) except ValueError: raise ApiException(422, "Please specify a valid 'page'.") models = { "province": (Province, Province.province_id), "municipality": (Municipality, Municipality.municipality_id), "ward": (Ward, Ward.ward_id), "voting_district": (VotingDistrict, VotingDistrict.voting_district_id) } model_filters = { "municipality": { "province": Municipality.province, }, "ward": { "province": Ward.province, "municipality": Ward.municipality, }, "voting_district": { "province": VotingDistrict.province, "municipality": VotingDistrict.municipality, "ward": VotingDistrict.ward, }, } if area_id: out = models[area][0].query.filter(models[area][1] == area_id).first() out = serialize_area(out, event_type) else: if filter_area and filter_id: logger.debug("filtering: " + filter_area + " - " + filter_id) # retrieve the entity that will be filtered on obj = models[filter_area][0].query.filter(models[filter_area][1]==filter_id).first() if obj is None: raise ApiException(404, "Could not find the specified filter. Check that you have provided a valid ID, or remove the filter.") count = models[area][0].query.filter(models[area][0].year==year).filter(model_filters[area][filter_area]==obj).count() items = models[area][0].query.filter(models[area][0].year==year).filter(model_filters[area][filter_area]==obj).order_by(models[area][1]).limit(per_page).offset(page*per_page).all() else: count = models[area][0].query.filter(models[area][0].year==year).count() items = models[area][0].query.filter(models[area][0].year==year).order_by(models[area][1]).limit(per_page).offset(page*per_page).all() next = None if count > (page + 1) * per_page: next = request.url_root + event_type + "/" + str(year) + "/" + area + "/?page=" + str(page+1) results = [] for item in items: results.append(serialize_area(item, event_type)) if len(results) == 0: raise ApiException(404, "Not Found") out = { 'count': count, 'next': next, 'results': results } return send_api_response(out)
def line_list(): lines = conductor.line.get_all_line() message = {"line": lines, "code": http_code.OK} message = json.dumps(message) logger.debug("GET /line/v1/list - %s" % http_code.OK) return message, http_code.OK
if __name__ == '__main__': app_ctx = app.app_context() app_ctx.push() logger.setLevel(C.log_level) db.logger = logger if logger is not None: db.logger = logger logger.info("****** Butler API Server ****************") logger.info(" * %s: as '%s' Using configuration: '%s'" % (sys.argv[0], getpass.getuser(), config_file)) logger.info(" * %s: db connection is '%s'" % (sys.argv[0], db)) logger.info("*****************************************") for variable in os.environ: logger.debug("%s=%s" % (variable, os.environ.get(variable))) logger.debug("logger = %s" % logger) #ogger.debug("mail = %s"%mail) logger.debug("db = %s" % db) logger.debug("db.logger = %s" % db.logger) logger.debug("app = %s" % app) logger.debug("app.root_path = %s" % app.root_path) logger.debug("app.static_folder = %s" % app.static_folder) logger.debug("app.template_folder 1 = %s" % app.template_folder) app.template_folder = "%s/templates" % (app.root_path) logger.debug("app.template_folder 2 = %s" % app.template_folder) for key in app.config.keys(): if key == key.upper(): logger.debug("%-40s = %s" % (key, app.config[key])) logger.debug("%-40s = %s" % ("app.root_path", app.root_path))
def get_uc6(logger): # Get Params file_name = request.form.get('file_name') tumor_type = request.form.get('tumorType') filter_json = request.form.get('filter') threshold_active = request.form.get('threshold_active')=="true" threshold_min = int(request.form.get('threshold_min')) logger.debug(f"tumor_type: {tumor_type}") logger.debug(f"file_name: {file_name}") logger.debug(f"filter: {filter_json}") logger.debug(f"threshold_active: {str(threshold_active)}") logger.debug(f"threshold_min: {str(threshold_min)}") CACHE_ID = "SIGNATURES#"+file_name+"#"+str(threshold_active)+"#"+str(tumor_type)+"#"+str(threshold_min) if not file_name: abort(400) jobID = register_job() def async_function(): try: if not filter_json and CACHE_ID in RESULTS_CACHE: update_job(jobID, RESULTS_CACHE[CACHE_ID]) return mutation_table_name = t_mutation_trinucleotide_test.name if DEBUG_MODE else t_mutation_trinucleotide.name mutations = intersect_and_group(mutation_table_name, file_name, ["tumor_type_id", "donor_id", "trinucleotide_id_r"], tumor_type=tumor_type, filter_json=filter_json) result = defaultdict(list) mutations = list(map(lambda x: [tumor_type_dict[x[0]][0], x[1], trinucleotides_dict[x[2]][0], x[3]], mutations)) for m in mutations: result[m[0]].append([ int(m[1]), m[2], int(m[3])]) # result ( tumorTypeString -> [donor, trinucleotide, count] ) def toDataframe(data): columns_str = "A[C>A]A A[C>A]C A[C>A]G A[C>A]T C[C>A]A C[C>A]C C[C>A]G C[C>A]T G[C>A]A G[C>A]C G[C>A]G G[C>A]T T[C>A]A T[C>A]C T[C>A]G T[C>A]T A[C>G]A A[C>G]C A[C>G]G A[C>G]T C[C>G]A C[C>G]C C[C>G]G C[C>G]T G[C>G]A G[C>G]C G[C>G]G G[C>G]T T[C>G]A T[C>G]C T[C>G]G T[C>G]T A[C>T]A A[C>T]C A[C>T]G A[C>T]T C[C>T]A C[C>T]C C[C>T]G C[C>T]T G[C>T]A G[C>T]C G[C>T]G G[C>T]T T[C>T]A T[C>T]C T[C>T]G T[C>T]T A[T>A]A A[T>A]C A[T>A]G A[T>A]T C[T>A]A C[T>A]C C[T>A]G C[T>A]T G[T>A]A G[T>A]C G[T>A]G G[T>A]T T[T>A]A T[T>A]C T[T>A]G T[T>A]T A[T>C]A A[T>C]C A[T>C]G A[T>C]T C[T>C]A C[T>C]C C[T>C]G C[T>C]T G[T>C]A G[T>C]C G[T>C]G G[T>C]T T[T>C]A T[T>C]C T[T>C]G T[T>C]T A[T>G]A A[T>G]C A[T>G]G A[T>G]T C[T>G]A C[T>G]C C[T>G]G C[T>G]T G[T>G]A G[T>G]C G[T>G]G G[T>G]T T[T>G]A T[T>G]C T[T>G]G T[T>G]T" columns = columns_str.split() df = pd.DataFrame(data, columns=["donor_id", "trinucleotide_id_t", "count"]) reshaped = df.pivot("donor_id", "trinucleotide_id_t", "count") for col in columns: if col not in reshaped.columns: reshaped[col] = 0 result = reshaped.fillna(0) return result[columns] final_results = {} sigs_df_norm = None for tumor in result.keys(): # columns: trin, index: patients table_donors = toDataframe(result[tumor]) # FILTER IF THRESHOLD IS ACTIVE if threshold_active: table_donors['counts'] = table_donors.sum(axis=1) table_donors = table_donors[table_donors['counts']>=threshold_min].drop("counts", axis=1) num_patients = table_donors.shape[0] if num_patients == 0: continue # if less than 5 patients if num_patients<5: table_donors = table_donors.sum().to_frame().transpose() region_file_table_name = "full_"+file_name user_file_df = pd.read_sql("SELECT * FROM "+region_file_table_name+";", db.get_engine()) user_file_df.columns = ["chrom", "start", "stop"] (with_donors, cacheit) = get_refitting(table_donors, user_file_df, sigs_df_norm) sigs_df_norm = cacheit final_results[tumor] = {} final_results[tumor]["data"] = with_donors.to_dict(orient='list') final_results[tumor]["num_patients"] = num_patients final_results[tumor]["threshold_min"] = threshold_min final_results[tumor]["threshold_active"] = threshold_active if not filter_json: RESULTS_CACHE[CACHE_ID] = final_results update_job(jobID, final_results) except Exception as e: unregister_job(jobID) logger.error("Async error", e) raise e executor.submit(async_function) return json.dumps( {"jobID": jobID} )