def study(study_id):
study = Studies.query.get(study_id)
user = Users.from_stormpath(stormpath_user)
if not study.is_owner(user):
abort(401)
page = int(request.args.get('page') or 1)
datasets = study.datasets\
.order_by(Datasets.created_at.desc())\
.paginate(page, per_page=15)
has_datasets = datasets.total > 0
study.users.filter_by(role="labeller").all()
labellers = Users.query.\
filter(study.is_labeller(Users)).\
all()
labellers = study.labellers()
users = labellers.all()
notusers = Users.query.except_(labellers).all()
return render_template('study.html',
study=study,
datasets=datasets.items,
pagination=datasets,
users=users,
notusers=notusers,
uploads=study.uploads,
has_datasets=has_datasets)
def new_study():
study = Studies(request.form['title'])
db.session.add(study)
user = Users.from_stormpath(stormpath_user)
study.add_user(user, "owner")
study.add_user(user, "labeller")
return redirect(url_for('study', study_id=study.id))
def delete_study(study_id):
study = Studies.query.get(study_id)
user = Users.from_stormpath(stormpath_user)
if not study.is_owner(user):
abort(401)
study.delete()
return redirect(url_for('dashboard'))
def dashboard():
page = int(request.args.get('page') or 1)
user = Users.from_stormpath(stormpath_user)
mystudies = user.studies().filter(StudyUsers.role == "owner").all()
tolabel = user.studies().filter(StudyUsers.role == "labeller").all()
return render_template('dashboard.html',
mystudies=mystudies,
tolabel=tolabel
)
def add_study_labeller(study_id):
study = Studies.query.get(study_id)
user = Users.from_stormpath(stormpath_user)
if not study.is_owner(user):
abort(401)
user_id = request.args.get('user_id')
study_user = Users.query.get(user_id)
study.add_user(study_user, "labeller")
return redirect(url_for('study', study_id=study.id))
def delete_dataset(dataset_id):
dataset = Datasets.query.get(dataset_id)
study = dataset.study
user = Users.from_stormpath(stormpath_user)
if not study.is_owner(user):
abort(401)
# db.session.delete(dataset)
# db.session.commit()
dataset.delete()
return redirect(url_for('study', study_id=study.id))
def label_study(study_id):
study = Studies.query.get(study_id)
user = Users.from_stormpath(stormpath_user)
if not study.is_labeller(user):
abort(401)
first_dataset = study.datasets\
.order_by(Datasets.created_at.desc())\
.first()
return redirect(url_for('dataset', dataset_id=first_dataset.id, mode="label"))
def upload(study_id):
study = Studies.query.get(study_id)
user = Users.from_stormpath(stormpath_user)
if not study.is_owner(user):
abort(401)
zfile = request.files['file']
# zfilename = secure_filename(zfile.filename)
# zpath = os.path.join(app.config['UPLOAD_FOLDER'], zfilename)
# zfile.save(zpath)
db.session.add(StudyUploads(zfile.filename, zfile.read(), study_id))
db.session.commit()
return jsonify({
'success': True
})
def labelled_dataset(dataset_id):
user = Users.from_stormpath(stormpath_user)
dataset = Datasets.query.get(dataset_id)
if not dataset.study.is_labeller(user):
abort(401)
# mark as labelled if not already
if not dataset.user_has_labelled(user):
labelled = LabelledDatasets(dataset.id, user.id)
db.session.add(labelled)
db.session.commit()
next_ds = dataset.next()
if(next_ds):
return redirect(url_for('dataset', dataset_id=next_ds.id, mode="label"))
else:
return redirect(url_for('dataset', dataset_id=dataset.id, mode="label"))
def reset_labels(dataset_id):
dataset = Datasets.query.get(dataset_id)
user = Users.from_stormpath(stormpath_user)
if not dataset.study.is_labeller(user):
abort(401)
data_labels = dataset.labels_for_user(user)
# mark as unlabelled
if dataset.user_has_labelled(user):
dataset.labelled.filter_by(user_id=user.id).delete()
db.session.commit()
dicts = [dict(id=data_label.UserLabels.id, label=False) for data_label in data_labels]
db.session.bulk_update_mappings(UserLabels, dicts)
db.session.commit()
return jsonify({
"success": True
})
def dataset(dataset_id):
mode = request.args.get('mode')
if not mode in ["view", "label"]:
abort(400)
user = Users.from_stormpath(stormpath_user)
dataset = Datasets.query.get(dataset_id)
if not dataset.study.is_labeller(user):
abort(401)
# Grab the list of datasets in this study
# What page is this dataset?
# has_next?
# has_prev?
prev_ds = dataset.prev()
next_ds = dataset.next()
all_ds = dataset.items()
if mode == "label":
# join labels for this user with datapoints for this dataset
data_labels = dataset.labels_for_user(user)
# populate labels if they're currently empty
if data_labels.count() == 0:
conn = db.engine.connect()
dicts = UserLabels.dicts_from_datapoints(dataset.data_points.filter_by(training=True), dataset.id, user.id)
conn.execute(UserLabels.__table__.insert(), dicts)
db.session.commit()
# json data for d3
def clean_selected(sel):
if not sel:
return 0
if sel:
return 1
return 0
graph_points = [{
"id": x.UserLabels.id,
"temp_c": x.DataPoints.value,
"time": x.DataPoints.timestamp.strftime("%Y-%m-%d %H:%M:%S"),
"selected": clean_selected(x.UserLabels.label)
} for x in data_labels]
else:
graph_points = [{
"id": x.id,
"temp_c": x.value,
"time": x.timestamp.strftime("%Y-%m-%d %H:%M:%S"),
"training": x.training
} for x in dataset.data_points.order_by(DataPoints.timestamp)]
is_owner = dataset.study.is_owner(user)
y_min = dataset.study.y_min
y_max = dataset.study.y_max
# Compute flag that is True is all the datasets have been labelled by all
# the labellers.
count_labellers = dataset.study.labellers().count()
all_labelled = all([ds.labelled.count() == count_labellers for ds in all_ds])
return render_template('dataset.html',
dataset=dataset,
title=dataset.title,
study=dataset.study.title,
studyid=dataset.study_id,
notes=dataset.notes,
points_json=json.dumps(graph_points),
mode_json=json.dumps(mode),
y_min_json=json.dumps(y_min),
y_max_json=json.dumps(y_max),
mode=mode,
next_ds=next_ds,
prev_ds=prev_ds,
all_ds=all_ds,
is_owner=is_owner,
all_labelled=all_labelled,
current_user=user)
If the user is valid, we'll log them in, and store their session for later.
"""
if request.method == 'GET':
return render_template('login.html')
try:
_user = User.from_login(
request.form.get('email'),
request.form.get('password'),
)
except StormpathError, err:
return render_template('login.html', error=err.message['message'])
login_user(_user, remember=True)
print stormpath_user.get_id()
user = Users.from_stormpath(stormpath_user)
print user.id
return redirect(request.args.get('next') or url_for('dashboard'))
@app.route('/dashboard', methods=['GET'])
@login_required
def dashboard():
page = int(request.args.get('page') or 1)
user = Users.from_stormpath(stormpath_user)
mystudies = user.studies().filter(StudyUsers.role == "owner").all()
tolabel = user.studies().filter(StudyUsers.role == "labeller").all()
return render_template('dashboard.html',
mystudies=mystudies,
tolabel=tolabel
)
