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 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 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 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 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 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 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 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 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 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 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 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
