def setUpClass(cls):
axis_labels = ['PC1', 'PC2', 'PC3']
cls.test_df1 = pd.DataFrame.from_dict(
{
's1': [0.1, 0.2, 7],
's2': [0.9, 0.2, 7],
},
orient='index',
columns=axis_labels,
)
cls.test_df1.index.name = 'Sample ID'
cls.pcoa1 = OrdinationResults(
'pcoa1',
'pcoa1',
eigvals=pd.Series(
[7, 2, 1],
index=axis_labels,
),
samples=cls.test_df1,
proportion_explained=pd.Series(
[0.7, 0.2, 0.1],
index=axis_labels,
),
)
cls.test_metadata = pd.DataFrame(
{
'age_cat': ['30s', '40s', '50s', '30s', None],
'num_cat': [7.24, 7.24, 8.25, 7.24, None],
'other': [1, 2, 3, 4, None],
},
index=pd.Series(['s1', 's2', 'c', 'd', 'e'], name='#SampleID'))
cls.resources = DictElement({
'datasets':
DictElement({
'dataset1':
DictElement({
'__metadata__':
MockMetadataElement(cls.test_metadata),
'__pcoa__':
PCOAElement({
'sample_set':
DictElement({
'beta_metric': cls.pcoa1,
}),
})
}),
'dataset2':
DictElement({
'__metadata__':
MockMetadataElement(cls.test_metadata),
}),
}),
})
cls.resources.accept(TrivialVisitor())
cls.res_patcher = patch(
'microsetta_public_api.api.emperor.get_resources')
cls.mock_resources = cls.res_patcher.start()
cls.mock_resources.return_value = cls.resources
def test_nested_element(self):
element = AlphaElement(DictElement({'a': 'b',
'c': MetadataElement('d')}))
mock = MagicMock()
element.accept(mock)
mock.visit_alpha.assert_called()
mock.visit_metadata.assert_called()
def atomic_update_resources(resource):
# create a new element to store the data in
element = DictElement()
element.update(resource)
visitor = Q2Visitor()
element.accept(visitor)
# after data has been loaded by the q2 visitor, update resources_alt
# so that it is accessible.
# Updating resources_alt from another element means the server will
# not show the skeleton of any unloaded data to the client
resources_alt.update(element)
def setUp(self):
super().setUp()
dm_values = [[0, 1, 2, 3], [1, 0, 3, 4], [2, 3, 0, 5], [3, 4, 5, 0]]
ids = ['s1', 's2', 's3', 's4']
dm = DistanceMatrix(
dm_values,
ids=ids,
)
self.resources = DictElement({
'datasets':
DictElement({
'dataset1':
DictElement({'__beta__': BetaElement({'unifrac': dm})}),
}),
})
self.resources.accept(TrivialVisitor())
self.res_patcher = patch(
'microsetta_public_api.api.diversity.beta.get_resources')
self.mock_resources = self.res_patcher.start()
self.mock_resources.return_value = self.resources
def setUp(self):
super().setUp()
neighbors = pd.DataFrame([['s2', 's3', 's4'], ['s1', 's3', 's4'],
['s1', 's2', 's4'], ['s1', 's2', 's3']],
columns=['k0', 'k1', 'k2'],
index=['s1', 's2', 's3', 's4'])
neighbors.index.name = 'sample_id'
self.resources = DictElement({
'datasets':
DictElement({
'dataset1':
DictElement(
{'__neighbors__': BetaElement({'unifrac': neighbors})}),
}),
})
self.resources.accept(TrivialVisitor())
self.res_patcher = patch(
'microsetta_public_api.api.diversity.beta.get_resources')
self.mock_resources = self.res_patcher.start()
self.mock_resources.return_value = self.resources
def setUp(self):
super().setUp()
faith_pd_values = [1, 2, 3, 4]
faith_pd_index = ['s01', 's02', 's04', 's05']
shannon_values = [7.24, 9.05, 8.25]
shannon_index = ['s01', 's02', 'sOther']
metadata = MockMetadataElement(
pd.DataFrame(
{
'age_cat': ['30s', '40s', '50s', '30s', '30s'],
'num_var': [3, 4, 5, 6, 7],
},
index=['s01', 's02', 's04', 's05', 'sOther']))
self.resources = DictElement({
'datasets':
DictElement({
'dataset1':
DictElement({
'__metadata__':
metadata,
'__alpha__':
AlphaElement({
'faith_pd':
pd.Series(faith_pd_values, index=faith_pd_index),
'shannon':
pd.Series(shannon_values, index=shannon_index),
})
}),
'dataset2':
DictElement({
'__metadata__': metadata,
}),
}),
})
self.resources.accept(TrivialVisitor())
self.res_patcher = patch(
'microsetta_public_api.api.plotting.get_resources')
self.mock_resources = self.res_patcher.start()
self.mock_resources.return_value = self.resources
def setUpClass(cls):
cls.post_body = {
'sample_ids': [
'sample-1',
'sample-2',
]
}
cls.table = biom.Table(np.array([[0, 1, 2], [2, 4, 6], [3, 0, 1]]),
['feature-1', 'feature-2', 'feature-3'],
['sample-1', 'sample-2', 'sample-3'])
cls.taxonomy_df = pd.DataFrame(
[['feature-1', 'a; b; c', 0.123],
['feature-2', 'a; b; c; d; e', 0.345],
['feature-3', 'a; f; g; h', 0.678]],
columns=['Feature ID', 'Taxon', 'Confidence'])
cls.taxonomy_df.set_index('Feature ID', inplace=True)
# variances
cls.table_vars = biom.Table(
np.array([[0, 1, 2], [2, 4, 6],
[3, 0, 1]]), ['feature-1', 'feature-2', 'feature-3'],
['sample-1', 'sample-2', 'sample-3'])
cls.table_name = 'some-table'
cls.table_with_var_name = 'some-table-w-var'
cls.resources = DictElement({
'datasets':
DictElement({
'dataset1':
DictElement({
'__taxonomy__':
TaxonomyElement({
cls.table_name: {
'table': cls.table,
'feature-data-taxonomy': cls.taxonomy_df,
},
cls.table_with_var_name: {
'table': cls.table,
'feature-data-taxonomy': cls.taxonomy_df,
'variances': cls.table_vars,
}
})
}),
'dataset2':
DictElement({}),
'__metadata__':
MockMetadataElement(
pd.DataFrame(
{
'age_cat': ['30s', '40s', '50s', '30s', '30s'],
'num_var': [3, 4, 5, 6, 7],
},
index=['s01', 's02', 's04', 's05', 'sOther']))
}),
})
cls.resources.accept(TrivialVisitor())
cls.res_patcher = patch(
'microsetta_public_api.api.taxonomy.get_resources')
cls.mock_resources = cls.res_patcher.start()
cls.mock_resources.return_value = cls.resources
def test_updates(self):
element = DictElement({'a': DictElement({'b': None})})
element.updates(MetadataElement('Arg'), 'a', 'b')
self.assertEqual('Arg', element.gets('a', 'b'))
element.updates('Arg2', 'a', 'b', 'c', 'd', 'e')
self.assertEqual('Arg2', element.gets('a', 'b', 'c', 'd', 'e'))
element.updates('Arg3', 'c', 'd')
self.assertEqual('Arg3', element['c']['d'])
element.updates(DictElement({'a': DictElement({'c': MetadataElement(
'Arg4')
})}))
self.assertEqual('Arg3', element['c']['d'])
self.assertEqual('Arg4', element['a']['c'])
exp = {'bar': {'qux': 'corge', 'hoge': 'piyo'}}
foo = DictElement({'bar': DictElement({'qux': 'corge'})})
foo.updates('piyo', 'bar', 'hoge')
self.assertDictEqual(exp, foo)
foo = DictElement({'bar': DictElement({'qux': 'corge'})})
foo.updates({'bar': DictElement({'hoge': 'piyo'})})
self.assertDictEqual(exp, foo)
exp = {'bar': {'qux': 'corge', 'hoge': 'fuga'}}
foo.updates('fuga', 'bar', 'hoge')
self.assertDictEqual(exp, foo)
foo.updates('waldo', 'bar', 'garp', 'grault')
exp = {'bar': {'qux': 'corge', 'hoge': 'fuga',
'garp': {'grault': 'waldo'}}}
self.assertDictEqual(exp, foo)
foo = DictElement()
foo.updates({'datasets': {'garply': 'grault'}})
self.assertDictEqual({'datasets': {'garply': 'grault'}}, foo)
foo = DictElement()
foo.updates({'datasets': AlphaElement({'garply': 'grault'})})
self.assertDictEqual({'datasets': {'garply': 'grault'}}, foo)
self.assertIsInstance(foo['datasets'], AlphaElement)
@timeit('vist_taxonomy')
def visit_taxonomy(self, element):
element.data = _transform_dict_of_table(element,
self.schema.taxonomy_kw)
@timeit('visit_pcoa')
def visit_pcoa(self, element):
element.data = _dict_of_dict_of_paths_to_pcoa(element,
self.schema.pcoa_kw)
@timeit('visit_metadata')
def visit_metadata(self, element):
element.data = _load_q2_metadata(element, self.schema.metadata_kw)
@timeit('visit_beta')
def visit_beta(self, element):
element.data = _dict_of_paths_to_beta_data(element,
self.schema.beta_kw)
@timeit('visit_dataset_detail')
def visit_dataset_detail(self, element):
element.data = _dict_of_literals_to_dict(element,
self.schema.detail_kw)
resources_alt = DictElement()
def get_resources():
return resources_alt