def beta_qlt(self, id=None):
c.beta = True
setup, struct = self.__load_setup(id)
if not setup:
abort(404)
quadrant = request.params.get('quadrant', None)
if not quadrant or quadrant not in ('A','B','C','D','E','F','G','H'):
abort(404)
plate_layout = struct.get('plate_layout', None)
if not plate_layout:
abort(404)
# TODO this line of code sucks (this whole thing sucks)
if plate_layout[2] in ('s', 'sh', 'sw'):
qlt_file = "%s/%s" % (config['qlb.setup_template_store'], plate_layout[0])
else:
qlt_file = "%s/%s" % (config['qlb.setup_template_store'], (plate_layout[0] % quadrant))
# figure out which plate layout to load
response.headers['Content-Type'] = 'application/quantalife-template'
h.set_download_response_header(request, response, "%s.qlt" % ("%s_%s" % (setup.prefix, quadrant)))
response.headers['Pragma'] = 'no-cache'
response.headers['Cache-Control'] = 'no-cache'
return forward(FileApp(qlt_file, response.headerlist))
def size_csv(self, id=None):
c.batch_test = self.__batch_test(id)
c.batch = self.__batch(id)
if not c.batch or not c.batch_test:
abort(404)
c.chips = defaultdict(lambda: defaultdict(lambda: None))
for chan in c.batch_test.size_channels:
c.chips[chan.chip_num - 1][chan.channel_num - 1] = chan
# print in row order
out = StringIO.StringIO()
out.write("Chip,Channel1,Channel2,Channel3,Channel4,Channel5,Channel6,Channel7,Channel8\n")
for i in range(5):
out.write("%s," % (i + 1))
out.write(",".join([str(c.chips[i][j].size_mean) if c.chips[i][j] else "" for j in range(8)]))
out.write("\n,")
out.write(",".join([str(c.chips[i][j].size_stdev) if c.chips[i][j] else "" for j in range(8)]))
out.write("\n,")
out.write(",".join([str(c.chips[i][j].droplet_count) if c.chips[i][j] else "" for j in range(8)]))
out.write("\n")
csv = out.getvalue()
response.headers["Content-Type"] = "text/csv"
h.set_download_response_header(request, response, "%s.csv" % c.batch.lot_num)
return csv
def cluster_csv(self, id=None, show_only_gated=True, *args, **kwargs):
from pyqlb.nstats.well import accepted_peaks
qlwell = self.__qlwell_from_threshold_form(id)
if show_only_gated != 'False':
peaks = accepted_peaks(qlwell)
else:
peaks = qlwell.peaks
from pyqlb.nstats.peaks import fam_amplitudes, fam_widths, vic_amplitudes, vic_widths, peak_times
from pyqlb.nstats.well import well_observed_cluster_assignments
response.headers['Content-Type'] = 'text/csv'
h.set_download_response_header(request, response, "%s_%s%s.csv" % \
(str(c.well.plate.plate.name), str(c.well.well_name), '' if show_only_gated != 'False' else '_all'))
out = StringIO.StringIO()
csvwriter = csv_pkg.writer(out)
csvwriter.writerow(['Plate',c.well.plate.plate.name])
csvwriter.writerow(['Well',c.well.well_name])
csvwriter.writerow([])
csvwriter.writerow(['Time','FAMAmplitude','FAMWidth','VICAmplitude','VICWidth','Cluster'])
csvwriter.writerow([])
pts = peak_times(peaks)
fas = fam_amplitudes(peaks)
fws = fam_widths(peaks)
vas = vic_amplitudes(peaks)
vws = vic_widths(peaks)
cls = well_observed_cluster_assignments(qlwell, peaks)
for row in zip(pts, fas, fws, vas, vws, cls):
csvwriter.writerow(row)
csv = out.getvalue()
out.close()
return csv
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 robocopy_generate(self):
self.__setup_robocopy_context()
box2 = Session.query(Box2).get(self.form_result['box2_id'])
c.src_dir = box2.src_dir
c.params = ' ' # reserve later to do QLP-only
response.content_type = 'text/cmd'
h.set_download_response_header(request, response, 'Robocopy %s.cmd' % box2.name)
return render('/box2/robocopy.mako')
def save(self):
if self.form_result['plate_setup_id']:
ps = Session.query(PlateSetup).get(self.form_result['plate_setup_id'])
prefix = ps.prefix
elif self.form_result['plate_template_id']:
pt = Session.query(PlateTemplate).get(self.form_result['plate_template_id'])
prefix = pt.prefix
else:
prefix = 'output'
response.headers['Content-Type'] = 'application/quantalife-template'
h.set_download_response_header(request, response, "%s.qlt" % prefix)
response.headers['Pragma'] = 'no-cache'
# build a plate
# TODO: add default fields
plate = ExperimentMetadataQLPlate(channel_names=['FAM','VIC'],
host_datetime=datetime.now(),
host_machine='QTools',
host_user='******',
plate_template_id=self.form_result['plate_template_id'],
plate_setup_id=self.form_result['plate_setup_id'])
for cell in sorted(self.form_result['cells'], key=lambda c: c['cell_name']):
well = ExperimentMetadataQLWell(name=cell['cell_name'],
num_channels=2,
sample=cell['sample'],
experiment_comment=cell['experiment_comment'],
experiment_name=cell['experiment_name'],
experiment_type=cell['experiment_type'],
temperature=cell['temperature'],
enzyme=cell['enzyme'],
enzyme_conc=cell['enzyme_conc'],
additive=cell['additive'],
additive_conc=cell['additive_conc'],
expected_cpd=cell['expected_cpd'],
expected_cpul=cell['expected_cpul'],
target_copy_num=cell['target_copy_num'],
ref_copy_num=cell['ref_copy_num'],
dg_cartridge=cell['cartridge'],
supermix=cell['supermix'])
well.channels[0].target = cell['fam_target']
well.channels[0].type = cell['fam_type']
well.channels[1].target = cell['vic_target']
well.channels[1].type = cell['vic_type']
plate.wells[str(cell['cell_name'])] = well
# generate QLT
# TODO: rowcol order
writer = QLTWriter(rowcol_order=self.form_result['rowcol_order'],
fgcolorfunc=self.__qlt_fgcolorfunc,
bgcolorfunc=self.__qlt_bgcolorfunc)
qlt = writer.getbytes(plate)
return qlt
def download_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)
h.set_download_response_header(request, response, thefile.name)
response.content_type = thefile.mime_type
file_path = self.__upload_file_path(c.box2, thefile.path)
response.headers['Pragma'] = 'no-cache'
response.headers['Cache-Control'] = 'no-cache'
return forward(FileApp(file_path, response.headerlist))
def validation_download(self):
plate_template = Session.query(PlateTemplate).get(self.form_result['plate_template_id'])
plate_type = Session.query(PlateType).filter_by(code=self.form_result['plate_type_code']).first()
plate_template.plate_type_id = plate_type.id
Session.commit()
response.headers['Content-Type'] = 'application/quantalife-template'
h.set_download_response_header(request, response, "%s.qlt" % plate_template.prefix)
response.headers['Pragma'] = 'no-cache'
# yeah, this is somewhat dangerous...
template_path = "%s/%s" % (config['qlb.setup_template_store'], os.path.basename(self.form_result['template_name']))
return forward(FileApp(template_path, response.headerlist))
def download(self, id=None, *args, **kwargs):
if id is None:
abort(404)
qlbwell = Session.query(QLBWell).get(id)
if not qlbwell:
abort(404)
if not qlbwell.file:
abort(404)
storage = QLStorageSource(config)
response.headers['Content-Type'] = 'application/quantalife-raw'
h.set_download_response_header(request, response, qlbwell.file.basename)
return forward(FileApp(storage.qlbwell_path(qlbwell), response.headerlist))
def peak_csv(self, id=None, show_only_gated=True, *args, **kwargs):
from qtools.lib.nstats.peaks import accepted_peaks
qlwell = self.__qlwell_from_threshold_form(id)
if show_only_gated != 'False':
peaks = accepted_peaks(qlwell)
else:
peaks = qlwell.peaks
from pyqlb.nstats.peaks import fam_amplitudes, fam_widths, fam_quality, vic_amplitudes, vic_widths, vic_quality, peak_times
response.headers['Content-Type'] = 'text/csv'
h.set_download_response_header(request, response, "%s_%s%s.csv" % \
(str(c.well.plate.plate.name), str(c.well.well_name), '' if show_only_gated != 'False' else '_all'))
out = StringIO.StringIO()
csvwriter = csv_pkg.writer(out)
csvwriter.writerow(['Plate',c.well.plate.plate.name])
csvwriter.writerow(['Well',c.well.well_name])
csvwriter.writerow([])
csvwriter.writerow(['FAMThreshold',qlwell.channels[0].statistics.threshold])
csvwriter.writerow(['VICThreshold',qlwell.channels[1].statistics.threshold])
csvwriter.writerow(['WidthGate',qlwell.channels[0].statistics.min_width_gate,qlwell.channels[0].statistics.max_width_gate])
csvwriter.writerow(['MinQualityGate',qlwell.channels[0].statistics.min_quality_gate])
csvwriter.writerow([])
csvwriter.writerow(['Time','FAMAmplitude','FAMWidth','FAMQuality','VICAmplitude','VICWidth','VICQuality'])
csvwriter.writerow([])
pts = peak_times(peaks)
fas = fam_amplitudes(peaks)
fws = fam_widths(peaks)
fqs = fam_quality(peaks)
vas = vic_amplitudes(peaks)
vws = vic_widths(peaks)
vqs = vic_quality(peaks)
for row in zip(pts, fas, fws, fqs, vas, vws, vqs):
csvwriter.writerow(row)
csv = out.getvalue()
out.close()
return csv
