def create_trait(**kw): assert bool(kw.get('dataset')) != bool( kw.get('dataset_name')), "Needs dataset ob. or name" assert bool(kw.get('name')), "Needs trait name" if kw.get('dataset_name'): if kw.get('dataset_name') != "Temp": dataset = create_dataset(kw.get('dataset_name')) else: dataset = kw.get('dataset') if dataset.type == 'Publish': permissions = check_resource_availability(dataset, kw.get('name')) else: permissions = check_resource_availability(dataset) if "view" in permissions['data']: the_trait = GeneralTrait(**kw) if the_trait.dataset.type != "Temp": the_trait = retrieve_trait_info( the_trait, the_trait.dataset, get_qtl_info=kw.get('get_qtl_info')) return the_trait else: return None
def check_access_permissions(): logger.debug("@app.before_request check_access_permissions") available = True if 'dataset' in request.args: permissions = DEFAULT_PRIVILEGES if request.args['dataset'] != "Temp": dataset = create_dataset(request.args['dataset']) if dataset.type == "Temp": permissions = DEFAULT_PRIVILEGES elif 'trait_id' in request.args: permissions = check_resource_availability( dataset, request.args['trait_id']) elif dataset.type != "Publish": permissions = check_resource_availability(dataset) if 'view' not in permissions['data']: return redirect(url_for("no_access_page"))
def test_check_resource_availability_non_default_mask( self, resource_id_mock, redis_mock, add_new_resource_mock, requests_mock): """Test the resource availability with non-default mask""" resource_id_mock.return_value = 1 redis_mock.smembers.return_value = [] add_new_resource_mock.return_value = {"default_mask": 2} requests_mock.return_value = TestResponse() test_dataset = mock.MagicMock() type(test_dataset).type = mock.PropertyMock(return_value="Test") self.assertEqual(check_resource_availability(test_dataset), ['foo'])
def test_check_resource_availability_default_mask(self, resource_id_mock, redis_mock, add_new_resource_mock): """Test the resource availability with default mask""" resource_id_mock.return_value = 1 redis_mock.smembers.return_value = [] test_dataset = mock.MagicMock() type(test_dataset).type = mock.PropertyMock(return_value="Test") add_new_resource_mock.return_value = {"default_mask": 2} self.assertEqual(check_resource_availability(test_dataset), 2)
def test_check_resource_availability_of_super_user(self, resource_id_mock, redis_mock, add_new_resource_mock, requests_mock): """Test the resource availability if the user is the super user""" resource_id_mock.return_value = 1 redis_mock.smembers.return_value = [b"Jane"] add_new_resource_mock.return_value = {"default_mask": 2} requests_mock.return_value = TestResponse() test_dataset = mock.MagicMock() type(test_dataset).type = mock.PropertyMock(return_value="Test") self.assertEqual(check_resource_availability(test_dataset), "SUPERUSER")
def __init__(self, kw): assert('type' in kw) assert('terms' in kw) self.type = kw['type'] self.terms = kw['terms'] assert(is_str(self.type)) if self.type == "gene": sql = """ SELECT Species.`Name` AS species_name, InbredSet.`Name` AS inbredset_name, Tissue.`Name` AS tissue_name, ProbeSetFreeze.Name AS probesetfreeze_name, ProbeSetFreeze.FullName AS probesetfreeze_fullname, ProbeSet.Name AS probeset_name, ProbeSet.Symbol AS probeset_symbol, CAST(ProbeSet.`description` AS BINARY) AS probeset_description, ProbeSet.Chr AS chr, ProbeSet.Mb AS mb, ProbeSetXRef.Mean AS mean, ProbeSetXRef.LRS AS lrs, ProbeSetXRef.`Locus` AS locus, ProbeSetXRef.`pValue` AS pvalue, ProbeSetXRef.`additive` AS additive, ProbeSetFreeze.Id AS probesetfreeze_id, Geno.Chr as geno_chr, Geno.Mb as geno_mb FROM Species INNER JOIN InbredSet ON InbredSet.`SpeciesId`=Species.`Id` INNER JOIN ProbeFreeze ON ProbeFreeze.InbredSetId=InbredSet.`Id` INNER JOIN Tissue ON ProbeFreeze.`TissueId`=Tissue.`Id` INNER JOIN ProbeSetFreeze ON ProbeSetFreeze.ProbeFreezeId=ProbeFreeze.Id INNER JOIN ProbeSetXRef ON ProbeSetXRef.ProbeSetFreezeId=ProbeSetFreeze.Id INNER JOIN ProbeSet ON ProbeSet.Id = ProbeSetXRef.ProbeSetId LEFT JOIN Geno ON ProbeSetXRef.Locus = Geno.Name AND Geno.SpeciesId = Species.Id WHERE ( MATCH (ProbeSet.Name,ProbeSet.description,ProbeSet.symbol,ProbeSet.alias,ProbeSet.GenbankId, ProbeSet.UniGeneId, ProbeSet.Probe_Target_Description) AGAINST ('%s' IN BOOLEAN MODE) ) AND ProbeSetFreeze.confidentiality < 1 AND ProbeSetFreeze.public > 0 ORDER BY species_name, inbredset_name, tissue_name, probesetfreeze_name, probeset_name LIMIT 6000 """ % (self.terms) with Bench("Running query"): logger.sql(sql) re = g.db.execute(sql).fetchall() trait_list = [] dataset_to_permissions = {} with Bench("Creating trait objects"): for i, line in enumerate(re): this_trait = {} this_trait['index'] = i + 1 this_trait['name'] = line[5] this_trait['dataset'] = line[3] this_trait['dataset_fullname'] = line[4] this_trait['hmac'] = hmac.data_hmac('{}:{}'.format(line[5], line[3])) this_trait['species'] = line[0] this_trait['group'] = line[1] this_trait['tissue'] = line[2] this_trait['symbol'] = line[6] if line[7]: this_trait['description'] = line[7].decode('utf-8', 'replace') else: this_trait['description'] = "N/A" this_trait['location_repr'] = 'N/A' if (line[8] != "NULL" and line[8] != "") and (line[9] != 0): this_trait['location_repr'] = 'Chr%s: %.6f' % (line[8], float(line[9])) try: this_trait['mean'] = '%.3f' % line[10] except: this_trait['mean'] = "N/A" this_trait['LRS_score_repr'] = "N/A" if line[11] != "" and line[11] != None: this_trait['LRS_score_repr'] = '%3.1f' % line[11] this_trait['additive'] = "N/A" if line[14] != "" and line[14] != None: this_trait['additive'] = '%.3f' % line[14] this_trait['dataset_id'] = line[15] this_trait['locus_chr'] = line[16] this_trait['locus_mb'] = line[17] dataset_ob = SimpleNamespace(id=this_trait["dataset_id"], type="ProbeSet",species=this_trait["species"]) if dataset_ob.id not in dataset_to_permissions: permissions = check_resource_availability(dataset_ob) dataset_to_permissions[dataset_ob.id] = permissions else: pemissions = dataset_to_permissions[dataset_ob.id] if "view" not in permissions['data']: continue max_lrs_text = "N/A" if this_trait['locus_chr'] != None and this_trait['locus_mb'] != None: max_lrs_text = "Chr" + str(this_trait['locus_chr']) + ": " + str(this_trait['locus_mb']) this_trait['max_lrs_text'] = max_lrs_text trait_list.append(this_trait) self.trait_count = len(trait_list) self.trait_list = json.dumps(trait_list) self.header_fields = ['Index', 'Record', 'Species', 'Group', 'Tissue', 'Dataset', 'Symbol', 'Description', 'Location', 'Mean', 'Max LRS', 'Max LRS Location', 'Additive Effect'] elif self.type == "phenotype": search_term = self.terms group_clause = "" if "_" in self.terms: if len(self.terms.split("_")[0]) == 3: search_term = self.terms.split("_")[1] group_clause = "AND InbredSet.`InbredSetCode` = '{}'".format(self.terms.split("_")[0]) sql = """ SELECT Species.`Name`, InbredSet.`Name`, PublishFreeze.`Name`, PublishFreeze.`FullName`, PublishXRef.`Id`, CAST(Phenotype.`Pre_publication_description` AS BINARY), CAST(Phenotype.`Post_publication_description` AS BINARY), Publication.`Authors`, Publication.`Year`, Publication.`PubMed_ID`, PublishXRef.`LRS`, PublishXRef.`additive`, InbredSet.`InbredSetCode`, PublishXRef.`mean` FROM Species,InbredSet,PublishFreeze,PublishXRef,Phenotype,Publication WHERE PublishXRef.`InbredSetId`=InbredSet.`Id` AND PublishFreeze.`InbredSetId`=InbredSet.`Id` AND InbredSet.`SpeciesId`=Species.`Id` {0} AND PublishXRef.`PhenotypeId`=Phenotype.`Id` AND PublishXRef.`PublicationId`=Publication.`Id` AND (Phenotype.Post_publication_description REGEXP "[[:<:]]{1}[[:>:]]" OR Phenotype.Pre_publication_description REGEXP "[[:<:]]{1}[[:>:]]" OR Phenotype.Pre_publication_abbreviation REGEXP "[[:<:]]{1}[[:>:]]" OR Phenotype.Post_publication_abbreviation REGEXP "[[:<:]]{1}[[:>:]]" OR Phenotype.Lab_code REGEXP "[[:<:]]{1}[[:>:]]" OR Publication.PubMed_ID REGEXP "[[:<:]]{1}[[:>:]]" OR Publication.Abstract REGEXP "[[:<:]]{1}[[:>:]]" OR Publication.Title REGEXP "[[:<:]]{1}[[:>:]]" OR Publication.Authors REGEXP "[[:<:]]{1}[[:>:]]" OR PublishXRef.Id REGEXP "[[:<:]]{1}[[:>:]]") ORDER BY Species.`Name`, InbredSet.`Name`, PublishXRef.`Id` LIMIT 6000 """.format(group_clause, search_term) logger.sql(sql) re = g.db.execute(sql).fetchall() trait_list = [] with Bench("Creating trait objects"): for i, line in enumerate(re): this_trait = {} this_trait['index'] = i + 1 this_trait['name'] = str(line[4]) if len(str(line[12])) == 3: this_trait['display_name'] = str(line[12]) + "_" + this_trait['name'] else: this_trait['display_name'] = this_trait['name'] this_trait['dataset'] = line[2] this_trait['dataset_fullname'] = line[3] this_trait['hmac'] = hmac.data_hmac('{}:{}'.format(line[4], line[2])) this_trait['species'] = line[0] this_trait['group'] = line[1] if line[9] != None and line[6] != None: this_trait['description'] = line[6].decode('utf-8', 'replace') elif line[5] != None: this_trait['description'] = line[5].decode('utf-8', 'replace') else: this_trait['description'] = "N/A" if line[13] != None and line[13] != "": this_trait['mean'] = line[13] else: this_trait['mean'] = "N/A" this_trait['authors'] = line[7] this_trait['year'] = line[8] if this_trait['year'].isdigit(): this_trait['pubmed_text'] = this_trait['year'] else: this_trait['pubmed_text'] = "N/A" if line[9] != "" and line[9] != None: this_trait['pubmed_link'] = webqtlConfig.PUBMEDLINK_URL % line[8] else: this_trait['pubmed_link'] = "N/A" if line[12]: this_trait['display_name'] = line[12] + "_" + str(this_trait['name']) this_trait['LRS_score_repr'] = "N/A" if line[10] != "" and line[10] != None: this_trait['LRS_score_repr'] = '%3.1f' % line[10] this_trait['additive'] = "N/A" if line[11] != "" and line[11] != None: this_trait['additive'] = '%.3f' % line[11] this_trait['max_lrs_text'] = "N/A" trait_ob = create_trait(dataset_name=this_trait['dataset'], name=this_trait['name'], get_qtl_info=True, get_sample_info=False) if not trait_ob: continue if this_trait['dataset'] == this_trait['group'] + "Publish": try: if trait_ob.locus_chr != "" and trait_ob.locus_mb != "": this_trait['max_lrs_text'] = "Chr" + str(trait_ob.locus_chr) + ": " + str(trait_ob.locus_mb) except: this_trait['max_lrs_text'] = "N/A" trait_list.append(this_trait) self.trait_count = len(trait_list) self.trait_list = json.dumps(trait_list) self.header_fields = ['Index', 'Species', 'Group', 'Record', 'Description', 'Authors', 'Year', 'Max LRS', 'Max LRS Location', 'Additive Effect']
def gen_search_result(self): """ Get the info displayed in the search result table from the set of results computed in the "search" function """ trait_list = [] json_trait_list = [] # result_set represents the results for each search term; a search of # "shh grin2b" would have two sets of results, one for each term if self.dataset.type == "ProbeSet": self.header_data_names = ['index', 'display_name', 'symbol', 'description', 'location', 'mean', 'lrs_score', 'lrs_location', 'additive'] elif self.dataset.type == "Publish": self.header_data_names = ['index', 'display_name', 'description', 'mean', 'authors', 'pubmed_text', 'lrs_score', 'lrs_location', 'additive'] elif self.dataset.type == "Geno": self.header_data_names = ['index', 'display_name', 'location'] for index, result in enumerate(self.results): if not result: continue trait_dict = {} trait_dict['index'] = index + 1 trait_dict['dataset'] = self.dataset.name if self.dataset.type == "ProbeSet": trait_dict['display_name'] = result[2] trait_dict['hmac'] = hmac.data_hmac('{}:{}'.format(trait_dict['display_name'], trait_dict['dataset'])) trait_dict['symbol'] = "N/A" if result[3] is None else result[3].strip() description_text = "N/A" if result[4] is None or str(result[4]) == "" else trait_dict['symbol'] target_string = result[5].decode('utf-8') if result[5] else "" description_display = description_text if target_string is None or str(target_string) == "" else description_text + "; " + str(target_string).strip() trait_dict['description'] = description_display trait_dict['location'] = "N/A" if (result[6] is not None) and (result[6] != "") and (result[7] is not None) and (result[7] != 0): trait_dict['location'] = f"Chr{result[6]}: {float(result[7]):.6f}" trait_dict['mean'] = "N/A" if result[8] is None or result[8] == "" else f"{result[8]:.3f}" trait_dict['additive'] = "N/A" if result[12] is None or result[12] == "" else f"{result[12]:.3f}" trait_dict['lod_score'] = "N/A" if result[9] is None or result[9] == "" else f"{float(result[9]) / 4.61:.1f}" trait_dict['lrs_location'] = "N/A" if result[13] is None or result[13] == "" or result[14] is None else f"Chr{result[13]}: {float(result[14]):.6f}" elif self.dataset.type == "Geno": trait_dict['display_name'] = str(result[0]) trait_dict['hmac'] = hmac.data_hmac('{}:{}'.format(trait_dict['display_name'], trait_dict['dataset'])) trait_dict['location'] = "N/A" if (result[4] != "NULL" and result[4] != "") and (result[5] != 0): trait_dict['location'] = f"Chr{result[4]}: {float(result[5]):.6f}" elif self.dataset.type == "Publish": # Check permissions on a trait-by-trait basis for phenotype traits trait_dict['name'] = trait_dict['display_name'] = str(result[0]) trait_dict['hmac'] = hmac.data_hmac('{}:{}'.format(trait_dict['name'], trait_dict['dataset'])) permissions = check_resource_availability(self.dataset, trait_dict['display_name']) if "view" not in permissions['data']: continue if result[10]: trait_dict['display_name'] = str(result[10]) + "_" + str(result[0]) trait_dict['description'] = "N/A" trait_dict['pubmed_id'] = "N/A" trait_dict['pubmed_link'] = "N/A" trait_dict['pubmed_text'] = "N/A" trait_dict['mean'] = "N/A" trait_dict['additive'] = "N/A" pre_pub_description = "N/A" if result[1] is None else result[1].strip() post_pub_description = "N/A" if result[2] is None else result[2].strip() if result[5] != "NULL" and result[5] != None: trait_dict['pubmed_id'] = result[5] trait_dict['pubmed_link'] = PUBMEDLINK_URL % trait_dict['pubmed_id'] trait_dict['description'] = post_pub_description else: trait_dict['description'] = pre_pub_description if result[4].isdigit(): trait_dict['pubmed_text'] = result[4] trait_dict['authors'] = result[3] if result[6] != "" and result[6] != None: trait_dict['mean'] = f"{result[6]:.3f}" try: trait_dict['lod_score'] = f"{float(result[7]) / 4.61:.1f}" except: trait_dict['lod_score'] = "N/A" try: trait_dict['lrs_location'] = f"Chr{result[11]}: {float(result[12]):.6f}" except: trait_dict['lrs_location'] = "N/A" trait_dict['additive'] = "N/A" if not result[8] else f"{result[8]:.3f}" # Convert any bytes in dict to a normal utf-8 string for key in trait_dict.keys(): if isinstance(trait_dict[key], bytes): try: trait_dict[key] = trait_dict[key].decode('utf-8') except UnicodeDecodeError: trait_dict[key] = trait_dict[key].decode('latin-1') trait_list.append(trait_dict) if self.results: self.max_widths = {} for i, trait in enumerate(trait_list): for key in trait.keys(): if key == "authors": authors_string = ",".join(str(trait[key]).split(",")[:6]) + ", et al." self.max_widths[key] = max(len(authors_string), self.max_widths[key]) if key in self.max_widths else len(str(trait[key])) else: self.max_widths[key] = max(len(str(trait[key])), self.max_widths[key]) if key in self.max_widths else len(str(trait[key])) self.wide_columns_exist = False if self.dataset.type == "Publish": if (self.max_widths['display_name'] > 25 or self.max_widths['description'] > 100 or self.max_widths['authors']> 80): self.wide_columns_exist = True if self.dataset.type == "ProbeSet": if (self.max_widths['display_name'] > 25 or self.max_widths['symbol'] > 25 or self.max_widths['description'] > 100): self.wide_columns_exist = True self.trait_list = trait_list
def test_check_resource_availability_temp(self): """Test the resource availability if the dataset is a string""" test_dataset = mock.MagicMock() type(test_dataset).type = mock.PropertyMock(return_value="Temp") self.assertEqual(check_resource_availability(test_dataset), "John Doe")
def test_check_resource_availability_string_dataset(self): """Test the resource availability if the dataset is a string""" self.assertEqual(check_resource_availability("Test"), "John Doe")