class AntibodyPrep(db.Model, MGIModel): __tablename__ = "gxd_antibodyprep" _antibodyprep_key = db.Column(db.Integer, primary_key=True) _antibody_key = db.Column(db.Integer, mgi_fk("gxd_antibody._antibody_key")) _secondary_key = db.Column(db.Integer) _label_key = db.Column(db.Integer) label = db.column_property( db.select([GxdLabel.label]).where(GxdLabel._label_key == _label_key)) secondary = db.column_property( db.select([GxdSecondary.secondary ]).where(GxdSecondary._secondary_key == _secondary_key)) # Relationships antibody = db.relationship("Antibody", backref=db.backref( "antibodypreps", order_by="AntibodyPrep._antibodyprep_key"), uselist=False) # assay # backref defined in Assay class marker = db.relationship("Marker", secondary=Assay.__table__, backref="antibodypreps", uselist=False) reference = db.relationship("Reference", secondary=Assay.__table__, backref="antibodypreps", uselist=False)
class Report(db.Model): __tablename__ = "pwi_report" __bind_key__ = "mgd" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(), index=True, nullable=False) description = db.Column(db.String()) sql_text = db.Column(db.String(), nullable=False) report_author = db.Column(db.String(), index=True, nullable=False) requested_by = db.Column(db.String(), index=True, nullable=False) type = db.Column(db.String()) created = db.Column(db.DateTime(), index=True, nullable=False) last_run = db.Column(db.DateTime()) last_run_duration = db.Column(db.String()) report_views = db.Column(db.String()) labels = db.relationship("ReportLabel", order_by="ReportLabel.label", backref=db.backref("report")) @property def tagString(self): return ", ".join(["%s" % l for l in self.labels]) @property def safeFileName(self): return "%s_%s.rpt" % (css(self.name), self.id) def __repr__(self): return "<Report id:%s,name:%s,author:%s>" % (self.id, self.name, self.report_author)
class GelLane(db.Model, MGIModel): __tablename__ = "gxd_gellane" _gellane_key = db.Column(db.Integer, primary_key=True) _assay_key = db.Column(db.Integer, mgi_fk("gxd_assay._assay_key")) _gelcontrol_key = db.Column(db.Integer, mgi_fk("gxd_gelcontrol")) _genotype_key = db.Column(db.Integer, mgi_fk("gxd_genotype._genotype_key")) _gelrnatype_key = db.Column(db.Integer) sequencenum = db.Column(db.Integer) age = db.Column(db.String()) agenote = db.Column(db.String()) lanelabel = db.Column(db.String()) lanenote = db.Column(db.String()) sampleamount = db.Column(db.String()) sex = db.Column(db.String()) controlcontent = db.column_property( db.select([GelControl.gellanecontent ]).where(GelControl._gelcontrol_key == _gelcontrol_key)) rnatype = db.column_property( db.select([GelRnaType.rnatype ]).where(GelRnaType._gelrnatype_key == _gelrnatype_key)) # relationships gelbands = db.relationship("GelBand", order_by="GelBand.gelrow_sequencenum", backref=db.backref("gellane", uselist=False)) structures = db.relationship( "ADStructure", primaryjoin="GelLane._gellane_key==GelLaneStructure._gellane_key", secondary=GelLaneStructure.__table__, secondaryjoin= "GelLaneStructure._structure_key==ADStructure._structure_key", foreign_keys="[GelLane._gellane_key, ADStructure._structure_key]", backref="gellanes") genotype = db.relationship("Genotype", uselist=False) @property def lanelabel_display(self): return self.lanelabel or 'Lane %s' % self.sequencenum @property def iscontrol(self): return self._gelcontrol_key != 1 @property def hasbandnote(self): hasBandNote = False for gelband in self.gelbands: if gelband.bandnote != None: hasBandNote = True return hasBandNote
class ProbeAllele(db.Model, MGIModel): __tablename__ = "prb_allele" _allele_key = db.Column(db.Integer, primary_key=True) _rflv_key = db.Column(db.Integer, mgi_fk("prb_rflv._rflv_key"), primary_key=True) allele = db.Column(db.String()) fragments = db.Column(db.String()) probe_allele_strains = db.relationship("ProbeAlleleStrain", backref=db.backref("probe", uselist=False))
class TrackRec(db.Model): __tablename__ = "wts_trackrec" key = db.Column(db.Integer, primary_key=True) priority_key = db.Column(db.Integer, db.ForeignKey("cv_wts_priority.key")) size_key = db.Column(db.Integer, db.ForeignKey("cv_wts_size.key"), index=True) status_key = db.Column(db.Integer, db.ForeignKey("cv_wts_status.key"), index=True) status_user_key = db.Column(db.Integer, db.ForeignKey("cv_user.key"), index=True) status_set_date = db.Column(db.DateTime()) locked_user_key = db.Column(db.Integer, db.ForeignKey("cv_user.key"), index=True) locked_date = db.Column(db.DateTime()) title = db.Column(db.String()) has_directory = db.Column(db.Boolean) attention_by = db.Column(db.DateTime()) creation_date = db.Column(db.DateTime(), default=db.func.now()) modification_date = db.Column(db.DateTime(), default=db.func.now()) description = db.Column(db.String()) progress_notes = db.Column(db.String()) priority = db.relationship("Priority", uselist=False, backref="trs") size = db.relationship("Size", uselist=False, backref="trs") status = db.relationship("Status", uselist=False, backref="trs") areas = db.relationship("Area", secondary=TRAreaAssoc.__table__, backref="trs") types = db.relationship("Type", secondary=TRTypeAssoc.__table__, backref="trs") assigned_users = db.relationship("User", secondary=TRAssignedUserAssoc.__table__) requested_by = db.relationship("User", secondary=TRRequestedUserAssoc.__table__) statusChanges = db.relationship("StatusHistory") child_trs = db.relationship( "TrackRec", secondary=TrackRecChildAssoc.__table__, primaryjoin="TrackRec.key==TrackRecChildAssoc.tr_key", secondaryjoin="TrackRec.key==TrackRecChildAssoc.child_tr_key", backref=db.backref("parent", uselist=False))
class DagNode(db.Model,MGIModel): __tablename__ = "dag_node" _node_key = db.Column(db.Integer,primary_key=True) _object_key = db.Column(db.Integer) _dag_key = db.Column(db.Integer, mgi_fk("dag_dag._dag_key")) _label_key = db.Column(db.Integer) dag_mgitype_key = db.column_property(db.select([Dag._mgitype_key]). where(Dag._dag_key==_dag_key) ) dag_name = db.column_property(db.select([Dag.name]). where(Dag._dag_key==_dag_key) ) label = db.column_property(db.select([DagLabel.label]). where(DagLabel._label_key==_label_key) ) # relationships parent_edges = db.relationship("DagEdge", primaryjoin="DagNode._node_key==DagEdge._child_key", order_by="DagEdge.sequencenum", backref=db.backref("child_node",uselist=False) ) child_edges = db.relationship("DagEdge", primaryjoin="DagNode._node_key==DagEdge._parent_key", order_by="DagEdge.sequencenum", backref=db.backref("parent_node",uselist=False) ) # vocterm # defined in VocTerm def __repr__(self): return "DagNode(key=%s)" % (self._node_key)
class AntibodyAlias(db.Model, MGIModel): __tablename__ = "gxd_antibodyalias" _antibodyalias_key = db.Column(db.Integer, primary_key=True) _antibody_key = db.Column(db.Integer, mgi_fk("gxd_antibody._antibody_key"), primary_key=True) _refs_key = db.Column(db.Integer, mgi_fk("bib_refs._refs_key")) alias = db.Column(db.String()) # relationships reference = db.relationship("Reference", backref=db.backref("AntibodyAlias", uselist=False), uselist=False)
class Specimen(db.Model, MGIModel): __tablename__ = "gxd_specimen" _specimen_key = db.Column(db.Integer, primary_key=True) _assay_key = db.Column(db.Integer, mgi_fk("gxd_assay._assay_key")) _genotype_key = db.Column(db.Integer, mgi_fk("gxd_genotype._genotype_key")) age = db.Column(db.String()) agenote = db.Column(db.String()) hybridization = db.Column(db.String()) sex = db.Column(db.String()) specimenlabel = db.Column(db.String()) specimennote = db.Column(db.String()) sequencenum = db.Column(db.Integer) _embedding_key = db.Column(db.Integer) _fixation_key = db.Column(db.Integer) embeddingmethod = db.column_property( db.select([EmbeddingMethod.embeddingmethod ]).where(EmbeddingMethod._embedding_key == _embedding_key)) fixation = db.column_property( db.select([FixationMethod.fixation ]).where(FixationMethod._fixation_key == _fixation_key)) insituresults = db.relationship( "InSituResult", primaryjoin="InSituResult._specimen_key==Specimen._specimen_key", foreign_keys="[InSituResult._specimen_key]", order_by="InSituResult.sequencenum", backref=db.backref("specimen", uselist=False)) genotype = db.relationship("Genotype", uselist=False) @property def imagepanes(self): panes = [] seen = set() if self.insituresults: for result in self.insituresults: for pane in result.imagepanes: if pane not in seen: panes.append(pane) seen.add(pane) return panes
class ProbeRFLV(db.Model, MGIModel): __tablename__ = "prb_rflv" _rflv_key = db.Column(db.Integer, primary_key=True) _reference_key = db.Column(db.Integer, mgi_fk("prb_reference._reference_key"), primary_key=True) _marker_key = db.Column(db.Integer, mgi_fk("mrk_marker._marker_key"), primary_key=True) endonuclease = db.Column(db.String()) # relationships marker = db.relationship( "Marker", primaryjoin="ProbeRFLV._marker_key==Marker._marker_key", foreign_keys="[Marker._marker_key]", uselist=False) probe_alleles = db.relationship("ProbeAllele", order_by="ProbeAllele.allele", backref=db.backref("probe", uselist=False))
class ProbeReferenceCache(db.Model, MGIModel): __tablename__ = "prb_reference" _reference_key = db.Column(db.Integer, primary_key=True) _probe_key = db.Column(db.Integer, mgi_fk("prb_probe._probe_key"), primary_key=True) _refs_key = db.Column(db.Integer, mgi_fk("bib_refs._refs_key"), primary_key=True) # constants _probe_mgitype_key = 3 _sequence_logicaldb_key = 9 # relationships probe_aliases = db.relationship("ProbeAlias", backref=db.backref("proberef", uselist=False)) probe_rflv = db.relationship("ProbeRFLV", backref=db.backref("proberef", uselist=False)) reference = db.relationship( "Reference", primaryjoin="ProbeReferenceCache._refs_key==Reference._refs_key", order_by="Reference.jnumid", foreign_keys="[Reference._refs_key]", uselist=False) refnotechunks = db.relationship( "ProbeReferenceNotes", primaryjoin= "ProbeReferenceCache._reference_key==ProbeReferenceNotes._reference_key", foreign_keys="[ProbeReferenceNotes._reference_key]", order_by="ProbeReferenceNotes.sequencenum") # # Map sequence IDs using sqlalchemy 'non-primary mapper' strategy # See: http://docs.sqlalchemy.org/en/rel_0_9/orm/join_conditions.html#relationship-to-non-primary-mapper # seqjoin = db.join(Accession, AccessionReference) seqmapper = None seqmapper = db.mapper( Accession, seqjoin, non_primary=True, properties={ "_refs_key": seqjoin.c.mgd_acc_accessionreference__refs_key, "_object_key": seqjoin.c.mgd_acc_accession__object_key, "_accession_key": [ seqjoin.c.mgd_acc_accession__accession_key, seqjoin.c.mgd_acc_accessionreference__accession_key ], "_mgitype_key": seqjoin.c.mgd_acc_accession__mgitype_key, "_logicaldb_key": seqjoin.c.mgd_acc_accession__logicaldb_key, "accid": seqjoin.c.mgd_acc_accession_accid }) sequence_accids = db.relationship( seqmapper, primaryjoin=db.and_( _refs_key == seqmapper.c._refs_key, _probe_key == seqmapper.c._object_key, seqmapper.c._mgitype_key == _probe_mgitype_key, seqmapper.c._logicaldb_key == _sequence_logicaldb_key), foreign_keys=[seqmapper.c._object_key, seqmapper.c._refs_key], order_by=seqmapper.c.accid) @property def refnote(self): return "".join([nc.note for nc in self.refnotechunks])
class Probe(db.Model, MGIModel): __tablename__ = "prb_probe" _probe_key = db.Column(db.Integer, primary_key=True) derivedfrom = db.Column(db.Integer, mgi_fk("prb_probe._probe_key")) _source_key = db.Column(db.Integer, mgi_fk("prb_source._source_key")) name = db.Column(db.String()) _segmenttype_key = db.Column(db.Integer) _vector_key = db.Column(db.Integer) primer1sequence = db.Column(db.String()) primer2sequence = db.Column(db.String()) regioncovered = db.Column(db.String()) insertsite = db.Column(db.String()) insertsize = db.Column(db.String()) productsize = db.Column(db.String()) # constants _mgitype_key = 3 # column properties mgiid = db.column_property( db.select([Accession.accid]).where( db.and_(Accession._mgitype_key == _mgitype_key, Accession.prefixpart == 'MGI:', Accession.preferred == 1, Accession._logicaldb_key == 1, Accession._object_key == _probe_key))) segmenttype = db.column_property( db.select([VocTerm.term]).where(VocTerm._term_key == _segmenttype_key)) vector = db.column_property( db.select([VocTerm.term]).where(VocTerm._term_key == _vector_key)) # relationships derivedfrom_probe = db.relationship( "Probe", primaryjoin="Probe.derivedfrom==Probe._probe_key", foreign_keys="[Probe._probe_key]", uselist=False) markers = db.relationship("Marker", secondary=ProbeMarkerCache.__table__, order_by="Marker.symbol", backref="probes") mgiid_object = db.relationship( "Accession", primaryjoin="and_(Accession._object_key==Probe._probe_key," "Accession.prefixpart=='MGI:'," "Accession.preferred==1," "Accession._logicaldb_key==1," "Accession._mgitype_key==%d)" % _mgitype_key, foreign_keys="[Accession._object_key]", uselist=False) other_mgiids = db.relationship( "Accession", primaryjoin="and_(Accession.prefixpart=='MGI:'," "Accession.preferred==0," "Accession._logicaldb_key==1," "Accession._object_key==Probe._probe_key," "Accession._mgitype_key==%d)" % _mgitype_key, foreign_keys="[Accession._object_key]", order_by="Accession.accid") # other_accids excludes sequence DB (logicaldb_key=9) other_accids = db.relationship( "Accession", primaryjoin="and_(Accession._logicaldb_key!=1," "Accession._logicaldb_key!=9," "Accession._object_key==Probe._probe_key," "Accession._mgitype_key==%d)" % _mgitype_key, foreign_keys="[Accession._object_key]", order_by="[Accession.logicaldb,Accession.accid]") _probe_marker_caches = db.relationship("ProbeMarkerCache", backref=db.backref("probe", uselist=False)) _probe_reference_caches = db.relationship( "ProbeReferenceCache", order_by="ProbeReferenceCache._refs_key", backref=db.backref("probe", uselist=False)) probenotechunks = db.relationship( "ProbeNoteChunk", primaryjoin="ProbeNoteChunk._probe_key==Probe._probe_key", foreign_keys="[ProbeNoteChunk._probe_key]", order_by="ProbeNoteChunk.sequencenum") # probepreps # backref defined in ProbePrep class references = db.relationship("Reference", secondary=ProbeReferenceCache.__table__, order_by="Reference._refs_key", backref="probes") source = db.relationship("ProbeSource") segmenttype_obj = db.relationship( "VocTerm", primaryjoin="Probe._segmenttype_key==VocTerm._term_key", foreign_keys="[VocTerm._term_key]", uselist=False) @property def aliases(self): aliases = [] for ref in self._probe_reference_caches: aliases.extend(ref.probe_aliases) aliases.sort(key=lambda a: a.alias) return aliases @property def assays(self): """ requires probepreps and probeprep.assays to be loaded first (lest queries will fly) """ assays = [] for prep in self.probepreps: assays.extend(prep.assays) assays.sort(key=lambda a: a.mgiid) return assays @property def chromosome(self): """ return chromosome of first marker """ chr = '' if self.markers: chr = self.markers[0].chromosome return chr @property def markers_with_putatives(self): """ list of markers with 'is_putative' attirbute flagged NOTE: assumes markers and _probe_marker_caches are preloaded (lest the queries will fly) """ putativeMarkerKeys = set([]) for probe_assoc in self._probe_marker_caches: if probe_assoc.relationship == 'P': putativeMarkerKeys.add(probe_assoc._marker_key) for marker in self.markers: is_putative = marker._marker_key in putativeMarkerKeys setattr(marker, 'is_putative', is_putative) return self.markers @property def probenote(self): return "".join([nc.note for nc in self.probenotechunks])
class Marker(db.Model, MGIModel): __tablename__ = "mrk_marker" _marker_key = db.Column(db.Integer, primary_key=True) _organism_key = db.Column(db.Integer()) _organism_key.hidden = True _marker_type_key = db.Column(db.Integer()) _marker_type_key.hidden = True _marker_status_key = db.Column(db.Integer()) _marker_status_key.hidden = True symbol = db.Column(db.String()) name = db.Column(db.String()) chromosome = db.Column(db.String()) cytogeneticoffset = db.Column(db.String()) #constants _mgitype_key = 2 _mcv_annottype_key = 1011 # the biotype conflict term _biotypeconflict_yes_key = 5420767 # joined fields organism = db.column_property( db.select([Organism.commonname ]).where(Organism._organism_key == _organism_key)) markertype = db.column_property( db.select([MarkerType.name ]).where(MarkerType._marker_type_key == _marker_type_key)) markerstatus = db.column_property( db.select([MarkerStatus.status ]).where(MarkerStatus._marker_status_key == _marker_status_key).label("markerstatus")) #mgiid = db.Column(db.String()) mgiid = db.column_property( db.select([Accession.accid]).where( db.and_(Accession._mgitype_key == _mgitype_key, Accession.prefixpart == 'MGI:', Accession.preferred == 1, Accession._logicaldb_key == 1, Accession._object_key == _marker_key))) # joined relationship # alleles # alleles backref defined in Allele class mgiid_object = db.relationship( "Accession", primaryjoin="and_(Accession._object_key==Marker._marker_key," "Accession.prefixpart=='MGI:'," "Accession.preferred==1," "Accession._logicaldb_key==1," "Accession._mgitype_key==%d)" % _mgitype_key, foreign_keys="[Accession._object_key]", uselist=False) featuretype_vocterms = db.relationship( "VocTerm", primaryjoin="and_(MarkerMCVCache._marker_key==Marker._marker_key," "MarkerMCVCache.qualifier=='D')", secondary=MarkerMCVCache.__table__, foreign_keys="[MarkerMCVCache._marker_key, MarkerMCVCache._mcvterm_key]" ) secondary_mgiids = db.relationship( "Accession", primaryjoin="and_(Accession._object_key==Marker._marker_key," "Accession.preferred==0," "Accession.prefixpart=='MGI:'," "Accession._logicaldb_key==1," "Accession._mgitype_key==%s)" % _mgitype_key, foreign_keys="[Accession._object_key]", order_by="Accession.accid") biotype_sequences = db.relationship( "SeqMarkerCache", primaryjoin="and_(SeqMarkerCache._marker_key==Marker._marker_key," "SeqMarkerCache.rawbiotype!=None)", foreign_keys="[SeqMarkerCache._marker_key]", order_by="SeqMarkerCache._logicaldb_key,SeqMarkerCache.accid") locations = db.relationship( "MarkerLocationCache", primaryjoin="Marker._marker_key==MarkerLocationCache._marker_key", foreign_keys="[MarkerLocationCache._marker_key]") synonyms = db.relationship( "Synonym", primaryjoin="and_(Marker._marker_key==Synonym._object_key, " "Synonym._mgitype_key==%d)" % _mgitype_key, order_by="Synonym.synonym", foreign_keys="[Synonym._object_key]") detailclipchunks = db.relationship( "MarkerDetailClipNoteChunk", primaryjoin="MarkerDetailClipNoteChunk._marker_key==Marker._marker_key", order_by="MarkerDetailClipNoteChunk.sequencenum", foreign_keys="[MarkerDetailClipNoteChunk._marker_key]") # only direct references via mgi_reference_assoc explicit_references = db.relationship( "Reference", secondary=ReferenceAssoc.__table__, primaryjoin="and_(Marker._marker_key==ReferenceAssoc._object_key, " "ReferenceAssoc._mgitype_key==%d)" % _mgitype_key, secondaryjoin="ReferenceAssoc._refs_key==Reference._refs_key", foreign_keys="[Marker._marker_key,Reference._refs_key]", backref="explicit_markers") # all marker references all_references = db.relationship("Reference", secondary=MarkerReferenceCache.__table__, backref="all_markers") expression_assays = db.relationship( "Assay", primaryjoin="Marker._marker_key==Assay._marker_key", foreign_keys="[Assay._marker_key]", backref=db.backref("marker", uselist=False)) # antibodies # backref defined in Antibody class # antibodypreps # backref in AntibodyPrep class # mapping_experiment_assocs # backref in ExperimentMarkerAssoc class # sequences # backref in Sequence class @classmethod def has_explicit_references(self): q = self.query.filter(Marker.explicit_references.any()) return db.object_session(self).query(db.literal(True)) \ .filter(q.exists()).scalar() @property def has_biotypeconflict(self): """ Requires loading self.biotype_sequences """ conflict = False if self.biotype_sequences: for seq_cache in self.biotype_sequences: if seq_cache._biotypeconflict_key == self._biotypeconflict_yes_key: conflict = True return conflict @property def featuretype(self): featuretype = '' if self.featuretype_vocterms: featuretype = ", ".join( [t.term for t in self.featuretype_vocterms]) return featuretype @property def secondaryids(self): ids = [a.accid for a in self.secondary_mgiids] return ids @property def replocation(self): return self.locations and self.locations[0] or None @property def detailclipnote(self): return "".join([nc.note for nc in self.detailclipchunks]) def __repr__(self): return "<Marker %s>" % self.symbol
class Reference(db.Model, MGIModel): __tablename__ = "bib_refs" _refs_key = db.Column(db.Integer, primary_key=True) _reviewstatus_key = db.Column(db.Integer()) # hide the join key from views _reviewstatus_key.hidden = True reftype = db.Column(db.String()) authors = db.Column(db.String()) _primary = db.Column(db.String()) title = db.Column(db.String()) # this is a way to fix unicode.decode errors, but has a slight performance cost abstract = db.Column( db.String(convert_unicode='force', unicode_error="ignore")) #abstract = db.Column(db.String()) journal = db.Column(db.String()) year = db.Column(db.Integer()) date = db.Column(db.Integer()) nlmstatus = db.Column(db.String()) isreviewarticle = db.Column(db.Integer()) #date.quote=False vol = db.Column(db.Integer()) issue = db.Column(db.Integer()) pgs = db.Column(db.Integer()) # constants _mgitype_key = 1 # mapped columns #jnumid = db.Column(db.String()) jnumid = db.column_property( db.select([Accession.accid]). \ where(db.and_(Accession._mgitype_key==_mgitype_key, Accession.prefixpart=='J:', Accession._object_key==_refs_key)) ) #pubmedid = db.Column(db.String()) pubmedid = db.column_property( db.select([Accession.accid]). \ where(db.and_(Accession._mgitype_key==_mgitype_key, Accession._logicaldb_key==29, Accession._object_key==_refs_key)) ) reviewstatus = db.column_property( db.select([ReviewStatus.name]). \ where(ReviewStatus._reviewstatus_key==_reviewstatus_key) ) # Relationships # accessions # backref defined in Accession class jnumid_object = db.relationship( "Accession", primaryjoin="and_(Accession._object_key==Reference._refs_key," "Accession.prefixpart=='J:'," "Accession.preferred==1," "Accession._logicaldb_key==1," "Accession._mgitype_key==%d)" % _mgitype_key, foreign_keys="[Accession._object_key]", uselist=False) pubmedid_object = db.relationship( "Accession", primaryjoin="and_(Accession._object_key==Reference._refs_key," "Accession.preferred==1," "Accession._logicaldb_key==29," "Accession._mgitype_key==%d)" % _mgitype_key, foreign_keys="[Accession._object_key]", uselist=False) # explicit_alleles # backref defined in Allele class # explicit_markers # backref defined in Marker class # all_markers # backref defined in Marker class experiment_notechunks = db.relationship("MLDReferenceNoteChunk") expression_assays = db.relationship( "Assay", primaryjoin="Reference._refs_key==Assay._refs_key", foreign_keys="[Assay._refs_key]", backref=db.backref("reference", uselist=False)) # mapping_experiments # backref in MappingExperiment class # antibodypreps # backref in AntibodyPrep class @property def citation(self): authors = self.authors or '' title = self.title or '' journal = self.journal or '' rdate = self.date or '' vol = self.vol or '' issue = self.issue or '' pgs = self.pgs or '' return "%s, %s, %s %s;%s(%s):%s"% \ (authors,title,journal, \ rdate,vol,issue,pgs) @property def experimentnote(self): return "".join([nc.note for nc in self.experiment_notechunks]) @property def short_citation(self): primary = self._primary or '' journal = self.journal or '' rdate = self.date or '' vol = self.vol or '' issue = self.issue or '' pgs = self.pgs or '' return "%s, %s %s;%s(%s):%s" % (primary, journal, rdate, vol, issue, pgs) def __repr__(self): return "<Reference %s,%s>" % (self.title, self.authors)
class Assay(db.Model, MGIModel): __tablename__ = "gxd_assay" _assay_key = db.Column(db.Integer, primary_key=True) _assaytype_key = db.Column(db.Integer, mgi_fk("gxd_assaytype._assaytype_key")) _refs_key = db.Column(db.Integer, mgi_fk("bib_refs._refs_key")) _marker_key = db.Column(db.Integer, mgi_fk("mrk_marker._marker_key")) _reportergene_key = db.Column(db.Integer, mgi_fk("voc_term._term_key")) _probeprep_key = db.Column(db.Integer, mgi_fk("gxd_probeprep._probeprep_key")) _antibodyprep_key = db.Column(db.Integer, mgi_fk("gxd_antibodyprep._antibodyprep_key")) _imagepane_key = db.Column(db.Integer, mgi_fk("img_imagepane._imagepane_key")) modification_date = db.Column(db.DateTime()) # constants _mgitype_key = 8 # column properties mgiid = db.column_property( db.select([Accession.accid]).where( db.and_(Accession._mgitype_key == _mgitype_key, Accession.prefixpart == 'MGI:', Accession.preferred == 1, Accession._logicaldb_key == 1, Accession._object_key == _assay_key))) reportergene = db.column_property( db.select([VocTerm.term ]).where(VocTerm._term_key == _reportergene_key)) assaytype = db.column_property( db.select([AssayType.assaytype ]).where(AssayType._assaytype_key == _assaytype_key)) # Relationships alleles = db.relationship("Allele", secondary=AssayAlleleView.__table__, backref="assays") probeprep = db.relationship("ProbePrep", uselist=False, backref="assays") antibodyprep = db.relationship("AntibodyPrep", backref=db.backref("assay", uselist=False), uselist=False) assaynotes = db.relationship("AssayNote", order_by="AssayNote.sequencenum") specimens = db.relationship( "Specimen", primaryjoin="Assay._assay_key==Specimen._assay_key", foreign_keys="[Specimen._assay_key]", order_by="Specimen.sequencenum", backref=db.backref("assay", uselist=False)) gellanes = db.relationship( "GelLane", primaryjoin="Assay._assay_key==GelLane._assay_key", foreign_keys="[GelLane._assay_key]", order_by="GelLane.sequencenum", backref=db.backref("assay", uselist=False)) gellane_imagepane = db.relationship("ImagePane", uselist=False, backref="gel_assays") gelrows = db.relationship("GelRow", order_by="GelRow.sequencenum") @property def assaynote(self): return "".join([n.assaynote for n in self.assaynotes]) @property def detectionmethod(self): method = 'direct detection' if self.probeprep: method = 'nucleotide' elif self.antibodyprep: method = 'antibody' return method @property def gellanes_with_agenotes(self): gellanes = [] for gellane in self.gellanes: if gellane.agenote: gellanes.append(gellane) return gellanes @property def gelrows_with_rownotes(self): gelrows = [] for gelrow in self.gelrows: if gelrow.rownote: gelrows.append(gelrow) return gelrows @property def gelbands_with_bandnotes(self): gelbands = [] for gellane in self.gellanes: for gelband in gellane.gelbands: if gelband.bandnote: gelbands.append(gelband) return gelbands # marker backref from mrk.Marker # reference backref from bib.Reference def __repr__(self): return "<Assay %s>" % self.mgiid
class ADStructure(db.Model, MGIModel): __tablename__ = "gxd_structure" _structure_key = db.Column(db.Integer, primary_key=True) _structurename_key = db.Column( db.Integer, mgi_fk("gxd_structurename._structurename_key")) _parent_key = db.Column(db.Integer, db.ForeignKey(_structure_key)) _stage_key = db.Column(db.Integer) printname = db.Column(db.String()) structurenote = db.Column(db.Integer) # constants _mgitype_key = 38 # column properties mgiid = db.column_property( db.select([Accession.accid]).where( db.and_(Accession._mgitype_key == _mgitype_key, Accession.prefixpart == 'MGI:', Accession.preferred == 1, Accession._logicaldb_key == 1, Accession._object_key == _structure_key))) # relationships mgiid_object = db.relationship( "Accession", primaryjoin="and_(Accession._object_key==ADStructure._structure_key," "Accession.prefixpart=='MGI:'," "Accession.preferred==1," "Accession._logicaldb_key==1," "Accession._mgitype_key==%d)" % _mgitype_key, foreign_keys="Accession._object_key", uselist=False) secondaryids = db.relationship( "Accession", primaryjoin="and_(Accession._object_key==ADStructure._structure_key," "Accession._logicaldb_key!=1," "Accession._mgitype_key==%d)" % _mgitype_key, foreign_keys="Accession._object_key", order_by="Accession.accid") # all names, including synonyms names = db.relationship( "ADStructureName", primaryjoin= "ADStructureName._structure_key==ADStructure._structure_key", foreign_keys="[ADStructureName._structure_key]") # results # backref in Result class # only synonyms synonyms = db.relationship( "ADStructureName", primaryjoin= "and_(ADStructureName._structure_key==ADStructure._structure_key," "ADStructureName._structurename_key!=ADStructure._structurename_key)", foreign_keys= "[ADStructureName._structure_key,ADStructureName._structurename_key]", order_by="ADStructureName.structure") children = db.relationship("ADStructure", backref=db.backref("parent", remote_side=_structure_key)) # parent # backref defined above @property def stage(self): return self._stage_key @property def emapsterm(self): term_object = None if self.mgiid_object and self.mgiid_object.emapsids: term_object = self.mgiid_object.emapsids[0].vocterm return term_object # for vocterm compatibility @property def primaryid(self): return self.mgiid @property def term(self): return self.printname @property def display(self): return "TS%s: %s" % (self.stage, self.printname) def __repr__(self): return self.display