def test_get_id(self):
load_exp_id = Experiment.get_id(self.seed_tup[0],
testing=True,
postgresql=self.postgresql)
load_fake_id = Experiment.get_id('Experiment Not Here',
testing=True,
postgresql=self.postgresql)
self.assertTrue(len(load_exp_id) == 1)
self.assertTrue(len(load_fake_id) == 0)
def from_db(cls, eartag, experiment_name, testing=False, postgresql=None):
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 cls.__from_db(cursor, mouse, experiment)
else:
with Cursor() as cursor:
mouse = Mouse.from_db(eartag)
experiment = Experiment.from_db(experiment_name)
return cls.__from_db(cursor, mouse, experiment)
def test_add_new_experiment(self):
test_exp = Experiment(self.seed_exp[0], self.seed_exp[1]).save_to_db(
testing=True, postgresql=self.postgresql)
self.assertEqual(util.prep_string_for_db(self.seed_exp[0]),
test_exp.experiment_name)
self.assertEqual(self.seed_exp[1], test_exp.experiment_dir)
self.assertFalse(test_exp.experiment_id is None)
def setUp(self):
self.postgresql = Postgresql()
database.handlers.handlers.handler_seed_sessions_table(self.postgresql)
[eartag, _, _, _, _, experiment_name, _, _] = test_mouse_table_seed.pop()
self.mouse = Mouse.from_db(eartag, testing=True, postgresql=self.postgresql)
self.experiment = Experiment.from_db(experiment_name, testing=True, postgresql=self.postgresql)
possible_sessions = test_session_table_seed[eartag, utils.prep_string_for_db(experiment_name)]
self.session_date, self.session_dir = possible_sessions.pop()
def setUp(self):
self.postgresql = Postgresql()
database.handlers.handlers.handler_seed_mouse(self.postgresql)
database.handlers.handlers.handler_seed_experiments(self.postgresql)
self.mouse = Mouse.from_db(9990, testing=True, postgresql=self.postgresql)
self.experiment = Experiment.from_db('test-experiment-one', testing=True, postgresql=self.postgresql)
self.session_date = 20200503
self.session_dir = '/exp/one/dir/9990/20200503_S2'
def test_from_db(self):
load_exp = Experiment.from_db(self.seed_tup[0],
testing=True,
postgresql=self.postgresql)
self.assertEqual(util.prep_string_for_db(self.seed_tup[0]),
load_exp.experiment_name)
self.assertEqual(self.seed_tup[1], load_exp.experiment_dir)
self.assertFalse(load_exp.experiment_name is None)
def test_delete_experiment(self):
experiment_to_delete = Experiment.from_db(self.seed_tup[0],
testing=True,
postgresql=self.postgresql)
experiment_to_delete.delete_from_db(testing=True,
postgresql=self.postgresql)
with TestingCursor(self.postgresql) as cursor:
all_experiments = list_all_experiments(cursor)
self.assertFalse(
util.prep_string_for_db(self.seed_tup[0]) in all_experiments)
def test_update_existing_experiment(self):
new_name = "New Experiment Name"
load_exp = Experiment.from_db(self.seed_tup[0],
testing=True,
postgresql=self.postgresql)
update_exp = load_exp
update_exp.experiment_name = new_name
saved_exp = update_exp.save_to_db(testing=True,
postgresql=self.postgresql)
self.assertEqual(util.prep_string_for_db(new_name),
saved_exp.experiment_name)
self.assertTrue(load_exp.experiment_id == saved_exp.experiment_id)
self.assertTrue(load_exp.experiment_dir == saved_exp.experiment_dir)
def test_from_db(self):
test_details = ParticipantDetails.from_db(self.mouse_seed[0],
self.mouse_seed[5],
testing=True,
postgresql=self.postgresql)
self.assertTrue(
Mouse.from_db(self.mouse_seed[0],
testing=True,
postgresql=self.postgresql) == test_details.mouse)
self.assertTrue(
Experiment.from_db(
self.mouse_seed[5], testing=True, postgresql=self.postgresql)
== test_details.experiment)
self.assertFalse(test_details.detail_id is None)
def test_add_new_participant_details(self):
test_mouse = Mouse.from_db(self.mouse_seed[0],
testing=True,
postgresql=self.postgresql)
test_exp = Experiment.from_db(self.mouse_seed[5],
testing=True,
postgresql=self.postgresql)
test_details = ParticipantDetails(
test_mouse, test_exp, self.mouse_seed[6],
self.mouse_seed[7]).save_to_db(testing=True,
postgresql=self.postgresql)
self.assertTrue(test_mouse == test_details.mouse)
self.assertTrue(test_exp == test_details.experiment)
self.assertFalse(test_details.detail_id is None)
def handler_seed_sessions_table(postgresql):
handler_seed_mouse(postgresql)
handler_seed_experiments(postgresql)
with TestingCursor(postgresql) as cursor:
for [mouse_eartag, experiment_name] in session_seed.keys():
all_sessions = session_seed[mouse_eartag, experiment_name]
mouse = Mouse.from_db(mouse_eartag,
testing=True,
postgresql=postgresql)
experiment = Experiment.from_db(experiment_name,
testing=True,
postgresql=postgresql)
for [session_date, session_dir] in all_sessions:
database.seed_tables.seed_tables.seed_sessions_table(
cursor, mouse.mouse_id, experiment.experiment_id,
utils.convert_date_int_yyyymmdd(session_date), session_dir)
def list_participants(cls, experiment_name, testing=False, postgresql=None):
def main(a_cursor, experiment_id):
a_cursor.execute("SELECT eartag FROM all_participants_all_trials "
"WHERE experiment_id = %s;", (experiment_id,))
no_dups = sorted(set(utils.list_from_cursor(cursor.fetchall())), key=int)
return no_dups
experiment = Experiment.from_db(experiment_name, testing, postgresql)
if testing:
with TestingCursor(postgresql) as cursor:
return main(cursor, experiment.experiment_id)
else:
with Cursor() as cursor:
return main(cursor, experiment.experiment_id)
def handler_seed_participant_details(postgresql):
handler_seed_mouse(postgresql)
handler_seed_experiments(postgresql)
with TestingCursor(postgresql) as cursor:
all_mice = list_all_mice(cursor)
for eartag in all_mice:
mouse = Mouse.from_db(eartag, testing=True, postgresql=postgresql)
for m in mouse_seed:
if m[0] == mouse.eartag:
experiment = Experiment.from_db(m[5],
testing=True,
postgresql=postgresql)
database.seed_tables.seed_tables.seed_participant_details(
cursor,
mouse.mouse_id,
experiment.experiment_id,
start_date=m[6],
end_date=m[7])
def list_participants(cls,
experiment_name,
testing=False,
postgresql=None):
def list_participants_main(a_cursor, exp_id):
a_cursor.execute(
"SELECT mouse_id FROM all_participants_all_experiments WHERE experiment_id = %s;",
(exp_id, ))
return utils.list_from_cursor(cursor.fetchall())
experiment_id = Experiment.get_id(experiment_name, testing, postgresql)
if len(experiment_id) == 1:
experiment_id = experiment_id[0]
else:
warnings.warn(
"Multiple experiments in the database with the same name.")
if testing:
with TestingCursor(postgresql) as cursor:
return list_participants_main(cursor, experiment_id)
else:
with Cursor() as cursor:
return list_participants_main(cursor, experiment_id)
project_base_dir = Path(__file__).parent.parent.parent
backup_csv_path = os.path.join(project_base_dir, 'data', 'database_backup_csv')
tables_to_populate = ['mouse', 'experiments', 'participant_details']
# MOUSE TABLE
all_mouses = read_table_csv_to_list(backup_csv_path, 'mouse')
for [mouse_id, eartag, birthdate, genotype, sex] in all_mouses:
eartag = int(eartag)
birthdate = ''.join(birthdate.split('-'))
Mouse(eartag, int(birthdate), genotype, sex).save_to_db()
# EXPERIMENTS TABLE
all_experiments = read_table_csv_to_list(backup_csv_path, 'experiments')
for [experiment_id, experiment_dir, experiment_name] in all_experiments:
Experiment(experiment_name, experiment_dir).save_to_db()
# PARTICIPANT DETAILS TABLE
all_participant_details = read_table_csv_to_list(backup_csv_path,
'participant_details')
for participant_detail in all_participant_details:
detail_id = participant_detail[0]
mouse_id = participant_detail[1]
experiment_id = participant_detail[2]
start_date = participant_detail[3]
start_date = int(''.join(start_date.split('-')))
end_date = participant_detail[4]
end_date = int(''.join(end_date.split('-')))
participant_dir = participant_detail[-1]
exp_spec_details = ''.join(participant_detail[5:-1])
paw_preference = None
from models.experiments import Experiment
from models.folders import Folder
from models.blind_folders import BlindFolder
from models.reviewers import Reviewer
from models.trials import Trial
from models.blind_trials import BlindTrial
import shutil
import os
Database.initialize(**dbDetails, **dbUser_Krista)
experiment_name = 'skilled-reaching'
reviewer_name = 'Krista K'
num_folders_to_mask = 25
sr_exp = Experiment.from_db(experiment_name)
all_folders = Folder.list_all_folders(sr_exp.experiment_id)
all_blind_folders = BlindFolder.list_all_blind_folders(sr_exp.experiment_id)
all_not_blind_folders = list()
for folder in all_folders:
for blind_folder in all_blind_folders:
if folder.folder_id == blind_folder.folder_id:
break
if folder.folder_id == blind_folder.folder_id:
continue
all_not_blind_folders.append(folder)
folders_to_mask = list()
for ii in range(num_folders_to_mask):
folders_to_mask.append(all_not_blind_folders.pop())
def test_duplicate_experiment(self):
test_exp = Experiment(self.seed_exp[0], self.seed_exp[1]).save_to_db(
testing=True, postgresql=self.postgresql)
dup_exp = test_exp.save_to_db(testing=True, postgresql=self.postgresql)
self.assertFalse(dup_exp.experiment_id is None)
