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 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 AlphaDiversityResult(mdb.EmbeddedDocument):
"""Embedded results for alpha diversity."""
# Categories dict has form: {<category_name>: [<category_value>, ...]}
categories = mdb.MapField(field=mdb.ListField(mdb.StringField()),
required=True)
tool_names = mdb.ListField(mdb.StringField())
by_tool = mdb.MapField(field=EmDoc(AlphaDiversityTool), required=True)
class HMPResult(mdb.EmbeddedDocument): # pylint: disable=too-few-public-methods
"""HMP document type."""
categories = mdb.MapField(field=StringList, required=True)
sites = mdb.ListField(mdb.StringField(), required=True)
data = mdb.MapField(field=EmDocList(HMPDatum), required=True)
def clean(self):
"""Ensure integrity of result content."""
for category, values in self.categories.items():
if category not in self.data:
msg = f'Category \'{category}\' is not present in \'data\'!'
raise ValidationError(msg)
values_present = [datum.name for datum in self.data[category]]
for value in values:
if value not in values_present:
msg = f'Value \'{value}\' is not present in \'data\'!'
raise ValidationError(msg)
for category_name, category_data in self.data.items():
if len(category_data) != len(self.categories[category_name]):
msg = (f'Category data for {category_name} does not match size of '
f'category values ({len(self.categories[category_name])})!')
raise ValidationError(msg)
for datum in category_data:
if len(datum.data) != len(self.sites):
msg = (f'Datum <{datum.name}> of size {len(datum.data)} '
f'does not match size of sites ({len(self.sites)})!')
raise ValidationError(msg)
class SampleSimilarityResult(mdb.EmbeddedDocument): # pylint: disable=too-few-public-methods
"""Sample Similarity document type."""
# Categories dict is of the form: {<category_name>: [<category_value>, ...]}
categories = mdb.MapField(field=StringList, required=True)
# Tools dict is of the form: {<tool_name>: <ToolDocument>}
tools = mdb.MapField(field=EmbeddedDoc(ToolDocument), required=True)
data_records = mdb.ListField(mdb.DictField(), required=True)
def clean(self):
"""Ensure that `data_records` contain valid records."""
category_names = self.categories.keys()
tool_names = self.tools.keys()
for record in self.data_records:
for category_name in category_names:
if category_name not in record:
msg = 'Record must have all categories.'
raise ValidationError(msg)
for tool_name in tool_names:
xname = '{}_x'.format(tool_name)
yname = '{}_y'.format(tool_name)
if (xname not in record) or (yname not in record):
msg = 'Record must x and y for all tools.'
raise ValidationError(msg)
# pylint: disable=too-few-public-methods
"""Average Genome Size display models."""
from app.extensions import mongoDB as mdb
from app.display_modules.shared_models import DistributionResult
# Define aliases
EmbeddedDoc = mdb.EmbeddedDocumentField # pylint: disable=invalid-name
StringList = mdb.ListField(mdb.StringField()) # pylint: disable=invalid-name
class AGSResult(mdb.EmbeddedDocument):
"""AGS document type."""
# Categories dict has form: {<category_name>: [<category_value>, ...]}
categories = mdb.MapField(field=StringList, required=True)
# Distribution dict has form: {<category_name>: {<category_value>: <dist>}}
distributions = mdb.MapField(
field=mdb.MapField(field=EmbeddedDoc(DistributionResult)),
required=True)
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 ToolCategoryDocument(mdb.EmbeddedDocument): # pylint: disable=too-few-public-methods
"""The base data type that generates a particular plot."""
pval_histogram = mdb.ListField(EmbeddedDoc(XYZPoint))
scatter_plot = mdb.ListField(EmbeddedDoc(XYZPoint), required=True)
class AlphaDiversityTool(mdb.EmbeddedDocument):
"""Store a map of rank -> AlphaDiversityRank."""
taxa_ranks = mdb.ListField(mdb.StringField())
by_taxa_rank = mdb.MapField(field=EmDoc(AlphaDiversityRank))
