class XYZPoint(mdb.EmbeddedDocument): # pylint: disable=too-few-public-methods
"""Represent a 3d point."""
xval = mdb.FloatField(required=True)
yval = mdb.FloatField(required=True)
zval = mdb.FloatField(default=1)
name = mdb.StringField()
class HmpSitesResult(ToolResult): # pylint: disable=too-few-public-methods
"""HMP Sites tool's result type."""
# Lists of values for each example microbiome comparison; may not be empty
skin = mongoDB.ListField(mongoDB.FloatField(), required=True)
oral = mongoDB.ListField(mongoDB.FloatField(), required=True)
urogenital_tract = mongoDB.ListField(mongoDB.FloatField(), required=True)
airways = mongoDB.ListField(mongoDB.FloatField(), required=True)
gastrointestinal = mongoDB.ListField(mongoDB.FloatField(), required=True)
def clean(self):
"""Check that all vals are in range [0, 1] if not then error."""
def validate(*vals):
"""Confirm values are in range [0,1], if they exist."""
for value_list in vals:
for value in value_list:
if value is not None and (value < 0 or value > 1):
return False
return True
if not validate(self.skin, self.oral, self.urogenital_tract,
self.airways, self.gastrointestinal):
msg = 'HMPSitesResult values in bad range'
raise ValidationError(msg)
@staticmethod
def site_names():
"""Return the names of the body sites."""
return [
'skin', 'oral', 'urogenital_tract', 'airways', 'gastrointestinal'
]
class ReadsClassifiedToolResult(ToolResult): # pylint: disable=too-few-public-methods
"""Reads Classified tool's result type."""
total = mongoDB.FloatField(required=True, default=0)
viral = mongoDB.FloatField(required=True, default=0)
archaeal = mongoDB.FloatField(required=True, default=0)
bacterial = mongoDB.FloatField(required=True, default=0)
host = mongoDB.FloatField(required=True, default=0)
nonhost_macrobial = mongoDB.FloatField(required=True, default=0)
fungal = mongoDB.FloatField(required=True, default=0)
nonfungal_eukaryotic = mongoDB.FloatField(required=True, default=0)
unknown = mongoDB.FloatField(required=True, default=0)
class ReadStatsSample(mdb.EmbeddedDocument): # pylint: disable=too-few-public-methods
"""A set of consistent fields for read stats."""
num_reads = mdb.IntField()
gc_content = mdb.FloatField()
codons = mdb.MapField(field=mdb.IntField(), required=True)
tetramers = mdb.MapField(field=mdb.IntField(), required=True)
class AlphaDiversityDatum(mdb.EmbeddedDocument):
"""AlphaDiv datum type."""
metrics = mdb.ListField(mdb.StringField())
category_value = mdb.StringField(required=True)
# metric -> distribution
by_metric = mdb.MapField(field=mdb.ListField(mdb.FloatField()))
class SingleReadsClassifiedResult(mdb.EmbeddedDocument): # pylint: disable=too-few-public-methods
"""Reads Classified for one sample."""
viral = mdb.FloatField(required=True, default=0)
archaeal = mdb.FloatField(required=True, default=0)
bacterial = mdb.FloatField(required=True, default=0)
host = mdb.FloatField(required=True, default=0)
nonhost_macrobial = mdb.FloatField(required=True, default=0)
fungal = mdb.FloatField(required=True, default=0)
nonfungal_eukaryotic = mdb.FloatField(required=True, default=0)
unknown = mdb.FloatField(required=True, default=0)
class ReadStatsToolResult(ToolResult): # pylint: disable=too-few-public-methods
"""A set of consistent fields for read stats."""
num_reads = mongoDB.IntField()
gc_content = mongoDB.FloatField()
codons = mongoDB.MapField(field=mongoDB.IntField(), required=True)
tetramers = mongoDB.MapField(field=mongoDB.IntField(), required=True)
@staticmethod
def stat_fields():
"""Return a list of the stats collected."""
return ['num_reads', 'gc_content', 'codons', 'tetramers']
class MicrobeCensusResult(ToolResult): # pylint: disable=too-few-public-methods
"""Mic Census tool's result type."""
average_genome_size = mongoDB.FloatField(required=True)
total_bases = mongoDB.IntField(required=True)
genome_equivalents = mongoDB.FloatField(required=True)
def clean(self):
"""Check all values are non-negative, if not raise an error."""
def validate(*vals):
"""Check vals are non-negative, return a bool."""
for val in vals:
if val is not None and val < 0:
return False
return True
if not validate(self.average_genome_size,
self.total_bases,
self.genome_equivalents):
msg = 'MicrobeCensusResult values must be non-negative'
raise ValidationError(msg)
class AncestryToolResult(ToolResult): # pylint: disable=too-few-public-methods
"""Ancestry result type."""
# Dict of form: {<location_id: string>: <percentage: float>}
populations = mongoDB.MapField(field=mongoDB.FloatField(), required=True)
def clean(self):
"""Check that all keys are known, all values are [0, 1]."""
for loc, val in self.populations.items():
if loc not in KNOWN_LOCATIONS:
raise ValidationError('No known location: {}'.format(loc))
if (val > 1) or (val < 0):
raise ValidationError('Value in bad range.')
class MacrobialRow(mongoDB.EmbeddedDocument): # pylint: disable=too-few-public-methods
"""Row for a gene in Macrobial."""
total_reads = mongoDB.IntField()
rpkm = mongoDB.FloatField()
class Humann2PathwaysRow(mongoDB.EmbeddedDocument): # pylint: disable=too-few-public-methods
"""Row for a pathways in humann2."""
abundance = mongoDB.FloatField()
coverage = mongoDB.FloatField()
class VFDBSampleDocument(mdb.EmbeddedDocument): # pylint: disable=too-few-public-methods
"""Tool document type."""
rpkm = mdb.MapField(mdb.FloatField(), required=True)
rpkmg = mdb.MapField(mdb.FloatField(), required=True)
class FunctionalGenesSampleDocument(mdb.EmbeddedDocument): # pylint: disable=too-few-public-methods
"""Row in Functional Genes table document type."""
rpkm = mdb.MapField(mdb.FloatField(), required=True)
rpkmg = mdb.MapField(mdb.FloatField(), required=True)
class Humann2NormalizeRow(mongoDB.EmbeddedDocument): # pylint: disable=too-few-public-methods
"""Row for a gene in Humann2 Normalize."""
rpk = mongoDB.FloatField()
rpkm = mongoDB.FloatField()
rpkmg = mongoDB.FloatField()
class VFDBRow(mongoDB.EmbeddedDocument): # pylint: disable=too-few-public-methods
"""Row for a gene in VFDB."""
rpk = mongoDB.FloatField()
rpkm = mongoDB.FloatField()
rpkmg = mongoDB.FloatField()
class HMPDatum(mdb.EmbeddedDocument): # pylint: disable=too-few-public-methods
"""HMP datum type."""
name = mdb.StringField(required=True)
data = mdb.ListField(mdb.ListField(mdb.FloatField()), required=True)
class ShortbredResult(ToolResult): # pylint: disable=too-few-public-methods
"""Shortbred tool's result type."""
# Abundances is of the form: {<amr_gene>: <abundance_value>}
abundances = mongoDB.MapField(mongoDB.FloatField(), required=True)
class MacrobeResult(mdb.EmbeddedDocument): # pylint: disable=too-few-public-methods
"""Set of macrobe results."""
samples = mdb.MapField(mdb.MapField(mdb.FloatField()), required=True)
class PopulationEntry(mdb.EmbeddedDocument):
"""Ancestry population entry."""
# Dict of form: {<location_id: string>: <percentage: float>}
populations = mdb.MapField(field=mdb.FloatField(), required=True)
class PathwaySampleDocument(mdb.EmbeddedDocument): # pylint: disable=too-few-public-methods
"""Pathway for a single sample."""
pathway_abundances = mdb.MapField(mdb.FloatField(), required=True)
pathway_coverages = mdb.MapField(mdb.FloatField(), required=True)
class AMRRow(mongoDB.EmbeddedDocument): # pylint: disable=too-few-public-methods
"""Row for a gene in CARD AMR Alignment."""
rpk = mongoDB.FloatField()
rpkm = mongoDB.FloatField()
rpkmg = mongoDB.FloatField()