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 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 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 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 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 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 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 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 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
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
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__()