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