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 generate_corr_json(corr_results,
this_trait,
dataset,
target_dataset,
for_api=False):
results_list = []
for i, trait in enumerate(corr_results):
if trait.view == False:
continue
results_dict = {}
results_dict['index'] = i + 1
results_dict['trait_id'] = trait.name
results_dict['dataset'] = trait.dataset.name
results_dict['hmac'] = hmac.data_hmac('{}:{}'.format(
trait.name, trait.dataset.name))
if target_dataset.type == "ProbeSet":
results_dict['symbol'] = trait.symbol
results_dict['description'] = "N/A"
results_dict['location'] = trait.location_repr
results_dict['mean'] = "N/A"
results_dict['additive'] = "N/A"
if bool(trait.description_display):
results_dict['description'] = trait.description_display
if bool(trait.mean):
results_dict['mean'] = f"{float(trait.mean):.3f}"
try:
results_dict[
'lod_score'] = f"{float(trait.LRS_score_repr) / 4.61:.1f}"
except:
results_dict['lod_score'] = "N/A"
results_dict['lrs_location'] = trait.LRS_location_repr
if bool(trait.additive):
results_dict['additive'] = f"{float(trait.additive):.3f}"
results_dict['sample_r'] = f"{float(trait.sample_r):.3f}"
results_dict['num_overlap'] = trait.num_overlap
results_dict['sample_p'] = f"{float(trait.sample_p):.3e}"
results_dict['lit_corr'] = "--"
results_dict['tissue_corr'] = "--"
results_dict['tissue_pvalue'] = "--"
if bool(trait.lit_corr):
results_dict['lit_corr'] = f"{float(trait.lit_corr):.3f}"
if bool(trait.tissue_corr):
results_dict['tissue_corr'] = f"{float(trait.tissue_corr):.3f}"
results_dict[
'tissue_pvalue'] = f"{float(trait.tissue_pvalue):.3e}"
elif target_dataset.type == "Publish":
results_dict['abbreviation_display'] = "N/A"
results_dict['description'] = "N/A"
results_dict['mean'] = "N/A"
results_dict['authors_display'] = "N/A"
results_dict['additive'] = "N/A"
if for_api:
results_dict['pubmed_id'] = "N/A"
results_dict['year'] = "N/A"
else:
results_dict['pubmed_link'] = "N/A"
results_dict['pubmed_text'] = "N/A"
if bool(trait.abbreviation):
results_dict['abbreviation_display'] = trait.abbreviation
if bool(trait.description_display):
results_dict['description'] = trait.description_display
if bool(trait.mean):
results_dict['mean'] = f"{float(trait.mean):.3f}"
if bool(trait.authors):
authors_list = trait.authors.split(',')
if len(authors_list) > 6:
results_dict['authors_display'] = ", ".join(
authors_list[:6]) + ", et al."
else:
results_dict['authors_display'] = trait.authors
if bool(trait.pubmed_id):
if for_api:
results_dict['pubmed_id'] = trait.pubmed_id
results_dict['year'] = trait.pubmed_text
else:
results_dict['pubmed_link'] = trait.pubmed_link
results_dict['pubmed_text'] = trait.pubmed_text
try:
results_dict[
'lod_score'] = f"{float(trait.LRS_score_repr) / 4.61:.1f}"
except:
results_dict['lod_score'] = "N/A"
results_dict['lrs_location'] = trait.LRS_location_repr
if bool(trait.additive):
results_dict['additive'] = f"{float(trait.additive):.3f}"
results_dict['sample_r'] = f"{float(trait.sample_r):.3f}"
results_dict['num_overlap'] = trait.num_overlap
results_dict['sample_p'] = f"{float(trait.sample_p):.3e}"
else:
results_dict['location'] = trait.location_repr
results_dict['sample_r'] = f"{float(trait.sample_r):.3f}"
results_dict['num_overlap'] = trait.num_overlap
results_dict['sample_p'] = f"{float(trait.sample_p):.3e}"
results_list.append(results_dict)
return json.dumps(results_list)
def correlation_json_for_table(correlation_data, this_trait, this_dataset,
target_dataset_ob):
"""Return JSON data for use with the DataTable in the correlation result page
Keyword arguments:
correlation_data -- Correlation results
this_trait -- Trait being correlated against a dataset, as a dict
this_dataset -- Dataset of this_trait, as a dict
target_dataset_ob - Target dataset, as a Dataset ob
"""
this_trait = correlation_data['this_trait']
this_dataset = correlation_data['this_dataset']
target_dataset = target_dataset_ob.as_dict()
corr_results = correlation_data['correlation_results']
results_list = []
file_name = f"{target_dataset['name']}_metadata.json"
file_path = os.path.join(TMPDIR, file_name)
new_traits_metadata = {}
try:
with open(file_path, "r+") as file_handler:
dataset_metadata = json.load(file_handler)
except FileNotFoundError:
Path(file_path).touch(exist_ok=True)
dataset_metadata = {}
for i, trait_dict in enumerate(corr_results):
trait_name = list(trait_dict.keys())[0]
trait = trait_dict[trait_name]
target_trait = dataset_metadata.get(trait_name)
if target_trait is None:
target_trait_ob = create_trait(dataset=target_dataset_ob,
name=trait_name,
get_qtl_info=True)
target_trait = jsonable(target_trait_ob, target_dataset_ob)
new_traits_metadata[trait_name] = target_trait
if target_trait['view'] == False:
continue
results_dict = {}
results_dict['index'] = i + 1
results_dict['trait_id'] = target_trait['name']
results_dict['dataset'] = target_dataset['name']
results_dict['hmac'] = hmac.data_hmac('{}:{}'.format(
target_trait['name'], target_dataset['name']))
results_dict['sample_r'] = f"{float(trait['corr_coefficient']):.3f}"
results_dict['num_overlap'] = trait['num_overlap']
results_dict['sample_p'] = f"{float(trait['p_value']):.3e}"
if target_dataset['type'] == "ProbeSet":
results_dict['symbol'] = target_trait['symbol']
results_dict['description'] = "N/A"
results_dict['location'] = target_trait['location']
results_dict['mean'] = "N/A"
results_dict['additive'] = "N/A"
if bool(target_trait['description']):
results_dict['description'] = target_trait['description']
if bool(target_trait['mean']):
results_dict['mean'] = f"{float(target_trait['mean']):.3f}"
try:
results_dict[
'lod_score'] = f"{float(target_trait['lrs_score']) / 4.61:.1f}"
except:
results_dict['lod_score'] = "N/A"
results_dict['lrs_location'] = target_trait['lrs_location']
if bool(target_trait['additive']):
results_dict[
'additive'] = f"{float(target_trait['additive']):.3f}"
results_dict['lit_corr'] = "--"
results_dict['tissue_corr'] = "--"
results_dict['tissue_pvalue'] = "--"
if this_dataset['type'] == "ProbeSet":
if 'lit_corr' in trait:
results_dict[
'lit_corr'] = f"{float(trait['lit_corr']):.3f}"
if 'tissue_corr' in trait:
results_dict[
'tissue_corr'] = f"{float(trait['tissue_corr']):.3f}"
results_dict[
'tissue_pvalue'] = f"{float(trait['tissue_p_val']):.3e}"
elif target_dataset['type'] == "Publish":
results_dict['abbreviation_display'] = "N/A"
results_dict['description'] = "N/A"
results_dict['mean'] = "N/A"
results_dict['authors_display'] = "N/A"
results_dict['additive'] = "N/A"
results_dict['pubmed_link'] = "N/A"
results_dict['pubmed_text'] = "N/A"
if bool(target_trait['abbreviation']):
results_dict['abbreviation_display'] = target_trait[
'abbreviation']
if bool(target_trait['description']):
results_dict['description'] = target_trait['description']
if bool(target_trait['mean']):
results_dict['mean'] = f"{float(target_trait['mean']):.3f}"
if bool(target_trait['authors']):
authors_list = target_trait['authors'].split(',')
if len(authors_list) > 6:
results_dict['authors_display'] = ", ".join(
authors_list[:6]) + ", et al."
else:
results_dict['authors_display'] = target_trait['authors']
if 'pubmed_id' in target_trait:
results_dict['pubmed_link'] = target_trait['pubmed_link']
results_dict['pubmed_text'] = target_trait['pubmed_text']
try:
results_dict[
'lod_score'] = f"{float(target_trait['lrs_score']) / 4.61:.1f}"
except:
results_dict['lod_score'] = "N/A"
results_dict['lrs_location'] = target_trait['lrs_location']
if bool(target_trait['additive']):
results_dict[
'additive'] = f"{float(target_trait['additive']):.3f}"
else:
results_dict['location'] = target_trait['location']
results_list.append(results_dict)
if bool(new_traits_metadata):
# that means new traits exists
dataset_metadata.update(new_traits_metadata)
with open(file_path, "w+") as file_handler:
json.dump(dataset_metadata, file_handler)
return json.dumps(results_list)
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 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 = []
species = webqtlDatabaseFunction.retrieve_species(
self.dataset.group.name)
# result_set represents the results for each search term; a search of
# "shh grin2b" would have two sets of results, one for each term
logger.debug("self.results is:", pf(self.results))
for index, result in enumerate(self.results):
if not result:
continue
#### Excel file needs to be generated ####
trait_dict = {}
trait_id = result[0]
trait_dict['index'] = index + 1
this_trait = trait.GeneralTrait(dataset=self.dataset,
name=trait_id,
get_qtl_info=True,
get_sample_info=False)
trait_dict['name'] = this_trait.name
if this_trait.dataset.type == "Publish":
trait_dict['display_name'] = this_trait.display_name
else:
trait_dict['display_name'] = this_trait.name
trait_dict['dataset'] = this_trait.dataset.name
trait_dict['hmac'] = hmac.data_hmac('{}:{}'.format(
this_trait.name, this_trait.dataset.name))
if this_trait.dataset.type == "ProbeSet":
trait_dict['symbol'] = this_trait.symbol
trait_dict[
'description'] = this_trait.description_display.decode(
'utf-8', 'replace')
trait_dict['location'] = this_trait.location_repr
trait_dict['mean'] = "N/A"
trait_dict['additive'] = "N/A"
if this_trait.mean != "" and this_trait.mean != None:
trait_dict['mean'] = '%.3f' % this_trait.mean
trait_dict['lrs_score'] = this_trait.LRS_score_repr
trait_dict['lrs_location'] = this_trait.LRS_location_repr
if this_trait.additive != "":
trait_dict['additive'] = '%.3f' % this_trait.additive
elif this_trait.dataset.type == "Geno":
trait_dict['location'] = this_trait.location_repr
elif this_trait.dataset.type == "Publish":
trait_dict['description'] = this_trait.description_display
trait_dict['authors'] = this_trait.authors
trait_dict['pubmed_id'] = "N/A"
if this_trait.pubmed_id:
trait_dict['pubmed_id'] = this_trait.pubmed_id
trait_dict['pubmed_link'] = this_trait.pubmed_link
trait_dict['pubmed_text'] = this_trait.pubmed_text
trait_dict['mean'] = "N/A"
if this_trait.mean != "" and this_trait.mean != None:
trait_dict['mean'] = '%.3f' % this_trait.mean
trait_dict['lrs_score'] = this_trait.LRS_score_repr
trait_dict['lrs_location'] = this_trait.LRS_location_repr
trait_dict['additive'] = "N/A"
if this_trait.additive != "":
trait_dict['additive'] = '%.3f' % this_trait.additive
trait_list.append(trait_dict)
#json_trait_list.append(trait.jsonable_table_row(this_trait, self.dataset.name, index + 1))
self.trait_list = json.dumps(trait_list)
def jsonable_table_row(trait, dataset_name, index):
"""Return a list suitable for json and intended to be displayed in a table
Actual turning into json doesn't happen here though"""
dataset = create_dataset(dataset_name)
if dataset.type == "ProbeSet":
if trait.mean == "":
mean = "N/A"
else:
mean = "%.3f" % round(float(trait.mean), 2)
if trait.additive == "":
additive = "N/A"
else:
additive = "%.3f" % round(float(trait.additive), 2)
return ['<input type="checkbox" name="searchResult" class="checkbox trait_checkbox" value="' + hmac.data_hmac('{}:{}'.format(str(trait.name), dataset.name)) + '">',
index,
'<a href="/show_trait?trait_id='+str(trait.name)+'&dataset='+dataset.name+'">'+str(trait.name)+'</a>',
trait.symbol,
trait.description_display,
trait.location_repr,
mean,
trait.LRS_score_repr,
trait.LRS_location_repr,
additive]
elif dataset.type == "Publish":
if trait.additive == "":
additive = "N/A"
else:
additive = "%.2f" % round(float(trait.additive), 2)
if trait.pubmed_id:
return ['<input type="checkbox" name="searchResult" class="checkbox trait_checkbox" value="' + hmac.data_hmac('{}:{}'.format(str(trait.name), dataset.name)) + '">',
index,
'<a href="/show_trait?trait_id='+str(trait.name)+'&dataset='+dataset.name+'">'+str(trait.name)+'</a>',
trait.description_display,
trait.authors,
'<a href="' + trait.pubmed_link + '">' + trait.pubmed_text + '</href>',
trait.LRS_score_repr,
trait.LRS_location_repr,
additive]
else:
return ['<input type="checkbox" name="searchResult" class="checkbox trait_checkbox" value="' + hmac.data_hmac('{}:{}'.format(str(trait.name), dataset.name)) + '">',
index,
'<a href="/show_trait?trait_id='+str(trait.name)+'&dataset='+dataset.name+'">'+str(trait.name)+'</a>',
trait.description_display,
trait.authors,
trait.pubmed_text,
trait.LRS_score_repr,
trait.LRS_location_repr,
additive]
elif dataset.type == "Geno":
return ['<input type="checkbox" name="searchResult" class="checkbox trait_checkbox" value="' + hmac.data_hmac('{}:{}'.format(str(trait.name), dataset.name)) + '">',
index,
'<a href="/show_trait?trait_id='+str(trait.name)+'&dataset='+dataset.name+'">'+str(trait.name)+'</a>',
trait.location_repr]
else:
return dict()
def test_data_hmac(self):
"""Test data_hmac fn with a utf-8 string"""
self.assertEqual(data_hmac("ファイ"), "ファイ:7410466338cfe109e946")
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 = []
species = webqtlDatabaseFunction.retrieve_species(
self.dataset.group.name)
# result_set represents the results for each search term; a search of
# "shh grin2b" would have two sets of results, one for each term
logger.debug("self.results is:", pf(self.results))
for index, result in enumerate(self.results):
if not result:
continue
#### Excel file needs to be generated ####
trait_dict = {}
trait_id = result[0]
this_trait = create_trait(dataset=self.dataset,
name=trait_id,
get_qtl_info=True,
get_sample_info=False)
if this_trait:
trait_dict['index'] = index + 1
trait_dict['name'] = this_trait.name
if this_trait.dataset.type == "Publish":
trait_dict['display_name'] = this_trait.display_name
else:
trait_dict['display_name'] = this_trait.name
trait_dict['dataset'] = this_trait.dataset.name
trait_dict['hmac'] = hmac.data_hmac('{}:{}'.format(
this_trait.name, this_trait.dataset.name))
if this_trait.dataset.type == "ProbeSet":
trait_dict['symbol'] = this_trait.symbol
trait_dict['description'] = "N/A"
if this_trait.description_display:
trait_dict[
'description'] = this_trait.description_display
trait_dict['location'] = this_trait.location_repr
trait_dict['mean'] = "N/A"
trait_dict['additive'] = "N/A"
if this_trait.mean != "" and this_trait.mean != None:
trait_dict['mean'] = f"{this_trait.mean:.3f}"
try:
trait_dict[
'lod_score'] = f"{float(this_trait.LRS_score_repr) / 4.61:.1f}"
except:
trait_dict['lod_score'] = "N/A"
trait_dict['lrs_location'] = this_trait.LRS_location_repr
if this_trait.additive != "":
trait_dict['additive'] = f"{this_trait.additive:.3f}"
elif this_trait.dataset.type == "Geno":
trait_dict['location'] = this_trait.location_repr
elif this_trait.dataset.type == "Publish":
trait_dict['description'] = "N/A"
if this_trait.description_display:
trait_dict[
'description'] = this_trait.description_display
trait_dict['authors'] = this_trait.authors
trait_dict['pubmed_id'] = "N/A"
if this_trait.pubmed_id:
trait_dict['pubmed_id'] = this_trait.pubmed_id
trait_dict['pubmed_link'] = this_trait.pubmed_link
trait_dict['pubmed_text'] = this_trait.pubmed_text
trait_dict['mean'] = "N/A"
if this_trait.mean != "" and this_trait.mean != None:
trait_dict['mean'] = f"{this_trait.mean:.3f}"
try:
trait_dict[
'lod_score'] = f"{float(this_trait.LRS_score_repr) / 4.61:.1f}"
except:
trait_dict['lod_score'] = "N/A"
trait_dict['lrs_location'] = this_trait.LRS_location_repr
trait_dict['additive'] = "N/A"
if this_trait.additive != "":
trait_dict['additive'] = f"{this_trait.additive:.3f}"
# Convert any bytes in dict to a normal utf-8 string
for key in trait_dict.keys():
if isinstance(trait_dict[key], bytes):
trait_dict[key] = trait_dict[key].decode('utf-8')
trait_list.append(trait_dict)
self.trait_list = trait_list
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']
