def save_to_db(self, testing=False, postgresql=None):
def insert_into_db(a_cursor):
a_cursor.execute(
"INSERT INTO experiments(experiment_dir, experiment_name) VALUES(%s, %s);",
(self.experiment_dir, self.experiment_name))
def update_db_entry(a_cursor):
a_cursor.execute(
"UPDATE experiments SET (experiment_name, experiment_dir) = (%s, %s) WHERE experiment_id = %s;",
(self.experiment_name, self.experiment_dir, self.experiment_id))
def save_to_db_main(a_cursor):
if self.experiment_name not in list_all_experiment_names(a_cursor):
insert_into_db(a_cursor)
return self.from_db(experiment_name=self.experiment_name)
elif self == self.from_db(experiment_name=self.experiment_name):
return self
else:
update_db_entry(a_cursor)
return self.from_db(experiment_name=self.experiment_name)
if testing:
with TestingCursor(postgresql) as cursor:
return save_to_db_main(cursor)
else:
with Cursor() as cursor:
return save_to_db_main(cursor)
def from_db(cls, session_id=None, session_dir=None, testing=False, postgresql=None):
def by_id(a_cursor, a_session_id):
a_cursor.execute("SELECT * FROM sessions WHERE session_id = %s;", (a_session_id,))
return a_cursor.fetchone()
def by_dir(a_cursor, a_session_dir):
a_cursor.execute("SELECT * FROM sessions WHERE session_dir = %s;", (a_session_dir,))
return a_cursor.fetchone()
def from_db_main(a_cursor, a_session_id, a_session_dir):
if a_session_id is not None:
session_data = by_id(a_cursor, a_session_id)
elif a_session_dir is not None:
session_data = by_dir(a_cursor, a_session_dir)
else:
session_data = None
if session_data is None:
return None
return cls(mouse_id=session_data[1], experiment_id=session_data[2], session_date=session_data[3],
session_dir=session_data[4], session_num=session_data[5], session_id=session_data[0])
if testing:
with TestingCursor(postgresql) as cursor:
return from_db_main(cursor, session_id, session_dir)
else:
with Cursor() as cursor:
return from_db_main(cursor, session_id, session_dir)
def save_to_db(self, testing=False, postgresql=None):
def insert_into_db(a_cursor):
a_cursor.execute("INSERT INTO sessions (mouse_id, experiment_id, session_date, session_dir, session_num) "
"VALUES (%s, %s, %s, %s, %s);",
(self.mouse_id, self.experiment_id, self.session_date, self.session_dir, self.session_num))
def update_db_entry(a_cursor):
a_cursor.execute("UPDATE sessions "
"SET (session_date, session_dir, session_num) = (%s, %s, %s) "
"WHERE session_id = %s;",
(self.session_date, self.session_dir, self.session_num, self.session_id))
def save_to_db_main(a_cursor):
return_session_id = self.from_db(session_id=self.session_id)
return_session_dir = self.from_db(session_dir=self.session_dir)
if self == return_session_id:
return self
elif return_session_id is None and return_session_dir is None:
insert_into_db(a_cursor)
return self.from_db(session_dir=self.session_dir)
else:
update_db_entry(a_cursor)
return self.from_db(session_dir=self.session_dir)
if testing:
with TestingCursor(postgresql) as cursor:
return save_to_db_main(cursor)
else:
with Cursor() as cursor:
return save_to_db_main(cursor)
def from_db(cls, experiment_name=None, experiment_id=None, testing=False, postgresql=None):
experiment_name = util.prep_string_for_db(experiment_name)
def by_experiment_name(a_cursor, exp_name):
a_cursor.execute("SELECT * FROM experiments WHERE experiment_name = %s;", (exp_name,))
return a_cursor.fetchone()
def by_id(a_cursor, exp_id):
a_cursor.execute("SELECT * FROM experiments WHERE experiment_id = %s;", (exp_id,))
return a_cursor.fetchone()
def from_db_main(a_cursor, exp_name, exp_id):
if exp_name is not None:
exp = by_experiment_name(a_cursor, exp_name)
elif exp_id is not None:
exp = by_id(a_cursor, exp_id)
else:
exp = None
if exp is None:
return None
return cls(experiment_name=exp[2], experiment_dir=exp[1],
experiment_id=exp[0])
if testing:
with TestingCursor(postgresql) as cursor:
return from_db_main(cursor, experiment_name, experiment_id)
else:
with Cursor() as cursor:
return from_db_main(cursor, experiment_name, experiment_id)
def save_to_db(self, testing=False, postgresql=None):
def insert_into_db(a_cursor):
a_cursor.execute(
"INSERT INTO trials (experiment_id, folder_id, trial_dir, trial_date) VALUES (%s, %s, %s, %s);",
(self.experiment_id, self.folder_id, self.trial_dir,
util.convert_date_int_yyyymmdd(self.trial_date)))
def update_db_entry(a_cursor):
a_cursor.execute(
"UPDATE trials "
"SET (trial_dir, trial_date) = (%s, %s) "
"WHERE trial_id = %s;",
(self.trial_dir, self.trial_date, self.trial_id))
def save_to_db_main(a_cursor):
return_trial_id = self.from_db(trial_id=self.trial_id)
return_trial_dir = self.from_db(trial_dir=self.trial_dir)
if self == return_trial_id:
return self
elif return_trial_id is None and return_trial_dir is None:
insert_into_db(a_cursor)
return self.from_db(trial_dir=self.trial_dir)
else:
update_db_entry(a_cursor)
return self.from_db(trial_dir=self.trial_dir)
if testing:
with TestingCursor(postgresql) as cursor:
return save_to_db_main(cursor)
else:
with Cursor() as cursor:
return save_to_db_main(cursor)
def save_to_db(self, testing=False, postgresql=None):
def insert_into_db(a_cursor):
a_cursor.execute(
"INSERT INTO blind_folders (folder_id, reviewer_id, blind_name) "
"VALUES (%s, %s, %s);",
(self.folder_id, self.reviewer_id, self.blind_name))
def update_db_entry(a_cursor):
a_cursor.execute(
"UPDATE blind_folders "
"SET (reviewer_id, blind_name) = (%s, %s) "
"WHERE blind_folder_id = %s;",
(self.reviewer_id, self.blind_name, self.folder_id))
def save_to_db_main(a_cursor):
return_blind_folder_id = self.from_db(
blind_folder_id=self.blind_folder_id)
return_blind_name = self.from_db(blind_name=self.blind_name)
if self == return_blind_folder_id:
return self.from_db(blind_name=self.blind_name)
elif return_blind_folder_id is None and return_blind_name is None:
insert_into_db(a_cursor)
return self.from_db(blind_name=self.blind_name)
else:
update_db_entry(a_cursor)
return self.from_db(blind_name=self.blind_name)
if testing:
with TestingCursor(postgresql) as cursor:
return save_to_db_main(cursor)
else:
with Cursor() as cursor:
return save_to_db_main(cursor)
def from_db(cls, eartag, experiment_name, testing=False, postgresql=None):
def from_db_main(a_cursor, a_mouse, a_experiment):
a_cursor.execute(
"SELECT * FROM participant_details WHERE mouse_id = %s AND experiment_id = %s;",
(a_mouse.mouse_id, a_experiment.experiment_id))
participant_details = cursor.fetchone()
if participant_details is None:
return None
return cls(mouse,
experiment,
participant_dir=participant_details[6],
start_date=participant_details[3],
end_date=participant_details[4],
exp_spec_details=participant_details[5],
detail_id=participant_details[0])
if testing:
with TestingCursor(postgresql) as cursor:
mouse = Mouse.from_db(eartag,
testing=testing,
postgresql=postgresql)
experiment = Experiment.from_db(experiment_name,
testing=testing,
postgresql=postgresql)
return from_db_main(cursor, mouse, experiment)
else:
with Cursor() as cursor:
mouse = Mouse.from_db(eartag)
experiment = Experiment.from_db(experiment_name)
return from_db_main(cursor, mouse, experiment)
def from_db(cls, eartag=None, mouse_id=None, testing=False, postgresql=None):
def by_eartag(a_cursor, a_eartag):
a_cursor.execute("SELECT * FROM mouse WHERE eartag = %s;", (a_eartag,))
return a_cursor.fetchone()
def by_id(a_cursor, a_mouse_id):
a_cursor.execute("SELECT * FROM mouse WHERE mouse_id = %s;", (a_mouse_id,))
return a_cursor.fetchone()
def from_db_main(a_cursor, a_eartag, a_mouse_id):
if eartag is not None:
mouse_data = by_eartag(a_cursor, a_eartag)
elif mouse_id is not None:
mouse_data = by_id(a_cursor, a_mouse_id)
else:
mouse_data = None
if mouse_data is None:
return None
return cls(eartag=mouse_data[1], birthdate=mouse_data[2],
genotype=util.decode_genotype(mouse_data[3]), sex=mouse_data[4], mouse_id=mouse_data[0])
if testing:
with TestingCursor(postgresql) as cursor:
return from_db_main(cursor, eartag, mouse_id)
else:
with Cursor() as cursor:
return from_db_main(cursor, eartag, mouse_id)
def save_to_db(self, testing=False, postgresql=None):
def insert_into_db(a_cursor):
a_cursor.execute("INSERT INTO mouse (eartag, birthdate, genotype, sex) VALUES (%s, %s, %s, %s);",
(self.eartag, self.birthdate, util.encode_genotype(self.genotype), self.sex))
def update_db_entry(a_cursor):
a_cursor.execute("UPDATE mouse "
"SET (birthdate, genotype, sex) = (%s, %s, %s) "
"WHERE eartag = %s;",
(self.birthdate, self.genotype, self.sex, self.eartag))
def save_to_db_main(a_cursor):
if self.from_db(eartag=self.eartag) is None:
insert_into_db(a_cursor)
return self.from_db(eartag=self.eartag)
elif self == self.from_db(eartag=self.eartag):
return self
else:
update_db_entry(a_cursor)
return self.from_db(eartag=self.eartag)
if testing:
with TestingCursor(postgresql) as cursor:
if self.from_db(eartag=self.eartag) is None:
return save_to_db_main(cursor)
else:
with Cursor() as cursor:
return save_to_db_main(cursor)
def save_to_db(self, testing=False, postgresql=None):
def insert_into_db(a_cursor):
a_cursor.execute(
"INSERT INTO blind_trials (trial_id, folder_id, full_path) VALUES (%s, %s, %s);",
(self.trial_id, self.folder_id, str(self.full_path)))
def update_db_entry(a_cursor):
a_cursor.execute(
"UPDATE blind_trials "
"SET (trial_id, folder_id, full_path) = (%s, %s, %s) "
"WHERE blind_trial_id = %s;",
(self.trial_id, self.folder_id, str(
self.full_path), self.blind_trial_id))
def save_to_db_main(a_cursor):
return_blind_trial_id = self.from_db(
blind_trial_id=self.blind_trial_id)
return_full_path = self.from_db(full_path=self.full_path)
if self == return_blind_trial_id:
return self
elif return_blind_trial_id is None and return_full_path is None:
insert_into_db(a_cursor)
return self.from_db(full_path=self.full_path)
else:
update_db_entry(a_cursor)
return self.from_db(full_path=self.full_path)
if testing:
with TestingCursor(postgresql) as cursor:
return save_to_db_main(cursor)
else:
with Cursor() as cursor:
return save_to_db_main(cursor)
def from_db(cls,
session_id=None,
reviewer_id=None,
session_score_count_id=None,
testing=False,
postgresql=None):
def by_id(a_cursor, a_session_score_count_id):
a_cursor.execute(
"SELECT * FROM session_score_counts WHERE session_score_count_id = %s;",
(a_session_score_count_id, ))
return a_cursor.fetchone()
def by_session_reviewer(a_cursor, a_session_id, a_reviewer_id):
a_cursor.execute(
"SELECT * FROM session_score_counts WHERE session_id = %s AND reviewer_id = %s;",
(a_session_id, a_reviewer_id))
return a_cursor.fetchone()
def from_db_main(a_cursor, a_session_id, a_reviewer_id,
a_session_score_count_id):
if session_score_count_id is not None:
session_score_count_data = by_id(a_cursor,
a_session_score_count_id)
elif session_id is not None and reviewer_id is not None:
session_score_count_data = by_session_reviewer(
a_cursor, a_session_id, a_reviewer_id)
else:
session_score_count_data = None
if session_score_count_data is None:
return None
a_session_score_count_id, a_session_id, a_reviewer_id, score0, score1, score2, score3, score4, score5, \
score6, score7, score8, score9, abnormal_movt_score, grooming_score = session_score_count_data
return cls(session_id=a_session_id,
reviewer_id=a_reviewer_id,
score0=score0,
score1=score1,
score2=score2,
score3=score3,
score4=score4,
score5=score5,
score6=score6,
score7=score7,
score8=score8,
score9=score9,
abnormal_movt_score=abnormal_movt_score,
grooming_score=grooming_score)
if testing:
with TestingCursor(postgresql) as cursor:
return from_db_main(cursor, session_id, reviewer_id,
session_score_count_id)
else:
with Cursor() as cursor:
return from_db_main(cursor, session_id, reviewer_id,
session_score_count_id)
def delete_from_db(self, testing=False, postgresql=None):
def delete_from_db_main(a_cursor, experiment_id):
a_cursor.execute("DELETE FROM experiments WHERE experiment_id = %s", (experiment_id,))
if testing:
with TestingCursor(postgresql) as cursor:
delete_from_db_main(cursor, self.experiment_id)
else:
with Cursor() as cursor:
delete_from_db_main(cursor, self.experiment_id)
def delete_from_db(self, testing=False, postgresql=None):
def delete_from_db_main(a_cursor):
a_cursor.execute("DELETE FROM mouse WHERE mouse_id = %s", (self.mouse_id,))
if testing:
with TestingCursor(postgresql) as cursor:
delete_from_db_main(cursor)
else:
with Cursor() as cursor:
delete_from_db_main(cursor)
def delete_from_db(self, testing=False, postgresql=None):
def delete_from_db_main(a_cursor):
a_cursor.execute(
"DELETE FROM session_score_counts WHERE session_score_count_id = %s",
(self.session_score_count_id, ))
if testing:
with TestingCursor(postgresql) as cursor:
delete_from_db_main(cursor)
else:
with Cursor() as cursor:
delete_from_db_main(cursor)
def delete_from_db(self, testing=False, postgresql=None):
def delete_from_db_main(a_cursor):
a_cursor.execute(
"DELETE FROM participant_details WHERE detail_id = %s",
(self.detail_id, ))
if testing:
with TestingCursor(postgresql) as cursor:
delete_from_db_main(cursor)
else:
with Cursor() as cursor:
delete_from_db_main(cursor)
def from_db(cls,
full_path=None,
blind_trial_id=None,
reviewer_id=None,
trial_id=None,
testing=False,
postgresql=None):
def by_full_path(a_cursor, a_full_path):
a_cursor.execute("SELECT * FROM blind_trials WHERE full_path = %s",
(a_full_path, ))
return a_cursor.fetchone()
def by_id(a_cursor, a_blind_trial_id):
a_cursor.execute(
"SELECT * FROM blind_trials WHERE blind_trial_id = %s;",
(a_blind_trial_id, ))
return a_cursor.fetchone()
def by_reviewer_trial_ids(a_cursor, a_reviewer_id, a_trial_id):
a_cursor.execute(
"SELECT * FROM blind_trials_all_upstream_ids WHERE reviewer_id = %s and trial_id = %s;",
(a_reviewer_id, a_trial_id))
return a_cursor.fetchone()
def from_db_main(a_cursor, a_full_path, a_blind_trial_id,
a_reviewer_id, a_trial_id):
a_full_path = str(a_full_path)
if a_blind_trial_id is not None:
blind_trial_data = by_id(a_cursor, a_blind_trial_id)
elif full_path is not None:
blind_trial_data = by_full_path(a_cursor, a_full_path)
elif reviewer_id is not None and trial_id is not None:
blind_trial_data = by_reviewer_trial_ids(
a_cursor, a_reviewer_id, a_trial_id)
else:
blind_trial_data = None
if blind_trial_data is None:
return None
return cls(trial_id=blind_trial_data[1],
folder_id=blind_trial_data[2],
full_path=blind_trial_data[3],
blind_trial_id=blind_trial_data[0])
if testing:
with TestingCursor(postgresql) as cursor:
return from_db_main(cursor, full_path, blind_trial_id,
reviewer_id, trial_id)
else:
with Cursor() as cursor:
return from_db_main(cursor, full_path, blind_trial_id,
reviewer_id, trial_id)
def from_db(cls,
blind_name=None,
blind_folder_id=None,
reviewer_id=None,
folder_id=None,
testing=False,
postgresql=None):
def by_reviewer_folder(a_cursor, a_reviewer_id, a_folder_id):
a_cursor.execute(
"SELECT * FROM blind_folders WHERE reviewer_id = %s AND folder_id = %s;",
(a_reviewer_id, a_folder_id))
return a_cursor.fetchone()
def by_blind_name(a_cursor, a_blind_name):
a_cursor.execute(
"SELECT * FROM blind_folders WHERE blind_name = %s;",
(a_blind_name, ))
return a_cursor.fetchone()
def by_id(a_cursor, a_blind_folder_id):
a_cursor.execute(
"SELECT * FROM blind_folders WHERE blind_folder_id = %s;",
(a_blind_folder_id, ))
return a_cursor.fetchone()
def from_db_main(a_cursor, a_blind_name, a_blind_folder_id,
a_reviewer_id, a_folder_id):
if a_blind_folder_id is not None:
blind_folder_data = by_id(a_cursor, a_blind_folder_id)
elif a_blind_name is not None:
blind_folder_data = by_blind_name(a_cursor, a_blind_name)
elif a_reviewer_id is not None and a_cursor is not None:
blind_folder_data = by_reviewer_folder(a_cursor, a_reviewer_id,
a_folder_id)
else:
blind_folder_data = None
if blind_folder_data is None:
return None
return cls(folder_id=blind_folder_data[1],
reviewer_id=blind_folder_data[2],
blind_name=blind_folder_data[3],
blind_folder_id=blind_folder_data[0])
if testing:
with TestingCursor(postgresql) as cursor:
return from_db_main(cursor, blind_name, blind_folder_id,
reviewer_id, folder_id)
else:
with Cursor() as cursor:
return from_db_main(cursor, blind_name, blind_folder_id,
reviewer_id, folder_id)
def create_views_main(db_details, main_user):
Database.initialize(database=db_details['database'],
host=db_details['host'],
port=5432,
user=main_user['user'],
password=main_user['password'])
with Cursor() as cursor:
create_view_all_participants_all_experiments(cursor)
create_view_folders_all_upstream_ids(cursor)
create_view_trials_all_upstream_ids(cursor)
create_view_blind_folders_all_upstream_ids(cursor)
create_view_blind_trials_all_upstream_ids(cursor)
create_view_trial_scores_all_ids(cursor)
def save_to_db(self, testing=False, postgresql=None):
def insert_into_db(a_cursor):
a_cursor.execute(
"INSERT INTO session_score_counts (session_id, reviewer_id, score0, score1, score2, "
"score3, score4, score5, score6, score7, score8, score9, abnormal_movt_score, "
"grooming_score) "
"VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s);",
(self.session_id, self.reviewer_id, int(self.score0),
int(self.score1), int(self.score2), int(self.score3),
int(self.score4), int(self.score5), int(self.score6),
int(self.score7), int(self.score8), int(self.score9),
int(self.abnormal_movt_score), int(self.grooming_score)))
def update_db_entry(a_cursor):
a_cursor.execute(
"UPDATE session_score_counts "
"SET (score0, score1, score2, score3, score4, score5, score6, score7, score8, score9, "
"abnormal_movt_score, grooming_score) "
" = (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s) "
"WHERE session_id = %s AND reviewer_id = %s;",
(int(self.score0), int(self.score1), int(self.score2),
int(self.score3), int(self.score4), int(self.score5),
int(self.score6), int(self.score7), int(self.score8),
int(self.score9), int(self.abnormal_movt_score),
int(self.grooming_score), self.session_id, self.reviewer_id))
def save_to_db_main(a_cursor):
if self.from_db(session_id=self.session_id,
reviewer_id=self.reviewer_id) is None:
insert_into_db(a_cursor)
return self.from_db(session_id=self.session_id,
reviewer_id=self.reviewer_id)
elif self == self.from_db(session_id=self.session_id,
reviewer_id=self.reviewer_id):
return self
else:
update_db_entry(a_cursor)
return self.from_db(session_id=self.session_id,
reviewer_id=self.reviewer_id)
if testing:
with TestingCursor(postgresql) as cursor:
return save_to_db_main(cursor)
else:
with Cursor() as cursor:
return save_to_db_main(cursor)
def from_db(cls,
trial_id=None,
reviewer_id=None,
trial_score_id=None,
testing=False,
postgresql=None):
def by_id(a_cursor, a_trial_score_id):
a_cursor.execute(
"SELECT * FROM trial_scores WHERE trial_score_id = %s;",
(a_trial_score_id, ))
return a_cursor.fetchone()
def by_trial_reviewer(a_cursor, a_trial_id, a_reviewer_id):
a_cursor.execute(
"SELECT * FROM trial_scores WHERE trial_id = %s AND reviewer_id = %s;",
(a_trial_id, a_reviewer_id))
return a_cursor.fetchone()
def from_db_main(a_cursor, a_trial_id, a_reviewer_id,
a_trial_score_id):
if trial_score_id is not None:
trial_score_data = by_id(a_cursor, a_trial_score_id)
elif trial_id is not None and reviewer_id is not None:
trial_score_data = by_trial_reviewer(a_cursor, a_trial_id,
a_reviewer_id)
else:
trial_score_data = None
if trial_score_data is None:
return None
return cls(trial_id=trial_score_data[1],
reviewer_id=trial_score_data[2],
trial_num=trial_score_data[3],
reach_score=trial_score_data[4],
abnormal_movt_score=trial_score_data[5],
grooming_score=trial_score_data[6],
trial_score_id=trial_score_data[0])
if testing:
with TestingCursor(postgresql) as cursor:
return from_db_main(cursor, trial_id, reviewer_id,
trial_score_id)
else:
with Cursor() as cursor:
return from_db_main(cursor, trial_id, reviewer_id,
trial_score_id)
def create_all_tables_main(db_details, main_user):
Database.initialize(database=db_details['database'],
host=db_details['host'],
port=5432,
user=main_user['user'],
password=main_user['password'])
with Cursor() as cursor:
cursor.execute("CREATE EXTENSION IF NOT EXISTS \"uuid-ossp\";")
create_mouse_table(cursor)
create_experiments_table(cursor)
create_participant_details_table(cursor)
create_sessions_table(cursor)
create_folders_table(cursor)
create_trials_table(cursor)
create_reviewers_table(cursor)
create_blind_folders_table(cursor)
create_blind_trials_table(cursor)
create_trial_score_table(cursor)
def save_to_db(self, testing=False, postgresql=None):
def insert_into_db(a_cursor):
a_cursor.execute(
"INSERT INTO trial_scores (trial_id, reviewer_id, trial_num, "
" reach_score, abnormal_movt_score, grooming_score) "
"VALUES (%s, %s, %s, %s, %s, %s);",
(self.trial_id, self.reviewer_id, int(self.trial_num),
int(self.reach_score), bool(
self.abnormal_movt_score), bool(self.grooming_score)))
def update_db_entry(a_cursor):
a_cursor.execute(
"UPDATE trial_scores "
"SET (trial_num, reach_score, abnormal_movt_score, grooming_score) "
" = (%s, %s, %s, %s) "
"WHERE trial_id = %s AND reviewer_id = %s;",
(int(self.trial_num), int(self.reach_score),
bool(self.abnormal_movt_score), bool(
self.grooming_score), self.trial_id, self.reviewer_id))
def save_to_db_main(a_cursor):
if self.from_db(trial_id=self.trial_id,
reviewer_id=self.reviewer_id) is None:
insert_into_db(a_cursor)
return self.from_db(trial_id=self.trial_id,
reviewer_id=self.reviewer_id)
elif self == self.from_db(trial_id=self.trial_id,
reviewer_id=self.reviewer_id):
return self
else:
update_db_entry(a_cursor)
return self.from_db(trial_id=self.trial_id,
reviewer_id=self.reviewer_id)
if testing:
with TestingCursor(postgresql) as cursor:
return save_to_db_main(cursor)
else:
with Cursor() as cursor:
return save_to_db_main(cursor)
def save_to_db(self, testing=False, postgresql=None):
def insert_into_db(a_cursor):
a_cursor.execute(
"INSERT INTO participant_details "
"(mouse_id, experiment_id, start_date, end_date, exp_spec_details, participant_dir) "
"VALUES (%s, %s, %s, %s, %s, %s);",
(self.mouse.mouse_id, self.experiment.experiment_id,
self.start_date, self.end_date, Json(
self.exp_spec_details), self.participant_dir))
def update_db_entry(a_cursor):
a_cursor.execute(
"UPDATE participant_details "
"SET (start_date, end_date, exp_spec_details, participant_dir) = (%s, %s, %s, %s) "
"WHERE detail_id = %s;",
(self.start_date, self.end_date, Json(self.exp_spec_details),
self.participant_dir, self.detail_id))
def save_to_db_main(a_cursor):
if self.from_db(self.mouse.eartag,
self.experiment.experiment_name) is None:
insert_into_db(a_cursor)
return self.from_db(self.mouse.eartag,
self.experiment.experiment_name)
elif self == self.from_db(self.mouse.eartag,
self.experiment.experiment_name):
return self
else:
update_db_entry(a_cursor)
return self.from_db(self.mouse.eartag,
self.experiment.experiment_name)
if testing:
with TestingCursor(postgresql) as cursor:
return save_to_db_main(cursor)
else:
with Cursor() as cursor:
return save_to_db_main(cursor)
def from_db(cls,
trial_dir=None,
trial_id=None,
testing=False,
postgresql=None):
def by_dir(a_cursor, a_trial_dir):
a_cursor.execute("SELECT * FROM trials WHERE trial_dir = %s",
(a_trial_dir, ))
return a_cursor.fetchone()
def by_id(a_cursor, a_trial_id):
a_cursor.execute("SELECT * FROM trials WHERE trial_id = %s",
(a_trial_id, ))
return a_cursor.fetchone()
def from_db_main(a_cursor, a_trial_dir, a_trial_id):
if a_trial_id is not None:
trial_data = by_id(a_cursor, a_trial_id)
elif a_trial_dir is not None:
trial_data = by_dir(a_cursor, a_trial_dir)
else:
trial_data = None
if trial_data is None:
return None
return cls(experiment_id=trial_data[1],
folder_id=trial_data[2],
trial_dir=trial_data[3],
trial_date=trial_data[4],
trial_id=trial_data[0])
if testing:
with TestingCursor(postgresql) as cursor:
return from_db_main(cursor, trial_dir, trial_id)
else:
with Cursor() as cursor:
return from_db_main(cursor, trial_dir, trial_id)
def list_all_blind_folder_ids(experiment):
with Cursor() as cursor:
return queries.list_all_blind_folder_ids(cursor, experiment.experiment_id)
def list_all_blind_names_for_reviewer_experiment(reviewer, experiment):
with Cursor() as cursor:
return queries.list_all_blind_names_for_reviewer_experiment(cursor, reviewer.reviewer_id,
experiment.experiment_id)
def list_all_blinded_trial_full_paths_for_reviewer_experiment(reviewer, experiment):
with Cursor() as cursor:
return queries.list_all_blind_trials_full_paths_for_reviewer_experiment(cursor, reviewer.reviewer_id,
experiment.experiment_id)
def list_all_session_dir_for_experiment(experiment):
with Cursor() as cursor:
return queries.list_all_session_dir_for_for_experiment(cursor, experiment.experiment_id)
def list_engaged_reaches_by_mouse_session():
with Cursor() as cursor:
return queries.list_engaged_reaches_by_mouse_session(cursor)
def list_all_trial_dir(experiment):
with Cursor() as cursor:
return queries.list_all_trial_dirs_for_experiment(cursor, experiment.experiment_id)
