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