def combine_mendelian_families_variants(request):
project, family_group = utils.get_project_and_family_group_for_user(request.user, request.GET)
form = api_forms.CombineMendelianFamiliesVariantsForm(request.GET)
if form.is_valid():
variants_grouped = get_variants_by_family_for_gene(
get_mall(project.project_id),
[f.xfamily() for f in form.cleaned_data['families']],
form.cleaned_data['inheritance_mode'],
form.cleaned_data['gene_id'],
variant_filter=form.cleaned_data['variant_filter'],
quality_filter=form.cleaned_data['quality_filter']
)
variants_by_family = []
for family in form.cleaned_data['families']:
variants = variants_grouped[(family.project.project_id, family.family_id)]
add_extra_info_to_variants_family(get_reference(), family, variants)
variants_by_family.append({
'project_id': family.project.project_id,
'family_id': family.family_id,
'family_name': str(family),
'variants': [v.toJSON() for v in variants],
})
return JSONResponse({
'is_error': False,
'variants_by_family': variants_by_family,
})
else:
return JSONResponse({
'is_error': True,
'error': server_utils.form_error_string(form)
})
def saved_variants(request, project_id):
project = get_object_or_404(Project, project_id=project_id)
if not project.can_view(request.user):
return HttpResponse('unauthorized')
variants = get_all_saved_variants_for_project(project)
if 'family' in request.GET:
requested_family_id = request.GET.get('family')
variants = filter(lambda v: v.extras['family_id'] == requested_family_id, variants)
variants = sorted(variants, key=lambda v: (v.extras['family_id'], v.xpos))
grouped_variants = itertools.groupby(variants, key=lambda v: v.extras['family_id'])
for family_id, family_variants in grouped_variants:
family = Family.objects.get(project=project, family_id=family_id)
family_variants = list(family_variants)
add_extra_info_to_variants_family(get_reference(), family, family_variants)
return render(request, 'project/saved_variants.html', {
'project': project,
'tag': None,
'variants_json': json.dumps([v.toJSON() for v in variants]),
'families_json': json.dumps({family.family_id: family.get_json_obj() for family in project.get_families()})
})
def get_variants_in_gene(family_group,
gene_id,
variant_filter=None,
quality_filter=None):
"""
"""
variants_by_family = []
for family in family_group.get_families():
variant_list = list(
get_mall(
family.project.project_id).variant_store.get_variants_in_gene(
family.project.project_id,
family.family_id,
gene_id,
variant_filter=variant_filter))
variant_list = search_utils.filter_gene_variants_by_variant_filter(
variant_list, gene_id, variant_filter)
add_extra_info_to_variants_family(get_reference(), family,
variant_list)
variants_by_family.append({
'variants': [v.toJSON() for v in variant_list],
'family_id':
family.family_id,
'project_id':
family.project.project_id,
'family_name':
str(family),
})
return variants_by_family
def fetch_project_individuals_data(project_id):
"""
Notes:
1. ONLY project-authorized user has access to this individual
"""
project = get_object_or_404(Project, project_id=project_id)
variants = get_causal_variants_for_project(project)
variants = sorted(variants, key=lambda v: (v.extras['family_id'], v.xpos))
grouped_variants = itertools.groupby(variants, key=lambda v: v.extras['family_id'])
for family_id, family_variants in grouped_variants:
family = Family.objects.get(project=project, family_id=family_id)
family_variants = list(family_variants)
add_extra_info_to_variants_family(get_reference(), family, family_variants)
family_data = [v.toJSON() for v in variants]
variant_data = {family.family_id: family.get_json_obj() for family in project.get_families()}
phenotype_entry_counts = gather_phenotype_data_for_project(project_id, variant_data)
status_description_map = {}
for abbrev, details in ANALYSIS_STATUS_CHOICES:
status_description_map[abbrev] = details[0]
families_json = json_displays.family_list(project.get_families())
family_statuses = {}
for f in families_json:
family_statuses[f['family_id']] = status_description_map[f['analysis_status']['status']]
return family_data, variant_data, phenotype_entry_counts, family_statuses
def mendelian_variant_search_spec(request):
project, family = get_project_and_family_for_user(request.user, request.GET)
search_hash = request.GET.get('search_hash')
search_spec_dict, variants = cache_utils.get_cached_results(project.project_id, search_hash)
search_spec = MendelianVariantSearchSpec.fromJSON(search_spec_dict)
if variants is None:
variants = api_utils.calculate_mendelian_variant_search(search_spec, family.xfamily())
else:
variants = [Variant.fromJSON(v) for v in variants]
add_extra_info_to_variants_family(get_reference(), family, variants)
return_type = request.GET.get('return_type')
if return_type == 'json' or not return_type:
return JSONResponse({
'is_error': False,
'variants': [v.toJSON() for v in variants],
'search_spec': search_spec_dict,
})
elif request.GET.get('return_type') == 'csv':
response = HttpResponse(content_type='text/csv')
response['Content-Disposition'] = 'attachment; filename="results_{}.csv"'.format(search_hash)
writer = csv.writer(response)
indiv_ids = family.indiv_ids_with_variant_data()
headers = xbrowse_displays.get_variant_display_headers(get_mall(project.project_id), project, indiv_ids)
writer.writerow(headers)
for variant in variants:
fields = xbrowse_displays.get_display_fields_for_variant(get_mall(project.project_id), project, variant, indiv_ids)
writer.writerow(fields)
return response
def mendelian_variant_search(request):
# TODO: how about we move project getter into the form, and just test for authX here?
# esp because error should be described in json, not just 404
project, family = get_project_and_family_for_user(request.user, request.GET)
form = api_forms.MendelianVariantSearchForm(request.GET)
if form.is_valid():
search_spec = form.cleaned_data['search_spec']
search_spec.family_id = family.family_id
variants = api_utils.calculate_mendelian_variant_search(search_spec, family.xfamily())
search_hash = cache_utils.save_results_for_spec(project.project_id, search_spec.toJSON(), [v.toJSON() for v in variants])
add_extra_info_to_variants_family(get_reference(), family, variants)
return_type = request.GET.get('return_type', 'json')
if return_type == 'json':
return JSONResponse({
'is_error': False,
'variants': [v.toJSON() for v in variants],
'search_hash': search_hash,
})
elif return_type == 'csv':
return ''
else:
return HttpResponse("Return type not implemented")
else:
return JSONResponse({
'is_error': True,
'error': server_utils.form_error_string(form)
})
def combine_mendelian_families_variants(request):
project, family_group = utils.get_project_and_family_group_for_user(request.user, request.GET)
form = api_forms.CombineMendelianFamiliesVariantsForm(request.GET)
if form.is_valid():
variants_grouped = get_variants_by_family_for_gene(
get_mall(project.project_id),
[f.xfamily() for f in form.cleaned_data['families']],
form.cleaned_data['inheritance_mode'],
form.cleaned_data['gene_id'],
variant_filter=form.cleaned_data['variant_filter'],
quality_filter=form.cleaned_data['quality_filter']
)
variants_by_family = []
for family in form.cleaned_data['families']:
variants = variants_grouped[(family.project.project_id, family.family_id)]
add_extra_info_to_variants_family(get_reference(), family, variants)
variants_by_family.append({
'project_id': family.project.project_id,
'family_id': family.family_id,
'family_name': str(family),
'variants': [v.toJSON() for v in variants],
})
return JSONResponse({
'is_error': False,
'variants_by_family': variants_by_family,
})
else:
return JSONResponse({
'is_error': True,
'error': server_utils.form_error_string(form)
})
def variants_with_tag(request, project_id, tag):
project = get_object_or_404(Project, project_id=project_id)
if not project.can_view(request.user):
return HttpResponse('unauthorized')
project_tag = get_object_or_404(ProjectTag, project=project, tag=tag)
variants = get_variants_by_tag(project, tag)
variants = sorted(variants, key=lambda v: v.extras['family_id'])
grouped_variants = itertools.groupby(variants,
key=lambda v: v.extras['family_id'])
for family_id, family_variants in grouped_variants:
family = Family.objects.get(project=project, family_id=family_id)
family_variants = list(family_variants)
add_extra_info_to_variants_family(get_reference(), family,
family_variants)
return render(
request, 'project/saved_variants.html', {
'project':
project,
'variants_json':
json.dumps([v.toJSON() for v in variants]),
'families_json':
json.dumps({
family.family_id: family.get_json_obj()
for family in project.get_families()
})
})
def diagnostic_search(request):
project, family = utils.get_project_and_family_for_user(request.user, request.GET)
if not project.can_view(request.user):
raise PermissionDenied
form = api_forms.DiagnosticSearchForm(family, request.GET)
if form.is_valid():
search_spec = form.cleaned_data['search_spec']
search_spec.family_id = family.family_id
gene_list = form.cleaned_data['gene_list']
diagnostic_info_list = []
for gene_id in gene_list.gene_id_list():
diagnostic_info = get_gene_diangostic_info(family, gene_id, search_spec.variant_filter)
add_extra_info_to_variants_family(get_reference(), family, diagnostic_info._variants)
diagnostic_info_list.append(diagnostic_info)
return JSONResponse({
'is_error': False,
'gene_diagnostic_info_list': [d.toJSON() for d in diagnostic_info_list],
'gene_list_info': gene_list.toJSON(details=True),
'data_summary': family.get_data_summary(),
})
else:
return JSONResponse({
'is_error': True,
'error': server_utils.form_error_string(form)
})
def mendelian_variant_search_spec(request):
project, family = get_project_and_family_for_user(request.user, request.GET)
# TODO: use form
search_hash = request.GET.get('search_hash')
search_spec_dict, variants = cache_utils.get_cached_results(project.project_id, search_hash)
search_spec = MendelianVariantSearchSpec.fromJSON(search_spec_dict)
if variants is None:
variants = api_utils.calculate_mendelian_variant_search(search_spec, family.xfamily())
else:
variants = [Variant.fromJSON(v) for v in variants]
add_extra_info_to_variants_family(get_reference(), family, variants)
return_type = request.GET.get('return_type')
if return_type == 'json' or not return_type:
return JSONResponse({
'is_error': False,
'variants': [v.toJSON() for v in variants],
'search_spec': search_spec_dict,
})
elif request.GET.get('return_type') == 'csv':
response = HttpResponse(content_type='text/csv')
response['Content-Disposition'] = 'attachment; filename="results_{}.csv"'.format(search_hash)
writer = csv.writer(response)
indiv_ids = family.indiv_ids_with_variant_data()
headers = xbrowse_displays.get_variant_display_headers(get_mall(project.project_id), project, indiv_ids)
writer.writerow(headers)
for variant in variants:
fields = xbrowse_displays.get_display_fields_for_variant(get_mall(project.project_id), project, variant, indiv_ids)
writer.writerow(fields)
return response
def diagnostic_search(request):
project, family = utils.get_project_and_family_for_user(request.user, request.GET)
if not project.can_view(request.user):
raise PermissionDenied
form = api_forms.DiagnosticSearchForm(family, request.GET)
if form.is_valid():
search_spec = form.cleaned_data['search_spec']
search_spec.family_id = family.family_id
gene_list = form.cleaned_data['gene_list']
diagnostic_info_list = []
for gene_id in gene_list.gene_id_list():
diagnostic_info = get_gene_diangostic_info(family, gene_id, search_spec.variant_filter)
add_extra_info_to_variants_family(get_reference(), family, diagnostic_info._variants)
diagnostic_info_list.append(diagnostic_info)
return JSONResponse({
'is_error': False,
'gene_diagnostic_info_list': [d.toJSON() for d in diagnostic_info_list],
'gene_list_info': gene_list.toJSON(details=True),
'data_summary': family.get_data_summary(),
})
else:
return JSONResponse({
'is_error': True,
'error': server_utils.form_error_string(form)
})
def causal_variants(request, project_id):
project = get_object_or_404(Project, project_id=project_id)
if not project.can_view(request.user):
raise PermissionDenied
variants = get_causal_variants_for_project(project)
variants = sorted(variants, key=lambda v: (v.extras['family_id'], v.xpos))
grouped_variants = itertools.groupby(variants,
key=lambda v: v.extras['family_id'])
for family_id, family_variants in grouped_variants:
family = Family.objects.get(project=project, family_id=family_id)
family_variants = list(family_variants)
add_extra_info_to_variants_family(get_reference(), family,
family_variants)
return render(
request, 'project/causal_variants.html', {
'project':
project,
'variants_json':
json.dumps([v.toJSON() for v in variants]),
'families_json':
json.dumps({
family.family_id: family.get_json_obj()
for family in project.get_families()
})
})
def mendelian_variant_search(request):
# TODO: how about we move project getter into the form, and just test for authX here?
# esp because error should be described in json, not just 404
request_dict = request.GET or request.POST
project, family = get_project_and_family_for_user(request.user,
request_dict)
form = api_forms.MendelianVariantSearchForm(request_dict)
if form.is_valid():
search_spec = form.cleaned_data['search_spec']
search_spec.family_id = family.family_id
try:
variants = api_utils.calculate_mendelian_variant_search(
search_spec, family.xfamily())
except Exception as e:
return JSONResponse({
'is_error': True,
'error': str(e.args[0]) if e.args else str(e)
})
sys.stderr.write("done fetching %s variants. Adding extra info..\n" %
len(variants))
hashable_search_params = search_spec.toJSON()
hashable_search_params['family_id'] = family.family_id
search_hash = cache_utils.save_results_for_spec(
project.project_id, hashable_search_params,
[v.toJSON() for v in variants])
add_extra_info_to_variants_family(get_reference(), family, variants)
sys.stderr.write(
"done adding extra info to %s variants. Sending response..\n" %
len(variants))
return_type = request_dict.get('return_type', 'json')
if return_type == 'json':
return JSONResponse({
'is_error': False,
'variants': [v.toJSON() for v in variants],
'search_hash': search_hash,
})
elif return_type == 'csv':
return ''
else:
return HttpResponse("Return type not implemented")
else:
return JSONResponse({
'is_error': True,
'error': server_utils.form_error_string(form)
})
def cohort_gene_search_variants(request):
# TODO: this view not like the others - refactor to forms
error = None
project, cohort = get_project_and_cohort_for_user(request.user, request.GET)
if not project.can_view(request.user):
return PermissionDenied
form = api_forms.CohortGeneSearchVariantsForm(request.GET)
if form.is_valid():
gene_id = form.cleaned_data['gene_id']
inheritance_mode = form.cleaned_data['inheritance_mode']
variant_filter = form.cleaned_data['variant_filter']
quality_filter = form.cleaned_data['quality_filter']
else:
error = server_utils.form_error_string(form)
if not error:
indivs_with_inheritance, gene_variation = cohort_search.get_individuals_with_inheritance_in_gene(
get_datastore(project.project_id),
get_reference(),
cohort.xcohort(),
inheritance_mode,
gene_id,
variant_filter=variant_filter,
quality_filter=quality_filter
)
relevant_variants = gene_variation.get_relevant_variants_for_indiv_ids(cohort.indiv_id_list())
api_utils.add_extra_info_to_variants_family(get_reference(), cohort, relevant_variants)
ret = {
'is_error': False,
'variants': [v.toJSON() for v in relevant_variants],
'gene_info': get_reference().get_gene(gene_id),
}
return JSONResponse(ret)
else:
ret = {
'is_error': True,
'error': error
}
return JSONResponse(ret)
def cohort_gene_search_variants(request):
# TODO: this view not like the others - refactor to forms
error = None
project, cohort = get_project_and_cohort_for_user(request.user,
request.GET)
if not project.can_view(request.user):
return HttpResponse('unauthorized')
form = api_forms.CohortGeneSearchVariantsForm(request.GET)
if form.is_valid():
gene_id = form.cleaned_data['gene_id']
inheritance_mode = form.cleaned_data['inheritance_mode']
variant_filter = form.cleaned_data['variant_filter']
quality_filter = form.cleaned_data['quality_filter']
else:
error = server_utils.form_error_string(form)
if not error:
indivs_with_inheritance, gene_variation = cohort_search.get_individuals_with_inheritance_in_gene(
get_datastore(project.project_id),
get_reference(),
cohort.xcohort(),
inheritance_mode,
gene_id,
variant_filter=variant_filter,
quality_filter=quality_filter)
relevant_variants = gene_variation.get_relevant_variants_for_indiv_ids(
cohort.indiv_id_list())
api_utils.add_extra_info_to_variants_family(get_reference(), cohort,
relevant_variants)
ret = {
'is_error': False,
'variants': [v.toJSON() for v in relevant_variants],
'gene_info': get_reference().get_gene(gene_id),
}
return JSONResponse(ret)
else:
ret = {'is_error': True, 'error': error}
return JSONResponse(ret)
def saved_variants(request, project_id, family_id):
project = get_object_or_404(Project, project_id=project_id)
family = get_object_or_404(Family, project=project, family_id=family_id)
if not project.can_view(request.user):
raise PermissionDenied
variants, couldntfind = get_saved_variants_for_family(family)
# TODO: first this shouldnt be in API - base should never depend on api
# TODO: also this should have better naming
add_extra_info_to_variants_family(get_reference(), family, variants)
return render(request, 'family/saved_family_variants.html', {
'project': project,
'family': family,
'variants_json': json.dumps([v.toJSON() for v in variants]),
})
def family_gene_lookup(request):
project, family = utils.get_project_and_family_for_user(request.user, request.GET)
if not project.can_view(request.user):
raise PermissionDenied
gene_id = request.GET.get('gene_id')
if not get_reference().is_valid_gene_id(gene_id):
return JSONResponse({
'is_error': True,
'error': 'Invalid gene',
})
family_gene_data = get_gene_diangostic_info(family, gene_id)
add_extra_info_to_variants_family(get_reference(), family, family_gene_data._variants)
return JSONResponse({
'is_error': False,
'family_gene_data': family_gene_data.toJSON(),
'data_summary': family.get_data_summary(),
'gene': get_reference().get_gene(gene_id),
})
def family_gene_lookup(request):
project, family = utils.get_project_and_family_for_user(request.user, request.GET)
if not project.can_view(request.user):
raise PermissionDenied
gene_id = request.GET.get('gene_id')
if not get_reference().is_valid_gene_id(gene_id):
return JSONResponse({
'is_error': True,
'error': 'Invalid gene',
})
family_gene_data = get_gene_diangostic_info(family, gene_id)
add_extra_info_to_variants_family(get_reference(), family, family_gene_data._variants)
return JSONResponse({
'is_error': False,
'family_gene_data': family_gene_data.toJSON(),
'data_summary': family.get_data_summary(),
'gene': get_reference().get_gene(gene_id),
})
def saved_variants(request, project_id, family_id):
project = get_object_or_404(Project, project_id=project_id)
family = get_object_or_404(Family, project=project, family_id=family_id)
if not project.can_view(request.user):
return HttpResponse('unauthorized')
variants, couldntfind = get_saved_variants_for_family(family)
# TODO: first this shouldnt be in API - base should never depend on api
# TODO: also this should have better naming
add_extra_info_to_variants_family(get_reference(), family, variants)
return render(request, 'family/saved_family_variants.html', {
'project': project,
'family': family,
'variants_json': json.dumps([v.toJSON() for v in variants]),
})
def causal_variants(request, project_id):
project = get_object_or_404(Project, project_id=project_id)
if not project.can_view(request.user):
raise PermissionDenied
variants = get_causal_variants_for_project(project)
variants = sorted(variants, key=lambda v: (v.extras['family_id'], v.xpos))
grouped_variants = itertools.groupby(variants, key=lambda v: v.extras['family_id'])
for family_id, family_variants in grouped_variants:
family = Family.objects.get(project=project, family_id=family_id)
family_variants = list(family_variants)
add_extra_info_to_variants_family(get_reference(), family, family_variants)
return render(request, 'project/causal_variants.html', {
'project': project,
'variants_json': json.dumps([v.toJSON() for v in variants]),
'families_json': json.dumps({family.family_id: family.get_json_obj() for family in project.get_families()})
})
def add_variant_note(request):
"""
"""
family = None
if 'family_id' in request.GET:
project, family = get_project_and_family_for_user(request.user, request.GET)
else:
project = utils.get_project_for_user(request.user, request.GET)
form = api_forms.VariantNoteForm(project, request.GET)
if form.is_valid():
note = VariantNote.objects.create(
user=request.user,
date_saved=datetime.datetime.now(),
project=project,
note=form.cleaned_data['note_text'],
xpos=form.cleaned_data['xpos'],
ref=form.cleaned_data['ref'],
alt=form.cleaned_data['alt'],
)
if family:
note.family = family
note.save()
variant = get_datastore(project.project_id).get_single_variant(
project.project_id,
family.family_id,
form.cleaned_data['xpos'],
form.cleaned_data['ref'],
form.cleaned_data['alt'],
)
add_extra_info_to_variants_family(get_reference(), family, [variant,])
ret = {
'is_error': False,
'variant': variant.toJSON(),
}
else:
ret = {
'is_error': True,
'error': server_utils.form_error_string(form)
}
return JSONResponse(ret)
def add_variant_note(request):
"""
"""
family = None
if 'family_id' in request.GET:
project, family = get_project_and_family_for_user(
request.user, request.GET)
else:
project = utils.get_project_for_user(request.user, request.GET)
form = api_forms.VariantNoteForm(project, request.GET)
if form.is_valid():
note = VariantNote.objects.create(
user=request.user,
date_saved=datetime.datetime.now(),
project=project,
note=form.cleaned_data['note_text'],
xpos=form.cleaned_data['xpos'],
ref=form.cleaned_data['ref'],
alt=form.cleaned_data['alt'],
)
if family:
note.family = family
note.save()
variant = get_datastore(project.project_id).get_single_variant(
project.project_id,
family.family_id,
form.cleaned_data['xpos'],
form.cleaned_data['ref'],
form.cleaned_data['alt'],
)
add_extra_info_to_variants_family(get_reference(), family, [
variant,
])
ret = {
'is_error': False,
'variant': variant.toJSON(),
}
else:
ret = {'is_error': True, 'error': server_utils.form_error_string(form)}
return JSONResponse(ret)
def variant_notes(request, project_id):
project = get_object_or_404(Project, project_id=project_id)
if not project.can_view(request.user):
return HttpResponse('unauthorized')
variants = get_variants_with_notes_for_project(project)
variants = sorted(variants, key=lambda v: v.extras['family_id'])
grouped_variants = itertools.groupby(variants, key=lambda v: v.extras['family_id'])
for family_id, family_variants in grouped_variants:
family = Family.objects.get(project=project, family_id=family_id)
family_variants = list(family_variants)
add_extra_info_to_variants_family(get_reference(), family, family_variants)
return render(request, 'project/variant_notes.html', {
'project': project,
'variants_json': json.dumps([v.toJSON() for v in variants]),
'families_json': json.dumps({family.family_id: family.get_json_obj() for family in project.get_families()})
})
def get_variants_in_gene(family_group, gene_id, variant_filter=None, quality_filter=None):
"""
"""
variants_by_family = []
for family in family_group.get_families():
variant_list = list(get_mall(family.project.project_id).variant_store.get_variants_in_gene(
family.project.project_id,
family.family_id,
gene_id,
variant_filter=variant_filter
))
variant_list = search_utils.filter_gene_variants_by_variant_filter(variant_list, gene_id, variant_filter)
add_extra_info_to_variants_family(get_reference(), family, variant_list)
variants_by_family.append({
'variants': [v.toJSON() for v in variant_list],
'family_id': family.family_id,
'project_id': family.project.project_id,
'family_name': str(family),
})
return variants_by_family
def edit_variant_tags(request):
family = None
if 'family_id' in request.GET:
project, family = get_project_and_family_for_user(
request.user, request.GET)
else:
project = utils.get_project_for_user(request.user, request.GET)
form = api_forms.VariantTagsForm(project, request.GET)
if form.is_valid():
VariantTag.objects.filter(family=family,
xpos=form.cleaned_data['xpos'],
ref=form.cleaned_data['ref'],
alt=form.cleaned_data['alt']).delete()
for project_tag in form.cleaned_data['project_tags']:
VariantTag.objects.create(
project_tag=project_tag,
family=family,
xpos=form.cleaned_data['xpos'],
ref=form.cleaned_data['ref'],
alt=form.cleaned_data['alt'],
)
variant = get_datastore(project.project_id).get_single_variant(
project.project_id,
family.family_id,
form.cleaned_data['xpos'],
form.cleaned_data['ref'],
form.cleaned_data['alt'],
)
add_extra_info_to_variants_family(get_reference(), family, [
variant,
])
ret = {
'is_error': False,
'variant': variant.toJSON(),
}
else:
ret = {'is_error': True, 'error': server_utils.form_error_string(form)}
return JSONResponse(ret)
def family_variant_view(request, project_id, family_id):
project = get_object_or_404(Project, project_id=project_id)
family = get_object_or_404(Family, project=project, family_id=family_id)
if not project.can_view(request.user):
return HttpResponse('unauthorized')
try:
xpos = int(request.GET.get('xpos'))
ref = request.GET.get('ref')
alt = request.GET.get('alt')
except:
return HttpResponse('Invalid View')
variant = get_datastore(project_id).get_single_variant(project_id, family_id, xpos, ref, alt)
add_extra_info_to_variants_family(get_reference(), family, [variant])
return render(request, 'family/family_variant_view.html', {
'project': project,
'family': family,
'variant_json': json.dumps(variant.toJSON()),
})
def edit_variant_tags(request):
family = None
if 'family_id' in request.GET:
project, family = get_project_and_family_for_user(request.user, request.GET)
else:
project = utils.get_project_for_user(request.user, request.GET)
form = api_forms.VariantTagsForm(project, request.GET)
if form.is_valid():
VariantTag.objects.filter(family=family, xpos=form.cleaned_data['xpos'], ref=form.cleaned_data['ref'], alt=form.cleaned_data['alt']).delete()
for project_tag in form.cleaned_data['project_tags']:
VariantTag.objects.create(
user=request.user,
date_saved=datetime.datetime.now(),
project_tag=project_tag,
family=family,
xpos=form.cleaned_data['xpos'],
ref=form.cleaned_data['ref'],
alt=form.cleaned_data['alt'],
)
variant = get_datastore(project.project_id).get_single_variant(
project.project_id,
family.family_id,
form.cleaned_data['xpos'],
form.cleaned_data['ref'],
form.cleaned_data['alt'],
)
add_extra_info_to_variants_family(get_reference(), family, [variant,])
ret = {
'is_error': False,
'variant': variant.toJSON(),
}
else:
ret = {
'is_error': True,
'error': server_utils.form_error_string(form)
}
return JSONResponse(ret)
def family_variant_view(request, project_id, family_id):
project = get_object_or_404(Project, project_id=project_id)
family = get_object_or_404(Family, project=project, family_id=family_id)
if not project.can_view(request.user):
raise PermissionDenied
try:
xpos = int(request.GET.get('xpos'))
ref = request.GET.get('ref')
alt = request.GET.get('alt')
except:
return HttpResponse('Invalid View')
variant = get_datastore(project_id).get_single_variant(project_id, family_id, xpos, ref, alt)
add_extra_info_to_variants_family(get_reference(), family, [variant])
return render(request, 'family/family_variant_view.html', {
'project': project,
'family': family,
'variant_json': json.dumps(variant.toJSON()),
})
def causal_variants(request, project_id):
project = get_object_or_404(Project, project_id=project_id)
if not project.can_view(request.user):
return HttpResponse("unauthorized")
variants = get_causal_variants_for_project(project)
variants = sorted(variants, key=lambda v: v.extras["family_id"])
grouped_variants = itertools.groupby(variants, key=lambda v: v.extras["family_id"])
for family_id, family_variants in grouped_variants:
family = Family.objects.get(project=project, family_id=family_id)
family_variants = list(family_variants)
add_extra_info_to_variants_family(get_reference(), family, family_variants)
return render(
request,
"project/causal_variants.html",
{
"project": project,
"variants_json": json.dumps([v.toJSON() for v in variants]),
"families_json": json.dumps({family.family_id: family.get_json_obj() for family in project.get_families()}),
},
)
def mendelian_variant_search(request):
# TODO: how about we move project getter into the form, and just test for authX here?
# esp because error should be described in json, not just 404
project, family = get_project_and_family_for_user(request.user,
request.GET)
form = api_forms.MendelianVariantSearchForm(request.GET)
if form.is_valid():
search_spec = form.cleaned_data['search_spec']
search_spec.family_id = family.family_id
variants = api_utils.calculate_mendelian_variant_search(
search_spec, family.xfamily())
search_hash = cache_utils.save_results_for_spec(
project.project_id, search_spec.toJSON(),
[v.toJSON() for v in variants])
add_extra_info_to_variants_family(get_reference(), family, variants)
return_type = request.GET.get('return_type', 'json')
if return_type == 'json':
return JSONResponse({
'is_error': False,
'variants': [v.toJSON() for v in variants],
'search_hash': search_hash,
})
elif return_type == 'csv':
return ''
else:
return HttpResponse("Return type not implemented")
else:
return JSONResponse({
'is_error': True,
'error': server_utils.form_error_string(form)
})
def variants_with_tag(request, project_id, tag):
project = get_object_or_404(Project, project_id=project_id)
if not project.can_view(request.user):
raise PermissionDenied
tag = urllib.unquote(tag)
#project_tag = get_object_or_404(ProjectTag, project=project, tag=tag)
variants = get_variants_by_tag(project, tag)
if 'family' in request.GET:
requested_family_id = request.GET.get('family')
variants = filter(
lambda v: v.extras['family_id'] == requested_family_id, variants)
variants = sorted(variants, key=lambda v: (v.extras['family_id'], v.xpos))
grouped_variants = itertools.groupby(variants,
key=lambda v: v.extras['family_id'])
for family_id, family_variants in grouped_variants:
try:
family = Family.objects.get(project=project, family_id=family_id)
except ObjectDoesNotExist as e:
print("family: %s not found" % str(family_id))
continue
family_variants = list(family_variants)
add_extra_info_to_variants_family(get_reference(), family,
family_variants)
if request.GET.get('download', ''):
response = HttpResponse(content_type='text/csv')
response[
'Content-Disposition'] = 'attachment; filename="{}_{}.csv"'.format(
project_id, tag)
header_fields = [
"chrom", "pos", "ref", "alt", "tags", "notes", "family", "gene",
"effect", "1kg_wgs_phase3", "1kg_wgs_phase3_popmax", "exac_v3",
"exac_v3_popmax", "sift", "polyphen", "hgvsc", "hgvsp"
]
genotype_header_fields = [
'sample_id', 'GT_genotype', 'filter', 'AD_allele_depth',
'DP_read_depth', 'GQ_genotype_quality', 'AB_allele_balance'
]
for i in range(0, 10):
for h in genotype_header_fields:
header_fields.append("%s_%d" % (h, i))
writer = csv.writer(response)
writer.writerow(header_fields)
for variant in variants:
if not (variant and variant.annotation
and variant.annotation.get("vep_annotation")):
continue
worst_annotation_idx = variant.annotation[
"worst_vep_annotation_index"]
worst_annotation = variant.annotation["vep_annotation"][
worst_annotation_idx]
family_id = variant.extras["family_id"]
family = Family.objects.get(project=project, family_id=family_id)
genotype_values = []
for individual in family.get_individuals():
genotype_values.append(individual.indiv_id)
genotype = variant.get_genotype(individual.indiv_id)
genotype_values.append("/".join(genotype.alleles) if genotype
and genotype.alleles else "./.")
genotype_values.append(genotype.filter if genotype else "")
genotype_values.append(
genotype.extras["ad"] if genotype else "")
genotype_values.append(
genotype.extras["dp"] if genotype else "")
genotype_values.append(genotype.gq if genotype
and genotype.gq is not None else "")
genotype_values.append("%0.3f" % genotype.ab if genotype
and genotype.ab is not None else "")
writer.writerow(
map(lambda s: unicode(s).encode('UTF-8'), [
variant.chr,
variant.pos,
variant.ref,
variant.alt,
"|".join([
tag['tag'] for tag in variant.extras['family_tags']
]) if 'family_tags' in variant.extras else '',
"|".join([
note['user']['display_name'] + ":" + note['note']
for note in variant.extras['family_notes']
]) if 'family_notes' in variant.extras else '',
variant.extras["family_id"],
worst_annotation.get("symbol", ""),
variant.annotation.get("vep_consequence", ""),
variant.annotation["freqs"].get("1kg_wgs_phase3", ""),
variant.annotation["freqs"].get("1kg_wgs_phase3_popmax",
""),
variant.annotation["freqs"].get("exac_v3", ""),
variant.annotation["freqs"].get("exac_v3_popmax", ""),
worst_annotation.get("sift", ""),
worst_annotation.get("polyphen", ""),
worst_annotation.get("hgvsc", ""),
worst_annotation.get("hgvsp", "").replace("%3D", "="),
] + genotype_values))
return response
else:
return render(
request, 'project/saved_variants.html', {
'project':
project,
'tag':
tag,
'variants_json':
json.dumps([v.toJSON() for v in variants]),
'families_json':
json.dumps({
family.family_id: family.get_json_obj()
for family in project.get_families()
})
})
def add_or_edit_variant_tags(request):
family = None
if 'family_id' in request.GET:
project, family = get_project_and_family_for_user(request.user, request.GET)
else:
project = utils.get_project_for_user(request.user, request.GET)
form = api_forms.VariantTagsForm(project, request.GET)
if not form.is_valid():
ret = {
'is_error': True,
'error': server_utils.form_error_string(form)
}
return JSONResponse(ret)
variant = get_datastore(project.project_id).get_single_variant(
project.project_id,
family.family_id,
form.cleaned_data['xpos'],
form.cleaned_data['ref'],
form.cleaned_data['alt'],
)
if not variant:
variant = Variant(form.cleaned_data['xpos'], form.cleaned_data['ref'], form.cleaned_data['alt'])
variant_tags_to_delete = {
variant_tag.id: variant_tag for variant_tag in VariantTag.objects.filter(
family=family,
xpos=form.cleaned_data['xpos'],
ref=form.cleaned_data['ref'],
alt=form.cleaned_data['alt'])
}
project_tag_events = {}
for project_tag in form.cleaned_data['project_tags']:
# retrieve tags
tag, created = VariantTag.objects.get_or_create(
project_tag=project_tag,
family=family,
xpos=form.cleaned_data['xpos'],
ref=form.cleaned_data['ref'],
alt=form.cleaned_data['alt'],
)
if not created:
# this tag already exists so just keep it (eg. remove it from the set of tags that will be deleted)
del variant_tags_to_delete[tag.id]
continue
# this a new tag, so update who saved it and when
project_tag_events[project_tag] = "add_variant_tag"
tag.user = request.user
tag.date_saved = timezone.now()
tag.search_url = form.cleaned_data['search_url']
tag.save()
# delete the tags that are no longer checked.
for variant_tag in variant_tags_to_delete.values():
project_tag_events[variant_tag.project_tag] = "delete_variant_tag"
variant_tag.delete()
# add the extra info after updating the tag info in the database, so that the new tag info is added to the variant JSON
add_extra_info_to_variants_family(get_reference(), family, [variant,])
# log tag creation
for project_tag, event_type in project_tag_events.items():
try:
settings.EVENTS_COLLECTION.insert({
'event_type': event_type,
'date': timezone.now(),
'project_id': ''.join(project.project_id),
'family_id': family.family_id,
'tag': project_tag.tag,
'title': project_tag.title,
'xpos':form.cleaned_data['xpos'],
'pos':variant.pos,
'chrom': variant.chr,
'ref':form.cleaned_data['ref'],
'alt':form.cleaned_data['alt'],
'gene_names': ", ".join(variant.extras['gene_names'].values()),
'username': request.user.username,
'email': request.user.email,
'search_url': form.cleaned_data.get('search_url'),
})
except Exception as e:
logging.error("Error while logging add_variant_tag event: %s" % e)
return JSONResponse({
'is_error': False,
'variant': variant.toJSON(),
})
def variants_with_tag(request, project_id, tag):
project = get_object_or_404(Project, project_id=project_id)
if not project.can_view(request.user):
return HttpResponse('unauthorized')
project_tag = get_object_or_404(ProjectTag, project=project, tag=tag)
variants = get_variants_by_tag(project, tag)
if 'family' in request.GET:
requested_family_id = request.GET.get('family')
variants = filter(lambda v: v.extras['family_id'] == requested_family_id, variants)
variants = sorted(variants, key=lambda v: (v.extras['family_id'], v.xpos))
grouped_variants = itertools.groupby(variants, key=lambda v: v.extras['family_id'])
for family_id, family_variants in grouped_variants:
family = Family.objects.get(project=project, family_id=family_id)
family_variants = list(family_variants)
add_extra_info_to_variants_family(get_reference(), family, family_variants)
if request.GET.get('download', ''):
response = HttpResponse(content_type='text/csv')
response['Content-Disposition'] = 'attachment; filename="{}_{}.csv"'.format(project_id, tag)
header_fields = ["chrom", "pos", "ref", "alt", "tags", "notes", "family", "gene", "effect",
"1kg_wgs_phase3", "1kg_wgs_phase3_popmax", "exac_v3", "exac_v3_popmax",
"sift", "polyphen", "hgvsc", "hgvsp"]
genotype_header_fields = ['sample_id', 'GT_genotype', 'filter', 'AD_allele_depth', 'DP_read_depth', 'GQ_genotype_quality', 'AB_allele_balance']
for i in range(0, 10):
for h in genotype_header_fields:
header_fields.append("%s_%d" % (h, i))
writer = csv.writer(response)
writer.writerow(header_fields)
for variant in variants:
worst_annotation_idx = variant.annotation["worst_vep_annotation_index"]
worst_annotation = variant.annotation["vep_annotation"][worst_annotation_idx]
family_id = variant.extras["family_id"]
family = Family.objects.get(project=project, family_id=family_id)
genotype_values = []
for individual in family.get_individuals():
genotype_values.append(individual.indiv_id)
genotype = variant.get_genotype(individual.indiv_id)
genotype_values.append("/".join(genotype.alleles) if genotype.alleles else "./.")
genotype_values.append(genotype.filter)
genotype_values.append(genotype.extras["ad"])
genotype_values.append(genotype.extras["dp"])
genotype_values.append(genotype.gq if genotype.gq is not None else "")
genotype_values.append("%0.3f" % genotype.ab if genotype.ab is not None else "")
writer.writerow(map(str,
[ variant.chr,
variant.pos,
variant.ref,
variant.alt,
"|".join([tag['tag'] for tag in variant.extras['family_tags']]) if 'family_tags' in variant.extras else '',
"|".join([note['user']['display_name'] +":"+ note['note'] for note in variant.extras['family_notes']]) if 'family_notes' in variant.extras else '',
variant.extras["family_id"],
worst_annotation.get("symbol", ""),
variant.annotation.get("vep_consequence", ""),
variant.annotation["freqs"].get("1kg_wgs_phase3", ""),
variant.annotation["freqs"].get("1kg_wgs_phase3_popmax", ""),
variant.annotation["freqs"].get("exac_v3", ""),
variant.annotation["freqs"].get("exac_v3_popmax", ""),
worst_annotation.get("sift", ""),
worst_annotation.get("polyphen", ""),
worst_annotation.get("hgvsc", ""),
worst_annotation.get("hgvsp", "").replace("%3D", "="),
] + genotype_values))
return response
else:
return render(request, 'project/saved_variants.html', {
'project': project,
'tag': tag,
'variants_json': json.dumps([v.toJSON() for v in variants]),
'families_json': json.dumps({family.family_id: family.get_json_obj() for family in project.get_families()})
})
def add_or_edit_variant_note(request):
"""Add a variant note"""
family = None
if 'family_id' in request.GET:
project, family = get_project_and_family_for_user(request.user, request.GET)
else:
project = utils.get_project_for_user(request.user, request.GET)
form = api_forms.VariantNoteForm(project, request.GET)
if not form.is_valid():
return JSONResponse({
'is_error': True,
'error': server_utils.form_error_string(form)
})
variant = get_datastore(project.project_id).get_single_variant(
project.project_id,
family.family_id,
form.cleaned_data['xpos'],
form.cleaned_data['ref'],
form.cleaned_data['alt'],
)
if not variant:
variant = Variant.fromJSON({
'xpos' : form.cleaned_data['xpos'], 'ref': form.cleaned_data['ref'], 'alt': form.cleaned_data['alt'],
'genotypes': {}, 'extras': {},
})
if 'note_id' in form.cleaned_data and form.cleaned_data['note_id']:
event_type = "edit_variant_note"
notes = VariantNote.objects.filter(
id=form.cleaned_data['note_id'],
project=project,
xpos=form.cleaned_data['xpos'],
ref=form.cleaned_data['ref'],
alt=form.cleaned_data['alt'],
)
if not notes:
return JSONResponse({
'is_error': True,
'error': 'note id %s not found' % form.cleaned_data['note_id']
})
note = notes[0]
note.user = request.user
note.note = form.cleaned_data['note_text']
note.date_saved = timezone.now()
if family:
note.family = family
note.save()
else:
event_type = "add_variant_note"
VariantNote.objects.create(
user=request.user,
project=project,
xpos=form.cleaned_data['xpos'],
ref=form.cleaned_data['ref'],
alt=form.cleaned_data['alt'],
note=form.cleaned_data['note_text'],
date_saved=timezone.now(),
family=family,
)
add_extra_info_to_variants_family(get_reference(), family, [variant,])
try:
settings.EVENTS_COLLECTION.insert({
'event_type': event_type,
'date': timezone.now(),
'project_id': ''.join(project.project_id),
'family_id': family.family_id,
'note': form.cleaned_data['note_text'],
'xpos':form.cleaned_data['xpos'],
'pos':variant.pos,
'chrom': variant.chr,
'ref':form.cleaned_data['ref'],
'alt':form.cleaned_data['alt'],
'gene_names': ", ".join(variant.extras['gene_names'].values()),
'username': request.user.username,
'email': request.user.email,
})
except Exception as e:
logging.error("Error while logging %s event: %s" % (event_type, e))
return JSONResponse({
'is_error': False,
'variant': variant.toJSON(),
})
