class ImagePaneAssocView(db.Model, MGIModel): __tablename__ = "img_imagepane_assoc_view" _assoc_key = db.Column(db.Integer, primary_key=True) _imagepane_key = db.Column(db.Integer, mgi_fk("img_imagepane._imagepane_key"), primary_key=True) _object_key = db.Column(db.Integer()) _mgitype_key = db.Column(db.Integer()) _imageclass_key = db.Column(db.Integer()) isprimary = db.Column(db.Integer()) mgiid = db.Column(db.String()) allele = db.relationship( "Allele", primaryjoin="and_(ImagePaneAssocView._object_key==Allele._allele_key, " "ImagePaneAssocView._mgitype_key==11) ", foreign_keys="[Allele._allele_key]", uselist=False) genotype = db.relationship( "Genotype", primaryjoin= "and_(ImagePaneAssocView._object_key==Genotype._genotype_key, " "ImagePaneAssocView._mgitype_key==12) ", foreign_keys="[Genotype._genotype_key]", uselist=False)
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 ProbeSource(db.Model, MGIModel): __tablename__ = "prb_source" _source_key = db.Column(db.Integer, primary_key=True) _organism_key = db.Column(db.Integer) _cellline_key = db.Column(db.Integer) _gender_key = db.Column(db.Integer) _refs_key = db.Column(db.Integer, mgi_fk("bib_refs._refs_key")) _strain_key = db.Column(db.Integer, mgi_fk("prb_strain._strain_key")) _tissue_key = db.Column(db.Integer) name = db.Column(db.String()) description = db.Column(db.String()) age = db.Column(db.String()) # column properties cellline = db.column_property( db.select([VocTerm.term]).where(VocTerm._term_key == _cellline_key)) gender = db.column_property( db.select([VocTerm.term]).where(VocTerm._term_key == _gender_key)) organism = db.column_property( db.select([Organism.commonname ]).where(Organism._organism_key == _organism_key)) tissue = db.column_property( db.select([ProbeTissue.tissue ]).where(ProbeTissue._tissue_key == _tissue_key)) # relationships reference = db.relationship("Reference", uselist=False) strain = db.relationship("Strain", uselist=False)
class MGIUser(db.Model, MGIModel): __tablename__ = "mgi_user" _user_key = db.Column(db.Integer, primary_key=True) _usertype_key = db.Column(db.Integer, mgi_fk("voc_term._term_key")) _userstatus_key = db.Column(db.Integer, mgi_fk("voc_term._term_key")) login = db.Column(db.String()) name = db.Column(db.String()) usertype_object = db.relationship( "VocTerm", primaryjoin="VocTerm._term_key==MGIUser._usertype_key", uselist=False) userstatus_object = db.relationship( "VocTerm", primaryjoin="VocTerm._term_key==MGIUser._userstatus_key", uselist=False) # Properties for Flask-Login functionality def is_authenticated(self): return True def is_active(self): return True def is_anonymous(self): return False def get_id(self): return self.login
class ExperimentMarkerAssoc(db.Model, MGIModel): __tablename__ = "mld_expt_marker" _expt_key = db.Column(db.Integer, mgi_fk("mld_expts._expt_key"), primary_key=True) _marker_key = db.Column(db.Integer, mgi_fk("mrk_marker._marker_key"), primary_key=True) sequencenum = db.Column(db.Integer, primary_key=True) _allele_key = db.Column(db.Integer, mgi_fk("all_allele._allele_key")) _assay_type_key = db.Column(db.Integer) description = db.Column(db.String()) matrixdata = db.Column(db.Integer) # column properties assaytype = db.column_property( db.select([ ExperimentAssayType.description ]).where(ExperimentAssayType._assay_type_key == _assay_type_key)) # relationships allele = db.relationship("Allele") marker = db.relationship("Marker", backref="mapping_experiment_assocs") @property def matrixdata_display(self): return self.matrixdata and 'yes' or 'no'
class InSituResult(db.Model, MGIModel): __tablename__ = "gxd_insituresult" _result_key = db.Column(db.Integer, primary_key=True) _specimen_key = db.Column(db.Integer, mgi_fk("gxd_specimen._specimen_key")) _strength_key = db.Column(db.Integer) _pattern_key = db.Column(db.Integer) sequencenum = db.Column(db.Integer) resultnote = db.Column(db.String()) pattern = db.column_property( db.select([GxdPattern.pattern ]).where(GxdPattern._pattern_key == _pattern_key)) strength = db.column_property( db.select([GxdStrength.strength ]).where(GxdStrength._strength_key == _strength_key)) # Relationships imagepanes = db.relationship("ImagePane", secondary=InSituResultImagePane.__table__, backref="insituresults") structures = db.relationship("ADStructure", secondary=InSituResultStructure.__table__, order_by="ADStructure.printname", backref="insituresults")
class MappingExperiment(db.Model, MGIModel): __tablename__ = "mld_expts" _expt_key = db.Column(db.Integer, primary_key=True) _refs_key = db.Column(db.Integer, mgi_fk("bib_refs._refs_key")) expttype = db.Column(db.String()) tag = db.Column(db.Integer()) chromosome = db.Column(db.String()) # key constants _mgitype_key = 4 # other constants # these are expttypes that are valid to display in the P-WI VALID_EXPTTYPES = [ 'TEXT', 'TEXT-Genetic Cross', 'TEXT-Physical Mapping', 'TEXT-QTL', 'TEXT-Congenic', 'TEXT-Meta Analysis', 'TEXT-QTL-Candidate Genes' ] # 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 == _expt_key))) # relationships mgiid_object = db.relationship( "Accession", primaryjoin="and_(Accession._object_key==MappingExperiment._expt_key," "Accession.prefixpart=='MGI:'," "Accession.preferred==1," "Accession._logicaldb_key==1," "Accession._mgitype_key==%d)" % _mgitype_key, foreign_keys="[Accession._object_key]", uselist=False) experiment_notechunks = db.relationship("ExperimentNoteChunk") # beware, this field is limitting its search to only displayable experiment types in the P-WI # this lets the marker detail know when to display a summary link to mapping data marker_assocs = db.relationship( "ExperimentMarkerAssoc", primaryjoin= "and_(ExperimentMarkerAssoc._expt_key==MappingExperiment._expt_key," "MappingExperiment.expttype.in_(%s))" % VALID_EXPTTYPES, order_by="ExperimentMarkerAssoc.sequencenum") reference = db.relationship("Reference", backref="mapping_experiments") @property def experimentnote(self): return "".join([nc.note for nc in self.experiment_notechunks])
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 GxdIndexRecord(db.Model, MGIModel): __tablename__ = "gxd_index" _index_key = db.Column(db.Integer, primary_key=True) _refs_key = db.Column(db.Integer, mgi_fk("bib_refs._refs_key")) _marker_key = db.Column(db.Integer, mgi_fk("mrk_marker._marker_key")) _priority_key = db.Column(db.Integer) _conditionalmutants_key = db.Column(db.Integer) comments = db.Column(db.String()) # column properties conditionalmutants = db.column_property( db.select([VocTerm.term ]).where(VocTerm._term_key == _conditionalmutants_key)) fully_coded = db.column_property(db.exists().where( db.and_(Result._marker_key == _marker_key, Result._refs_key == _refs_key))) priority = db.column_property( db.select([VocTerm.term]).where(VocTerm._term_key == _priority_key)) # Relationships marker = db.relationship("Marker", backref="gxdindex_records", uselist=False) reference = db.relationship("Reference", backref="gxdindex_records", uselist=False) indexstages = db.relationship("GxdIndexStage") @property def unique_stages(self): """ return sorted unique list of stageids """ stageids = gxdindex_aggregator.getUniqueStageids([self]) return stageids @property def unique_assays(self): """ return sorted unique list of indexassays with their ordered stage values as [{'indexassay':'...', stages:[False,True,True,etc] """ assays = gxdindex_aggregator.getUniqueAssays([self]) return assays
class ImagePane(db.Model, MGIModel): __tablename__ = "img_imagepane" _imagepane_key = db.Column(db.Integer, primary_key=True) _image_key = db.Column(db.Integer(), mgi_fk("img_image._image_key")) panelabel = db.Column(db.String()) x = db.Column(db.Integer()) y = db.Column(db.Integer()) width = db.Column(db.Integer()) height = db.Column(db.Integer()) image = db.relationship("Image", uselist=False) imagePaneAlleleAssocs = db.relationship( "ImagePaneAssocView", primaryjoin= "and_(ImagePane._imagepane_key==ImagePaneAssocView._imagepane_key, " "ImagePaneAssocView._mgitype_key==11) ", foreign_keys="[ImagePaneAssocView._imagepane_key]") imagePaneGenotypeAssocs = db.relationship( "ImagePaneAssocView", primaryjoin= "and_(ImagePane._imagepane_key==ImagePaneAssocView._imagepane_key, " "ImagePaneAssocView._mgitype_key==12) ", foreign_keys="[ImagePaneAssocView._imagepane_key]") # gel_assays # backref defined in gxd.Assay class # insituresults # backref defined in InsituResult class @property def figurelabel(self): figurelabel = self.image.figurelabel or '' panelabel = self.panelabel or '' return '%s%s' % (figurelabel, panelabel) @property def distinctInsituAssays(self): distinctAssays = [] distinctAssaysKeys = [] for result in self.insituresults: if result.specimen.assay._assay_key not in distinctAssaysKeys: distinctAssays.append(result.specimen.assay) distinctAssaysKeys.append(result.specimen.assay._assay_key) distinctAssays.sort(key=lambda x: x.mgiid) #ut.sort(key=lambda x: x.count, reverse=True) return distinctAssays
class Accession(db.Model,MGIModel): __tablename__ = "acc_accession" _accession_key = db.Column(db.Integer,primary_key=True) accid = db.Column(db.String()) prefixpart = db.Column(db.String()) numericpart = db.Column(db.Integer()) _logicaldb_key = db.Column(db.Integer(), mgi_fk("acc_logicaldb._logicaldb_key")) _object_key = db.Column(db.Integer()) _mgitype_key = db.Column(db.Integer()) private = db.Column(db.Integer()) preferred = db.Column(db.Integer()) _createdby_key = db.Column(db.Integer()) _modifiedby_key = db.Column(db.Integer()) logicaldb = db.column_property( db.select([LogicalDb.name]). where(LogicalDb._logicaldb_key==_logicaldb_key) ) # relationships logicaldb_object = db.relationship("LogicalDb", uselist=False) mgitype = db.relationship("MGIType", uselist=False, primaryjoin="MGIType._mgitype_key==Accession._mgitype_key", foreign_keys="[MGIType._mgitype_key]") references = db.relationship("Reference", secondary=AccessionReference.__table__, backref="accessions") emapsids = db.relationship("Accession", primaryjoin="Accession.accid==EmapSMapping.accid", secondary=EmapSMapping.__table__, secondaryjoin="Accession.accid==EmapSMapping.emapsid", foreign_keys="[EmapSMapping.emapsid, Accession.accid]", backref="adstructureids") vocterm = db.relationship("VocTerm", primaryjoin="VocTerm._term_key==Accession._object_key", foreign_keys="VocTerm._term_key", uselist=False ) def __repr__(self): return "<AccID %s>"%(self.accid,)
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 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 ReferenceAssoc(db.Model, MGIModel): __tablename__ = "mgi_reference_assoc" _assoc_key = db.Column(db.Integer, primary_key=True) _refs_key = db.Column(db.Integer, mgi_fk("bib_refs._refs_key")) _object_key = db.Column(db.Integer) _mgitype_key = db.Column(db.Integer) _refassoctype_key = db.Column(db.Integer) reference = db.relationship("Reference", uselist=False)
class Sequence(db.Model, MGIModel): __tablename__ = "seq_sequence" _sequence_key = db.Column(db.Integer, primary_key=True) _sequencetype_key = db.Column(db.Integer) _sequencequality_key = db.Column(db.Integer) _sequencestatus_key = db.Column(db.Integer) _sequenceprovider_key = db.Column(db.Integer) _organism_key = db.Column(db.Integer, mgi_fk("mgi_organism._organism_key")) length = db.Column(db.String()) description = db.Column(db.String()) version = db.Column(db.String()) division = db.Column(db.String()) # constants _mgitype_key = 19 # column definitions type = db.column_property( db.select([VocTerm.term ]).where(VocTerm._term_key == _sequencetype_key)) #relationships markers = db.relationship( "Marker", secondary=SeqMarkerCache.__table__, primaryjoin="Sequence._sequence_key==SeqMarkerCache._sequence_key", secondaryjoin="SeqMarkerCache._marker_key==Marker._marker_key", foreign_keys="[Sequence._sequence_key,Marker._marker_key]", backref="sequences", order_by="Marker.symbol") # sequence can have multiple IDs accession_objects = db.relationship( "Accession", primaryjoin="and_(Accession._object_key==Sequence._sequence_key," "Accession.preferred==1," "Accession._mgitype_key==%s)" % (_mgitype_key), foreign_keys="[Accession._object_key]", order_by="Accession.accid") source = db.relationship("ProbeSource", secondary=SeqSourceAssoc.__table__, uselist=False)
class AccessionReference(db.Model,MGIModel): __tablename__ = "acc_accessionreference" _accession_key = db.Column(db.Integer, mgi_fk("acc_accession._accession_key"), primary_key=True) _refs_key = db.Column(db.Integer, mgi_fk("bib_refs._refs_key"), primary_key=True) accession = db.relationship("Accession", uselist=False)
class AllelePair(db.Model, MGIModel): __tablename__ = "gxd_allelepair" _allelepair_key = db.Column(db.Integer, primary_key=True) _genotype_key = db.Column(db.Integer, mgi_fk("gxd_genotype._genotype_key")) _allele_key_1 = db.Column(db.Integer, mgi_fk("all_allele._allele_key")) _allele_key_2 = db.Column(db.Integer, mgi_fk("all_allele._allele_key")) _marker_key = db.Column(db.Integer, mgi_fk("mrk_marker._marker_key")) _pairstate_key = db.Column(db.Integer) sequencenum = db.Column(db.Integer) chromosome = db.column_property( db.select([Marker.chromosome ]).where(Marker._marker_key == _marker_key)) pairstate = db.column_property( db.select([VocTerm.term]).where(VocTerm._term_key == _pairstate_key)) # relationships allele1 = db.relationship( "Allele", primaryjoin="Allele._allele_key==AllelePair._allele_key_1", uselist=False) allele2 = db.relationship( "Allele", primaryjoin="Allele._allele_key==AllelePair._allele_key_2", uselist=False) @property def display(self): """ displays allele 1 and 2 symbols exactly as they are, without combination logic """ sym1 = self.allele1.symbol sym2 = '' if self.allele2: sym2 = self.allele2.symbol return "%s / %s" % (sym1, sym2) def __repr__(self): return self.display
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 ProbeAlleleStrain(db.Model, MGIModel): __tablename__ = "prb_allele_strain" _allele_key = db.Column(db.Integer, mgi_fk("prb_allele._allele_key"), primary_key=True) _strain_key = db.Column(db.Integer(), mgi_fk("prb_strain._strain_key"), primary_key=True) strain = db.relationship("Strain", uselist=False)
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 SeqMarkerCache(db.Model, MGIModel): __tablename__ = "seq_marker_cache" _cache_key = db.Column(db.Integer, primary_key=True) _sequence_key = db.Column(db.Integer, mgi_fk("seq_sequence._sequence_key")) _marker_key = db.Column(db.Integer, mgi_fk("mrk_marker._marker_key")) _organism_key = db.Column(db.Integer) _logicaldb_key = db.Column(db.Integer, mgi_fk("acc_logicaldb._logicaldb_key")) accid = db.Column(db.String()) rawbiotype = db.Column(db.String()) _sequenceprovider_key = db.Column(db.Integer) _biotypeconflict_key = db.Column(db.Integer, mgi_fk("voc_term._term_key")) annotation_date = db.Column(db.DateTime) # constants # the biotype conflict term _biotypeconflict_yes_key = 5420767 # column properties sequenceprovider = db.column_property( db.select([VocTerm.term ]).where(VocTerm._term_key == _sequenceprovider_key)) marker = db.relationship("Marker") logicaldb_obj = db.relationship("LogicalDb") @property def sequence_url(self): """ This requires loading logicaldb_obj and logicaldb_obj.actualdb """ url = "" if self.logicaldb_obj and \ self.logicaldb_obj.actualdb: url = self.logicaldb_obj.actualdb.url.replace("@@@@", self.accid) return url
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 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 LogicalDb(db.Model,MGIModel): __tablename__ = "acc_logicaldb" _logicaldb_key = db.Column(db.Integer, primary_key=True) name = db.Column(db.String()) actualdbs = db.relationship("ActualDb") @property def actualdb(self): """ Returns the first actualdb object """ return self.actualdbs and self.actualdbs[0] or None
class NOM_Marker(db.Model, MGIModel): __tablename__ = "nom_marker" _nomen_key = db.Column(db.Integer, primary_key=True) _marker_type_key = db.Column(db.Integer) _marker_type_key.hidden = True _nomenstatus_key = db.Column(db.Integer) _nomenstatus_key.hidden = True symbol = db.Column(db.String()) name = db.Column(db.String()) chromosome = db.Column(db.String()) statusnote = db.Column( db.String(convert_unicode='force', unicode_error="ignore")) # key constants _mgitype_key = 21 _nomenstatus_vocab_key = 16 # mapped fields markertype = db.column_property( db.select([MarkerType.name ]).where(MarkerType._marker_type_key == _marker_type_key)) nomenstatus = db.column_property( db.select([VocTerm.term]). where(db.and_(VocTerm._term_key==_nomenstatus_key, \ VocTerm._vocab_key==_nomenstatus_vocab_key) ) ) 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 == _nomen_key))) # one to many objects synonyms = db.relationship( "Synonym", primaryjoin="and_(NOM_Marker._nomen_key==Synonym._object_key, " "Synonym._mgitype_key==%d)" % _mgitype_key, order_by="Synonym.synonym", foreign_keys="[Synonym._object_key]") def __repr__(self): return "<NOM %s (%s) - %s>" % (self.symbol, self.mgiid, self.nomenstatus)
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 GelBand(db.Model, MGIModel): __tablename__ = "gxd_gelband" _gelband_key = db.Column(db.Integer, primary_key=True) _gelrow_key = db.Column(db.Integer, mgi_fk("gxd_gelrow._gelrow_key")) _gellane_key = db.Column(db.Integer, mgi_fk("gxd_gellane._gellane_key")) _strength_key = db.Column(db.Integer) bandnote = db.Column(db.String()) strength = db.column_property( db.select([GxdStrength.strength ]).where(GxdStrength._strength_key == _strength_key)) gelrow_sequencenum = db.column_property( db.select([GelRow.sequencenum ]).where(GelRow._gelrow_key == _gelrow_key)) gelrow = db.relationship("GelRow", uselist=False)
class Note(db.Model, MGIModel): __tablename__ = "mgi_note" _note_key = db.Column(db.Integer, primary_key=True) _object_key = db.Column(db.Integer) _mgitype_key = db.Column(db.Integer) _notetype_key = db.Column(db.Integer) notetype = db.column_property( db.select([NoteType.notetype ]).where(NoteType._notetype_key == _notetype_key)) chunks = db.relationship("NoteChunk", order_by="NoteChunk.sequencenum") @property def text(self): return ''.join([c.note for c in self.chunks]) def __repr__(self): return self.text
class Antigen(db.Model, MGIModel): __tablename__ = "gxd_antigen" _antigen_key = db.Column(db.Integer, primary_key=True) _source_key = db.Column(db.Integer, mgi_fk("prb_source._source_key")) antigenname = db.Column(db.String()) regioncovered = db.Column(db.String()) antigennote = db.Column(db.String()) _mgitype_key = 7 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 == _antigen_key))) # antibodies # backref defined in Antibody class source = db.relationship("ProbeSource", uselist=False)
class ProbePrep(db.Model, MGIModel): __tablename__ = "gxd_probeprep" _probeprep_key = db.Column(db.Integer, primary_key=True) _probe_key = db.Column(db.Integer, mgi_fk("prb_probe._probe_key")) _sense_key = db.Column(db.Integer) _label_key = db.Column(db.Integer) _visualization_key = db.Column(db.Integer) type = db.Column(db.String()) label = db.column_property( db.select([GxdLabel.label]).where(GxdLabel._label_key == _label_key)) sense = db.column_property( db.select([ProbeSense.sense ]).where(ProbeSense._sense_key == _sense_key)) visualization = db.column_property( db.select([ VisualizationMethod.visualization ]).where(VisualizationMethod._visualization_key == _visualization_key)) # Relationships probe = db.relationship("Probe", backref="probepreps")
# 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) # define ancestor_vocterms here to avoid cyclic import VocTerm.ancestor_vocterms = db.relationship("VocTerm", primaryjoin="and_(DagClosure._descendentobject_key==VocTerm._term_key," "DagClosure._mgitype_key==%d)" % VocTerm._mgitype_key, secondary=DagClosure.__table__, secondaryjoin="DagClosure._ancestorobject_key==VocTerm._term_key", foreign_keys="[DagClosure._descendentobject_key, VocTerm._term_key]" )