def load_logged_in_user(): user_id = session.get("user_id") if user_id is None: g.user = None else: g.user = (get_db().users.find_one({"_id": ObjectId(user_id)}))
def get_runs(): if request.method == "GET": context = get_checklist_data() return render_template("dacapo/runs.html", **context) if request.method == "POST": db = get_db() data = [{ "name": run["hash"].split(":")[0], "repetition": run["repetition"], "trained_iterations": db.training_stats.find({ "run": run["id"] }).count(), "started": datetime.fromtimestamp(run["started"]) if run["started"] is not None else "NA", "task": run["task_config"], "data": "NA", "model": run["model_config"], "optimizer": run["optimizer_config"], } for run in db.runs.find({})] raise NotImplementedError( "Return json with runs filtered by post data") return render_template("dacapo/runs.html")
def create_new_run(): if request.method == "GET": context = get_checklist_data() return render_template("dacapo/new_run.html", **context) if request.method == "POST": request_data = request.json run_component_ids = itertools.product( request_data["tasks"], request_data["datasets"], request_data["models"], request_data["optimizers"], ) db = get_db() new_runs = [{ "task": db.tasks.find_one({"id": t}, projection={"_id": False}), "dataset": db.datasets.find_one({"id": d}, projection={"_id": False}), "model": db.models.find_one({"id": m}, projection={"_id": False}), "optimizer": db.optimizers.find_one({"id": o}, projection={"_id": False}), } for t, d, m, o in run_component_ids if db.runs.find_one({ "task": t, "dataset": d, "model": m, "optimizer": o }) is None] print(new_runs) return jsonify(new_runs) return render_template("dacapo/new_run.html")
def register(): """Register a new user. Validates that the username is not already taken. Hashes the password for security. """ if request.method == 'POST': username = request.form['username'] password = request.form['password'] db = get_db() error = None if not username: error = 'Username is required.' elif not password: error = 'Password is required.' elif db.execute('SELECT id FROM user WHERE username = ?', (username, )).fetchone() is not None: error = 'User {0} is already registered.'.format(username) if error is None: # the name is available, store it in the database and go to # the login page db.execute('INSERT INTO user (username, password) VALUES (?, ?)', (username, generate_password_hash(password))) db.commit() return redirect(url_for('auth.login')) flash(error) return render_template('auth/register.html')
def index(): """Show all the posts, most recent first.""" db = get_db() posts = db.execute('SELECT p.id, title, body, created, author_id, username' ' FROM post p JOIN user u ON p.author_id = u.id' ' ORDER BY created DESC').fetchall() return render_template('blog/index.html', posts=posts)
def get_results(): if request.method == "GET": db = get_db() context = get_checklist_data() context.update( { "scores": set( [ key for run in db.runs.find({}) for validation_score in db.validation_scores.find( {"run": run["id"]} ).limit(1) for key in validation_score["parameter_scores"]["0"]["scores"][ "sample" ].keys() ] ), } ) return render_template("dacapo/results.html", **context) elif request.method == "POST": db = get_db() request_data = request.json runs = [ { "name": run["hash"].split(":")[0], "repetition": run["repetition"], "trained_iterations": db.training_stats.find( {"run": run["id"]} ).count(), "started": datetime.fromtimestamp(run["started"]) if run["started"] is not None else "NA", "task": run["task_config"], "data": "NA", "model": run["model_config"], "optimizer": run["optimizer_config"], } for run in db.runs.find( {"task_config": {"$in": [x.strip() for x in request_data["tasks"]]}} ) ] return jsonify(runs) return render_template("dacapo/results.html")
def get_runs(): if request.method == "GET": context = get_checklist_data() return render_template("dacapo/runs.html", **context) if request.method == "POST": request_data = request.json run_component_ids = itertools.product( request_data["tasks"], request_data["datasets"], request_data["models"], request_data["optimizers"], ) db = get_db() runs = [{ "id": run["id"], "execution_details": run["execution_details"], "task": db.tasks.find_one({"id": t}, projection={"_id": False}), "dataset": db.datasets.find_one({"id": d}, projection={"_id": False}), "model": db.models.find_one({"id": m}, projection={"_id": False}), "optimizer": db.optimizers.find_one({"id": o}, projection={"_id": False}), } for t, d, m, o in run_component_ids if (run := db.runs.find_one({ "task": t, "dataset": d, "model": m, "optimizer": o })) is not None] return jsonify(runs) # data = [ # { # "name": run["hash"].split(":")[0], # "repetition": run["repetition"], # "trained_iterations": db.training_stats.find( # {"run": run["id"]} # ).count(), # "started": datetime.fromtimestamp(run["started"]) # if run["started"] is not None # else "NA", # "task": run["task_config"], # "data": "NA", # "model": run["model_config"], # "optimizer": run["optimizer_config"], # } # for run in db.runs.find({}) # ] # raise NotImplementedError("Return json with runs filtered by post data") return render_template("dacapo/runs.html")
def load_logged_in_user(): """If a user id is stored in the session, load the user object from the database into ``g.user``.""" user_id = session.get('user_id') if user_id is None: g.user = None else: g.user = get_db().execute('SELECT * FROM user WHERE id = ?', (user_id, )).fetchone()
def delete(id): """Delete a post. Ensures that the post exists and that the logged in user is the author of the post. """ get_post(id) db = get_db() db.execute('DELETE FROM post WHERE id = ?', (id, )) db.commit() return redirect(url_for('blog.index'))
def new_task_from_existing(): if request.method == "POST": try: data = request.json new_task = converter.structure(data, dacapo.configurables.Task) new_task.verify() db = get_db() db.add_task(new_task) return jsonify({"success": True}) except Exception as e: raise (e) return jsonify({"success": False, "error": str(e)}) fields = parse_fields(dacapo.configurables.Task) task_to_copy = get_db().tasks.find_one({}) print(task_to_copy) return render_template("dacapo/forms/task_from_existing.html", fields=fields, task_to_copy=task_to_copy, id_prefix="task")
def delete_configs(): if request.method == "POST": db = get_db() request_data = request.json deleted_configs = [] for task in request_data["tasks"]: task_doc = db.tasks.find_one({"id": task}) assert task_doc is not None db.tasks.delete_one(task_doc) deleted_configs.append({ "config_type": "tasks", "name": task_doc["name"], "id": task_doc["id"] }) for dataset in request_data["datasets"]: dataset_doc = db.datasets.find_one({"id": dataset}) assert dataset_doc is not None db.datasets.delete_one(dataset_doc) deleted_configs.append({ "config_type": "datasets", "name": dataset_doc["name"], "id": dataset_doc["id"], }) for model in request_data["models"]: model_doc = db.models.find_one({"id": model}) assert model_doc is not None db.models.delete_one(model_doc) deleted_configs.append({ "config_type": "models", "name": model_doc["name"], "id": model_doc["id"], }) for optimizer in request_data["optimizers"]: optimizer_doc = db.optimizers.find_one({"id": optimizer}) assert (optimizer_doc is not None), f"Cannot find optimizer with id: {optimizer}" db.optimizers.delete_one(optimizer_doc) print(optimizer_doc["id"], optimizer) deleted_configs.append({ "config_type": "optimizers", "name": optimizer_doc["name"], "id": str(optimizer_doc["id"]), }) print(jsonify(deleted_configs)) return jsonify(deleted_configs)
def get_checklist_data(): db = get_db() context = { "tasks": [(task["id"], task.get("name", "UGH")) for task in db.tasks.find({})], "datasets": [(dataset["id"], dataset.get("name", "UGH")) for dataset in db.datasets.find({})], "models": [(model["id"], model.get("name", "UGH")) for model in db.models.find({})], "optimizers": [(optimizer["id"], optimizer.get("name", "UGH")) for optimizer in db.optimizers.find({})], "users": [user["username"] for user in db.users.find({})], } return context
def new_model(): if request.method == "POST": try: data = request.json new_model = converter.structure(data, dacapo.configurables.Model) new_model.verify() db = get_db() db.add_model(new_model) return jsonify({"success": True}) except Exception as e: raise(e) return jsonify({"success": False, "error": str(e)}) fields = parse_fields(dacapo.configurables.Model) return render_template("dacapo/forms/model.html", fields=fields, id_prefix="model")
def lasthour(): db = get_db() sensor_data = {"date": [], "temp": [], "hum": [], "soil": []} try: with db.cursor() as cursor: select_cmd = "SELECT `date`, AVG(`temp`) AS `temp`, AVG(`hum`) AS `hum`, AVG(`soil`) AS `soil` FROM `sensor_log` WHERE `date` > NOW() - INTERVAL 1 HOUR GROUP BY YEAR(`date`), MONTH(`date`), DAY(`date`), HOUR(`date`), MINUTE(`date`)" cursor.execute(select_cmd) for point in cursor: sensor_data["date"].append(point["date"].isoformat()) sensor_data["temp"].append(round(point["temp"], 2)) sensor_data["hum"].append(round(point["hum"], 2)) sensor_data["soil"].append(round(point["soil"], 2)) except Exception as e: return "Error: " + str(e) return jsonify(sensor_data)
def create(): """Create a new post for the current user.""" if request.method == 'POST': title = request.form['title'] body = request.form['body'] error = None if not title: error = 'Title is required.' if error is not None: flash(error) else: db = get_db() db.execute( 'INSERT INTO post (title, body, author_id)' ' VALUES (?, ?, ?)', (title, body, g.user['id'])) db.commit() return redirect(url_for('blog.index')) return render_template('blog/create.html')
def login(): if request.method == "POST": username = request.form["username"] password = request.form["password"] db = get_db() error = None user = db.users.find_one({"username": username}) if user is None: error = "Incorrect username." elif not check_password_hash(user["password"], password): error = "Incorrect password." if error is None: session.clear() session["user_id"] = str(user["_id"]) return redirect(url_for("dacapo.get_results")) flash(error) return render_template("auth/login.html")
def update(id): """Update a post if the current user is the author.""" post = get_post(id) if request.method == 'POST': title = request.form['title'] body = request.form['body'] error = None if not title: error = 'Title is required.' if error is not None: flash(error) else: db = get_db() db.execute('UPDATE post SET title = ?, body = ? WHERE id = ?', (title, body, id)) db.commit() return redirect(url_for('blog.index')) return render_template('blog/update.html', post=post)
def get_post(id, check_author=True): """Get a post and its author by id. Checks that the id exists and optionally that the current user is the author. :param id: id of post to get :param check_author: require the current user to be the author :return: the post with author information :raise 404: if a post with the given id doesn't exist :raise 403: if the current user isn't the author """ post = get_db().execute( 'SELECT p.id, title, body, created, author_id, username' ' FROM post p JOIN user u ON p.author_id = u.id' ' WHERE p.id = ?', (id, )).fetchone() if post is None: abort(404, "Post id {0} doesn't exist.".format(id)) if check_author and post['author_id'] != g.user['id']: abort(403) return post
def login(): """Log in a registered user by adding the user id to the session.""" if request.method == 'POST': username = request.form['username'] password = request.form['password'] db = get_db() error = None user = db.execute('SELECT * FROM user WHERE username = ?', (username, )).fetchone() if user is None: error = 'Incorrect username.' elif not check_password_hash(user['password'], password): error = 'Incorrect password.' if error is None: # store the user id in a new session and return to the index session.clear() session['user_id'] = user['id'] return redirect(url_for('index')) flash(error) return render_template('auth/login.html')
def register(): if request.method == "POST": username = request.form["username"] password = request.form["password"] db = get_db() error = None if not username: error = "Username is required." elif not password: error = "Password is required." elif db.users.find_one({"username": username}) is not None: error = "Username already exists." if error is None: db.users.insert_one({ "username": username, "password": generate_password_hash(password) }) return redirect(url_for("auth.login")) flash(error) return render_template("auth/register.html")