def seed_db():
"""Seed the database."""
bchrobot = User(username='******',
email='*****@*****.**',
password='******')
dcdanko = User(username='******',
email='*****@*****.**',
password='******')
cmason = User(username='******',
email='*****@*****.**',
password='******')
abrf_analysis_result_01 = AnalysisResultMeta(reads_classified=reads_classified).save()
abrf_sample_01 = Sample(name='SomethingUnique_A',
analysis_result=abrf_analysis_result_01).save()
abrf_analysis_result_02 = AnalysisResultMeta(reads_classified=reads_classified).save()
abrf_sample_02 = Sample(name='SomethingUnique_B',
analysis_result=abrf_analysis_result_02).save()
abrf_analysis_result.save()
abrf_uuid = UUID('00000000-0000-4000-8000-000000000000')
abrf_description = 'ABRF San Diego Mar 24th-29th 2017'
abrf_2017_group = SampleGroup(name='ABRF 2017',
analysis_result=abrf_analysis_result,
description=abrf_description)
abrf_2017_group.id = abrf_uuid
abrf_2017_group.samples = [abrf_sample_01, abrf_sample_02]
uw_analysis_result.save()
uw_sample = Sample(name='UW_Madison_00', analysis_result=uw_analysis_result).save()
uw_group_result = AnalysisResultMeta().save()
uw_madison_group = SampleGroup(name='The UW Madison Project',
analysis_result=uw_group_result)
uw_madison_group.samples = [uw_sample]
fuzz_uuid = UUID('00000000-0000-4000-8000-000000000001')
fuzz_group = create_saved_group(uuid=fuzz_uuid)
mason_lab = Organization(name='Mason Lab', admin_email='*****@*****.**')
mason_lab.users = [bchrobot, dcdanko, cmason]
mason_lab.sample_groups = [abrf_2017_group, uw_madison_group, fuzz_group]
db.session.add(mason_lab)
db.session.commit()
mason_lab.add_admin(bchrobot)
mason_lab.add_admin(dcdanko)
db.session.commit()
def test_collate_samples(self):
"""Ensure collate_samples task works."""
sample1_data = {'name': 'Sample01', KRAKEN_NAME: create_kraken()}
sample2_data = {'name': 'Sample02', KRAKEN_NAME: create_kraken()}
sample1 = Sample(**sample1_data).save()
sample2 = Sample(**sample2_data).save()
sample_group = add_sample_group(name='SampleGroup01')
sample_group.samples = [sample1, sample2]
db.session.commit()
samples = [sample.fetch_safe() for sample in [sample1, sample2]]
result = collate_samples.delay(KRAKEN_NAME, ['taxa'], samples).get()
self.assertIn('Sample01', result)
self.assertIn('Sample02', result)
self.assertIn('taxa', result['Sample01'])
self.assertIn('taxa', result['Sample02'])
def create_sample(i):
"""Create unique sample for index i."""
return Sample(name=f'Sample{i}',
metadata={
'foobar': f'baz{i}'
},
align_to_methyltransferases=create_methyls()).save()
def create_sample(i):
"""Create unique sample for index i."""
return Sample(name=f'Sample{i}',
metadata={
'foobar': f'baz{i}'
},
vfdb_quantify=create_vfdb()).save()
def test_add_microbe_directory(self):
"""Ensure Microbe Directory result model is created correctly."""
microbe_directory = MicrobeDirectoryToolResult(**TEST_DIRECTORY).save()
sample = Sample(name='SMPL_01',
microbe_directory_annotate=microbe_directory).save()
self.assertTrue(sample.microbe_directory_annotate)
def test_upload_shortbred(self, auth_headers, *_):
"""Ensure a raw Shortbred tool result can be uploaded."""
sample = Sample(name='SMPL_Shortbred_01').save()
sample_uuid = str(sample.uuid)
with self.client:
response = self.client.post(
f'/api/v1/samples/{sample_uuid}/{SHORTBRED_NAME}',
headers=auth_headers,
data=json.dumps(dict(abundances=TEST_ABUNDANCES, )),
content_type='application/json',
)
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 201)
self.assertIn('abundances', data['data'])
abundances = data['data']['abundances']
self.assertEqual(abundances['AAA98484'], 3.996805816740154)
self.assertEqual(abundances['BAC77251'], 3.6770613514009423)
self.assertEqual(abundances['TEM_137'], 38.705908962115174)
self.assertEqual(abundances['YP_002317674'], 4.178478808410161)
self.assertEqual(abundances['YP_310429'], 10.943634974407566)
self.assertEqual(abundances['soxR_2'], 5.10702965472353)
self.assertIn('success', data['status'])
# Reload object to ensure HMP Sites result was stored properly
sample = Sample.objects.get(uuid=sample_uuid)
self.assertTrue(hasattr(sample, SHORTBRED_NAME))
def create_sample(i):
"""Create unique sample for index i."""
data = create_humann2()
return Sample(name=f'Sample{i}',
metadata={
'foobar': f'baz{i}'
},
humann2_functional_profiling=data).save()
def samples(self):
"""
Get SampleGroup's associated Samples.
This will hit Mongo every time it is called! Responsibility for caching
the result lies on the calling method.
"""
return Sample.objects(uuid__in=self.sample_ids)
def test_categories_from_metadata(self):
"""Ensure categories_from_metadata task works."""
metadata1 = {
'valid_category': 'foo',
'invalid_category': 'bar',
}
metadata2 = {
'valid_category': 'baz',
}
sample1 = Sample(name='Sample01', metadata=metadata1).save()
sample2 = Sample(name='Sample02', metadata=metadata2).save()
result = categories_from_metadata.delay([sample1, sample2]).get()
self.assertEqual(1, len(result.keys()))
self.assertNotIn('invalid_category', result)
self.assertIn('valid_category', result)
self.assertIn('foo', result['valid_category'])
self.assertIn('baz', result['valid_category'])
def test_add_malformed_hmp_sites_result(self): # pylint: disable=invalid-name
"""Ensure validation fails for value outside of [0,1]."""
bad_hmp = dict(create_values())
bad_hmp['skin'] = [0.5, 1.5]
hmp_sites = HmpSitesResult(**bad_hmp)
args = {'name': 'SMPL_01', MODULE_NAME: hmp_sites}
sample = Sample(**args)
self.assertRaises(ValidationError, sample.save)
def create_sample(i):
"""Create unique sample for index i."""
data = create_alpha_diversity()
return Sample(name=f'Sample{i}',
metadata={
'foobar': f'baz{i}'
},
alpha_diversity_stats=data).save()
def create_sample(i):
"""Create unique sample for index i."""
data = create_read_stats()
return Sample(name=f'Sample{i}',
metadata={
'foobar': f'baz{i}'
},
read_stats=data).save()
def test_add_sample(self):
"""Ensure sample model is created correctly."""
sample = Sample(name='SMPL_01', metadata={'subject_group': 1}).save()
self.assertTrue(sample.id)
self.assertTrue(sample.uuid)
self.assertEqual(sample.name, 'SMPL_01')
self.assertEqual(sample.metadata, {'subject_group': 1})
self.assertTrue(sample.created_at)
def create_sample(i):
"""Create unique sample for index i."""
data = create_hmp_sites()
return Sample(name=f'Sample{i}',
metadata={
'foobar': f'baz{i}'
},
hmp_site_dists=data).save()
def create_sample(i):
"""Create unique sample for index i."""
data = create_macrobe()
return Sample(**{
'name': f'Sample{i}',
'metadata': {'foobar': f'baz{i}'},
MacrobeResultModule.name(): data
}).save()
def test_add_hmp_sites_result(self):
"""Ensure Microbe Census result model is created correctly."""
microbe_census = MicrobeCensusResult(**TEST_CENSUS).save()
sample = Sample(name='SMPL_01', microbe_census=microbe_census).save()
self.assertTrue(sample.microbe_census)
tool_result = sample.microbe_census.fetch()
self.assertEqual(tool_result['average_genome_size'], 3)
self.assertEqual(tool_result['total_bases'], 5)
self.assertEqual(tool_result['genome_equivalents'], 250)
def seed_db():
"""Seed the database."""
default_user = get_user()
# Create Mason Lab
mason_lab = User(
username='******',
email='*****@*****.**',
user_type='organization',
)
membership = OrganizationMembership(role='admin')
membership.user = default_user
mason_lab.user_memberships.append(membership)
db.session.add_all([mason_lab, membership])
db.session.commit()
# Create ABRF sample group
abrf_uuid = UUID('00000000-0000-4000-8000-000000000000')
abrf_description = 'ABRF San Diego Mar 24th-29th 2017'
abrf_2017_group = SampleGroup(
name='ABRF 2017',
owner_uuid=mason_lab.uuid,
owner_name=mason_lab.username,
is_library=True,
analysis_result=create_abrf_result(save=True),
description=abrf_description)
abrf_2017_group.uuid = abrf_uuid
abrf_sample_01 = Sample(name='SomethingUnique_A',
library_uuid=abrf_uuid,
analysis_result=create_abrf_result(save=True),
metadata=generate_metadata()).save()
abrf_sample_02 = Sample(name='SomethingUnique_B',
library_uuid=abrf_uuid,
analysis_result=create_abrf_result(save=True),
metadata=generate_metadata()).save()
abrf_2017_group.samples = [abrf_sample_01, abrf_sample_02]
db.session.add(abrf_2017_group)
db.session.commit()
# Create fuzzed group
fuzz_uuid = UUID('00000000-0000-4000-8000-000000000001')
create_saved_group(owner=mason_lab, uuid=fuzz_uuid)
def test_add_samples(self):
"""Ensure that samples can be added to SampleGroup."""
sample_group = add_sample_group('Sample Group One',
access_scheme='public')
sample_one = Sample(name='SMPL_01', metadata={
'subject_group': 1
}).save()
sample_two = Sample(name='SMPL_02', metadata={
'subject_group': 4
}).save()
sample_group.samples = [sample_one, sample_two]
db.session.commit()
self.assertEqual(len(sample_group.sample_ids), 2)
self.assertIn(sample_one.uuid, sample_group.sample_ids)
self.assertIn(sample_two.uuid, sample_group.sample_ids)
samples = sample_group.samples
self.assertEqual(len(samples), 2)
self.assertIn(sample_one, samples)
self.assertIn(sample_two, samples)
def create_sample(i):
"""Create unique sample for index i."""
args = {
'name': f'Sample{i}',
'metadata': {'foobar': f'baz{i}'},
CARDAMRResultModule.name(): create_card_amr(),
KrakenResultModule.name(): create_kraken(),
Metaphlan2ResultModule.name(): create_metaphlan2(),
}
return Sample(**args).save()
def create_sample(i):
"""Create unique sample for index i."""
args = {
'name': f'Sample{i}',
'metadata': {
'foobar': f'baz{i}'
},
TOOL_MODULE_NAME: create_card_amr(),
}
return Sample(**args).save()
def create_sample(i):
"""Create unique sample for index i."""
metadata = {'foobar': f'baz{i}'}
sample_data = {
'name': f'Sample{i}',
'metadata': metadata,
KRAKEN_NAME: create_kraken(),
KRAKENHLL_NAME: create_krakenhll(),
METAPHLAN2_NAME: create_metaphlan2(),
}
return Sample(**sample_data).save()
def create_sample(i):
"""Create unique sample for index i."""
data = create_ancestry()
args = {
'name': f'Sample{i}',
'metadata': {
'foobar': f'baz{i}'
},
TOOL_MODULE_NAME: data,
}
return Sample(**args).save()
def create_sample(i):
"""Create unique sample for index i."""
return Sample(
**{
'name': f'Sample{i}',
'metadata': {
'foobar': f'baz{i}'
},
KrakenResultModule.name(): create_kraken(),
KrakenHLLResultModule.name(): create_krakenhll(),
Metaphlan2ResultModule.name(): create_metaphlan2(),
}).save()
def add_sample(resp): # pylint: disable=unused-argument
"""Add sample."""
try:
post_data = request.get_json()
sample_group_uuid = post_data['sample_group_uuid']
sample_name = post_data['name']
except TypeError:
raise ParseError('Missing Sample creation payload.')
except KeyError:
raise ParseError('Invalid Sample creation payload.')
try:
sample_group = SampleGroup.query.filter_by(id=sample_group_uuid).one()
except NoResultFound:
raise InvalidRequest('Sample Group does not exist!')
sample = Sample.objects(name=sample_name).first()
if sample is not None:
raise InvalidRequest('A Sample with that name already exists.')
try:
analysis_result = AnalysisResultMeta().save()
sample = Sample(name=sample_name,
analysis_result=analysis_result,
metadata={
'name': sample_name
}).save()
sample_group.sample_ids.append(sample.uuid)
db.session.commit()
result = sample_schema.dump(sample).data
return result, 201
except ValidationError as validation_error:
current_app.logger.exception('Sample could not be created.')
raise InternalError(str(validation_error))
except IntegrityError as integrity_error:
current_app.logger.exception(
'Sample could not be added to Sample Group.')
db.session.rollback()
raise InternalError(str(integrity_error))
def add_sample(
name,
analysis_result=None,
metadata={}, # pylint: disable=dangerous-default-value
created_at=datetime.datetime.utcnow(),
sample_kwargs={}):
"""Wrap functionality for adding sample."""
if not analysis_result:
analysis_result = AnalysisResultMeta().save()
return Sample(name=name,
metadata=metadata,
analysis_result=analysis_result,
created_at=created_at,
**sample_kwargs).save()
def prepare_middleware_test(self): # pylint: disable=no-self-use
"""Prepare database forsample middleware test."""
data = create_ancestry()
args = {
'name': 'AncestrySample',
'metadata': {
'foobar': 'baz'
},
TOOL_MODULE_NAME: data,
}
sample = Sample(**args).save()
db.session.commit()
return sample
def test_add_shortbred_result(self):
"""Ensure Shortbred result model is created correctly."""
tool_result = ShortbredResult(abundances=TEST_ABUNDANCES).save()
sample_data = {'name': 'SMPL_01', SHORTBRED_NAME: tool_result}
sample = Sample(**sample_data).save()
self.assertTrue(hasattr(sample, SHORTBRED_NAME))
tool_result = getattr(sample, SHORTBRED_NAME).fetch()
abundances = tool_result.abundances
self.assertEqual(len(abundances), 6)
self.assertEqual(abundances['AAA98484'], 3.996805816740154)
self.assertEqual(abundances['BAC77251'], 3.6770613514009423)
self.assertEqual(abundances['TEM_137'], 38.705908962115174)
self.assertEqual(abundances['YP_002317674'], 4.178478808410161)
self.assertEqual(abundances['YP_310429'], 10.943634974407566)
self.assertEqual(abundances['soxR_2'], 5.10702965472353)
def test_upload_microbe_directory(self, auth_headers, *_):
"""Ensure a raw Microbe Directory tool result can be uploaded."""
sample = Sample(name='SMPL_Microbe_Directory_01').save()
sample_uuid = str(sample.uuid)
with self.client:
response = self.client.post(
f'/api/v1/samples/{sample_uuid}/microbe_directory_annotate',
headers=auth_headers,
data=json.dumps(TEST_DIRECTORY),
content_type='application/json',
)
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 201)
self.assertIn('success', data['status'])
for field in TEST_DIRECTORY:
self.assertIn(field, data['data'])
# Reload object to ensure microbe directory result was stored properly
sample = Sample.objects.get(uuid=sample_uuid)
self.assertTrue(sample.microbe_directory_annotate)
def test_upload_mic_census(self, auth_headers, *_):
"""Ensure a raw Microbe Census tool result can be uploaded."""
sample = Sample(name='SMPL_MicCensus_01').save()
sample_uuid = str(sample.uuid)
with self.client:
response = self.client.post(
f'/api/v1/samples/{sample_uuid}/microbe_census',
headers=auth_headers,
data=json.dumps(TEST_CENSUS),
content_type='application/json',
)
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 201)
self.assertEqual(data['data']['average_genome_size'], 3)
self.assertEqual(data['data']['total_bases'], 5)
self.assertEqual(data['data']['genome_equivalents'], 250)
self.assertIn('success', data['status'])
# Reload object to ensure HMP Sites result was stored properly
sample = Sample.objects.get(uuid=sample_uuid)
self.assertTrue(sample.microbe_census)
def drop_mongo_collections():
"""Drop all mongo collections."""
AnalysisResultMeta.drop_collection()
Sample.drop_collection()
for tool_result in all_tool_results:
tool_result.result_model().drop_collection()
