def create_user():
to_post = request.json.get('to_post')
res = {"posted": []}
if not g.user.admin_rights:
res["posted"].append({
"error":
"Permission required! Only administrator can create users."
})
elif to_post:
for c in to_post:
try:
username = from_dict(c, 'username')
password = from_dict(c, 'password')
admin_rights = from_dict(c, 'admin_rights')
exp_admin_rights = from_dict(c, 'exp_admin_rights')
user = User.create(username, password, admin_rights,
exp_admin_rights)
db.session.add(user)
db.session.commit()
message = user.to_dict()
except Exception as e:
message = {"error": str(e)}
res["posted"].append(message)
else:
res["posted"].append({
"error":
"Request must provide 'to_post' array of objects with 'username', "
"'password', 'admin_rights', 'exp_admin_rights' fields."
})
return jsonify(res)
def get_experiment_by_user():
to_get = request.json.get('to_get')
res = {"response": []}
incomplete_description = {
"error":
"Request must provide list 'to_get' of objects with 'user_id' or 'username'."
}
if to_get:
for g in to_get:
username = from_dict(g, 'username')
user_id = from_dict(g, 'user_id')
try:
user = User.get(user_id, username)
user_id = user.id
exps = db.session.query(Experiment).filter(
Experiment.author == user_id).all()
local_res = {"user": user.to_dict(), "experiments": []}
for exp in exps:
local_res["experiments"].append(exp.to_dict())
res["response"].append(local_res)
except Exception as e:
err = {"error": str(e)}
if user_id:
err['user_id'] = user_id
if username:
err['username'] = username
res["response"].append(err)
else:
res['response'].append(incomplete_description)
return jsonify(res)
def delete_user():
to_delete = request.json.get('to_delete')
res = {"deleted": []}
if not g.user.admin_rights:
res["deleted"].append({
"error":
"Permission required! Only administrator can delete users."
})
elif to_delete:
for d in to_delete:
try:
username = from_dict(d, 'username')
user_id = from_dict(d, 'user_id')
user = User.get(user_id, username)
message = User.delete(user)
# db.session.delete(user)
# db.session.commit()
#
# message = user.to_dict()
except Exception as e:
message = {"error": str(e)}
res["deleted"].append(message)
else:
res["deleted"].append({
"error":
"Request must provide to_delete array of objects with 'username' field."
})
return jsonify(res)
def upd_dataformat():
to_update = request.json.get('to_update')
res = []
if to_update:
for u in to_update:
name = from_dict(u, 'name')
dataformat_id = from_dict(u, 'dataformat_id')
new_name = from_dict(u, 'new_name')
new_format = from_dict(u, 'new_file_format')
new_schema_uri = from_dict(u, 'new_schema_uri')
try:
df = DataFormat.get(dataformat_id, name)
df.update(new_name, new_format, new_schema_uri)
dataformat_id = df.id
name = df.name
db.session.commit()
res.append(df.to_dict())
except Exception as e:
err = {"error": str(e)}
if dataformat_id:
err['dataformat_id'] = dataformat_id
if name:
err['name'] = name
res.append(err)
else:
res.append({"error": "Request must provide list 'to_update' of objects with 'dataformat_id' or 'name' "
"and data to update ('new_name','new_file_format','new_schema_uri')."})
return jsonify({"updated": res})
def get_user():
to_get = request.json.get('to_get')
res = {"response": []}
incomplete_description = {
"error":
"Request must provide list 'to_get' of objects with 'user_id' or 'username'."
}
if to_get:
for g in to_get:
username = from_dict(g, 'username')
user_id = from_dict(g, 'user_id')
try:
us = User.get(user_id, username)
res["response"].append(us.to_dict())
except Exception as e:
err = {"error": str(e)}
if user_id:
err['user_id'] = user_id
if username:
err['username'] = username
res["response"].append(err)
else:
res['response'].append(incomplete_description)
else:
res['response'].append(incomplete_description)
return jsonify(res)
def del_environment():
to_delete = request.json.get('to_delete')
res = []
if to_delete:
for d in to_delete:
name = from_dict(d, 'name')
env_id = from_dict(d, 'env_id')
try:
env = Environment.get(env_id, name)
env_id = env.id
name = env.name
message = Environment.delete(env)
# db.session.delete(env)
# db.session.commit()
# message = env.to_dict()
res.append(message)
except Exception as e:
err = {"error": str(e)}
if env_id:
err['env_id'] = env_id
if name:
err['name'] = name
res.append(err)
else:
res.append({
"error":
"Request must provide list 'to_delete' of objects with 'env_id' or 'name'."
})
return jsonify({"deleted": res})
def post_dataformat():
to_post = request.json.get('to_post')
res = []
if to_post:
for p in to_post:
name = from_dict(p, 'name')
format = from_dict(p, 'file_format')
schema_uri = from_dict(p, 'schema_uri')
try:
df = DataFormat.create(name, format, schema_uri, g.user)
db.session.add(df)
db.session.commit()
res.append(df.to_dict())
except Exception as e:
err = {"error": str(e)}
if name:
err['name'] = name
res.append(err)
else:
res.append({"error": "Request must provide list 'to_post' of objects"
" with 'name', 'file_format' and 'schema_uri'."})
return jsonify({"posted": res})
def post_dataset():
to_post = request.json.get('to_post')
res = []
if to_post:
for p in to_post:
title = from_dict(p, 'title')
format_name = from_dict(p, 'format_name')
format_id = from_dict(p, 'format_id')
uri = from_dict(p, 'uri')
try:
ds = DataSet.create(title, uri, format_id, format_name, g.user)
db.session.add(ds)
db.session.commit()
res.append(ds.to_dict_light())
except Exception as e:
err = {"error": str(e)}
if title:
err['title'] = title
res.append(err)
else:
res.append({
"error":
"Request must provide list 'to_post' of objects"
" with 'title', 'uri' and 'format_name' (or 'format_id')."
})
return jsonify({"posted": res})
def del_dataset():
to_delete = request.json.get('to_delete')
res = []
if to_delete:
for d in to_delete:
title = from_dict(d, 'title')
dataset_id = from_dict(d, 'dataset_id')
try:
ds = DataSet.get(dataset_id, title)
dataset_id = ds.Id
title = ds.Title
message = DataSet.delete(ds)
# db.session.delete(ds)
# db.session.commit()
# message = ds.to_dict_light()
res.append(message)
except Exception as e:
err = {"error": str(e)}
if dataset_id:
err['dataset_id'] = dataset_id
if title:
err['title'] = title
res.append(err)
else:
res.append({
"error":
"Request must provide list 'to_delete' of objects with 'dataset_id' or 'title'."
})
return jsonify({"deleted": res})
def get_experiment():
to_get = request.json.get('to_get')
res = {"response": []}
incomplete_description = {
"error":
"Request must provide list 'to_get' of objects with 'exp_id' or 'title'."
}
if to_get:
for g in to_get:
title = from_dict(g, 'title')
exp_id = from_dict(g, 'exp_id')
if (exp_id is not None) or (title is not None):
try:
exp = Experiment.get(exp_id, title)
res["response"].append(exp.to_dict())
except Exception as e:
err = {"error": str(e)}
if exp_id:
err['exp_id'] = exp_id
if title:
err['title'] = title
res["response"].append(err)
else:
res['response'].append(incomplete_description)
else:
res['response'].append(incomplete_description)
return jsonify(res)
def del_experiment():
to_delete = request.json.get('to_delete')
res = []
if to_delete:
for d in to_delete:
title = from_dict(d, 'title')
exp_id = from_dict(d, 'exp_id')
try:
exp = Experiment.get(id, title)
message = Experiment.delete(exp)
# message = exp.to_dict()
#
# db.session.delete(exp)
# db.session.commit()
res.append(message)
except Exception as e:
err = {"error": str(e)}
if exp_id:
err['exp_id'] = exp_id
if title:
err['title'] = title
res.append(err)
else:
res.append({
"error":
"Request must provide list 'to_delete' of objects with 'exp_id' or 'title'."
})
return jsonify({"deleted": res})
def get_environment():
to_get = request.json.get('to_get')
res = {"response": []}
incomplete_description = {
"error":
"Request must provide list 'to_get' of objects with 'env_id' or 'name'."
}
if to_get:
for g in to_get:
name = from_dict(g, 'name')
env_id = from_dict(g, 'env_id')
if (env_id is not None) or (name is not None):
try:
df = Environment.get(env_id, name)
res["response"].append(df.to_dict())
except Exception as e:
err = {"error": str(e)}
if env_id:
err['env_id'] = env_id
if name:
err['name'] = name
res["response"].append(err)
else:
res['response'].append(incomplete_description)
else:
res['response'].append(incomplete_description)
return jsonify(res)
def get_processing():
to_get = request.json.get('to_get')
res = {"response": []}
incomplete_description = {
"error":
"Request must provide list 'to_get' of objects with 'processing_id' or 'name'."
}
if to_get:
for g in to_get:
name = from_dict(g, 'name')
processing_id = from_dict(g, 'processing_id')
if (processing_id is not None) or (name is not None):
try:
proc = Processing.get(processing_id, name)
res["response"].append(proc.to_dict())
except Exception as e:
err = {"error": str(e)}
if processing_id:
err['processing_id'] = processing_id
if name:
err['username'] = name
res["response"].append(err)
else:
res['response'].append(incomplete_description)
else:
res['response'].append(incomplete_description)
return jsonify(res)
def del_processing():
to_delete = request.json.get('to_delete')
res = []
if to_delete:
for d in to_delete:
name = from_dict(d, 'name')
processing_id = from_dict(d, 'processing_id')
try:
p = Processing.get(processing_id, name)
message = Processing.delete(p)
# message = p.to_dict()
#
# db.session.delete(p)
# db.session.commit()
res.append(message)
except Exception as e:
err = {"error": str(e)}
if processing_id:
err['processing_id'] = processing_id
if name:
err['name'] = name
res.append(err)
else:
res.append({
"error":
"Request must provide list 'to_delete' of objects with 'processing_id' or 'name'."
})
return jsonify({"deleted": res})
def del_dataformat():
to_delete = request.json.get('to_delete')
res = []
if to_delete:
for d in to_delete:
name = from_dict(d, 'name')
dataformat_id = from_dict(d, 'dataformat_id')
try:
df = DataFormat.get(dataformat_id, name)
dataformat_id = df.id
name = df.name
message = DataFormat.delete(df)
# db.session.delete(df)
# db.session.commit()
# message = df.to_dict()
res.append(message)
except Exception as e:
err = {"error": str(e)}
if dataformat_id:
err['dataformat_id'] = dataformat_id
if name:
err['name'] = name
res.append(err)
else:
res.append({"error": "Request must provide list 'to_delete' of objects with 'dataformat_id' or 'name'."})
return jsonify({"deleted": res})
def post_environment():
to_post = request.json.get('to_post')
res = []
if to_post:
for p in to_post:
name = from_dict(p, 'name')
cuda_version = from_dict(p, 'cuda_version')
gpu_required = from_dict(p, 'gpu_required')
py_dependencies = from_dict(p, 'py_dependencies')
architecture = from_dict(p, 'architecture')
try:
env = Environment.create(name, cuda_version, gpu_required,
py_dependencies, architecture, g.user)
db.session.add(env)
db.session.commit()
res.append(env.to_dict())
except Exception as e:
err = {"error": str(e)}
if name:
err['name'] = name
res.append(err)
else:
res.append({
"error":
"Request must provide list 'to_post' of objects"
" with 'name', 'cuda_version', 'gpu_required', 'architecture' and 'py_dependencies'."
})
return jsonify({"posted": res})
def post_processing():
to_post = request.json.get('to_post')
res = []
incomplete_description = {
"error":
"Request must provide list 'to_post' of objects"
" with 'name', 'input_id' ( or 'input_name'), 'output_id'"
" ( or 'output_name'), 'env_id' ( or 'env_name'),"
" 'source_uri', 'lang_name'."
}
if to_post:
for p in to_post:
name = from_dict(p, 'name')
input_id = from_dict(p, 'input_id')
input_name = from_dict(p, 'input_name')
output_id = from_dict(p, 'output_id')
output_name = from_dict(p, 'output_name')
source_uri = from_dict(p, 'source_uri')
lang_name = from_dict(p, 'lang_name')
# args_info = from_dict(p, 'args_info')
env_id = from_dict(p, 'env_id')
env_name = from_dict(p, 'env_name')
status_name = from_dict(p, 'status_name')
full = all([
x is not None
for x in [name, source_uri, lang_name, status_name]
] + [(input_id is not None) or (input_name is not None),
(output_id is not None) or (output_name is not None),
(env_id is not None) or (env_name is not None)])
from flask import current_app
if full:
try:
proc = Processing.create(name, input_id, input_name,
output_id, output_name,
source_uri, lang_name, env_id,
env_name, status_name, g.user)
db.session.add(proc)
db.session.commit()
res.append(proc.to_dict())
except Exception as e:
err = {"error": str(e)}
if name:
err['name'] = name
res.append(err)
else:
res.append(incomplete_description)
else:
res.append(incomplete_description)
return jsonify({"posted": res})
def run():
to_run = request.json.get('to_run')
res = []
args_message = "'args' (optional) is an array of strings of arguments to" \
" corresponding preprocessing stages."
if to_run:
for r in to_run:
title = from_dict(r, 'title')
exp_id = from_dict(r, 'exp_id')
delayed = from_dict(r, 'delayed')
args = from_dict(r, 'args')
try:
exp = Experiment.get(exp_id, title)
if g.user.exp_admin_rights or (exp.Author == g.user):
if args and (type(args) is list):
for a in args:
if type(a) is not str:
raise Exception(args_message)
elif args and (type(args) is not list):
raise Exception(args_message)
message = exp.run(delayed, args, g.user)
else:
raise Exception(
"Only Experiment Admin can run someone else's experiment."
)
res.append(message)
except Exception as e:
err = {"error": str(e)}
if exp_id:
err['exp_id'] = exp_id
if title:
err['title'] = title
res.append(err)
else:
res.append({
"error":
"Request must provide list 'to_run' of objects with 'exp_id' or 'title'. "
"'delayed' and 'args' are optional. "
"The time of delayed task start should be a string in the format: "
"'Year-Month-Day Hour:Minute:Second'. "
"'args' is an array of strings of arguments to corresponding preprocessing stages."
})
return jsonify({"started": res})
def get_result():
to_get = request.json.get('to_get')
res = {"response": []}
incomplete_description = {
"error": "Request must provide list 'to_get' of objects with 'res_id'."
}
if to_get:
for g in to_get:
res_id = from_dict(g, 'res_id')
if res_id is not None:
try:
exp_res = ExpResult.get(res_id)
res["response"].append(exp_res.to_dict())
except Exception as e:
err = {"error": str(e)}
if res_id:
err['res_id'] = res_id
res["response"].append(err)
else:
res['response'].append(incomplete_description)
else:
res['response'].append(incomplete_description)
return jsonify(res)
def del_result():
to_delete = request.json.get('to_delete')
res = []
if to_delete:
for d in to_delete:
res_id = from_dict(d, 'res_id')
try:
exp_res = ExpResult.get(res_id)
message = ExpResult.delete(exp_res)
# message = exp_res.to_dict_light()
#
# db.session.delete(exp_res)
# db.session.commit()
#
res.append(message)
except Exception as e:
err = {"error": str(e)}
if res_id:
err['res_id'] = res_id
res.append(err)
else:
res.append({
"error":
"Request must provide list 'to_delete' of objects with 'res_id'."
})
return jsonify({"deleted": res})
def post_experiment():
to_post = request.json.get('to_post')
res = []
incomplete_description = {
"error":
"Request must provide list 'to_post' of objects"
" with 'title', 'res_format_id' ( or 'res_format_name'), 'dataset_id'"
" ( or 'dataset_title'), 'short_title', 'comment', 'baseline', 'processing_arr'."
}
if to_post:
for p in to_post:
title = from_dict(p, 'title')
short_title = from_dict(p, 'short_title')
comment = from_dict(p, 'comment')
baseline = from_dict(p, 'baseline')
processing_arr = from_dict(p, 'processing_arr')
res_format_id = from_dict(p, 'res_format_id')
res_format_name = from_dict(p, 'res_format_name')
dataset_id = from_dict(p, 'dataset_id')
dataset_title = from_dict(p, 'dataset_title')
full = all([
x is not None for x in
[title, short_title, comment, baseline, processing_arr]
] + [(res_format_id is not None) or (res_format_name is not None),
(dataset_id is not None) or (dataset_title is not None)])
if full:
try:
exp = Experiment.create(title, short_title, comment,
processing_arr, baseline,
res_format_id, res_format_name,
dataset_id, dataset_title, g.user)
db.session.add(exp)
db.session.commit()
res.append(exp.to_dict())
except Exception as e:
err = {"error": str(e)}
if title:
err['title'] = title
res.append(err)
else:
res.append(incomplete_description)
else:
res.append(incomplete_description)
return jsonify({"posted": res})
def post_result():
to_post = request.json.get('to_post')
res = []
incomplete_description = {
"error":
"Request must provide list 'to_post' of objects with 'exe_id', 'result'."
}
if to_post:
for p in to_post:
s = Serializer(current_app.config['SECRET_KEY'])
tokenized_exe_id = from_dict(p, 'tokenized_exe_id')
result = from_dict(p, 'result')
status = from_dict(p, 'status')
exe_id = s.loads(tokenized_exe_id)['exe_id']
try:
exp_exe = ExpExecution.get(exe_id)
exp_exe.set_status(ExecutionStatus[status])
if status == ExecutionStatus.finished.value:
exp_exe.cancel()
exp = exp_exe.get_experiment()
exp_res = ExpResult()
exp_res.set_experiment(exp)
exp_res.set_result(result)
exp_res.set_author(exp_exe.get_author())
db.session.add(exp_res)
db.session.commit()
except Exception as e:
res.append({"error": str(e)})
else:
res.append(incomplete_description)
return jsonify({"posted": res})
def monitoring():
res = []
to_monitor = request.json.get('to_monitor')
if to_monitor:
for m in to_monitor:
exe_id = from_dict(m, 'exe_id')
try:
exp_exe = ExpExecution.get(exe_id)
res.append(exp_exe.to_dict())
except Exception as e:
res.append({"error": str(e)})
else:
res.append({
"error":
"Request must provide list 'to_monitor' of objects with 'exe_id'."
})
return jsonify({"started": res})
def cancel():
res = []
to_cancel = request.json.get('to_cancel')
if to_cancel:
for c in to_cancel:
exe_id = from_dict(c, 'exe_id')
try:
exp_exe = ExpExecution.get(exe_id)
exp_exe.cancel()
res.append(exp_exe.to_dict())
except Exception as e:
res.append({"error": str(e)})
else:
res.append({
"error":
"Request must provide list 'to_monitor' of objects with 'exe_id'."
})
return jsonify({"canceled": res})
def upd_environment():
to_update = request.json.get('to_update')
res = []
if to_update:
for u in to_update:
name = from_dict(u, 'name')
env_id = from_dict(u, 'env_id')
new_name = from_dict(u, 'new_name')
new_cuda_version = from_dict(u, 'new_cuda_version')
new_gpu_required = from_dict(u, 'new_gpu_required')
new_py_dependencies = from_dict(u, 'new_py_dependencies')
new_architecture = from_dict(u, 'new_architecture')
try:
env = Environment.get(env_id, name)
env.update(new_name, new_cuda_version, new_gpu_required,
new_py_dependencies, new_architecture)
env_id = env.Id
name = env.name
db.session.commit()
res.append(env.to_dict())
except Exception as e:
err = {"error": str(e)}
if env_id:
err['env_id'] = env_id
if name:
err['name'] = name
res.append(err)
else:
res.append({
"error":
"Request must provide list 'to_update' of objects with 'env_id' or 'name' "
"and data to update ('new_name', 'new_cuda_version', 'new_gpu_required',"
" 'new_architecture', 'new_py_dependencies')."
})
return jsonify({"updated": res})
def upd_dataset():
to_update = request.json.get('to_update')
res = []
if to_update:
for u in to_update:
title = from_dict(u, 'title')
dataset_id = from_dict(u, 'dataset_id')
new_title = from_dict(u, 'new_title')
new_format_name = from_dict(u, 'new_format_name')
new_format_id = from_dict(u, 'new_format_id')
new_uri = from_dict(u, 'new_uri')
try:
ds = DataSet.get(dataset_id, title)
ds.update(new_title, new_uri, new_format_id, new_format_name)
dataset_id = ds.Id
title = ds.Title
db.session.commit()
res.append(ds.to_dict_light())
except Exception as e:
err = {"error": str(e)}
if dataset_id:
err['dataset_id'] = dataset_id
if title:
err['title'] = title
res.append(err)
else:
res.append({
"error":
"Request must provide list 'to_update' of objects with 'dataset_id' or 'title' "
"and data to update ('new_title', 'new_format_name', 'new_format_id', 'new_uri')."
})
return jsonify({"updated": res})
def update_user():
to_update = request.json.get('to_update')
res = {"updated": []}
if not g.user.admin_rights:
res["updated"].append({
"error":
"Permission required! Only administrator can update users."
})
elif to_update:
for u in to_update:
try:
user_id = from_dict(u, 'user_id')
username = from_dict(u, 'username')
new_username = from_dict(u, 'new_username')
new_password = from_dict(u, 'new_password')
new_admin_rights = from_dict(u, 'new_admin_rights')
new_exp_admin_rights = from_dict(u, 'new_exp_admin_rights')
user = User.get(user_id, username)
user.update(new_username, new_password, new_admin_rights,
new_exp_admin_rights)
db.session.commit()
message = user.to_dict()
res["updated"].append(message)
except Exception as e:
res["updated"].append({"error": str(e)})
else:
res["updated"].append({
"error":
"Request must provide 'to_update' array of objects with 'username' "
"(or 'user_id'), 'new_password', 'new_admin_rights',"
" 'new_exp_admin_rights' fields."
})
return jsonify(res)
def upd_processing():
to_update = request.json.get('to_update')
res = []
if to_update:
for u in to_update:
name = from_dict(u, 'name')
processing_id = from_dict(u, 'processing_id')
new_name = from_dict(u, 'new_name')
new_input_id = from_dict(u, 'new_input_id')
new_input_name = from_dict(u, 'new_input_name')
new_output_id = from_dict(u, 'new_output_id')
new_output_name = from_dict(u, 'new_output_name')
new_source_uri = from_dict(u, 'new_source_uri')
new_lang_name = from_dict(u, 'new_lang_name')
# new_args = from_dict(u, 'new_args')
new_env_id = from_dict(u, 'new_env_id')
new_env_name = from_dict(u, 'new_env_name')
new_status_name = from_dict(u, 'new_status_name')
try:
proc = Processing.get(processing_id, name)
proc.update(new_name, new_input_id, new_input_name,
new_output_id, new_output_name, new_source_uri,
new_lang_name, new_env_id, new_env_name,
new_status_name)
db.session.commit()
res.append(proc.to_dict())
except Exception as e:
err = {"error": str(e)}
if processing_id:
err['processing_id'] = processing_id
if name:
err['name'] = name
res.append(err)
#
else:
res.append({
"error":
"Request must provide list 'to_update' of objects with 'processing_id' or 'name' "
"and data to update ('new_name', 'new_input_id', 'new_input_name', 'new_output_id',"
" 'new_output_name', 'new_source_uri', 'new_lang_name', 'new_status_name')."
})
return jsonify({"updated": res})
def upd_experiment():
to_update = request.json.get('to_update')
res = []
if to_update:
for u in to_update:
title = from_dict(u, 'title')
exp_id = from_dict(u, 'exp_id')
new_title = from_dict(u, 'new_title')
short_title = from_dict(u, 'new_short_title')
comment = from_dict(u, 'new_comment')
baseline = from_dict(u, 'new_baseline')
processing_arr = from_dict(u, 'new_processing_arr')
res_format_id = from_dict(u, 'new_res_format_id')
res_format_name = from_dict(u, 'new_res_format_name')
dataset_id = from_dict(u, 'new_dataset_id')
dataset_title = from_dict(u, 'new_dataset_title')
try:
exp = Experiment.get(exp_id, title)
exp.update(new_title, short_title, comment, processing_arr,
baseline, res_format_id, res_format_name,
dataset_id, dataset_title)
db.session.commit()
res.append(exp.to_dict())
except Exception as e:
err = {"error": str(e)}
if exp_id:
err['exp_id'] = exp_id
if title:
err['title'] = title
res.append(err)
else:
res.append({
"error":
"Request must provide list 'to_update' of objects with 'exp_id' or 'title' "
"and data to update ('new_title', 'new_short_title', 'new_comment', 'new_baseline', "
"'processing_arr', 'new_format_id', 'new_format_name',"
" 'new_dataset_id', 'new_dataset_title')."
})
return jsonify({"updated": res})
