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