Python Session.query方法代码示例

# 需要导入模块: from qtools.model import Session [as 别名]
# 或者: from qtools.model.Session import query [as 别名]
 def __vendor_enzymes(self, name):
     vendor = Session.query(Vendor).filter_by(name=unicode(name)).first()
     # this might be better off with a regular SQL statement
     all_enzymes = Session.query(VendorEnzyme, Enzyme.name, Enzyme.cutseq, Enzyme.methylation_sensitivity,\
                                 func.sum(VendorEnzyme.stock_units).label('total_stock_units')
                                ).join(Enzyme).filter(VendorEnzyme.vendor_id == vendor.id).group_by(VendorEnzyme.enzyme_id).all()
     return all_enzymes

# 需要导入模块: from qtools.model import Session [as 别名]
# 或者: from qtools.model.Session import query [as 别名]
 def reader_history(self, id=None, admin=True):
     box2 = self.__setup_box2_context_by_code(id)
     c.admin = admin != 'False'
     logs = Session.query(Box2Log).filter_by(box2_id=box2.id)\
                                  .order_by('time_effective desc')\
                                  .options(joinedload_all(Box2Log.circuit))\
                                  .all()
     
     statuses = Session.query(DRStatusLog).filter_by(box2_id=box2.id)\
                                          .order_by('time_effective desc')\
                                          .options(joinedload_all(DRStatusLog.reporter))\
                                          .all()
     
     fixes = Session.query(DRFixLog).filter_by(box2_id=box2.id)\
                                    .order_by('time_effective desc')\
                                    .all()
     
     log_pairs = [(logs[i].time_effective, [logs[i],(logs[i+1] if i < len(logs)-1 else None)]) for i in range(len(logs))]
     for pair in log_pairs:
         pair[1].append((sorted(box2log_mv.labeleditems(pair[1][0]).items()),
                         sorted(box2log_mv.labeleditems(pair[1][1]).items())))
     status_pairs = [(status.time_effective, status) for status in statuses]
     fix_pairs = [(fix.time_effective, fix) for fix in fixes]
     changes = log_pairs + status_pairs + fix_pairs
     c.changes = sorted(changes, key=operator.itemgetter(0))
     c.changes.reverse()
     
     return render('/admin/reader_history.html')             

# 需要导入模块: from qtools.model import Session [as 别名]
# 或者: from qtools.model.Session import query [as 别名]
def apply_template_to_plate(qlplate, dbplate):
    """
    Determine if a plate has an applicable template, either by
    explicit setting or by implicit naming.

    :param qlplate: The QLP file to read
    :param dbplate: The DB plate to update
    """
    # new-style: if plate file has plate_template_id in it,
    # just bind
    if qlplate.plate_template_id:
        template = Session.query(PlateTemplate).get(int(qlplate.plate_template_id))
        if template:
            inherit_template_attributes(dbplate, template)
            return True
    
    # otherwise, check the name
    dirname = dbplate.qlbplate.file.dirname
    basename = dbplate.qlbplate.file.basename
    complete_name = basename[:-4] # -- .qlp

    # duplicate prefixes are possible; use most recent
    templates = Session.query(PlateTemplate).order_by('prefix desc, id desc').all()
    
    for template in templates:
        if complete_name.startswith(template.prefix):
            inherit_template_attributes(dbplate, template)
            return True
    
    return False

# 需要导入模块: from qtools.model import Session [as 别名]
# 或者: from qtools.model.Session import query [as 别名]
def apply_setup_to_plate(qlplate, dbplate):
    """
    Determine if a plate has an applicable template, either by
    explicit setting or by implicit naming.

    :param qlplate: The QLP file to read
    :param dbplate: The DB plate to update
    """
    if qlplate.plate_setup_id:
        setup = Session.query(PlateSetup).get(int(qlplate.plate_setup_id))
        if setup:
            inherit_setup_attributes(dbplate, setup)
            return True
    
    dirname = dbplate.qlbplate.file.dirname
    basename = dbplate.qlbplate.file.basename
    complete_name = basename[:-4] # -- .qlp

    setups = Session.query(PlateSetup).order_by('prefix desc').all()

    for setup in setups:
        if complete_name.startswith(setup.prefix):
            inherit_setup_attributes(dbplate, setup)
            return True
    
    return False

# 需要导入模块: from qtools.model import Session [as 别名]
# 或者: from qtools.model.Session import query [as 别名]
def make_plate_name(plate, experiment_name=None):
    """
    Given a plate and assigned project, operator
    and experiment, generate a name that conforms
    to the QTools naming standard.

    Name will be project_operator_experiment.

    :param plate:
    :param experiment_name:
    :return:
    """
    # this is the hard way, before the relation is saved.
    if plate.project_id:
        project = Session.query(Project).get(plate.project_id)
        if project:
            if project.code:
                project_code = project.code
            else:
                project_code = project.name
        else:
            project_code = ''
    else:
        project_code = ''
    
    operator = Session.query(Person).get(plate.operator_id)
    if operator:
        user_code = operator.name_code
    else:
        user_code = ''
    
    
    fields = [project_code, user_code, experiment_name]
    return '_'.join([field for field in fields if field])

# 需要导入模块: from qtools.model import Session [as 别名]
# 或者: from qtools.model.Session import query [as 别名]
 def by_well_tag(self):
     well_tag_field = fl.well_tag_field(str(self.form_result['well_tag']))
     c.group_by_plate = self.form_result['group_by_plate']
     c.tag_id = self.form_result['well_tag']
     c.tag_name = Session.query(WellTag).get(c.tag_id).name
     c.form = h.LiteralFormSelectPatch(
         value = {'well_tag': well_tag_field['value'],
                  'group_by_plate': [u'1' if c.group_by_plate else u'0']},
         option = {'well_tag': [('--','--')]+well_tag_field['options'],
                   'group_by_plate': [(u'1', '')]}
     )
     
     well_tags = Session.query(WellTag).\
                         filter_by(id=c.tag_id).\
                         options(joinedload_all(WellTag.tag_wells, QLBWell.plate, QLBPlate.file, innerjoin=True),
                                 joinedload_all(WellTag.tag_wells, QLBWell.plate, QLBPlate.plate, innerjoin=True)).\
                         all()
     
     c.label_names = []
     
     if not len(well_tags):
         c.wells = []
         c.well_groups = []
     elif c.group_by_plate:
         wells = sorted(well_tags[0].wells, key=lambda well: (well.plate_id, well.well_name))
         well_groups = [(plate, list(wells)) for plate, wells in itertools.groupby(wells, lambda well: well.plate)]
         c.well_groups = sorted(well_groups, key=lambda tup: tup[0].host_datetime)
         c.well_groups.reverse()
     else:
         c.wells = sorted(well_tags[0].wells, key=lambda well: well.host_datetime)
         c.wells.reverse()
     
     return render('/box2/by_well_tag.html')

# 需要导入模块: from qtools.model import Session [as 别名]
# 或者: from qtools.model.Session import query [as 别名]
    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()

# 需要导入模块: from qtools.model import Session [as 别名]
# 或者: from qtools.model.Session import query [as 别名]
    def runs(self, id=None):
        c.dg = Session.query(DropletGenerator).get(int(id))
        if not c.dg:
            abort(404)
        
        reprocess_config_id = request.params.get('rp_id', None)
        if reprocess_config_id:
            reprocess_config_id = int(reprocess_config_id)
        
        runs = Session.query(DropletGeneratorRun).filter(
                    and_(DropletGeneratorRun.droplet_generator_id == c.dg.id,
                         DropletGeneratorRun.run_number != None)).all()
        
        run_dict = dict([(run.run_number, run) for run in runs])

        wells = Session.query(WellMetric,
                              QLBWell.id,
                              QLBWell.sample_name,
                              QLBWell.dg_run_number,
                              QLBWell.consumable_channel_num)\
                       .join(QLBWell)\
                       .join(PlateMetric)\
                       .filter(and_(QLBWell.droplet_generator_id == id,
                                    QLBWell.dg_run_number != None,
                                    PlateMetric.reprocess_config_id == reprocess_config_id))\
                       .order_by(QLBWell.dg_run_number, QLBWell.consumable_channel_num).all()
        
        sorted_runs = sorted(groupinto(wells, lambda tup: (tup[3])), key=operator.itemgetter(0))
        c.runs = [(run_id, run_dict[run_id], sorted(info, key=operator.itemgetter(4))) for run_id, info in sorted_runs if run_dict.get(run_id, None)]
        #raise Exception, c.runs
        return render('/product/dg/runs.html')

# 需要导入模块: from qtools.model import Session [as 别名]
# 或者: from qtools.model.Session import query [as 别名]
def plate_query():

    # writing it this way because the .join seems to muck up
    # filter_by statements downstream
    box2s = [tup[0] for tup in Session.query(Box2.id).all()]

    query = Session.query(Plate).filter(Plate.box2_id.in_(box2s))
    return query

# 需要导入模块: from qtools.model import Session [as 别名]
# 或者: from qtools.model.Session import query [as 别名]
    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='qtools',
                        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

# 需要导入模块: from qtools.model import Session [as 别名]
# 或者: from qtools.model.Session import query [as 别名]
    def _list_base(self):
        groove_test = Session.query(Project).filter_by(name="GrooveTest").first()
        query = Session.query(PlateSetup).filter_by(project_id=groove_test.id).order_by("time_updated desc, name")

        c.paginator = paginate.Page(query, page=int(request.params.get("page", 1)), items_per_page=20)

        c.pager_kwargs = {}
        c.plate_type_field = groove_plate_type_field()
        return render("/product/groove/list.html")

# 需要导入模块: from qtools.model import Session [as 别名]
# 或者: from qtools.model.Session import query [as 别名]
    def _algcommand_base(self):
        ags = Session.query(AnalysisGroup).filter_by(active=True).order_by(AnalysisGroup.name).all()
        rps = Session.query(ReprocessConfig).filter_by(active=True).order_by(ReprocessConfig.name).all()

        c.analysis_groups = {'value': '',
                             'options': [(ag.id, ag.name) for ag in ags]}
        c.reprocess_configs = {'value': '',
                               'options': [(rp.id, rp.name) for rp in rps]}

        return render('/product/algorithms/select.html')

# 需要导入模块: from qtools.model import Session [as 别名]
# 或者: from qtools.model.Session import query [as 别名]
def analyzed_channel_query(plate_list, channel_num):

    if not plate_list:
        # intentional empty?
        return Session.query(QLBWellChannel).filter(QLBWellChannel.id < 0)
    
    query = Session.query(QLBWellChannel).join(QLBWell, QLBPlate, Plate, Box2).\
                   filter(QLBWellChannel.channel_num == channel_num).\
                   filter(QLBWell.file_id != -1).\
                   filter(Plate.id.in_([p.id for p in plate_list])).\
                   options(joinedload_all(QLBWellChannel.well, QLBWell.plate, QLBPlate.plate, innerjoin=True))
    
    return query

# 需要导入模块: from qtools.model import Session [as 别名]
# 或者: from qtools.model.Session import query [as 别名]
    def __load_groove_setup(self, id=None):
        if not id:
            return None

        project = Session.query(Project).filter_by(name="GrooveTest").first()
        setup = Session.query(PlateSetup).get(int(id))
        if not setup:
            return None

        if setup.project_id != project.id:
            return None

        return setup

# 需要导入模块: from qtools.model import Session [as 别名]
# 或者: from qtools.model.Session import query [as 别名]
    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))