class ImagePaneAssocView(db.Model, MGIModel):
__tablename__ = "img_imagepane_assoc_view"
_assoc_key = db.Column(db.Integer, primary_key=True)
_imagepane_key = db.Column(db.Integer,
mgi_fk("img_imagepane._imagepane_key"),
primary_key=True)
_object_key = db.Column(db.Integer())
_mgitype_key = db.Column(db.Integer())
_imageclass_key = db.Column(db.Integer())
isprimary = db.Column(db.Integer())
mgiid = db.Column(db.String())
allele = db.relationship(
"Allele",
primaryjoin="and_(ImagePaneAssocView._object_key==Allele._allele_key, "
"ImagePaneAssocView._mgitype_key==11) ",
foreign_keys="[Allele._allele_key]",
uselist=False)
genotype = db.relationship(
"Genotype",
primaryjoin=
"and_(ImagePaneAssocView._object_key==Genotype._genotype_key, "
"ImagePaneAssocView._mgitype_key==12) ",
foreign_keys="[Genotype._genotype_key]",
uselist=False)
class AntibodyPrep(db.Model, MGIModel):
__tablename__ = "gxd_antibodyprep"
_antibodyprep_key = db.Column(db.Integer, primary_key=True)
_antibody_key = db.Column(db.Integer, mgi_fk("gxd_antibody._antibody_key"))
_secondary_key = db.Column(db.Integer)
_label_key = db.Column(db.Integer)
label = db.column_property(
db.select([GxdLabel.label]).where(GxdLabel._label_key == _label_key))
secondary = db.column_property(
db.select([GxdSecondary.secondary
]).where(GxdSecondary._secondary_key == _secondary_key))
# Relationships
antibody = db.relationship("Antibody",
backref=db.backref(
"antibodypreps",
order_by="AntibodyPrep._antibodyprep_key"),
uselist=False)
# assay
# backref defined in Assay class
marker = db.relationship("Marker",
secondary=Assay.__table__,
backref="antibodypreps",
uselist=False)
reference = db.relationship("Reference",
secondary=Assay.__table__,
backref="antibodypreps",
uselist=False)
class ProbeSource(db.Model, MGIModel):
__tablename__ = "prb_source"
_source_key = db.Column(db.Integer, primary_key=True)
_organism_key = db.Column(db.Integer)
_cellline_key = db.Column(db.Integer)
_gender_key = db.Column(db.Integer)
_refs_key = db.Column(db.Integer, mgi_fk("bib_refs._refs_key"))
_strain_key = db.Column(db.Integer, mgi_fk("prb_strain._strain_key"))
_tissue_key = db.Column(db.Integer)
name = db.Column(db.String())
description = db.Column(db.String())
age = db.Column(db.String())
# column properties
cellline = db.column_property(
db.select([VocTerm.term]).where(VocTerm._term_key == _cellline_key))
gender = db.column_property(
db.select([VocTerm.term]).where(VocTerm._term_key == _gender_key))
organism = db.column_property(
db.select([Organism.commonname
]).where(Organism._organism_key == _organism_key))
tissue = db.column_property(
db.select([ProbeTissue.tissue
]).where(ProbeTissue._tissue_key == _tissue_key))
# relationships
reference = db.relationship("Reference", uselist=False)
strain = db.relationship("Strain", uselist=False)
class MGIUser(db.Model, MGIModel):
__tablename__ = "mgi_user"
_user_key = db.Column(db.Integer, primary_key=True)
_usertype_key = db.Column(db.Integer, mgi_fk("voc_term._term_key"))
_userstatus_key = db.Column(db.Integer, mgi_fk("voc_term._term_key"))
login = db.Column(db.String())
name = db.Column(db.String())
usertype_object = db.relationship(
"VocTerm",
primaryjoin="VocTerm._term_key==MGIUser._usertype_key",
uselist=False)
userstatus_object = db.relationship(
"VocTerm",
primaryjoin="VocTerm._term_key==MGIUser._userstatus_key",
uselist=False)
# Properties for Flask-Login functionality
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return self.login
class ExperimentMarkerAssoc(db.Model, MGIModel):
__tablename__ = "mld_expt_marker"
_expt_key = db.Column(db.Integer,
mgi_fk("mld_expts._expt_key"),
primary_key=True)
_marker_key = db.Column(db.Integer,
mgi_fk("mrk_marker._marker_key"),
primary_key=True)
sequencenum = db.Column(db.Integer, primary_key=True)
_allele_key = db.Column(db.Integer, mgi_fk("all_allele._allele_key"))
_assay_type_key = db.Column(db.Integer)
description = db.Column(db.String())
matrixdata = db.Column(db.Integer)
# column properties
assaytype = db.column_property(
db.select([
ExperimentAssayType.description
]).where(ExperimentAssayType._assay_type_key == _assay_type_key))
# relationships
allele = db.relationship("Allele")
marker = db.relationship("Marker", backref="mapping_experiment_assocs")
@property
def matrixdata_display(self):
return self.matrixdata and 'yes' or 'no'
class InSituResult(db.Model, MGIModel):
__tablename__ = "gxd_insituresult"
_result_key = db.Column(db.Integer, primary_key=True)
_specimen_key = db.Column(db.Integer, mgi_fk("gxd_specimen._specimen_key"))
_strength_key = db.Column(db.Integer)
_pattern_key = db.Column(db.Integer)
sequencenum = db.Column(db.Integer)
resultnote = db.Column(db.String())
pattern = db.column_property(
db.select([GxdPattern.pattern
]).where(GxdPattern._pattern_key == _pattern_key))
strength = db.column_property(
db.select([GxdStrength.strength
]).where(GxdStrength._strength_key == _strength_key))
# Relationships
imagepanes = db.relationship("ImagePane",
secondary=InSituResultImagePane.__table__,
backref="insituresults")
structures = db.relationship("ADStructure",
secondary=InSituResultStructure.__table__,
order_by="ADStructure.printname",
backref="insituresults")
class MappingExperiment(db.Model, MGIModel):
__tablename__ = "mld_expts"
_expt_key = db.Column(db.Integer, primary_key=True)
_refs_key = db.Column(db.Integer, mgi_fk("bib_refs._refs_key"))
expttype = db.Column(db.String())
tag = db.Column(db.Integer())
chromosome = db.Column(db.String())
# key constants
_mgitype_key = 4
# other constants
# these are expttypes that are valid to display in the P-WI
VALID_EXPTTYPES = [
'TEXT', 'TEXT-Genetic Cross', 'TEXT-Physical Mapping', 'TEXT-QTL',
'TEXT-Congenic', 'TEXT-Meta Analysis', 'TEXT-QTL-Candidate Genes'
]
# column properties
mgiid = db.column_property(
db.select([Accession.accid]).where(
db.and_(Accession._mgitype_key == _mgitype_key,
Accession.prefixpart == 'MGI:', Accession.preferred == 1,
Accession._logicaldb_key == 1,
Accession._object_key == _expt_key)))
# relationships
mgiid_object = db.relationship(
"Accession",
primaryjoin="and_(Accession._object_key==MappingExperiment._expt_key,"
"Accession.prefixpart=='MGI:',"
"Accession.preferred==1,"
"Accession._logicaldb_key==1,"
"Accession._mgitype_key==%d)" % _mgitype_key,
foreign_keys="[Accession._object_key]",
uselist=False)
experiment_notechunks = db.relationship("ExperimentNoteChunk")
# beware, this field is limitting its search to only displayable experiment types in the P-WI
# this lets the marker detail know when to display a summary link to mapping data
marker_assocs = db.relationship(
"ExperimentMarkerAssoc",
primaryjoin=
"and_(ExperimentMarkerAssoc._expt_key==MappingExperiment._expt_key,"
"MappingExperiment.expttype.in_(%s))" % VALID_EXPTTYPES,
order_by="ExperimentMarkerAssoc.sequencenum")
reference = db.relationship("Reference", backref="mapping_experiments")
@property
def experimentnote(self):
return "".join([nc.note for nc in self.experiment_notechunks])
class GelLane(db.Model, MGIModel):
__tablename__ = "gxd_gellane"
_gellane_key = db.Column(db.Integer, primary_key=True)
_assay_key = db.Column(db.Integer, mgi_fk("gxd_assay._assay_key"))
_gelcontrol_key = db.Column(db.Integer, mgi_fk("gxd_gelcontrol"))
_genotype_key = db.Column(db.Integer, mgi_fk("gxd_genotype._genotype_key"))
_gelrnatype_key = db.Column(db.Integer)
sequencenum = db.Column(db.Integer)
age = db.Column(db.String())
agenote = db.Column(db.String())
lanelabel = db.Column(db.String())
lanenote = db.Column(db.String())
sampleamount = db.Column(db.String())
sex = db.Column(db.String())
controlcontent = db.column_property(
db.select([GelControl.gellanecontent
]).where(GelControl._gelcontrol_key == _gelcontrol_key))
rnatype = db.column_property(
db.select([GelRnaType.rnatype
]).where(GelRnaType._gelrnatype_key == _gelrnatype_key))
# relationships
gelbands = db.relationship("GelBand",
order_by="GelBand.gelrow_sequencenum",
backref=db.backref("gellane", uselist=False))
structures = db.relationship(
"ADStructure",
primaryjoin="GelLane._gellane_key==GelLaneStructure._gellane_key",
secondary=GelLaneStructure.__table__,
secondaryjoin=
"GelLaneStructure._structure_key==ADStructure._structure_key",
foreign_keys="[GelLane._gellane_key, ADStructure._structure_key]",
backref="gellanes")
genotype = db.relationship("Genotype", uselist=False)
@property
def lanelabel_display(self):
return self.lanelabel or 'Lane %s' % self.sequencenum
@property
def iscontrol(self):
return self._gelcontrol_key != 1
@property
def hasbandnote(self):
hasBandNote = False
for gelband in self.gelbands:
if gelband.bandnote != None:
hasBandNote = True
return hasBandNote
class GxdIndexRecord(db.Model, MGIModel):
__tablename__ = "gxd_index"
_index_key = db.Column(db.Integer, primary_key=True)
_refs_key = db.Column(db.Integer, mgi_fk("bib_refs._refs_key"))
_marker_key = db.Column(db.Integer, mgi_fk("mrk_marker._marker_key"))
_priority_key = db.Column(db.Integer)
_conditionalmutants_key = db.Column(db.Integer)
comments = db.Column(db.String())
# column properties
conditionalmutants = db.column_property(
db.select([VocTerm.term
]).where(VocTerm._term_key == _conditionalmutants_key))
fully_coded = db.column_property(db.exists().where(
db.and_(Result._marker_key == _marker_key,
Result._refs_key == _refs_key)))
priority = db.column_property(
db.select([VocTerm.term]).where(VocTerm._term_key == _priority_key))
# Relationships
marker = db.relationship("Marker",
backref="gxdindex_records",
uselist=False)
reference = db.relationship("Reference",
backref="gxdindex_records",
uselist=False)
indexstages = db.relationship("GxdIndexStage")
@property
def unique_stages(self):
"""
return sorted unique list
of stageids
"""
stageids = gxdindex_aggregator.getUniqueStageids([self])
return stageids
@property
def unique_assays(self):
"""
return sorted unique list
of indexassays with their ordered stage values
as [{'indexassay':'...', stages:[False,True,True,etc]
"""
assays = gxdindex_aggregator.getUniqueAssays([self])
return assays
class ImagePane(db.Model, MGIModel):
__tablename__ = "img_imagepane"
_imagepane_key = db.Column(db.Integer, primary_key=True)
_image_key = db.Column(db.Integer(), mgi_fk("img_image._image_key"))
panelabel = db.Column(db.String())
x = db.Column(db.Integer())
y = db.Column(db.Integer())
width = db.Column(db.Integer())
height = db.Column(db.Integer())
image = db.relationship("Image", uselist=False)
imagePaneAlleleAssocs = db.relationship(
"ImagePaneAssocView",
primaryjoin=
"and_(ImagePane._imagepane_key==ImagePaneAssocView._imagepane_key, "
"ImagePaneAssocView._mgitype_key==11) ",
foreign_keys="[ImagePaneAssocView._imagepane_key]")
imagePaneGenotypeAssocs = db.relationship(
"ImagePaneAssocView",
primaryjoin=
"and_(ImagePane._imagepane_key==ImagePaneAssocView._imagepane_key, "
"ImagePaneAssocView._mgitype_key==12) ",
foreign_keys="[ImagePaneAssocView._imagepane_key]")
# gel_assays
# backref defined in gxd.Assay class
# insituresults
# backref defined in InsituResult class
@property
def figurelabel(self):
figurelabel = self.image.figurelabel or ''
panelabel = self.panelabel or ''
return '%s%s' % (figurelabel, panelabel)
@property
def distinctInsituAssays(self):
distinctAssays = []
distinctAssaysKeys = []
for result in self.insituresults:
if result.specimen.assay._assay_key not in distinctAssaysKeys:
distinctAssays.append(result.specimen.assay)
distinctAssaysKeys.append(result.specimen.assay._assay_key)
distinctAssays.sort(key=lambda x: x.mgiid)
#ut.sort(key=lambda x: x.count, reverse=True)
return distinctAssays
class Accession(db.Model,MGIModel):
__tablename__ = "acc_accession"
_accession_key = db.Column(db.Integer,primary_key=True)
accid = db.Column(db.String())
prefixpart = db.Column(db.String())
numericpart = db.Column(db.Integer())
_logicaldb_key = db.Column(db.Integer(), mgi_fk("acc_logicaldb._logicaldb_key"))
_object_key = db.Column(db.Integer())
_mgitype_key = db.Column(db.Integer())
private = db.Column(db.Integer())
preferred = db.Column(db.Integer())
_createdby_key = db.Column(db.Integer())
_modifiedby_key = db.Column(db.Integer())
logicaldb = db.column_property(
db.select([LogicalDb.name]).
where(LogicalDb._logicaldb_key==_logicaldb_key)
)
# relationships
logicaldb_object = db.relationship("LogicalDb",
uselist=False)
mgitype = db.relationship("MGIType",
uselist=False,
primaryjoin="MGIType._mgitype_key==Accession._mgitype_key",
foreign_keys="[MGIType._mgitype_key]")
references = db.relationship("Reference",
secondary=AccessionReference.__table__,
backref="accessions")
emapsids = db.relationship("Accession",
primaryjoin="Accession.accid==EmapSMapping.accid",
secondary=EmapSMapping.__table__,
secondaryjoin="Accession.accid==EmapSMapping.emapsid",
foreign_keys="[EmapSMapping.emapsid, Accession.accid]",
backref="adstructureids")
vocterm = db.relationship("VocTerm",
primaryjoin="VocTerm._term_key==Accession._object_key",
foreign_keys="VocTerm._term_key",
uselist=False
)
def __repr__(self):
return "<AccID %s>"%(self.accid,)
class TrackRec(db.Model):
__tablename__ = "wts_trackrec"
key = db.Column(db.Integer, primary_key=True)
priority_key = db.Column(db.Integer, db.ForeignKey("cv_wts_priority.key"))
size_key = db.Column(db.Integer,
db.ForeignKey("cv_wts_size.key"),
index=True)
status_key = db.Column(db.Integer,
db.ForeignKey("cv_wts_status.key"),
index=True)
status_user_key = db.Column(db.Integer,
db.ForeignKey("cv_user.key"),
index=True)
status_set_date = db.Column(db.DateTime())
locked_user_key = db.Column(db.Integer,
db.ForeignKey("cv_user.key"),
index=True)
locked_date = db.Column(db.DateTime())
title = db.Column(db.String())
has_directory = db.Column(db.Boolean)
attention_by = db.Column(db.DateTime())
creation_date = db.Column(db.DateTime(), default=db.func.now())
modification_date = db.Column(db.DateTime(), default=db.func.now())
description = db.Column(db.String())
progress_notes = db.Column(db.String())
priority = db.relationship("Priority", uselist=False, backref="trs")
size = db.relationship("Size", uselist=False, backref="trs")
status = db.relationship("Status", uselist=False, backref="trs")
areas = db.relationship("Area",
secondary=TRAreaAssoc.__table__,
backref="trs")
types = db.relationship("Type",
secondary=TRTypeAssoc.__table__,
backref="trs")
assigned_users = db.relationship("User",
secondary=TRAssignedUserAssoc.__table__)
requested_by = db.relationship("User",
secondary=TRRequestedUserAssoc.__table__)
statusChanges = db.relationship("StatusHistory")
child_trs = db.relationship(
"TrackRec",
secondary=TrackRecChildAssoc.__table__,
primaryjoin="TrackRec.key==TrackRecChildAssoc.tr_key",
secondaryjoin="TrackRec.key==TrackRecChildAssoc.child_tr_key",
backref=db.backref("parent", uselist=False))
class Report(db.Model):
__tablename__ = "pwi_report"
__bind_key__ = "mgd"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(), index=True, nullable=False)
description = db.Column(db.String())
sql_text = db.Column(db.String(), nullable=False)
report_author = db.Column(db.String(), index=True, nullable=False)
requested_by = db.Column(db.String(), index=True, nullable=False)
type = db.Column(db.String())
created = db.Column(db.DateTime(), index=True, nullable=False)
last_run = db.Column(db.DateTime())
last_run_duration = db.Column(db.String())
report_views = db.Column(db.String())
labels = db.relationship("ReportLabel",
order_by="ReportLabel.label",
backref=db.backref("report"))
@property
def tagString(self):
return ", ".join(["%s" % l for l in self.labels])
@property
def safeFileName(self):
return "%s_%s.rpt" % (css(self.name), self.id)
def __repr__(self):
return "<Report id:%s,name:%s,author:%s>" % (self.id, self.name,
self.report_author)
class ReferenceAssoc(db.Model, MGIModel):
__tablename__ = "mgi_reference_assoc"
_assoc_key = db.Column(db.Integer, primary_key=True)
_refs_key = db.Column(db.Integer, mgi_fk("bib_refs._refs_key"))
_object_key = db.Column(db.Integer)
_mgitype_key = db.Column(db.Integer)
_refassoctype_key = db.Column(db.Integer)
reference = db.relationship("Reference", uselist=False)
class Sequence(db.Model, MGIModel):
__tablename__ = "seq_sequence"
_sequence_key = db.Column(db.Integer, primary_key=True)
_sequencetype_key = db.Column(db.Integer)
_sequencequality_key = db.Column(db.Integer)
_sequencestatus_key = db.Column(db.Integer)
_sequenceprovider_key = db.Column(db.Integer)
_organism_key = db.Column(db.Integer, mgi_fk("mgi_organism._organism_key"))
length = db.Column(db.String())
description = db.Column(db.String())
version = db.Column(db.String())
division = db.Column(db.String())
# constants
_mgitype_key = 19
# column definitions
type = db.column_property(
db.select([VocTerm.term
]).where(VocTerm._term_key == _sequencetype_key))
#relationships
markers = db.relationship(
"Marker",
secondary=SeqMarkerCache.__table__,
primaryjoin="Sequence._sequence_key==SeqMarkerCache._sequence_key",
secondaryjoin="SeqMarkerCache._marker_key==Marker._marker_key",
foreign_keys="[Sequence._sequence_key,Marker._marker_key]",
backref="sequences",
order_by="Marker.symbol")
# sequence can have multiple IDs
accession_objects = db.relationship(
"Accession",
primaryjoin="and_(Accession._object_key==Sequence._sequence_key,"
"Accession.preferred==1,"
"Accession._mgitype_key==%s)" % (_mgitype_key),
foreign_keys="[Accession._object_key]",
order_by="Accession.accid")
source = db.relationship("ProbeSource",
secondary=SeqSourceAssoc.__table__,
uselist=False)
class AccessionReference(db.Model,MGIModel):
__tablename__ = "acc_accessionreference"
_accession_key = db.Column(db.Integer,
mgi_fk("acc_accession._accession_key"),
primary_key=True)
_refs_key = db.Column(db.Integer,
mgi_fk("bib_refs._refs_key"),
primary_key=True)
accession = db.relationship("Accession",
uselist=False)
class AllelePair(db.Model, MGIModel):
__tablename__ = "gxd_allelepair"
_allelepair_key = db.Column(db.Integer, primary_key=True)
_genotype_key = db.Column(db.Integer, mgi_fk("gxd_genotype._genotype_key"))
_allele_key_1 = db.Column(db.Integer, mgi_fk("all_allele._allele_key"))
_allele_key_2 = db.Column(db.Integer, mgi_fk("all_allele._allele_key"))
_marker_key = db.Column(db.Integer, mgi_fk("mrk_marker._marker_key"))
_pairstate_key = db.Column(db.Integer)
sequencenum = db.Column(db.Integer)
chromosome = db.column_property(
db.select([Marker.chromosome
]).where(Marker._marker_key == _marker_key))
pairstate = db.column_property(
db.select([VocTerm.term]).where(VocTerm._term_key == _pairstate_key))
# relationships
allele1 = db.relationship(
"Allele",
primaryjoin="Allele._allele_key==AllelePair._allele_key_1",
uselist=False)
allele2 = db.relationship(
"Allele",
primaryjoin="Allele._allele_key==AllelePair._allele_key_2",
uselist=False)
@property
def display(self):
"""
displays allele 1 and 2 symbols
exactly as they are, without combination logic
"""
sym1 = self.allele1.symbol
sym2 = ''
if self.allele2:
sym2 = self.allele2.symbol
return "%s / %s" % (sym1, sym2)
def __repr__(self):
return self.display
class Specimen(db.Model, MGIModel):
__tablename__ = "gxd_specimen"
_specimen_key = db.Column(db.Integer, primary_key=True)
_assay_key = db.Column(db.Integer, mgi_fk("gxd_assay._assay_key"))
_genotype_key = db.Column(db.Integer, mgi_fk("gxd_genotype._genotype_key"))
age = db.Column(db.String())
agenote = db.Column(db.String())
hybridization = db.Column(db.String())
sex = db.Column(db.String())
specimenlabel = db.Column(db.String())
specimennote = db.Column(db.String())
sequencenum = db.Column(db.Integer)
_embedding_key = db.Column(db.Integer)
_fixation_key = db.Column(db.Integer)
embeddingmethod = db.column_property(
db.select([EmbeddingMethod.embeddingmethod
]).where(EmbeddingMethod._embedding_key == _embedding_key))
fixation = db.column_property(
db.select([FixationMethod.fixation
]).where(FixationMethod._fixation_key == _fixation_key))
insituresults = db.relationship(
"InSituResult",
primaryjoin="InSituResult._specimen_key==Specimen._specimen_key",
foreign_keys="[InSituResult._specimen_key]",
order_by="InSituResult.sequencenum",
backref=db.backref("specimen", uselist=False))
genotype = db.relationship("Genotype", uselist=False)
@property
def imagepanes(self):
panes = []
seen = set()
if self.insituresults:
for result in self.insituresults:
for pane in result.imagepanes:
if pane not in seen:
panes.append(pane)
seen.add(pane)
return panes
class ProbeAlleleStrain(db.Model, MGIModel):
__tablename__ = "prb_allele_strain"
_allele_key = db.Column(db.Integer,
mgi_fk("prb_allele._allele_key"),
primary_key=True)
_strain_key = db.Column(db.Integer(),
mgi_fk("prb_strain._strain_key"),
primary_key=True)
strain = db.relationship("Strain", uselist=False)
class ProbeAllele(db.Model, MGIModel):
__tablename__ = "prb_allele"
_allele_key = db.Column(db.Integer, primary_key=True)
_rflv_key = db.Column(db.Integer,
mgi_fk("prb_rflv._rflv_key"),
primary_key=True)
allele = db.Column(db.String())
fragments = db.Column(db.String())
probe_allele_strains = db.relationship("ProbeAlleleStrain",
backref=db.backref("probe",
uselist=False))
class SeqMarkerCache(db.Model, MGIModel):
__tablename__ = "seq_marker_cache"
_cache_key = db.Column(db.Integer, primary_key=True)
_sequence_key = db.Column(db.Integer, mgi_fk("seq_sequence._sequence_key"))
_marker_key = db.Column(db.Integer, mgi_fk("mrk_marker._marker_key"))
_organism_key = db.Column(db.Integer)
_logicaldb_key = db.Column(db.Integer,
mgi_fk("acc_logicaldb._logicaldb_key"))
accid = db.Column(db.String())
rawbiotype = db.Column(db.String())
_sequenceprovider_key = db.Column(db.Integer)
_biotypeconflict_key = db.Column(db.Integer, mgi_fk("voc_term._term_key"))
annotation_date = db.Column(db.DateTime)
# constants
# the biotype conflict term
_biotypeconflict_yes_key = 5420767
# column properties
sequenceprovider = db.column_property(
db.select([VocTerm.term
]).where(VocTerm._term_key == _sequenceprovider_key))
marker = db.relationship("Marker")
logicaldb_obj = db.relationship("LogicalDb")
@property
def sequence_url(self):
"""
This requires loading logicaldb_obj
and logicaldb_obj.actualdb
"""
url = ""
if self.logicaldb_obj and \
self.logicaldb_obj.actualdb:
url = self.logicaldb_obj.actualdb.url.replace("@@@@", self.accid)
return url
class ProbeRFLV(db.Model, MGIModel):
__tablename__ = "prb_rflv"
_rflv_key = db.Column(db.Integer, primary_key=True)
_reference_key = db.Column(db.Integer,
mgi_fk("prb_reference._reference_key"),
primary_key=True)
_marker_key = db.Column(db.Integer,
mgi_fk("mrk_marker._marker_key"),
primary_key=True)
endonuclease = db.Column(db.String())
# relationships
marker = db.relationship(
"Marker",
primaryjoin="ProbeRFLV._marker_key==Marker._marker_key",
foreign_keys="[Marker._marker_key]",
uselist=False)
probe_alleles = db.relationship("ProbeAllele",
order_by="ProbeAllele.allele",
backref=db.backref("probe", uselist=False))
class DagNode(db.Model,MGIModel):
__tablename__ = "dag_node"
_node_key = db.Column(db.Integer,primary_key=True)
_object_key = db.Column(db.Integer)
_dag_key = db.Column(db.Integer, mgi_fk("dag_dag._dag_key"))
_label_key = db.Column(db.Integer)
dag_mgitype_key = db.column_property(db.select([Dag._mgitype_key]).
where(Dag._dag_key==_dag_key)
)
dag_name = db.column_property(db.select([Dag.name]).
where(Dag._dag_key==_dag_key)
)
label = db.column_property(db.select([DagLabel.label]).
where(DagLabel._label_key==_label_key)
)
# relationships
parent_edges = db.relationship("DagEdge",
primaryjoin="DagNode._node_key==DagEdge._child_key",
order_by="DagEdge.sequencenum",
backref=db.backref("child_node",uselist=False)
)
child_edges = db.relationship("DagEdge",
primaryjoin="DagNode._node_key==DagEdge._parent_key",
order_by="DagEdge.sequencenum",
backref=db.backref("parent_node",uselist=False)
)
# vocterm
# defined in VocTerm
def __repr__(self):
return "DagNode(key=%s)" % (self._node_key)
class LogicalDb(db.Model,MGIModel):
__tablename__ = "acc_logicaldb"
_logicaldb_key = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
actualdbs = db.relationship("ActualDb")
@property
def actualdb(self):
"""
Returns the first actualdb object
"""
return self.actualdbs and self.actualdbs[0] or None
class NOM_Marker(db.Model, MGIModel):
__tablename__ = "nom_marker"
_nomen_key = db.Column(db.Integer, primary_key=True)
_marker_type_key = db.Column(db.Integer)
_marker_type_key.hidden = True
_nomenstatus_key = db.Column(db.Integer)
_nomenstatus_key.hidden = True
symbol = db.Column(db.String())
name = db.Column(db.String())
chromosome = db.Column(db.String())
statusnote = db.Column(
db.String(convert_unicode='force', unicode_error="ignore"))
# key constants
_mgitype_key = 21
_nomenstatus_vocab_key = 16
# mapped fields
markertype = db.column_property(
db.select([MarkerType.name
]).where(MarkerType._marker_type_key == _marker_type_key))
nomenstatus = db.column_property(
db.select([VocTerm.term]).
where(db.and_(VocTerm._term_key==_nomenstatus_key, \
VocTerm._vocab_key==_nomenstatus_vocab_key)
)
)
mgiid = db.column_property(
db.select([Accession.accid]).where(
db.and_(Accession._mgitype_key == _mgitype_key,
Accession.prefixpart == 'MGI:', Accession.preferred == 1,
Accession._logicaldb_key == 1,
Accession._object_key == _nomen_key)))
# one to many objects
synonyms = db.relationship(
"Synonym",
primaryjoin="and_(NOM_Marker._nomen_key==Synonym._object_key, "
"Synonym._mgitype_key==%d)" % _mgitype_key,
order_by="Synonym.synonym",
foreign_keys="[Synonym._object_key]")
def __repr__(self):
return "<NOM %s (%s) - %s>" % (self.symbol, self.mgiid,
self.nomenstatus)
class AntibodyAlias(db.Model, MGIModel):
__tablename__ = "gxd_antibodyalias"
_antibodyalias_key = db.Column(db.Integer, primary_key=True)
_antibody_key = db.Column(db.Integer,
mgi_fk("gxd_antibody._antibody_key"),
primary_key=True)
_refs_key = db.Column(db.Integer, mgi_fk("bib_refs._refs_key"))
alias = db.Column(db.String())
# relationships
reference = db.relationship("Reference",
backref=db.backref("AntibodyAlias",
uselist=False),
uselist=False)
class GelBand(db.Model, MGIModel):
__tablename__ = "gxd_gelband"
_gelband_key = db.Column(db.Integer, primary_key=True)
_gelrow_key = db.Column(db.Integer, mgi_fk("gxd_gelrow._gelrow_key"))
_gellane_key = db.Column(db.Integer, mgi_fk("gxd_gellane._gellane_key"))
_strength_key = db.Column(db.Integer)
bandnote = db.Column(db.String())
strength = db.column_property(
db.select([GxdStrength.strength
]).where(GxdStrength._strength_key == _strength_key))
gelrow_sequencenum = db.column_property(
db.select([GelRow.sequencenum
]).where(GelRow._gelrow_key == _gelrow_key))
gelrow = db.relationship("GelRow", uselist=False)
class Note(db.Model, MGIModel):
__tablename__ = "mgi_note"
_note_key = db.Column(db.Integer, primary_key=True)
_object_key = db.Column(db.Integer)
_mgitype_key = db.Column(db.Integer)
_notetype_key = db.Column(db.Integer)
notetype = db.column_property(
db.select([NoteType.notetype
]).where(NoteType._notetype_key == _notetype_key))
chunks = db.relationship("NoteChunk", order_by="NoteChunk.sequencenum")
@property
def text(self):
return ''.join([c.note for c in self.chunks])
def __repr__(self):
return self.text
class Antigen(db.Model, MGIModel):
__tablename__ = "gxd_antigen"
_antigen_key = db.Column(db.Integer, primary_key=True)
_source_key = db.Column(db.Integer, mgi_fk("prb_source._source_key"))
antigenname = db.Column(db.String())
regioncovered = db.Column(db.String())
antigennote = db.Column(db.String())
_mgitype_key = 7
mgiid = db.column_property(
db.select([Accession.accid]).where(
db.and_(Accession._mgitype_key == _mgitype_key,
Accession.prefixpart == 'MGI:', Accession.preferred == 1,
Accession._logicaldb_key == 1,
Accession._object_key == _antigen_key)))
# antibodies
# backref defined in Antibody class
source = db.relationship("ProbeSource", uselist=False)
class ProbePrep(db.Model, MGIModel):
__tablename__ = "gxd_probeprep"
_probeprep_key = db.Column(db.Integer, primary_key=True)
_probe_key = db.Column(db.Integer, mgi_fk("prb_probe._probe_key"))
_sense_key = db.Column(db.Integer)
_label_key = db.Column(db.Integer)
_visualization_key = db.Column(db.Integer)
type = db.Column(db.String())
label = db.column_property(
db.select([GxdLabel.label]).where(GxdLabel._label_key == _label_key))
sense = db.column_property(
db.select([ProbeSense.sense
]).where(ProbeSense._sense_key == _sense_key))
visualization = db.column_property(
db.select([
VisualizationMethod.visualization
]).where(VisualizationMethod._visualization_key == _visualization_key))
# Relationships
probe = db.relationship("Probe", backref="probepreps")
# relationships
parent_edges = db.relationship("DagEdge",
primaryjoin="DagNode._node_key==DagEdge._child_key",
order_by="DagEdge.sequencenum",
backref=db.backref("child_node",uselist=False)
)
child_edges = db.relationship("DagEdge",
primaryjoin="DagNode._node_key==DagEdge._parent_key",
order_by="DagEdge.sequencenum",
backref=db.backref("parent_node",uselist=False)
)
# vocterm
# defined in VocTerm
def __repr__(self):
return "DagNode(key=%s)" % (self._node_key)
# define ancestor_vocterms here to avoid cyclic import
VocTerm.ancestor_vocterms = db.relationship("VocTerm",
primaryjoin="and_(DagClosure._descendentobject_key==VocTerm._term_key,"
"DagClosure._mgitype_key==%d)" % VocTerm._mgitype_key,
secondary=DagClosure.__table__,
secondaryjoin="DagClosure._ancestorobject_key==VocTerm._term_key",
foreign_keys="[DagClosure._descendentobject_key, VocTerm._term_key]"
)
