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}
)
