def trait_view(report_slug, trait_slug="", rerun=None):
report_data = list(
report.select(report, trait, mapping.trait_id)
.join(trait)
.where(
((report.report_slug == report_slug) & (report.release == 0))
| ((report.report_hash == report_slug) & (report.release > 0))
)
.join(mapping, JOIN.LEFT_OUTER)
.distinct()
.dicts()
.execute()
)
if not report_data:
return render_template("404.html"), 404
if report_data[0]["release"] == 0:
report_url_slug = report_data[0]["report_slug"]
else:
report_url_slug = report_data[0]["report_hash"]
if not trait_slug:
return redirect(url_for("trait_view", report_slug=report_url_slug, trait_slug=report_data[0]["trait_slug"]))
else:
try:
trait_data = [x for x in report_data if x["trait_slug"] == trait_slug][0]
except:
# Redirect user to first trait if it can't be found.
return redirect(url_for("trait_view", report_slug=report_url_slug, trait_slug=report_data[0]["trait_slug"]))
page_title = trait_data["report_name"] + " > " + trait_data["trait_name"]
title = trait_data["report_name"]
subtitle = trait_data["trait_name"]
# Define report and trait slug
report_slug = trait_data["report_slug"] # don't remove
trait_slug = trait_data["trait_slug"] # don't remove
r = report.get(report_slug=report_slug)
t = trait.get(report=r, trait_slug=trait_slug)
# phenotype data
phenotype_data = list(
trait_value.select(strain.strain, trait_value.value)
.join(trait)
.join(report)
.switch(trait_value)
.join(strain)
.where(report.report_slug == r.report_slug)
.where(trait.trait_slug == t.trait_slug)
.dicts()
.execute()
)
if rerun == "rerun":
t.status = "queue"
t.save()
launch_mapping(verify_request=False)
# Return user to current trait
return redirect(url_for("trait_view", report_slug=report_url_slug, trait_slug=trait_slug))
report_trait = "%s/%s" % (report_slug, trait_slug)
base_url = "https://storage.googleapis.com/cendr/" + report_trait
# Fetch significant mappings
mapping_results = list(
mapping.select(mapping, report, trait)
.join(trait)
.join(report)
.filter((report.report_slug == report_slug), (trait.trait_slug == trait_slug))
.dicts()
.execute()
)
#######################
# Variant Correlation #
#######################
var_corr = []
for m in mapping_results:
var_corr.append(correlation.get_correlated_genes(r, t, m["chrom"], m["interval_start"], m["interval_end"]))
tbl_color = {"LOW": "success", "MODERATE": "warning", "HIGH": "danger"}
#######################
# Fetch geo locations #
#######################
geo_gt = {}
for m in mapping_results:
try:
result = GT.fetch_geo_gt(m["chrom"], m["pos"])
geo_gt[m["chrom"] + ":" + str(m["pos"])] = result
except:
pass
geo_gt = json.dumps(geo_gt)
status = trait_data["status"]
# List available datasets
report_files = list(storage.Client().get_bucket("cendr").list_blobs(prefix=report_trait + "/tables"))
report_files = [os.path.split(x.name)[1] for x in report_files]
# Fetch biotypes descriptions
from cendr import biotypes
return render_template("report.html", **locals())
def process_gwa():
release_dict = {"public": 0, "embargo12": 1, "private": 2}
req = request.get_json()
# Add Validation
rep_names = report_namecheck(req["report_name"])
req["report_slug"] = rep_names["report_slug"]
req["report_hash"] = rep_names["report_hash"]
if "error" in rep_names.keys():
return ""
data = req["trait_data"]
del req["trait_data"]
req["release"] = release_dict[req["release"]]
req["version"] = 1
trait_names = data[0][1:]
strain_set = []
trait_keep = []
with db.atomic():
report_rec = report(**req)
report_rec.save()
trait_data = []
for row in data[1:]:
if row[0] is not None and row[0] != "":
q = row[0].strip().replace("(", "\(").replace(")", "\)")
strain_name = resolve_strain_isotype(q)
strain_set.append(strain_name)
trait_set = data[0][1:]
for n, t in enumerate(trait_set):
trait_vals = [row[n + 1] for row in data[1:] if row[n + 1]]
if t and len(trait_vals) > 0:
submit_time = datetime.now(pytz.timezone("America/Chicago"))
trait_keep.append(t)
trait_set[n] = trait.insert(
report=report_rec, trait_name=t, trait_slug=slugify(t), status="queue", submission_date=submit_time
).execute()
else:
trait_set[n] = None
for col, t in enumerate(trait_set):
for row, s in enumerate(strain_set):
if t and s and is_number(data[1:][row][col + 1]):
trait_data.append({"trait": t, "strain": s, "value": autoconvert(data[1:][row][col + 1])})
trait_value.insert_many(trait_data).execute()
for t in trait_keep:
req["trait_name"] = t
req["trait_slug"] = slugify(t)
req["db_name"] = dbname
req["submission_date"] = datetime.now(pytz.timezone("America/Chicago")).isoformat()
# Submit job to task queue.
launch_mapping(verify_request=False)
req["success"] = True
# Send user email
if req["release"] > 0:
report_slug = req["report_hash"]
else:
report_slug = req["report_slug"]
mail.send_mail(
sender="CeNDR <*****@*****.**>",
to=req["email"],
subject="CeNDR Mapping Report - " + req["report_slug"],
body=mapping_submission.format(report_slug=report_slug),
)
return str(json.dumps(req))
