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
