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 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 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 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 GxdIndexStage(db.Model, MGIModel): __tablename__ = "gxd_index_stages" _index_key = db.Column(db.Integer, mgi_fk("gxd_index._index_key"), primary_key=True) _indexassay_key = db.Column(db.Integer, primary_key=True) _stageid_key = db.Column(db.Integer, primary_key=True) # column properties indexassay = db.column_property( db.select([VocTerm.term]).where(VocTerm._term_key == _indexassay_key)) stageid = db.column_property( db.select([VocTerm.term]).where(VocTerm._term_key == _stageid_key))
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 DagEdge(db.Model,MGIModel): __tablename__ = "dag_edge" _edge_key = db.Column(db.Integer,primary_key=True) _dag_key = db.Column(db.Integer, mgi_fk("dag_dag._dag_key")) _label_key = db.Column(db.Integer) _parent_key = db.Column(db.Integer, mgi_fk("dag_node._node_key")) _child_key = db.Column(db.Integer, mgi_fk("dag_node._node_key")) sequencenum = db.Column(db.Integer) 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) )
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 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 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 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 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 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 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")
class GelRow(db.Model, MGIModel): __tablename__ = "gxd_gelrow" _gelrow_key = db.Column(db.Integer, primary_key=True) _assay_key = db.Column(db.Integer, mgi_fk("gxd_assay._assay_key")) _gelunits_key = db.Column(db.Integer) sequencenum = db.Column(db.Integer) rownote = db.Column(db.String()) size = db.Column(db.Float()) gelunits = db.column_property( db.select([GelUnits.units ]).where(GelUnits._gelunits_key == _gelunits_key)) @property def size_and_units(self): return "%s %s" % (self.size, self.gelunits)
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 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 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 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 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 Image(db.Model, MGIModel): __tablename__ = "img_image" _image_key = db.Column(db.Integer, primary_key=True) _mgitype_key = db.Column(db.Integer) _imageclass_key = db.Column(db.Integer) _refs_key = db.Column(db.Integer) _thumbnailimage_key = db.Column(db.Integer, mgi_fk("img_image._image_key")) xdim = db.Column(db.Integer) ydim = db.Column(db.Integer) figurelabel = db.Column(db.String()) # key constants acc_mgitype_key = 9 caption_note_key = 1024 copyright_note_key = 1023 externallink_note_key = 1039 mgiid = db.column_property( db.select([Accession.accid]).where( db.and_(Accession._mgitype_key == acc_mgitype_key, Accession.prefixpart == 'MGI:', Accession.preferred == 1, Accession._logicaldb_key == 1, Accession._object_key == _image_key))) pixnum = db.column_property( db.select([Accession.numericpart]).where( db.and_(Accession._mgitype_key == acc_mgitype_key, Accession.prefixpart == 'PIX:', Accession.preferred == 1, Accession._logicaldb_key == 19, Accession._object_key == _image_key))) # relationships reference = db.relationship( "Reference", primaryjoin="and_(Image._refs_key==Reference._refs_key) ", foreign_keys="[Reference._refs_key]", uselist=False) thumbnail = db.relationship( "Image", primaryjoin="and_(Image._thumbnailimage_key==Image._image_key) ", foreign_keys="[Image._image_key]", uselist=False) caption = db.relationship( "Note", primaryjoin="and_(Image._image_key==Note._object_key, " "Note._mgitype_key==9, Note._notetype_key==%d) " % caption_note_key, foreign_keys="[Note._object_key]", uselist=False) copyright = db.relationship( "Note", primaryjoin="and_(Image._image_key==Note._object_key, " "Note._mgitype_key==9, Note._notetype_key==%d) " % copyright_note_key, foreign_keys="[Note._object_key]", uselist=False) externallink = db.relationship( "Note", primaryjoin="and_(Image._image_key==Note._object_key, " "Note._mgitype_key==9, Note._notetype_key==%d) " % externallink_note_key, foreign_keys="[Note._object_key]", uselist=False) # other accession IDs besides MGI or PIX (ldb=19) otherdb_ids = db.relationship( "Accession", primaryjoin="and_(Accession._object_key==Image._image_key," "Accession.private==0," "Accession.preferred==1," "Accession._logicaldb_key!=1," "Accession._logicaldb_key!=19," "Accession._mgitype_key==%d)" % acc_mgitype_key, foreign_keys="[Accession._object_key]") imagepanes = db.relationship("ImagePane", order_by="ImagePane.panelabel")
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 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
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 Allele(db.Model, MGIModel): __tablename__ = "all_allele" _allele_key = db.Column(db.Integer, primary_key=True) _marker_key = db.Column(db.Integer, mgi_fk("mrk_marker._marker_key")) _allele_status_key = db.Column(db.Integer) _allele_type_key = db.Column(db.Integer()) _mode_key = db.Column(db.Integer()) _transmission_key = db.Column(db.Integer()) _collection_key = db.Column(db.Integer()) _strain_key = db.Column(db.Integer(), mgi_fk("prb_strain._strain_key")) iswildtype = db.Column(db.Integer()) name = db.Column(db.String()) symbol = db.Column(db.String()) # key constants _mgitype_key = 11 _allele_status_vocab_key = 37 _molecular_mutation_key = 36 _allele_type_vocab_key = 38 _transmission_vocab_key = 61 _collection_vocab_key = 92 _mode_vocab_key = 35 _allele_subtype_voc_annot_key = 1014 _allele_driver_note_type = 1034 _nomen_note_type = 1022 _mp_annottype_key = 1002 _disease_geno_anottype_key = 1005 _disease_allele_annottype_key = 1012 # joined fields alleletype = db.column_property( db.select([VocTerm.term]). where(db.and_(VocTerm._term_key==_allele_type_key, \ VocTerm._vocab_key==_allele_type_vocab_key)) ) collection = db.column_property( db.select([VocTerm.term]). where(db.and_(VocTerm._term_key==_collection_key, \ VocTerm._vocab_key==_collection_vocab_key)) ) #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 == _allele_key))) modeRaw = db.column_property( db.select([VocTerm.term]). where(db.and_(VocTerm._term_key==_mode_key, \ VocTerm._vocab_key==_mode_vocab_key)) ) status = db.column_property( db.select([VocTerm.term]). where(db.and_(VocTerm._term_key==_allele_status_key, \ VocTerm._vocab_key==_allele_status_vocab_key)) ) transmission = db.column_property( db.select([VocTerm.term]). where(db.and_(VocTerm._term_key==_transmission_key, \ VocTerm._vocab_key==_transmission_vocab_key)) ) # relationships mgiid_object = db.relationship( "Accession", primaryjoin="and_(Accession._object_key==Allele._allele_key," "Accession.prefixpart=='MGI:'," "Accession.preferred==1," "Accession._logicaldb_key==1," "Accession._mgitype_key==%d)" % _mgitype_key, foreign_keys="[Accession._object_key]", uselist=False) strain = db.relationship("Strain", uselist=False, backref="alleles") allelecelllineassoc = db.relationship("AlleleCelllineAssoc") molecularmutation = db.relationship( "VocTerm", secondary=AlleleMutation.__table__, secondaryjoin="and_(VocTerm._term_key==AlleleMutation._mutation_key," "VocTerm._vocab_key ==%d)" % _molecular_mutation_key) transmissionref = db.relationship( "ReferenceAssoc", primaryjoin= "and_(Allele._allele_key==ReferenceAssoc._object_key, ReferenceAssoc._refassoctype_key==1023, ReferenceAssoc._mgitype_key==%d)" % _mgitype_key, foreign_keys="[ReferenceAssoc._object_key]", uselist=False) molecularrefs = db.relationship( "ReferenceAssoc", primaryjoin= "and_(Allele._allele_key==ReferenceAssoc._object_key, ReferenceAssoc._refassoctype_key==1012, ReferenceAssoc._mgitype_key==%d)" % _mgitype_key, foreign_keys="[ReferenceAssoc._object_key]") primaryimagepane = db.relationship( "ImagePane", primaryjoin="and_(Allele._allele_key==ImagePaneAssocView._object_key, " "ImagePaneAssocView._imageclass_key==6481782, " "ImagePaneAssocView.isprimary==1, " "ImagePaneAssocView._mgitype_key==%d)" % _mgitype_key, secondary=ImagePaneAssocView.__table__, secondaryjoin= "ImagePaneAssocView._imagepane_key==ImagePane._imagepane_key", foreign_keys= "[ImagePaneAssocView._object_key, ImagePaneAssocView._imagepane_key]", uselist=False) phenoimagepanes = db.relationship( "ImagePane", primaryjoin="and_(Allele._allele_key==ImagePaneAssocView._object_key, " "ImagePaneAssocView._imageclass_key==6481782, " "ImagePaneAssocView._mgitype_key==%d)" % _mgitype_key, secondary=ImagePaneAssocView.__table__, secondaryjoin= "ImagePaneAssocView._imagepane_key==ImagePane._imagepane_key", foreign_keys= "[ImagePaneAssocView._object_key, ImagePaneAssocView._imagepane_key]", order_by="desc(ImagePaneAssocView.isprimary)") molecularimagepanes = db.relationship( "ImagePane", primaryjoin="and_(Allele._allele_key==ImagePaneAssocView._object_key, " "ImagePaneAssocView._imageclass_key==6481783, " "ImagePaneAssocView._mgitype_key==%d)" % _mgitype_key, secondary=ImagePaneAssocView.__table__, secondaryjoin= "ImagePaneAssocView._imagepane_key==ImagePane._imagepane_key", foreign_keys= "[ImagePaneAssocView._object_key, ImagePaneAssocView._imagepane_key]", order_by="ImagePaneAssocView.isprimary") imageAssocs = db.relationship( "ImagePaneAssocView", primaryjoin="and_(Allele._allele_key==ImagePaneAssocView._object_key, " "ImagePaneAssocView._mgitype_key==%d)" % _mgitype_key, foreign_keys="[ImagePaneAssocView._object_key]") molecularimage = db.relationship( "ImagePaneAssocView", primaryjoin="and_(Allele._allele_key==ImagePaneAssocView._object_key, " "ImagePaneAssocView._imageclass_key==6481783, " "ImagePaneAssocView._mgitype_key==%d)" % _mgitype_key, foreign_keys="[ImagePaneAssocView._object_key]") synonyms = db.relationship( "Synonym", primaryjoin="and_(Allele._allele_key==Synonym._object_key, " "Synonym._mgitype_key==%d)" % _mgitype_key, order_by="Synonym.synonym", foreign_keys="[Synonym._object_key]") subtypes = db.relationship( "VocTerm", secondary=VocAnnot.__table__, primaryjoin="and_(Allele._allele_key==VocAnnot._object_key, " "VocAnnot._annottype_key==%d)" % _allele_subtype_voc_annot_key, secondaryjoin="VocAnnot._term_key==VocTerm._term_key", foreign_keys="[Allele._allele_key,VocTerm._term_key]", backref="explicit_subtypes") drivernote = db.relationship( "Note", primaryjoin="and_(Allele._allele_key==Note._object_key, " "Note._mgitype_key==11, Note._notetype_key==1034) ", foreign_keys="[Note._object_key]", uselist=False) induciblenote = db.relationship( "Note", primaryjoin="and_(Allele._allele_key==Note._object_key, " "Note._mgitype_key==11, Note._notetype_key==1032) ", foreign_keys="[Note._object_key]", uselist=False) nomennoteRaw = db.relationship( "Note", primaryjoin="and_(Allele._allele_key==Note._object_key, " "Note._mgitype_key==11, Note._notetype_key==1022) ", foreign_keys="[Note._object_key]", uselist=False) generalnoteRaw = db.relationship( "Note", primaryjoin="and_(Allele._allele_key==Note._object_key, " "Note._mgitype_key==11, Note._notetype_key==1020) ", foreign_keys="[Note._object_key]", uselist=False) molecularnote = db.relationship( "Note", primaryjoin="and_(Allele._allele_key==Note._object_key, " "Note._mgitype_key==11, Note._notetype_key==1021) ", foreign_keys="[Note._object_key]", uselist=False) marker = db.relationship("Marker", uselist=False, backref="alleles") mp_annots = db.relationship( "VocAnnot", secondary=AlleleAnnotView.__table__, secondaryjoin="and_(VocAnnot._annot_key==AlleleAnnotView._annot_key," "VocAnnot._annottype_key==%d)" % _mp_annottype_key) disease_annots = db.relationship( "VocAnnot", secondary=AlleleAnnotView.__table__, secondaryjoin="and_(VocAnnot._annot_key==AlleleAnnotView._annot_key," "VocAnnot._annottype_key.in_(%s))" % [_disease_geno_anottype_key, _disease_allele_annottype_key]) explicit_references = db.relationship( "Reference", secondary=ReferenceAssoc.__table__, primaryjoin="and_(Allele._allele_key==ReferenceAssoc._object_key, " "ReferenceAssoc._mgitype_key==%d)" % _mgitype_key, secondaryjoin="ReferenceAssoc._refs_key==Reference._refs_key", foreign_keys="[ReferenceAssoc._object_key, Reference._refs_key]", backref="explicit_alleles") genotypes = db.relationship("Genotype", secondary=AlleleGenotype.__table__, order_by="AlleleGenotype.sequencenum") # assays # assays backref defined in GxdAssay class # transient property methods @property def allelecelllines(self): return ", ".join([ assoc.allelecelllineview.cellline for assoc in self.allelecelllineassoc ]) @property def alleleparentcellline(self): parentCellLine = "" if (self.allelecelllineassoc): # use first allele assoc - data identical for this field parentCellLine = self.allelecelllineassoc[ 0].allelecelllineview.parentcellline return parentCellLine @property def celllinetype(self): celllinetype = "" if (self.allelecelllineassoc): # use first allele assoc - data identical for this field celllinetype = self.allelecelllineassoc[ 0].allelecelllineview.celllinetype return celllinetype @property def disease_terms(self): terms = [d.term for d in self.disease_annots] terms.sort() return terms @property def generalnote(self): generalnote = self.generalnoteRaw or '' return generalnote @property def mode(self): mode = self.modeRaw or '' return mode @property def molecularimageid(self): imageMgiID = "" if (self.molecularimage): # use first allele assoc - data identical for this field imageMgiID = self.molecularimage[0].mgiid return imageMgiID @property def nomennote(self): nomennote = self.nomennoteRaw or '' return nomennote @property def primaryimageid(self): imageMgiID = "" if (self.primaryimage): # use first allele assoc - data identical for this field imageMgiID = self.primaryimage[0].mgiid return imageMgiID @property def summary_mp_display(self): """ mp column on allele summary """ val = '' if self.mp_annots: if len(self.mp_annots) == len( [m for m in self.mp_annots if m.qualifier == 'normal']): val = 'no abnormal phenotype observed' else: val = 'has data' return val @property def vector(self): vector = "" if (self.allelecelllineassoc): # use first allele assoc - data identical for this field vector = self.allelecelllineassoc[0].allelecelllineview.vector return vector @property def vectortype(self): vectortype = "" if (self.allelecelllineassoc): # use first allele assoc - data identical for this field vectortype = self.allelecelllineassoc[ 0].allelecelllineview.vectortype return vectortype @property def genotypes_with_phenotypes(self): """ Filters out any genotypes with no mp_annots (tip: might want to pre-load all the mp_annot objects with batchLoadAttribute to avoid numerous queries) """ return [geno for geno in self.genotypes if geno.mp_annots] @property def hasImages(self): hasImages = False if (self.phenoimagepanes): hasImages = True if (self.molecularimagepanes): hasImages = True return hasImages # @classmethod # def has_explicit_references(self): # q = self.query.filter(Allele.explicit_references.any()) # return db.object_session(self).query(db.literal(True)) \ # .filter(q.exists()).scalar() def __repr__(self): return "<Allele %s>" % (self.mgiid, )
class Genotype(db.Model, MGIModel): __tablename__ = "gxd_genotype" _genotype_key = db.Column(db.Integer, primary_key=True) _strain_key = db.Column(db.Integer, mgi_fk("prb_strain._strain_key")) isconditional = db.Column(db.Integer) note = db.Column(db.String()) # constants _mgitype_key = 12 comb1_notetype_key = 1016 _mp_annottype_key = 1002 _disease_geno_anottype_key = 1005 # combination1 is a cache loaded note combination1_cache = db.column_property( db.select([NoteChunk.note]).where( db.and_(Note._note_key == NoteChunk._note_key, NoteChunk.sequencenum == 1, Note._object_key == _genotype_key, Note._mgitype_key == _mgitype_key, Note._notetype_key == comb1_notetype_key))) geneticbackground = db.column_property( db.select([Strain.strain]).where(Strain._strain_key == _strain_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 == _genotype_key))) # relationships allelepairs = db.relationship("AllelePair", order_by="AllelePair.sequencenum") mp_annots = db.relationship( "VocAnnot", primaryjoin="and_(VocAnnot._object_key==Genotype._genotype_key," "VocAnnot._annottype_key==%d)" % _mp_annottype_key, foreign_keys="[VocAnnot._object_key]") disease_annots = db.relationship( "VocAnnot", primaryjoin="and_(VocAnnot._object_key==Genotype._genotype_key," "VocAnnot._annottype_key==%d)" % _disease_geno_anottype_key, foreign_keys="[VocAnnot._object_key]") primaryimagepane = db.relationship( "ImagePane", primaryjoin="and_(Genotype._genotype_key==ImagePaneAssoc._object_key," "ImagePaneAssoc.isprimary==1," "ImagePaneAssoc._mgitype_key==%d)" % _mgitype_key, secondary=ImagePaneAssoc.__table__, secondaryjoin="ImagePaneAssoc._imagepane_key==ImagePane._imagepane_key", foreign_keys= "[ImagePaneAssoc._object_key,ImagePaneAssoc._imagepane_key]", uselist=False) imagepanes = db.relationship( "ImagePane", primaryjoin="and_(Genotype._genotype_key==ImagePaneAssoc._object_key," "ImagePaneAssoc._mgitype_key==%d)" % _mgitype_key, secondary=ImagePaneAssoc.__table__, secondaryjoin="ImagePaneAssoc._imagepane_key==ImagePane._imagepane_key", foreign_keys= "[ImagePaneAssoc._object_key,ImagePaneAssoc._imagepane_key]") def __init__(self): # add any non-database attribute defaults self.mp_headers = [] @db.reconstructor def init_on_load(self): self.__init__()
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 Antibody(db.Model, MGIModel): __tablename__ = "gxd_antibody" _antibody_key = db.Column(db.Integer, primary_key=True) _antigen_key = db.Column(db.Integer, mgi_fk("gxd_antigen._antigen_key")) _antibodyclass_key = db.Column(db.Integer) _antibodytype_key = db.Column(db.Integer) _organism_key = db.Column(db.Integer) antibodyname = db.Column(db.String()) antibodynote = db.Column(db.String()) _mgitype_key = 6 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 == _antibody_key))) antibodyclass = db.column_property( db.select([ AntibodyClass.antibodyclass ]).where(AntibodyClass._antibodyclass_key == _antibodyclass_key)) antibodytype = db.column_property( db.select([ AntibodyType.antibodytype ]).where(AntibodyType._antibodytype_key == _antibodytype_key)) organism = db.column_property( db.select([Organism.commonname ]).where(Organism._organism_key == _organism_key)) # relationships antigen = db.relationship("Antigen", backref="antibodies", uselist=False) aliases = db.relationship("AntibodyAlias", backref="antibodies") # antibodypreps # backref defined in AntibodyPrep class markers = db.relationship("Marker", secondary=AntibodyMarkerAssoc.__table__, order_by="Marker.symbol", backref="antibodies") references = db.relationship( "Reference", primaryjoin="and_(ReferenceAssoc._object_key==Antibody._antibody_key," "ReferenceAssoc._mgitype_key==%d)" % _mgitype_key, secondary=ReferenceAssoc.__table__, secondaryjoin="ReferenceAssoc._refs_key==Reference._refs_key", foreign_keys="[ReferenceAssoc._object_key,ReferenceAssoc._refs_key]", order_by="Reference._refs_key", backref="antibodies") mgiid_object = db.relationship( "Accession", primaryjoin="and_(Accession._object_key==Antibody._antibody_key," "Accession.prefixpart=='MGI:'," "Accession.preferred==1," "Accession._logicaldb_key==1," "Accession._mgitype_key==%d)" % _mgitype_key, foreign_keys="[Accession._object_key]", uselist=False) @property def reference(self): """ hopefully there is only one reference per antibody """ reference = None # just pick the first one if self.references: reference = self.references[0] return reference