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