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 create_shotgun_process(user, norm_plate):
kappa = ReagentComposition(4)
stub = ReagentComposition(5)
shotgun_process = LibraryPrepShotgunProcess.create(
user, norm_plate, 'Test Shotgun Library %s' % datetime.now(), kappa,
stub, 4000, Plate(19), Plate(20))
shotgun_plate = shotgun_process.plates[0]
return shotgun_process, shotgun_plate
def create_shotgun_process(user, norm_plate):
kappa = ReagentComposition(4)
stub = ReagentComposition(5)
primer_a, primer_b = get_primer_plate(is_96=False)
shotgun_process = LibraryPrepShotgunProcess.create(
user, norm_plate, 'Test Shotgun Library %s' % datetime.now(), kappa,
stub, 4000, primer_a, primer_b)
shotgun_plate = shotgun_process.plates[0]
return shotgun_process, shotgun_plate
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):
plate_name = self.get_argument('plate_name')
volume = self.get_argument('volume')
plate = self.get_argument('plate')
i5_plate = self.get_argument('i5_plate')
i7_plate = self.get_argument('i7_plate')
kappa_hyper_plus_kit = self.get_argument('kappa_hyper_plus_kit')
stub_lot = self.get_argument('stub_lot')
process = LibraryPrepShotgunProcess.create(
self.current_user, Plate(plate), plate_name,
ReagentComposition.from_external_id(kappa_hyper_plus_kit),
ReagentComposition.from_external_id(stub_lot), volume,
Plate(i5_plate), Plate(i7_plate))
self.write({'process': process.id})
def post(self):
user = self.current_user
plates_info = self.get_argument('plates_info')
water = self.get_argument('water')
total_vol = self.get_argument('total_vol')
ng = self.get_argument('ng')
min_vol = self.get_argument('min_vol')
max_vol = self.get_argument('max_vol')
resolution = self.get_argument('resolution')
reformat = self.get_argument('reformat')
processes = [[
plate_id,
NormalizationProcess.create(
user,
Plate(plate_id).quantification_process,
ReagentComposition.from_external_id(water),
plate_name,
total_vol=float(total_vol),
ng=float(ng),
min_vol=float(min_vol),
max_vol=float(max_vol),
resolution=float(resolution),
reformat=reformat).id
] for plate_id, plate_name in json_decode(plates_info)]
self.write({'processes': processes})
def post(self):
user = self.current_user
plate_id = self.get_argument('plate_id')
water = self.get_argument('water')
plate_name = self.get_argument('plate_name')
total_vol = self.get_argument('total_vol')
ng = self.get_argument('ng')
min_vol = self.get_argument('min_vol')
max_vol = self.get_argument('max_vol')
resolution = self.get_argument('resolution')
reformat = self.get_argument('reformat')
qprocess = Plate(plate_id).quantification_process
process = NormalizationProcess.create(
user,
qprocess,
ReagentComposition.from_external_id(water),
plate_name,
total_vol=float(total_vol),
ng=float(ng),
min_vol=float(min_vol),
max_vol=float(max_vol),
resolution=float(resolution),
reformat=reformat)
self.write({'process': process.id})
def create_normalization_process(user, quant_process):
water = ReagentComposition(3)
norm_process = NormalizationProcess.create(
user, quant_process, water,
'Normalized test plate %s' % datetime.now())
norm_plate = norm_process.plates[0]
return norm_process, norm_plate
def post(self):
user = self.current_user
plates_info = self.get_argument('plates_info')
water = self.get_argument('water')
total_vol = self.get_argument('total_vol')
ng = self.get_argument('ng')
min_vol = self.get_argument('min_vol')
max_vol = self.get_argument('max_vol')
resolution = self.get_argument('resolution')
reformat = self.get_argument('reformat')
# NB: JavaScript uses true and false, posting converts them to strings
reformat = reformat == 'true'
processes = [[
plate_id,
NormalizationProcess.create(
user,
QuantificationProcess(quantification_process_id),
ReagentComposition.from_external_id(water),
plate_name,
total_vol=float(total_vol),
ng=float(ng),
min_vol=float(min_vol),
max_vol=float(max_vol),
resolution=float(resolution),
reformat=reformat).id
] for plate_id, plate_name, quantification_process_id in json_decode(
plates_info)]
self.write({'processes': processes})
def post(self):
user = self.current_user
plates_info = self.get_argument('plates_info')
volume = self.get_argument('volume')
kappa_hyper_plus_kit = self.get_argument('kappa_hyper_plus_kit')
stub_lot = self.get_argument('stub_lot')
processes = [[
pid,
LibraryPrepShotgunProcess.create(
user, Plate(pid), plate_name,
ReagentComposition.from_external_id(kappa_hyper_plus_kit),
ReagentComposition.from_external_id(stub_lot), volume,
Plate(i5p), Plate(i7p)).id
] for pid, plate_name, i5p, i7p in json_decode(plates_info)]
self.write({'processes': processes})
def get(self):
reagent_type = self.get_argument('reagent_type', None)
term = self.get_argument('term', None)
self.write(
json_encode(
ReagentComposition.list_reagents(reagent_type=reagent_type,
term=term)))
def test_reagent_composition_attributes(self):
obs = ReagentComposition(1)
self.assertEqual(obs.upstream_process, ReagentCreationProcess(5))
self.assertEqual(obs.container, Tube(1))
self.assertEqual(obs.total_volume, 10)
self.assertIsNone(obs.notes)
self.assertEqual(obs.composition_id, 3073)
self.assertEqual(obs.external_lot_id, '157022406')
self.assertEqual(obs.reagent_type, 'extraction kit')
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 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 test_reagent_composition_list_reagents(self):
obs = ReagentComposition.list_reagents()
exp = ['157022406', '443912', 'KHP1', 'RNBF7110', 'STUBS1']
self.assertEqual(obs, exp)
obs = ReagentComposition.list_reagents(term='39')
exp = ['443912']
self.assertEqual(obs, exp)
obs = ReagentComposition.list_reagents(reagent_type='extraction kit')
exp = ['157022406']
self.assertEqual(obs, exp)
obs = ReagentComposition.list_reagents(reagent_type='water', term='BF')
exp = ['RNBF7110']
self.assertEqual(obs, exp)
obs = ReagentComposition.list_reagents(reagent_type='water', term='22')
exp = []
self.assertEqual(obs, exp)
def test_composition_factory(self):
self.assertEqual(Composition.factory(3073), ReagentComposition(1))
self.assertEqual(Composition.factory(1537), PrimerComposition(1))
self.assertEqual(Composition.factory(1), PrimerSetComposition(1))
self.assertEqual(Composition.factory(3081), SampleComposition(1))
self.assertEqual(Composition.factory(3082), GDNAComposition(1))
self.assertEqual(Composition.factory(3083),
LibraryPrep16SComposition(1))
self.assertEqual(Composition.factory(3085),
NormalizedGDNAComposition(1))
self.assertEqual(Composition.factory(3086),
LibraryPrepShotgunComposition(1))
self.assertEqual(Composition.factory(3078), PoolComposition(1))
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 = 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):
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 test_reagent_composition_from_external_id(self):
self.assertEqual(ReagentComposition.from_external_id('157022406'),
ReagentComposition(1))
with self.assertRaises(LabmanUnknownIdError):
ReagentComposition.from_external_id('Does not exist')
