def reduction_started(self):
logger.info("Run %s has started reduction" %
self._data_dict['run_number'])
reduction_run = self.find_run()
if reduction_run:
if str(reduction_run.status.value) == "Error" or str(
reduction_run.status.value) == "Queued":
reduction_run.status = StatusUtils().get_processing()
reduction_run.started = datetime.datetime.now()
session.add(reduction_run)
session.commit()
else:
logger.error(
"An invalid attempt to re-start a reduction run was captured. Experiment: %s, "
"Run Number: %s, Run Version %s" %
(self._data_dict['rb_number'],
self._data_dict['run_number'],
self._data_dict['run_version']))
else:
logger.error(
"A reduction run started that wasn't found in the database. Experiment: %s, Run Number: %s, "
"Run Version %s" %
(self._data_dict['rb_number'], self._data_dict['run_number'],
self._data_dict['run_version']))
def _process_house_item(self, item):
item['area'] = int(item['area'][:-1])
item['rent'] = int(item['rent'])
session.add(House(**item))
session.commit()
session.close()
return item
def _create_variables(self, instrument, script, variable_dict,
is_advanced):
variables = []
for key, value in variable_dict.iteritems():
str_value = str(value).replace('[', '').replace(']', '')
if len(str_value) > 300:
raise DataTooLong
variable = Variable(name=key,
value=str_value,
type=VariableUtils().get_type_string(value),
is_advanced=is_advanced,
help_text=self._get_help_text(
'standard_vars', key, instrument.name,
script))
instrument_variable = InstrumentVariable(start_run=0,
instrument=instrument,
variable=variable,
tracks_script=1)
session.add(variable)
session.add(instrument_variable)
session.commit()
variables.append(instrument_variable)
return variables
def to_html(self):
# not good to have imports here...
from queries import get_question, get_last_question_response, get_peer_tasks_for_grader, get_self_tasks_for_student
from auth import validate_user
self.set_metadata()
user = validate_user()
if user.type == "guest":
return "Sorry, but only students can view peer assessment questions."
vars = {"question": get_question(self.question_id)}
# if peer assessment was assigned
if len(self.peer_pts):
peer_tasks = get_peer_tasks_for_grader(self.question_id, user.stuid)
vars['peer_responses'] = [get_last_question_response(self.question_id, task.student) for task in peer_tasks]
# if self assessment was assigned
if self.self_pts is not None:
# add the task if it hasn't been already
response = get_last_question_response(self.question_id, user.stuid)
if response and not get_self_tasks_for_student(self.question_id, user.stuid):
session.add(GradingTask(grader=user.stuid,
student=user.stuid,
question_id=self.question_id))
session.commit()
vars['self_response'] = response
# jinja2 to get template for peer review questions
from jinja2 import Environment, PackageLoader
env = Environment(autoescape=True, loader=PackageLoader("ohms", "templates"))
template = env.get_template("peer_review_question.html")
return template.render(**vars)
def createUser(login_session):
newUser = User(name=login_session['username'],
email=login_session['email'],
picture=login_session['picture'])
session.add(newUser)
session.commit()
user = session.query(User).filter_by(email=login_session['email']).one()
return user.id
def _process_job_item(self, item):
item['salary_lower'] = int(item['salary_lower'][:-1])
item['salary_upper'] = int(item['salary_upper'][:-1])
item['experience_lower'] = int(item['experience_lower'])
item['experience_upper'] = int(item['experience_upper'])
session.add(Job(**item))
session.commit()
session.close()
return item
def signup():
form = RegisterForm()
if form.validate_on_submit():
new_user = User(form.username.data, form.email.data,
form.password.data)
session.add(new_user)
session.commit()
flash('Thanks for registrering, You are a registered user now !!')
return redirect('/login')
return render_template('register.html', titles='Register', form=form)
def save_run_variables(self, instrument_vars, reduction_run):
logger.info('Saving run variables for ' +
str(reduction_run.run_number))
run_variables = map(
lambda ins_var: self.derive_run_variable(ins_var, reduction_run),
instrument_vars)
for run_variable in run_variables:
session.add(run_variable)
session.commit()
return run_variables
def log_error_and_notify(message):
"""
Helper method to log an error and save a notifcation
"""
logger.error(message)
notification = Notification(is_active=True,
is_staff_only=True,
severity='e',
message=message)
session.add(notification)
session.commit()
def update_category(category_id):
"""
Updating category in DB with fields from request form
* better replace with arguments, to make method more independent
"""
name = flask.request.form['name']
category_to_update = session.query(Category).get(category_id)
category_to_update.name = name
session.add(category_to_update)
session.commit()
def add_category():
"""
Adding new category to DB with fields from request form
* better replace with arguments, to make method more independent
"""
name = flask.request.form['name']
owner = user_info()['id']
new_category = Category(name, owner)
session.add(new_category)
session.commit()
def post():
print(request.is_json)
content = request.get_json()
nom = content['nom']
email = content['email']
password = content['password']
user = Data.User(nom, email, password)
session.add(user)
session.flush()
session.commit()
return 'User added'
def add_user(self, user_id):
"""
Добавляем пользователя в БД.
"""
candidate_user = User(user_id=user_id, green_points=0, green_tickets=0)
session.add(candidate_user)
try:
session.commit()
return True
except sqlalchemy.exc.IntegrityError:
session.rollback()
return False
def newCategory():
if not userIsLoggedIn():
return redirect(url_for('showLogin'))
if request.method == 'POST':
newCategory = Category(name=request.form['name'])
newCategory.user_id = login_session['user_id']
session.add(newCategory)
flash('New Category %s Successfully Created' % newCategory.name)
session.commit()
return redirect(url_for('showCategories'))
else:
return render_template('newCategory.html')
def _get_status(status_value):
"""
Helper method that will try to get a status matching the given name or create one if it doesn't yet exist
"""
status = session.query(Status).filter_by(value=status_value)[0]
if status is None:
new_status = Status(value=status_value)
session.add(new_status)
session.commit()
status = session.query(InstrumentVariable).filter_by(value=status_value)[0]
logger.warn("%s status was not found, created it." % status_value)
return status
def reduction_complete(self):
try:
logger.info("Run %s has completed reduction" %
self._data_dict['run_number'])
reduction_run = self.find_run()
if reduction_run:
if reduction_run.status.value == "Processing":
reduction_run.status = StatusUtils().get_completed()
reduction_run.finished = datetime.datetime.now()
for name in ['message', 'reduction_log', 'admin_log']:
setattr(reduction_run, name,
self._data_dict.get(name, ""))
if 'reduction_data' in self._data_dict:
for location in self._data_dict['reduction_data']:
reduction_location = ReductionLocation(
file_path=location,
reduction_run=reduction_run)
session.add(reduction_location)
session.commit()
# Get any .png files and store them as base64 strings
# Currently doesn't check sub-directories
graphs = glob.glob(location + '*.[pP][nN][gG]')
for graph in graphs:
with open(graph, "rb") as image_file:
encoded_string = 'data:image/png;base64,' + base64.b64encode(
image_file.read())
if reduction_run.graph is None:
reduction_run.graph = [encoded_string]
else:
reduction_run.graph.append(
encoded_string)
session.add(reduction_run)
session.commit()
else:
logger.error(
"An invalid attempt to complete a reduction run that wasn't processing has been "
"captured. Experiment: %s, Run Number: %s, Run Version %s"
% (self._data_dict['rb_number'],
self._data_dict['run_number'],
self._data_dict['run_version']))
else:
logger.error(
"A reduction run completed that wasn't found in the database. Experiment: %s, Run Number: "
"%s, Run Version %s" % (self._data_dict['rb_number'],
self._data_dict['run_number'],
self._data_dict['run_version']))
except BaseException as e:
logger.error("Error: %s" % e)
def insert_member(member):
"""
Persists member data into database
:param member: the member data
:return:
"""
assert member is not None, 'Member not specified'
try:
session.add(member)
# Commit session
session.commit()
except (exc.SQLAlchemyError, exc.DBAPIError) as e:
logging.error("Failed to insert member: [" + member.to_string() + "]: " + str(e))
def add_item(category_id):
"""
Adding item to DB with fields from request form
* better replace with arguments, to make method more independent
"""
name = flask.request.form['name']
owner = user_info()['id']
description = flask.request.form['description']
new_item = Item(name, description, owner)
new_item.category_id = category_id
session.add(new_item)
session.commit()
def update_item(item_id):
"""
Updating item in DB with fields from request form
* better replace with arguments, to make method more independent
"""
name = flask.request.form['name']
description = flask.request.form['description']
item_to_update = session.query(Item).get(item_id)
item_to_update.name = name
item_to_update.description = description
session.add(item_to_update)
session.commit()
def insert_location(location):
"""
Persists location data into database
:param location: the location data
:return:
"""
assert location is not None, 'Location not specified'
try:
session.add(location)
# Commit session
session.commit()
except (exc.SQLAlchemyError, exc.DBAPIError) as e:
logging.error("Failed to insert location: [" +
location.to_string() + "]: " + str(e))
def reduction_error(self):
if 'message' in self._data_dict:
logger.info(
"Run %s has encountered an error - %s" %
(self._data_dict['run_number'], self._data_dict['message']))
else:
logger.info(
"Run %s has encountered an error - No error message was found"
% (self._data_dict['run_number']))
reduction_run = self.find_run()
if not reduction_run:
logger.error(
"A reduction run that caused an error wasn't found in the database. Experiment: %s, "
"Run Number: %s, Run Version %s" %
(self._data_dict['rb_number'], self._data_dict['run_number'],
self._data_dict['run_version']))
return
reduction_run.status = StatusUtils().get_error()
# TODO : Here, and in other places where datetime is used, need to make sure we are using GMT.
reduction_run.finished = datetime.datetime.now()
for name in ['message', 'reduction_log', 'admin_log']:
setattr(reduction_run, name, self._data_dict.get(name, ""))
session.add(reduction_run)
session.commit()
if 'retry_in' in self._data_dict:
experiment = session.query(Experiment).filter_by(
reference_number=self._data_dict['rb_number']).first()
previous_runs = session.query(ReductionRun).filter_by(
run_number=self._data_dict['run_number'],
experiment=experiment).all()
max_version = -1
for previous_run in previous_runs:
current_version = previous_run.run_version
if current_version > max_version:
max_version = current_version
# If we have already tried more than 5 times, we want to give up and we don't want to retry the run
if max_version <= 4:
self.retry_run(reduction_run, self._data_dict["retry_in"])
else:
# Need to delete the retry_in entry from the dictionary so that the front end doesn't report a false
# retry instance.
del self._data_dict['retry_in']
self.notify_run_failure(reduction_run)
def get_new_yaks():
yaks = client.get_new_yaks(config['lat'], config['long'])
for yak in yaks:
cur_yak = session.query(db.Yak).filter_by(yid=yak.message_id).first()
if not cur_yak:
cur_yak = db.Yak(yid=yak.message_id, time=yak.time, text=yak.message, score=yak.number_of_likes, handle=yak.nickname or '')
print(' NEW:', repr(cur_yak))
session.add(cur_yak)
else:
if cur_yak.score != yak.number_of_likes:
diff = yak.number_of_likes - cur_yak.score
cur_yak.score = yak.number_of_likes
print('{: =+4}:'.format(diff), repr(cur_yak))
session.commit()
def copy_metadata(new_var):
source_var = variables[0]
if isinstance(source_var, InstrumentVariable):
# Copy the source variable's metadata to the new one.
map(
lambda name: setattr(new_var, name,
getattr(source_var, name)),
["instrument", "experiment_reference", "start_run"])
elif isinstance(source_var, RunVariable):
# Create a run variable.
VariableUtils().derive_run_variable(new_var,
source_var.reduction_run)
else:
return
session.add(new_var)
session.commit()
def add_movie():
data = loads(request.data)
title = data['title']
year = data['year']
country = data['country']
genre = data['genre']
movie_row = Movie(
title=title,
year=year,
country=session.query(Country).filter(Country.name == country).first())
movie_row.genre.append(
session.query(Genre).filter(Genre.name == genre).first())
session.add(movie_row)
session.commit()
message = 'Movie {} was added!'.format(title)
dic = {'message': message}
return jsonify(dic)
def from_xml(node):
# if question already has ID assigned, fetch it
if 'id' in node.attrib:
question = session.query(Question).get(node.attrib['id'])
# otherwise, create a new one
else:
if 'review' in node.attrib and 't' in node.attrib['review'].lower():
question = PeerReview()
else:
question = Question()
session.add(question)
session.flush()
question.sync_from_node(node)
session.commit()
return question
def editItem(category_id, item_id):
editedItem = session.query(Item).filter_by(id=item_id).one()
if not userIsOwner(editedItem.user_id):
return redirect(url_for('showLogin'))
category = session.query(Category).filter_by(id=category_id).one()
if request.method == 'POST':
if request.form['name']:
editedItem.name = request.form['name']
if request.form['description']:
editedItem.description = request.form['description']
if request.form['price']:
editedItem.price = request.form['price']
session.add(editedItem)
session.commit()
flash('Item Successfully Edited')
return redirect(url_for('showItems', category_id=category_id))
else:
return render_template('edititem.html', category_id=category_id, item_id=item_id, item=editedItem)
def update_variable(old_var):
old_var.keep = True
# Find the new variable from the script.
matching_vars = filter(
lambda temp_var: temp_var.name == old_var.name, defaults)
if matching_vars and old_var.tracks_script: # Check whether we should and can update the old one.
new_var = matching_vars[0]
map(
lambda name: setattr(old_var, name, getattr(new_var, name)
),
["value", "type", "is_advanced", "help_text"]
) # Copy the new one's important attributes onto the old variable.
if save:
session.add(old_var)
session.commit()
elif not matching_vars:
# Or remove the variable if it doesn't exist any more.
if save:
session.delete(old_var)
session.commit()
old_var.keep = False
def from_xml(node):
"""Constructs a Item object from an xml node"""
klass_map = {'Multiple Choice': MultipleChoiceItem,
'Long Answer': LongAnswerItem,
'Short Answer': ShortAnswerItem}
if node.attrib['type'] in klass_map:
klass = klass_map[node.attrib['type']]
else:
raise ValueError('type of question not recognized, options are %s' % `klass_map.keys()`)
# get existing item based on ID, if specified
if 'id' in node.attrib:
item = session.query(Item).get(node.attrib['id'])
# otherwise create new item
else:
item = klass()
session.add(item)
item.sync_from_node(node)
item.xml = ET.tostring(node, method="xml")
session.flush()
return item
def submit_response(self, stuid, responses):
from queries import get_last_question_response
last_submission = get_last_question_response(self.id, stuid)
if not self.check_if_locked(last_submission):
item_responses = [ItemResponse(item_id=item.id, response=response) \
for item, response in zip(self.items, responses)]
score, comments = self.check(responses)
question_response = QuestionResponse(
stuid=stuid,
time=pdt_now(),
question_id=self.id,
item_responses=item_responses,
score=score,
comments=comments
)
session.add(question_response)
session.commit()
return {
'submission': self.delay_feedback(question_response),
'locked': self.check_if_locked(question_response),
}
else:
raise Exception("The deadline for submitting this homework has passed.")
def newCategoryItem(category_id):
if not userIsLoggedIn():
return redirect(url_for('showLogin'))
#Find requested category
category = session.query(Category).filter_by(id=category_id).one()
#Handle form submit
if request.method == 'POST':
newItem = Item(name=request.form['name'], description=request.form[
'description'], price=request.form['price'], category_id=category_id)
#Assign creator id
newItem.user_id = login_session['user_id']
#Store new item
session.add(newItem)
session.commit()
flash('New Menu %s Item Successfully Created' % (newItem.name))
return redirect(url_for('showItems', category_id=category_id))
else:
return render_template('newitem.html', category_id=category_id)
app.debug = (options.target != "prod")
@app.errorhandler(Exception)
def handle_exceptions(error):
return make_response(error.message, 403)
stuid = auth_stuid()
if not stuid:
raise Exception("You are no longer logged in. Please refresh the page.")
try:
user = get_user(stuid)
except:
user = User(stuid=stuid,
name=auth_student_name(),
type="student")
session.add(user)
session.commit()
@app.route("/")
def index():
return render_template("admin/index.html", options=options, user=user)
@app.route("/reminder_email/<int:hw_id>", methods=['POST'])
def reminder_email(hw_id):
homework = session.query(Homework).get(hw_id)
# get users who haven't completed peer grading
users = set()
for question in homework.questions:
def assign_tasks(hw_id, due_date, send_emails=False):
homework = session.query(Homework).get(hw_id)
users = session.query(User).filter(User.type == "student").order_by(User.stuid).all()
for q in homework.questions:
# only if this is a peer graded question
if not isinstance(q.items[0], LongAnswerItem):
continue
random.seed(q.id) # setting a seed will be useful for debugging
responsible_kids = list() # did the homework!
irresponsible_kids = list() # didn't do the homework!
# Figure out who did the homework
for user in users:
if get_last_question_response(q.id, user.stuid):
responsible_kids.append(user.stuid)
else:
irresponsible_kids.append(user.stuid)
# Make the assignments for the responsible kids
n = len(responsible_kids)
random.shuffle(responsible_kids)
for i, stuid in enumerate(responsible_kids):
# Make the assignments for this responsible student
for offset in [1, 3, 6]:
j = (i + offset) % n
gt = GradingTask(grader=stuid,
student=responsible_kids[j],
question_id=q.id)
session.add(gt)
# Make the assignments for the irresponsible kids:
# Do so in round robin order, shuffling the responsible students again
# to minimize the number of pairs of students grading together.
random.shuffle(responsible_kids)
for i, stuid in enumerate(irresponsible_kids):
# Make the assignments for this irresponsible student
for offset in range(3):
j = (i * 3 + offset) % n
gt = GradingTask(grader=stuid,
student=responsible_kids[j],
question_id=q.id)
session.add(gt)
# Make all self-assignments
for stuid in (responsible_kids + irresponsible_kids):
gt = GradingTask(grader=stuid,
student=stuid,
question_id=q.id)
session.add(gt)
session.commit()
if not send_emails:
return "Successfully assigned %d students"
# Send email notifications to all the students
send_all(users, "Peer Assessment for %s is Ready" % homework.name[:-1],
r"""Dear %s,
We've made the peer-grading assignments for this week. The assessments
are due {due_date}, and you can start after lecture today at 11:00AM.
You will be able to view your peer's comments on your answers as they
are submitted, but your score will not be available until {due_date}.
At that time, please log in to view and respond to the comments you
received from your peers.
Best,
STATS 60 Staff""".format(due_date=due_date.strftime("%A, %b %d at %I:%M %p")))
# Send email to the course staff
admins = session.query(User).filter_by(type="admin").all()
send_all(admins, "Peer Assessment for %s is Ready" % homework.name[:-1],
r"""Dear %s (and other members of the STATS 60 Staff),
Just letting you know that the peer assessment for this week was just released.
It is due at {due_date}.
Sincerely,
OHMS
P.S. This is an automatically generated message ;-)
""".format(due_date=due_date.strftime("%A, %b %d at %I:%M %p")))
return r'''Successfully assigned %d students. You should have received an
e-mail confirmation.''' % len(users)
def add_grade(student, homework, score, excused=False):
grade = Grade(student=student, homework=homework,
score=score, excused=excused)
session.add(grade)
session.commit()
