def test_list_equipment(self):
obs = Equipment.list_equipment()
# Since we are creating equipment in another test, limit the list to
# those that are already in the test DB
obs = obs[:18]
exp = [{'equipment_id': 1, 'external_id': 'Echo550'},
{'equipment_id': 2, 'external_id': 'BUZZ'},
{'equipment_id': 3, 'external_id': 'STINGER'},
{'equipment_id': 4, 'external_id': 'PRICKLY'},
{'equipment_id': 5, 'external_id': 'LUCY'},
{'equipment_id': 6, 'external_id': 'ROB-E'},
{'equipment_id': 7, 'external_id': 'RIK-E'},
{'equipment_id': 8, 'external_id': 'JER-E'},
{'equipment_id': 9, 'external_id': 'HOWE'},
{'equipment_id': 10, 'external_id': 'Carmen'},
{'equipment_id': 11, 'external_id': 'KF1'},
{'equipment_id': 12, 'external_id': 'KF2'},
{'equipment_id': 13, 'external_id': 'KF3'},
{'equipment_id': 14, 'external_id': 'KF4'},
{'equipment_id': 15, 'external_id': '108379Z'},
{'equipment_id': 16, 'external_id': '109375A'},
{'equipment_id': 17, 'external_id': '311411B'}]
self.assertEqual(obs[:-1], exp)
obs = Equipment.list_equipment('echo')
exp = [{'equipment_id': 1, 'external_id': 'Echo550'}]
self.assertEqual(obs, exp)
obs = Equipment.list_equipment('mosquito')
exp = [{'equipment_id': 2, 'external_id': 'BUZZ'},
{'equipment_id': 3, 'external_id': 'STINGER'},
{'equipment_id': 4, 'external_id': 'PRICKLY'}]
self.assertEqual(obs, exp)
def post(self):
plates_info = self.get_argument('plates_info')
volume = self.get_argument('volume')
preparation_date = self.get_argument('preparation_date')
month, day, year = map(int, preparation_date.split('/'))
preparation_date = date(year, month, day)
processes = [
LibraryPrep16SProcess.create(
self.current_user,
Plate(pid),
Plate(pp),
pn,
Equipment(ep),
Equipment(ep300),
Equipment(ep50),
ReagentComposition.from_external_id(mm),
ReagentComposition.from_external_id(w),
volume,
preparation_date=preparation_date).id
for pid, pn, pp, ep, ep300, ep50, mm, w in json_decode(plates_info)
]
self.write({'processes': processes})
def get(self):
plate_ids = self.get_arguments('plate_id')
robots = Equipment.list_equipment('EpMotion')
tools = Equipment.list_equipment('tm 1000 8 channel pipette head')
self.render('extraction.html',
plate_ids=plate_ids,
robots=robots,
tools=tools)
def get(self):
plate_ids = self.get_arguments('plate_id')
process_id = self.get_argument('process_id', None)
gdna_plate = None
epmotion = None
epmotion_tm300 = None
epmotion_tm50 = None
primer_plate = None
master_mix = None
water_lot = None
volume = None
prep_date = None
if process_id is not None:
try:
process = LibraryPrep16SProcess(process_id)
except LabmanUnknownIdError:
raise HTTPError(404,
reason="Amplicon process %s doesn't exist" %
process_id)
gdna_plate = process.gdna_plate.id
epmotion = process.epmotion.id
epmotion_tm300 = process.epmotion_tm300_tool.id
epmotion_tm50 = process.epmotion_tm50_tool.id
master_mix = process.mastermix.external_lot_id
water_lot = process.water_lot.external_lot_id
primer_plate = process.primer_plate.id
volume = process.volume
prep_date = process.date.strftime(process.get_date_format())
robots = Equipment.list_equipment('EpMotion')
tools_tm300_8 = Equipment.list_equipment(
'tm 300 8 channel pipette head')
tools_tm50_8 = Equipment.list_equipment('tm 50 8 channel pipette head')
primer_plates = []
for pp in Plate.list_plates(['primer']):
plate = Plate(pp['plate_id'])
if plate.process.primer_set.target_name == 'Amplicon':
primer_plates.append(pp)
self.render('library_prep_16S.html',
plate_ids=plate_ids,
robots=robots,
tools_tm300_8=tools_tm300_8,
tools_tm50_8=tools_tm50_8,
primer_plates=primer_plates,
process_id=process_id,
gdna_plate=gdna_plate,
epmotion=epmotion,
epmotion_tm300=epmotion_tm300,
epmotion_tm50=epmotion_tm50,
master_mix=master_mix,
water_lot=water_lot,
primer_plate=primer_plate,
preparationDate=prep_date,
volume=volume)
def create_gdna_extraction_process(user, plate):
kingfisher = Equipment(11)
epmotion = Equipment(6)
epmotion_tool = Equipment(15)
extraction_kit = ReagentComposition(1)
ext_process = GDNAExtractionProcess.create(
user, plate, kingfisher, epmotion, epmotion_tool, extraction_kit, 100,
'GDNA test plate %s' % datetime.now())
gdna_plate = ext_process.plates[0]
return ext_process, gdna_plate
def get(self):
plate_ids = self.get_arguments('plate_id')
robots = Equipment.list_equipment('EpMotion')
tools_tm300_8 = Equipment.list_equipment(
'tm 300 8 channel pipette head')
tools_tm50_8 = Equipment.list_equipment('tm 50 8 channel pipette head')
primer_plates = Plate.list_plates('primer')
self.render('library_prep_16S.html',
plate_ids=plate_ids,
robots=robots,
tools_tm300_8=tools_tm300_8,
tools_tm50_8=tools_tm50_8,
primer_plates=primer_plates)
def create_amplicon_prep(user, plate):
primer_plate = Plate(11)
epmotion = Equipment(6)
master_mix = ReagentComposition(2)
water_lot = ReagentComposition(3)
epmotion_tool_tm300 = Equipment(16)
epmotion_tool_tm50 = Equipment(17)
amplicon_process = LibraryPrep16SProcess.create(
user, plate, primer_plate, 'Amplicon test plate %s' % datetime.now(),
epmotion, epmotion_tool_tm300, epmotion_tool_tm50, master_mix,
water_lot, 75,)
amplicon_plate = amplicon_process.plates[0]
return amplicon_process, amplicon_plate
def post(self):
robot = self.get_argument('robot')
tool = self.get_argument('tool')
kit = self.get_argument('kit')
plates = self.get_argument('plates')
volume = self.get_argument('volume')
plates = [Plate(pid) for pid in json_decode(plates)]
process = GDNAExtractionProcess.create(
self.current_user, Equipment(robot), Equipment(tool),
ReagentComposition.from_external_id(kit), plates, volume)
self.write({'process': process.id})
def post(self):
plates_info = json_decode(self.get_argument('plates-info'))
results = []
for pinfo in plates_info:
plate_result = self._compute_pools(pinfo)
plate = Plate(plate_result['plate_id'])
pool_name = 'Pool from plate %s (%s)' % (
plate.external_id,
datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
# create input molar percentages
pcts = calc_pool_pcts(plate_result['comp_vals'],
plate_result['pool_vals'])
quant_process = plate.quantification_process
input_compositions = []
for comp, _, _ in quant_process.concentrations:
well = comp.container
row = well.row - 1
column = well.column - 1
input_compositions.append(
{'composition': comp,
'input_volume': plate_result['pool_vals'][row][column],
'percentage_of_output': pcts[row][column]})
robot = (Equipment(plate_result['robot'])
if plate_result['robot'] is not None else None)
process = PoolingProcess.create(
self.current_user, quant_process, pool_name,
plate_result['pool_vals'].sum(), input_compositions,
plate_result['func_data'], robot=robot,
destination=plate_result['destination'])
results.append({'plate-id': plate.id, 'process-id': process.id})
self.write(json_encode(results))
def create_sequencing_process(user, pools):
seq_process = SequencingProcess.create(
user, pools, 'New sequencing run %s' % datetime.now(),
'Run experiment %s' % datetime.now(), Equipment(18), 151, 151,
User('*****@*****.**'),
contacts=[User('*****@*****.**'), User('*****@*****.**')])
return seq_process
def get(self):
plate_ids = self.get_arguments('plate_id')
process_id = self.get_argument('process_id', None)
kingfisher = None
epmotion = None
epmotion_tool = None
extraction_kit = None
sample_plate = None
externally_extracted = False
volume = None
ext_date = None
notes = None
if process_id is not None:
try:
process = GDNAExtractionProcess(process_id)
except LabmanUnknownIdError:
raise HTTPError(404,
reason="Extraction process %s doesn't exist" %
process_id)
kingfisher = process.kingfisher.id
epmotion = process.epmotion.id
epmotion_tool = process.epmotion_tool.id
extraction_kit = process.extraction_kit.external_lot_id
sample_plate = process.sample_plate.id
externally_extracted = process.externally_extracted
volume = process.volume
ext_date = process.date.strftime(process.get_date_format())
notes = process.notes
ep_robots = Equipment.list_equipment('EpMotion')
kf_robots = Equipment.list_equipment('King Fisher')
tools = Equipment.list_equipment('tm 1000 8 channel pipette head')
self.render('extraction.html',
plate_ids=plate_ids,
kf_robots=kf_robots,
ep_robots=ep_robots,
tools=tools,
process_id=process_id,
kingfisher=kingfisher,
epmotion=epmotion,
epmotion_tool=epmotion_tool,
extraction_kit=extraction_kit,
sample_plate=sample_plate,
externally_extracted=externally_extracted,
volume=volume,
extraction_date=ext_date,
notes=notes)
def get(self):
plate_ids = self.get_arguments('plate_id')
process_id = self.get_argument('process_id', None)
input_plate = None
pool_func_data = None
pool_values = []
pool_blanks = []
plate_names = []
plate_type = None
if process_id is not None:
try:
process = PoolingProcess(process_id)
except LabmanUnknownIdError:
raise HTTPError(404, reason="Pooling process %s doesn't exist"
% process_id)
plate = process.components[0][0].container.plate
input_plate = plate.id
pool_func_data = process.pooling_function_data
_, pool_values, pool_blanks, plate_names = \
make_2D_arrays(plate, process.quantification_process)
pool_values = pool_values.tolist()
pool_blanks = pool_blanks.tolist()
plate_names = plate_names.tolist()
elif len(plate_ids) > 0:
content_types = {type(Plate(pid).get_well(1, 1).composition)
for pid in plate_ids}
if len(content_types) > 1:
raise HTTPError(400, reason='Plates contain different types '
'of compositions')
plate_type = ('16S library prep'
if content_types.pop() == LibraryPrep16SComposition
else 'shotgun library prep')
robots = (Equipment.list_equipment('EpMotion') +
Equipment.list_equipment('echo'))
self.render('library_pooling.html', plate_ids=plate_ids,
robots=robots, pool_params=HTML_POOL_PARAMS,
input_plate=input_plate, pool_func_data=pool_func_data,
process_id=process_id, pool_values=pool_values,
plate_type=plate_type, pool_blanks=pool_blanks,
plate_names=plate_names)
def post(self):
master_mix = self.get_argument('master_mix')
water = self.get_argument('water')
robot = self.get_argument('robot')
tm300_8_tool = self.get_argument('tm300_8_tool')
tm50_8_tool = self.get_argument('tm50_8_tool')
volume = self.get_argument('volume')
plates = self.get_argument('plates')
plates = [(Plate(pid), Plate(ppid))
for pid, ppid in json_decode(plates)]
process = LibraryPrep16SProcess.create(
self.current_user, ReagentComposition.from_external_id(master_mix),
ReagentComposition.from_external_id(water), Equipment(robot),
Equipment(tm300_8_tool), Equipment(tm50_8_tool), volume, plates)
self.write({'process': process.id})
def get(self):
sequencers = []
for model, lanes in SequencingProcess.sequencer_lanes.items():
for sequencer in Equipment.list_equipment(model):
sequencer['lanes'] = lanes
sequencers.append(sequencer)
self.render('sequencing.html',
users=User.list_users(),
sequencers=sequencers)
def test_create(self):
# This tests the create type, create function and accessing the
# attributes
Equipment.create_type('Test Equipment Type')
obs = Equipment.create('Test Equipment Type', 'New Equipment')
self.assertEqual(obs.external_id, 'New Equipment')
self.assertEqual(obs.equipment_type, 'Test Equipment Type')
self.assertIsNone(obs.notes)
obs.notes = 'New notes'
self.assertEqual(obs.notes, 'New notes')
# Test creation failure due to non-existent type
self.assertRaises(LabmanUnknownIdError, Equipment.create,
'Non-existent Equipment Type', 'New Equipment 2')
# Test creation failure due to duplicated external id
self.assertRaises(LabmanDuplicateError, Equipment.create,
'Test Equipment Type', 'New Equipment')
def test_list_equipment_types(self):
obs = Equipment.list_equipment_types()
exp = [
'echo', 'EpMotion', 'HiSeq1500', 'HiSeq2500', 'HiSeq3000',
'HiSeq4000', 'King Fisher', 'MiniSeq', 'MiSeq', 'mosquito',
'NextSeq', 'Not applicable', 'NovaSeq',
'tm 1000 8 channel pipette head', 'tm 300 8 channel pipette head',
'tm 50 8 channel pipette head'
]
self.assertEqual(obs, exp)
def test_create(self):
# This tests the create type, create function and accessing the
# attributes
try:
Equipment.create_type('Test Equipment Type')
# Test type creation failure due to duplicated description
self.assertRaises(LabmanDuplicateError, Equipment.create_type,
'Test Equipment Type')
obs = Equipment.create('Test Equipment Type', 'New Equipment')
self.assertEqual(obs.external_id, 'New Equipment')
self.assertEqual(obs.equipment_type, 'Test Equipment Type')
self.assertIsNone(obs.notes)
obs.notes = 'New notes'
self.assertEqual(obs.notes, 'New notes')
# Test creation failure due to non-existent type
self.assertRaises(LabmanUnknownIdError, Equipment.create,
'Non-existent Equipment Type', 'New Equipment 2')
# Test creation failure due to duplicated external id
self.assertRaises(LabmanDuplicateError, Equipment.create,
'Test Equipment Type', 'New Equipment')
finally:
# not in TearDown as this clean-up is specific to this test only;
# running sql directly on the db from a test isn't pretty, but it
# is still preferable to interdependence between tests.
# Deletes both values that should have been added to db as well
# as values whose add should have failed (just in case this test
# failed by not preventing those additions).
with sql_connection.TRN as TRN:
sql = """DELETE
FROM labman.equipment
WHERE external_id in
('New Equipment', 'New Equipment 2');
DELETE
FROM labman.equipment_type
WHERE description in ('Test Equipment Type',
'Non-existent Equipment Type');"""
TRN.add(sql)
TRN.execute()
def post(self):
plates_info = self.get_argument('plates_info')
extraction_date = self.get_argument('extraction_date')
volume = self.get_argument('volume')
month, day, year = map(int, extraction_date.split('/'))
extraction_date = date(year, month, day)
plates_info = [
(Plate(pid), Equipment(kf), Equipment(ep), Equipment(ept),
ReagentComposition.from_external_id(kit), p_name)
for pid, kf, ep, ept, kit, p_name in json_decode(plates_info)
]
process = GDNAExtractionProcess.create(self.current_user,
plates_info,
volume,
extraction_date=extraction_date)
self.write({'process': process.id})
def post(self):
plates = self.get_argument('plates')
plate_ext_id = self.get_argument('plate_ext_id')
robot = self.get_argument('robot')
plates = [Plate(pid) for pid in json_decode(plates)]
process = GDNAPlateCompressionProcess.create(self.current_user, plates,
plate_ext_id,
Equipment(robot))
self.write({'process': process.id})
def create_plate_pool_process(user, quant_process, plate, func_data):
input_compositions = []
echo = Equipment(8)
for well in chain.from_iterable(plate.layout):
if well is not None:
input_compositions.append({
'composition': well.composition, 'input_volume': 1,
'percentage_of_output': 1/9.0})
pool_process = PoolingProcess.create(
user, quant_process, 'New test pool name %s' % datetime.now(),
4, input_compositions, func_data, robot=echo)
return pool_process
def post(self):
plates_info = self.get_argument('plates_info')
extraction_date = self.get_argument('extraction_date')
volume = self.get_argument('volume')
month, day, year = map(int, extraction_date.split('/'))
extraction_date = date(year, month, day)
# We create one process per plate
processes = []
for pid, ee, kf, ep, ept, kit, p_name, nt in json_decode(plates_info):
# Check whether plate was externally extracted
if ee is True:
# find the id of null things
eq_no = \
Equipment.list_equipment('Not applicable')[0]['equipment_id']
ep = ept = kf = Equipment(eq_no)
kit = ReagentComposition.from_external_id('Not applicable')
else:
kf = Equipment(kf)
ep = Equipment(ep)
ept = Equipment(ept)
kit = ReagentComposition.from_external_id(kit)
processes.append(
GDNAExtractionProcess.create(self.current_user,
Plate(pid),
kf,
ep,
ept,
kit,
volume,
p_name,
externally_extracted=ee,
extraction_date=extraction_date,
notes=nt).id)
self.write({'processes': processes})
def post(self):
pool_id = self.get_argument('pool')
run_name = self.get_argument('run_name')
sequencer_id = self.get_argument('sequencer')
fwd_cycles = int(self.get_argument('fwd_cycles'))
rev_cycles = int(self.get_argument('rev_cycles'))
assay = self.get_argument('assay')
pi = self.get_argument('principal_investigator')
c0 = self.get_argument('contact_0')
c1 = self.get_argument('contact_1')
c2 = self.get_argument('contact_2')
process = SequencingProcess.create(
self.current_user, PoolComposition(pool_id), run_name,
Equipment(sequencer_id), fwd_cycles, rev_cycles, assay,
User(pi), User(c0), User(c1), User(c2))
self.write({'process': process.id})
def post(self):
pools = self.get_argument('pools')
run_name = self.get_argument('run_name')
experiment = self.get_argument('experiment')
sequencer_id = self.get_argument('sequencer')
fwd_cycles = int(self.get_argument('fwd_cycles'))
rev_cycles = int(self.get_argument('rev_cycles'))
pi = self.get_argument('principal_investigator')
contacts = self.get_argument('additional_contacts')
pools = [PoolComposition(x) for x in json_decode(pools)]
contacts = [User(x) for x in json_decode(contacts)]
process = SequencingProcess.create(self.current_user, pools,
run_name, experiment,
Equipment(sequencer_id), fwd_cycles,
rev_cycles, User(pi), contacts)
self.write({'process': process.id})
def get(self):
plate_ids = self.get_arguments('plate_id')
process_id = self.get_argument('process_id', None)
input_plate = None
pool_func_data = None
pool_values = []
plate_type = None
if process_id is not None:
try:
process = PoolingProcess(process_id)
except LabmanUnknownIdError:
raise HTTPError(404, reason="Pooling process %s doesn't exist"
% process_id)
plate = process.components[0][0].container.plate
input_plate = plate.id
pool_func_data = process.pooling_function_data
pool_values = make_2D_arrays(
plate, plate.quantification_process)[1].tolist()
if pool_func_data['function'] == 'amplicon':
pool_func_data['parameters']['epmotion-'] = process.robot.id
pool_func_data['parameters'][
'dest-tube-'] = process.destination
elif len(plate_ids) > 0:
content_types = {type(Plate(pid).get_well(1, 1).composition)
for pid in plate_ids}
if len(content_types) > 1:
raise HTTPError(400, reason='Plates contain different types '
'of compositions')
plate_type = ('16S library prep'
if content_types.pop() == LibraryPrep16SComposition
else 'shotgun library prep')
epmotions = Equipment.list_equipment('EpMotion')
self.render('library_pooling.html', plate_ids=plate_ids,
epmotions=epmotions, pool_params=HTML_POOL_PARAMS,
input_plate=input_plate, pool_func_data=pool_func_data,
process_id=process_id, pool_values=pool_values,
plate_type=plate_type)
def get(self):
plate_ids = self.get_arguments('plate_id')
process_id = self.get_argument('process_id', None)
plate_name = None
robot = None
gdna_plates = []
if process_id is not None:
try:
process = GDNAPlateCompressionProcess(process_id)
except LabmanUnknownIdError:
raise HTTPError(404,
reason="Compression process %s doesn't "
"exist" % process_id)
plate_name = process.plates[0].external_id
robot = process.robot.id
gdna_plates = [p.id for p in process.gdna_plates]
robots = Equipment.list_equipment('EpMotion')
self.render('compression.html',
plate_ids=plate_ids,
robots=robots,
plate_name=plate_name,
robot=robot,
gdna_plates=gdna_plates,
process_id=process_id)
def get(self):
plate_ids = self.get_arguments('plate_id')
epmotions = Equipment.list_equipment('EpMotion')
self.render('library_pooling.html', plate_ids=plate_ids,
epmotions=epmotions, pool_params=HTML_POOL_PARAMS)
def test_create_type_error(self):
# Type creatio failure: duplicate
Equipment.create_type('Test create type')
self.assertRaises(LabmanDuplicateError, Equipment.create_type,
'Test create type')
def create_compression_process(user, gdna_plates):
comp_process = GDNAPlateCompressionProcess.create(
user, gdna_plates, 'Compressed test plate %s' % datetime.now(),
Equipment(6))
compressed_plate = comp_process.plates[0]
return comp_process, compressed_plate
def test_list_equipment(self):
obs = Equipment.list_equipment()
exp = [{
'equipment_id': 15,
'external_id': '108379Z'
}, {
'equipment_id': 16,
'external_id': '109375A'
}, {
'equipment_id': 17,
'external_id': '311411B'
}, {
'equipment_id': 2,
'external_id': 'BUZZ'
}, {
'equipment_id': 10,
'external_id': 'Carmen'
}, {
'equipment_id': 1,
'external_id': 'Echo550'
}, {
'equipment_id': 9,
'external_id': 'HOWE'
}, {
'equipment_id': 19,
'external_id': 'IGM-HiSeq4000'
}, {
'equipment_id': 8,
'external_id': 'JER-E'
}, {
'equipment_id': 11,
'external_id': 'KF1'
}, {
'equipment_id': 12,
'external_id': 'KF2'
}, {
'equipment_id': 13,
'external_id': 'KF3'
}, {
'equipment_id': 14,
'external_id': 'KF4'
}, {
'equipment_id': 18,
'external_id': 'KL-MiSeq'
}, {
'equipment_id': 5,
'external_id': 'LUCY'
}, {
'equipment_id': 20,
'external_id': 'Not applicable'
}, {
'equipment_id': 4,
'external_id': 'PRICKLY'
}, {
'equipment_id': 7,
'external_id': 'RIK-E'
}, {
'equipment_id': 6,
'external_id': 'ROB-E'
}]
self.assertEqual(obs[:-1], exp)
obs = Equipment.list_equipment('echo')
exp = [{'equipment_id': 1, 'external_id': 'Echo550'}]
self.assertEqual(obs, exp)
obs = Equipment.list_equipment('mosquito')
exp = [{
'equipment_id': 2,
'external_id': 'BUZZ'
}, {
'equipment_id': 4,
'external_id': 'PRICKLY'
}, {
'equipment_id': 3,
'external_id': 'STINGER'
}]
self.assertEqual(obs, exp)
def get(self):
pools = [[p['pool_composition_id'], p['external_id']]
for p in PoolComposition.list_pools()]
sequencers = Equipment.list_equipment('miseq')
self.render('sequencing.html', users=User.list_users(), pools=pools,
sequencers=sequencers)
