def __update_batch_plate_record(self, record):
record.dg_method = self.form_result['dg_method']
record.qc_plate = self.form_result['qc_plate'] and True or False
record.plate_notes = self.form_result['plate_notes']
record.thermal_cycler_id = self.form_result['thermal_cycler_id']
Session.add(record)
Session.commit()
def command(self):
app = self.load_wsgi_app()
min_id = 0
if len(self.args) > 1:
min_id = self.args[0]
storage = QLStorageSource(app.config)
qlbplates = Session.query(QLBPlate).filter(QLBPlate.id > min_id).order_by('id').all()
for qlbplate in qlbplates:
try:
path = storage.qlbplate_path(qlbplate)
except Exception:
print "Could not find plate: %s (%s)" % (qlbplate.plate.name if qlbplate.plate else 'Name unknown', qlbplate.id)
continue
try:
qlplate = get_plate(path)
except Exception:
print "Could not read plate: %s (%s)" % (qlbplate.plate.name if qlbplate.plate else 'Name Unknown', qlbplate.id)
continue
if qlplate.is_fam_vic:
qlbplate.dyeset = QLBPlate.DYESET_FAM_VIC
elif qlplate.is_fam_hex:
qlbplate.dyeset = QLBPlate.DYESET_FAM_HEX
elif qlplate.is_eva_green:
qlbplate.dyeset = QLBPlate.DYESET_EVA
else:
qlbplate.dyeset = QLBPlate.DYESET_UNKNOWN
print "Assigned dye %s - %s (%s)" % (qlbplate.dyeset, qlbplate.plate.name if qlbplate.plate else 'Name Unknown', qlbplate.id)
Session.commit()
def tearDown(self):
from qtools.model import Session
Session.delete(self.testUser)
Session.delete(self.testProject)
Session.delete(self.readQLP)
Session.delete(self.unreadQLP)
Session.commit()
def register_algorithm(self):
storage = QSAlgorithmSource(config)
existing_folders = [tup[0] for tup in Session.query(ReprocessConfig.original_folder).all()]
errors = dict()
src_dir = self.form_result['src_dir']
if src_dir in existing_folders:
errors['src_dir'] = 'This algorithm has already been registered.'
elif not storage.source_path_exists(src_dir):
errors['src_dir'] = 'This algorithm is not accessible in the file system.'
if self.form_result['peak_detection_version'] == (0,0):
# this is arbitrary
peak_detection_version = (0, QUANTASOFT_DIR_VERSION_RE.search(src_dir).group(1).split('_')[-1])
else:
peak_detection_version = self.form_result['peak_detection_version']
if self.form_result['peak_quantitation_version'] == (0,0):
peak_quantitation_version = (0, QUANTASOFT_DIR_VERSION_RE.search(src_dir).group(1).split('_')[-1])
else:
peak_quantitation_version = self.form_result['peak_quantitation_version']
if errors:
resp = self._algorithms_base()
defaults = AlgorithmRegisterForm.from_python(self.form_result)
return h.render_bootstrap_form(resp,
defaults=defaults,
errors=errors,
error_formatters=h.tw_bootstrap_error_formatters)
try:
rp = ReprocessConfig(name=src_dir.split(os.path.sep)[0],
code=self.form_result['code'],
peak_detection_major=peak_detection_version[0],
peak_detection_minor=peak_detection_version[1],
peak_quant_major=peak_quantitation_version[0],
peak_quant_minor=peak_quantitation_version[1],
trigger_fixed_width=100,
active=True,
cluster_mode=ReprocessConfig.CLUSTER_MODE_CLUSTER,
original_folder=src_dir)
storage.add_reprocessor(src_dir, self.form_result['code'])
Session.add(rp)
Session.commit()
session['flash'] = 'New algorithm reprocessor created.'
session.save()
return redirect(url(controller='product', action='algorithms'))
except shutil.Error:
session['flash'] = 'Could not copy source algorithm to destination.'
session['flash_class'] = 'error'
session.save()
return redirect(url(controller='product', action='algorithms'))
except IOError:
session['flash'] = "Could not access the algorithm's file system."
session['flash_class'] = 'error'
session.save()
return redirect(url(controller='product', action='algorithms'))
def command(self):
app = self.load_wsgi_app()
root = app.config['qlb.dg_root']
top_folders = app.config['qlb.top_dg_folders']
source = DGLogSource(root, top_folders)
min_file_dict = dict(Session.query(DropletGeneratorRun.dirname,
func.max(DropletGeneratorRun.basename).label('last_file')).\
group_by(DropletGeneratorRun.dirname).all())
min_file_prefix = '2011-03-21'
dgs = Session.query(DropletGenerator).all()
dg_ids = [dg.id for dg in dgs]
for dirname, basename in source.path_iter(min_file_name=min_file_prefix, min_file_dict=min_file_dict):
print dirname, basename
dg_run = read_dg_log(source.full_path(dirname, basename))
if not dg_run:
continue
dg_run.dirname = dirname
dg_run.basename = basename
if dg_run.droplet_generator_id in dg_ids:
Session.add(dg_run)
Session.commit()
def batch_plate_template_download(self, id=None):
plate = self.__load_batch_plate(id)
box2 = Session.query(Box2).get(self.form_result['box2_id'])
if not plate or not box2:
abort(404)
code = plate.batch.plate_type.code
if self.form_result['qc_plate']:
plate.qc_plate = self.form_result['qc_plate']
Session.commit()
# TODO FIXFIX or incorporate into model
if plate.qc_plate:
serial = 'QC'
else:
serial = box2.name.split(' ')[-1]
# only mfgco supported right now
if code == 'mfgco':
qlt_file = "%s/carryover.qlt" % config['qlb.setup_template_store']
elif code == 'fvtitr':
qlt_file = "%s/fvbatch_QC.qlt" % config['qlb.setup_template_store']
else:
abort(404)
response.headers['Content-Type'] = 'application/quantalife-template'
h.set_download_response_header(request, response, "%s_%s.qlt" % (serial, plate.name))
response.headers['Pragma'] = 'no-cache'
response.headers['Cache-Control'] = 'no-cache'
return forward(FileApp(qlt_file, response.headerlist))
def batch_plate_do_upload(self, id=None):
batch_plate = self.__load_batch_plate(id)
if not batch_plate:
abort(404)
box2 = self.form_result['box2']
plate = self.form_result['plate']
plate_type = batch_plate.batch.plate_type
if plate_type.code == 'fvtitr' and len(plate.analyzed_wells) == 4:
# if four wells, it's really a MFGCC (FVTITR FAM+/VIC+ should have 2)
plate_type = Session.query(PlateType).filter_by(code='mfgcc').one()
plateobj = save_plate_from_upload_request(request.POST['plate'], plate, box2, plate_type_obj=plate_type)
# I want to put this in the form validator, but it's field dependent, so not right now
if plate_type.code in ('mfgcc', 'bcc'):
ok, message = validate_colorcomp_plate(plate)
if not ok:
response = self._batch_plate_upload_base(id)
Session.rollback()
return h.render_bootstrap_form(response, errors={'plate': message})
Session.add(plateobj)
if batch_plate.batch.plate_type.code == plate_type.code:
batch_plate.plate = plateobj
else:
batch_plate.secondary_plate = plateobj
batch_plate.qc_plate = self.form_result['qc_plate']
batch_plate.plate_notes = self.form_result['plate_notes']
Session.commit()
session['flash'] = 'Plate linked.'
session.save()
return redirect(url(controller='metrics', action='per_plate', id=plateobj.id))
def batch_csfv_unhook(self):
plate = self.__load_batch_plate(self.form_result['batch_plate_id'])
plate.plate_id = None
Session.commit()
session['flash'] = 'CSFV QC plate discarded.'
session.save()
return redirect(url(controller='product', action='batch_plates', id=plate.mfg_batch_id))
def save(self, id=None):
"""
"""
if id is None:
abort(404)
assay_q = Session.query(Assay)
assay = assay_q.filter_by(id=id).first()
if assay is None:
abort(404)
reload_sequences = False
for k, v in self.form_result.items():
if k in ("primer_fwd", "primer_rev", "chromosome", "probe_pos", "amplicon_width", "snp_rsid"):
if getattr(assay, k) != v:
reload_sequences = True
if k not in ("id"):
setattr(assay, k, v)
# blow away previous sequences; on view, this will update.
if reload_sequences:
cached_sequences = assay.cached_sequences
for i in range(len(cached_sequences)):
cs = cached_sequences[-1]
snps = cs.snps
for j in range(len(snps)):
snp = snps.pop()
Session.delete(snp)
cached_sequences.pop()
Session.delete(cs)
self.__update_tms(assay)
Session.commit()
session.save()
redirect(url(controller="assay", action="view", id=assay.id))
def batch_delete(self, id=None):
batch = self.__load_batch(id)
if not batch:
abort(404)
# check for bound plates
bound_plates = [p for p in batch.plates if p.plate_id is not None]
if bound_plates:
session['flash'] = "Cannot delete this batch; there are run plates bound to it."
session['flash_class'] = 'error'
session.save()
return redirect(url(controller='product', action='batch_edit', id=id))
else:
try:
for plate in batch.plates:
Session.delete(plate)
batch.plates = []
Session.delete(batch)
Session.commit()
session['flash'] = "Batch deleted."
session.save()
except Exception, e:
logging.exception("Error from batch deletion:")
session['flash'] = "Could not delete the batch from the database."
session['flash_class'] = 'error'
session.save()
return redirect(url(controller='product', action='batch_edit', id=id))
# redirect = Exception! good to know-- don't put in try block...
return redirect(url(controller='product', action='batch_list'))
def sensitivity(self):
enz = Session.query(Enzyme).get(self.form_result['enzyme'])
if not self.form_result['sensitivity']:
enz.methylation_sensitivity = None
else:
enz.methylation_sensitivity = self.form_result['sensitivity']
Session.commit()
return "OK"
def instock(self):
enz = Session.query(VendorEnzyme).get(self.form_result['vendor_enzyme_id'])
if self.form_result['in_stock']:
enz.stock_units = 1
else:
enz.stock_units = 0
Session.commit()
return 'OK'
def enzyme_conc_create(self):
conc = EnzymeConcentration()
for k, v in self.form_result.items():
setattr(conc, k, v)
Session.add(conc)
Session.commit()
redirect(url(controller="assay", action="view", id=self.form_result["assay_id"]))
def update_reader(self):
log_entry = self.__make_box2_log_entry(self.form_result)
Session.add(log_entry)
Session.commit()
box2 = Session.query(Box2).get(self.form_result['box2_id'])
session['flash'] = 'Configuration for %s updated.' % box2.name
session.save()
redirect(url(controller='admin', action='reader_history', id=box2.code))
def save_reagents(self, id=None):
self.__load_context()
setup, struct = self.__load_setup(id)
if not setup:
abort(404)
for k, v in self.form_result.items():
setattr(setup, k, v)
Session.commit()
redirect(url(controller='setup', action='dg', id=id, beta=c.beta))
def upload_file(self, id=None):
self.__setup_box2_code_context(id)
source = QLStorageSource(config)
basename = upload_basename(self.form_result['file'].filename)
errors = {}
existing_path = self.__file_name_query(c.box2.id, basename)
if existing_path and not self.form_result['file_id'] == existing_path.id:
# todo, if existing update path
errors = dict(file='File with this name already exists for this reader. Use the Update page.')
path = "%s_%s" % (int(round(time.time())), basename)
thefile = self.form_result['file'].file
filerec = self.__file_id_query(c.box2.id, self.form_result['file_id'])
new_record = False
if not filerec:
filerec = Box2File(box2_id=c.box2.id)
new_record = True
filerec.name = basename
filerec.deleted = False
filerec.path = path
filerec.updated = datetime.datetime.now()
filerec.description = self.form_result['description']
filerec.mime_type = guess_type(basename)[0] or 'text/plain'
if errors:
response = self._upload_base(id)
return h.render_bootstrap_form(response, errors=errors, error_formatters=h.tw_bootstrap_error_formatters)
try:
attachment_dir = self.__upload_file_dir(c.box2)
if not os.path.exists(attachment_dir):
os.mkdir(attachment_dir)
permanent_path = self.__upload_file_path(c.box2, path)
permanent_file = open(permanent_path, 'wb')
shutil.copyfileobj(thefile, permanent_file)
thefile.close()
permanent_file.close()
filerec.size = os.stat(permanent_path).st_size
if new_record:
Session.add(filerec)
else:
Session.merge(filerec)
Session.commit()
session['flash'] = 'File uploaded.'
write_success = True
except Exception, e:
session['flash'] = 'Could not upload file: %s' % str(e)
session['flash_class'] = 'error'
write_success = False
def donotrun(self, id=None):
c.beta = True
setup, struct = self.__load_setup(id)
if not setup:
abort(404)
setup.donotrun = True
Session.commit()
session['flash'] = "Marked %s as skipped." % setup.name
session.save()
redirect(url(controller='setup', action='list', beta=c.beta))
def __save_setup(self, setup, key, block):
setup_obj = json.loads(setup.setup or '{}')
# Hack.
if type(block) == type(dict()) and block.get('notes', None) is not None:
notes = block.pop('notes')
setup.notes = notes
setup_obj[key] = block
setup.setup = json.dumps(setup_obj)
if key == 'progress':
setup.completed = (self.__check_progress(setup_obj) == 'Done')
Session.commit()
def create(self):
self.__load_context()
plate_setup = PlateSetup()
plate_setup.project_id = self.form_result['project_id']
plate_setup.author_id = self.form_result['author_id']
plate_setup.name = self.form_result['name']
plate_setup.prefix = make_setup_name(plate_setup)
Session.add(plate_setup)
Session.commit()
redirect(url(controller='setup', action='consumable', id=plate_setup.id, beta=c.beta))
def delete_file(self, id=None):
self.__setup_box2_code_context(id)
thefile = self.__file_id_query(c.box2.id, self.form_result['file_id'])
if not thefile:
abort(404)
Session.delete(thefile)
Session.commit()
session['flash'] = 'File deleted.'
session.save()
return redirect(url(controller='metrics', action='certification', id=c.box2.code))
def update(self, id=None):
batch = self.__batch(id)
batch.manufacturer = self.form_result["manufacturer"]
batch.insert = self.form_result["insert"]
batch.consumable_molding_style_id = self.form_result["molding_style"]
batch.consumable_bonding_style_id = self.form_result["bonding_style"]
batch.manufacturing_date = self.form_result["manufacture_date"]
batch.bside = self.form_result["bside"]
Session.commit()
session.flash = "Updated batch %s" % batch.lot_num
return redirect(url(controller="consumable", action="details", id=batch.id))
def save_name(self, id=None):
self.__load_context()
setup, struct = self.__load_setup(id)
if not setup:
abort(404)
for k, v in self.form_result.items():
setattr(setup, k, v)
setup.prefix = make_setup_name(setup)
Session.commit()
redirect(url(controller='setup', action='consumable', id=id, beta=c.beta))
def command(self):
self.load_wsgi_app()
unknown_plates = Session.query(QLBPlate).filter(QLBPlate.plate == None)
for qlbplate in unknown_plates:
try:
plate = plate_from_qlp(qlbplate)
Session.add(plate)
qlbplate.plate = plate
Session.commit()
except Exception:
Session.rollback()
def tearDown(self):
Session.rollback() # catches pending changes
Session.delete(self.plateTemplate)
Session.delete(self.shortTemplate)
Session.delete(self.qlbPlate)
Session.delete(self.plateVariant)
Session.delete(self.unknownPlate)
Session.delete(self.nameVariant)
Session.delete(self.unknownName)
Session.commit()
super(TestNamePlate, self).tearDown()
def update_size(self, id=None):
batch = self.__batch(id)
if not batch:
abort(404)
batch_test = self.__batch_test(id)
if not batch_test:
batch_test = ConsumableBatchTest(consumable_batch_id=batch.id)
Session.add(batch_test)
batch_test.pixel_calibration = self.form_result["pixel_calibration"]
garbage = []
# check for cleared entities first
for chan in batch_test.size_channels:
thechip = [chip for chip in self.form_result["chips"] if chip["chip_num"] == chan.chip_num]
if not thechip:
garbage.append(chan)
continue
thechan = [c for c in thechip[0]["channels"] if c["channel_num"] == chan.channel_num]
if not thechan:
garbage.append(chan)
continue
if thechan[0]["droplet_count"] is None and thechan[0]["mean"] is None and thechan[0]["stdev"] is None:
garbage.append(chan)
for g in garbage:
batch_test.size_channels.remove(g)
Session.delete(g)
# This is the case for a GAE-like Entity or a Mongo object or storing
# JSON in a text column or whatever
for chip in self.form_result["chips"]:
for channel in chip["channels"]:
if channel["droplet_count"] is not None or channel["mean"] is not None or channel["stdev"] is not None:
dbchan = batch_test.size_channel(chip["chip_num"], channel["channel_num"])
if not dbchan:
dbchan = ConsumableBatchSizeChannel(
chip_num=chip["chip_num"], channel_num=channel["channel_num"]
)
batch_test.size_channels.append(dbchan)
dbchan.size_mean = channel["mean"]
dbchan.size_stdev = channel["stdev"]
dbchan.droplet_count = channel["droplet_count"]
Session.commit()
session["flash"] = "Sizes updated."
session.save()
return redirect(url(controller="consumable", action="size", id=batch.id))
def command(self):
self.load_wsgi_app()
qlbplates = Session.query(QLBPlate).\
filter(and_(QLBPlate.file_id != None, QLBPlate.plate_id != None)).\
order_by(desc(QLBPlate.id)).\
options(joinedload_all(QLBPlate.plate, innerjoin=True))
for qlbplate in qlbplates:
qlbplate.plate.score = Plate.compute_score(qlbplate.plate)
print "%s: %s points" % (qlbplate.plate.id, qlbplate.plate.score)
Session.commit()
def enzyme_conc_delete(self, id=None):
if id is None:
abort(404)
conc = Session.query(EnzymeConcentration).get(id)
if not conc:
abort(404)
assay_id = conc.assay_id
Session.delete(conc)
Session.commit()
redirect(url(controller="assay", action="view", id=assay_id))
def unreject(self, id=None):
if id is None:
abort(404)
assay = Session.query(Assay).get(id)
if not assay:
abort(404)
assay.rejected = False
Session.commit()
session["flash"] = "Assay marked as valid."
session.save()
redirect(url(controller="assay", action="view", id=id))
def save_cycler(self, id=None):
self.__load_context()
setup, struct = self.__load_setup(id)
if not setup:
abort(404)
for k, v in self.form_result.items():
setattr(setup, k, v)
Session.commit()
if c.beta:
redirect(url(controller='setup', action='plan', id=id, beta=c.beta))
else:
redirect(url(controller='setup', action='reader', id=id, beta=c.beta))
def delete(self, id=None):
"""
"""
if id is None:
abort(404)
assay_q = Session.query(Assay)
assay = assay_q.filter_by(id=id).first()
if assay:
Session.delete(assay)
Session.commit()
session["flash"] = "Assay deleted."
session.save()
redirect(url(controller="assay", action="list"))
