def column_summary_boxplot(request, node_id, label, variant_column):
get_node_subclass_or_404(request.user, node_id) # Permission check
graph_class_name = full_class_name(ColumnBoxplotGraph)
cached_graph = graphcache.async_graph(graph_class_name, node_id, label,
variant_column)
return HttpResponseRedirect(
reverse("cached_generated_file_check",
kwargs={"cgf_id": cached_graph.id}))
def node_graph(request, node_id, graph_type_id, cmap):
get_node_subclass_or_404(request.user, node_id) # Permission check
node_graph_type = NodeGraphType.objects.get(pk=graph_type_id)
cached_graph = graphcache.async_graph(node_graph_type.graph_class, cmap,
node_id)
return HttpResponseRedirect(
reverse("cached_generated_file_check",
kwargs={"cgf_id": cached_graph.id}))
def vcf_locus_filters(request, node_id, vcf_id):
node = get_node_subclass_or_404(request.user, node_id)
if vcf_id:
vcf = VCF.get_for_user(request.user, vcf_id)
else:
vcf = None
context = {"vcf": vcf}
if vcf:
vcf_filter_descriptions = {"PASS": "******"}
set_filters = {}
for npf in NodeVCFFilter.filter_for_node(node, vcf):
if npf.vcf_filter:
filter_id = npf.vcf_filter.filter_id
else:
filter_id = "PASS"
set_filters[filter_id] = True
existing_filter_settings = {"PASS": "******" in set_filters}
for vcf_filter in vcf.vcffilter_set.all():
filter_id = vcf_filter.filter_id
vcf_filter_descriptions[filter_id] = vcf_filter.description
existing_filter_settings[filter_id] = filter_id in set_filters
context["has_filters"] = vcf.has_filters
context["has_filters_set"] = bool(set_filters)
context["vlf_form"] = VCFLocusFilterForm(
vcf_filters=existing_filter_settings)
context["vlf_descriptions"] = vcf_filter_descriptions
return render(request, 'analysis/node_editors/vcf_locus_filters.html',
context)
def cohort_zygosity_filters(request, cohort_node_id, cohort_id):
""" Called from Cohort Node editor - cohort is what's currently selected,
not what is saved in node """
cohort_node = get_node_subclass_or_404(request.user, cohort_node_id)
cohort = Cohort.get_for_user(request.user, cohort_id)
cnzfc = CohortNodeZygosityFiltersCollection.get_for_node_and_cohort(
cohort_node, cohort)
class CohortSampleNameReadOnlyTextInput(forms.TextInput):
input_type = 'text'
def render(self, name, value, attrs=None, renderer=None):
cs = CohortSample.objects.get(pk=value)
return cs.sample.name
CNZFFormSet = inlineformset_factory(
CohortNodeZygosityFiltersCollection,
CohortNodeZygosityFilter,
can_delete=False,
fields=[
'cohort_sample', 'show_in_grid', 'zygosity_ref', 'zygosity_het',
'zygosity_hom', 'zygosity_none'
],
widgets={
'cohort_sample':
CohortSampleNameReadOnlyTextInput(attrs={'readonly': 'readonly'})
},
extra=0)
formset = CNZFFormSet(request.POST or None, instance=cnzfc)
context = {'formset': formset}
template = 'analysis/node_editors/cohort_zygosity_filters.html'
return render(request, template, context)
def node_populate_clingen_alleles(request, node_id):
node = get_node_subclass_or_404(request.user, node_id)
an_as, _ = AnalysisNodeAlleleSource.objects.get_or_create(node=node)
populate_clingen_alleles_from_allele_source.si(
an_as.pk,
settings.CLINGEN_ALLELE_REGISTRY_MAX_MANUAL_REQUESTS).apply_async()
return JsonResponse({})
def node_column_summary(request, analysis_version, node_id, node_version,
extra_filters, grid_column_name, significant_figures):
node = get_node_subclass_or_404(request.user,
node_id,
version=node_version)
grid = VariantGrid(request.user, node, extra_filters)
cm = grid.get_column_colmodel(grid_column_name)
variant_column = cm['name']
sorttype = cm.get('sorttype')
quantitative = sorttype in ['float', 'int']
context = {
"node_id": node.id,
"node_version": node.version,
"extra_filters": extra_filters
}
if quantitative:
label = cm['label']
poll_url = reverse(column_summary_boxplot,
kwargs={
"node_id": node_id,
"label": label,
"variant_column": variant_column
})
context["poll_url"] = poll_url
template = 'analysis/node_data/node_data_graph.html'
return render(request, template, context)
context['grid_column_name'] = grid_column_name
context['significant_figures'] = int(significant_figures)
template = 'analysis/node_data/node_data_column_summary_grid.html'
return render(request, template, context)
def node_method_description(request, node_id, node_version):
node = get_node_subclass_or_404(request.user,
node_id,
version=node_version)
nodes = AnalysisNode.depth_first(node)
context = {"node": node, "nodes": nodes}
return render(request, 'analysis/node_method_description.html', context)
def create_filter_child(request, node_id):
node = get_node_subclass_or_404(request.user, node_id)
column_name = request.POST['column_name']
column_filter = request.POST['column_filter']
child_node = create_filter_child_node(node, column_name, column_filter)
data = get_rendering_dict(child_node)
data["node_id"] = node.get_css_id()
return JsonResponse(data)
def node_view(request, analysis_version, node_id, node_version, extra_filters):
""" So we don't fill up urls with lots of different views, just come here and dispatch
to subclasses of NodeView in analysis.views.nodes based on the model field """
node = get_node_subclass_or_404(request.user,
node_id,
version=node_version)
view = NODE_DISPATCHER[node.__class__]
return view(request,
pk=node_id,
version_id=node_version,
extra_filters=extra_filters)
def node_cancel_load(request, node_id):
node = get_node_subclass_or_404(request.user, node_id)
if node_task := NodeTask.objects.filter(node=node,
version=node.version).first():
if node_task.celery_task:
logging.debug("TODO: Cancelling task %s", node_task.celery_task)
app.control.revoke(node_task.celery_task,
terminate=True) # @UndefinedVariable
result = AbortableAsyncResult(node_task.celery_task)
result.abort()
if node_task.db_pid:
run_sql("select pg_cancel_backend(%s)", [node_task.db_pid])
def get_snp_matrix_counts(user: User, node_id, version_id):
node = get_node_subclass_or_404(user, node_id, version=version_id)
qs = node.get_queryset().filter(locus__ref__length=1, alt__length=1)
count_qs = qs.values_list('locus__ref__seq',
'alt__seq').distinct().annotate(Count('id'))
bases = list('ACGT')
counts_df = pd.DataFrame(index=bases, columns=bases, dtype='i').fillna(0)
for ref, alt, count in count_qs:
if alt == Variant.REFERENCE_ALT:
alt = ref
counts_df[ref][alt] = count
return counts_df
def node_async_wait(request, analysis_version, node_id, node_version,
extra_filters):
node = get_node_subclass_or_404(request.user, node_id)
context = {
"analysis_version": analysis_version,
"node_id": node_id,
"node_version": node_version,
"node": node,
"extra_filters": extra_filters
}
template = 'analysis/node_data/node_async_wait.html'
return render(request, template, context)
def create_selected_child(request, node_id):
node = get_node_subclass_or_404(request.user, node_id)
x = node.x + 50 + random.randrange(-10, 10)
y = node.y + 100 + random.randrange(-10, 10)
selected_node = SelectedInParentNode.objects.create(analysis=node.analysis,
x=x,
y=y,
ready=False)
selected_node.add_parent(node)
selected_node.save()
update_analysis(node.analysis.pk)
data = get_rendering_dict(selected_node)
data["node_id"] = node.get_css_id()
return JsonResponse(data)
def analysis_template_variable(request, node_id):
node = get_node_subclass_or_404(request.user, node_id, write=True)
field = request.POST["field"]
operation = request.POST["op"]
kwargs = {"node": node, "field": field}
if operation == 'add':
class_name = AnalysisVariable.get_node_field_class_name(node, field)
AnalysisVariable.objects.get_or_create(**kwargs,
defaults={
"class_name": class_name
})
elif operation == 'del':
AnalysisVariable.objects.filter(**kwargs).delete()
return JsonResponse({})
def create_extra_filter_child(request, node_id, extra_filters):
node = get_node_subclass_or_404(request.user, node_id, write=True)
x = node.x + 50 + random.randrange(-10, 10)
y = node.y + 100 + random.randrange(-10, 10)
filter_node = BuiltInFilterNode.objects.create(
analysis=node.analysis,
built_in_filter=extra_filters,
x=x,
y=y,
ready=False)
filter_node.add_parent(node)
filter_node.save()
update_analysis(node.analysis.pk)
data = get_rendering_dict(filter_node)
data["node_id"] = node.get_css_id()
return JsonResponse(data)
def nodes_copy(request, analysis_id):
node_ids = json.loads(request.POST["nodes"])
node_ids = set([int(i) for i in node_ids])
nodes = []
edges = []
analysis = get_analysis_or_404(request.user, analysis_id, write=True)
nodes_qs = analysis.analysisnode_set.filter(
id__in=node_ids).select_subclasses()
topo_sorted = get_toposorted_nodes(nodes_qs)
old_new_map = {}
for group in topo_sorted:
for node in group:
if analysis_id is None:
analysis_id = node.analysis_id
template_node = get_node_subclass_or_404(request.user, node.id)
parents = template_node.analysisnode_ptr.parents().filter(
id__in=old_new_map).values_list('id', flat=True)
clone_node = template_node.save_clone()
clone_node.x += 10
clone_node.y += 10
clone_node.status = NodeStatus.DIRTY
clone_node.save()
old_new_map[node.id] = clone_node
clone_node.adjust_cloned_parents(old_new_map)
for parent_id in parents:
new_parent = old_new_map[parent_id]
new_parent.add_child(clone_node)
edge = clone_node.get_connection_data(new_parent)
edges.append(edge)
if not clone_node.is_valid():
clone_node.count = None
clone_node.save()
nodes.append(get_rendering_dict(clone_node))
update_analysis(analysis.pk)
return JsonResponse({"nodes": nodes, "edges": edges})
def node_data_grid(request, analysis_version, node_id, node_version,
extra_filters):
try:
node = get_node_subclass_or_404(request.user,
node_id,
version=node_version)
except NodeOutOfDateException:
return HttpResponseRedirect(
reverse("node_load", kwargs={"node_id": node_id}))
context = {
"analysis_version": analysis_version,
"node_id": node_id,
"node_version": node_version,
"extra_filters": extra_filters,
"bams_dict": node.get_bams_dict()
}
return render(request, 'analysis/node_data/node_data_grid.html', context)
def set_variant_selected(request, node_id):
node = get_node_subclass_or_404(request.user, node_id, write=True)
variant_id = request.POST['variant_id']
checked = json.loads(request.POST['checked'])
kwargs = {"variant_id": variant_id, "node_id": node.pk}
if checked:
NodeVariant.objects.get_or_create(**kwargs)
else:
NodeVariant.objects.filter(**kwargs).delete()
kids_qs = AnalysisEdge.objects.filter(parent=node).values_list(
"child_id", flat=True) # @UndefinedVariable
for node in SelectedInParentNode.objects.filter(pk__in=kids_qs):
node.queryset_dirty = True
node.save()
update_analysis(node.analysis.pk)
return JsonResponse({})
def node_doc(request, node_id):
node = get_node_subclass_or_404(request.user, node_id)
has_write_permission = node.analysis.can_write(request.user)
form = forms.AnalysisNodeForm(request.POST or None, instance=node)
if not has_write_permission:
set_form_read_only(form)
if request.method == "POST":
node.analysis.check_can_write(request.user)
if form.is_valid():
# Doesn't set "queryset_dirty" so won't cause expensive reloads
node = form.save()
context = {
"form": form,
"node": node,
"has_write_permission": has_write_permission
}
return render(request, "analysis/node_editors/grid_editor_doc_tab.html",
context)
def node_data_graph(request, analysis_version, node_id, node_version,
graph_type_id, cmap):
context = {
"node_id": node_id,
"node_version": node_version,
"extra_filters": None
}
node = get_node_subclass_or_404(request.user,
node_id,
version=node_version)
poll_url = reverse(node_graph,
kwargs={
"node_id": node.id,
"graph_type_id": graph_type_id,
"cmap": cmap
})
context["poll_url"] = poll_url
template = 'analysis/node_data/node_data_graph.html'
return render(request, template, context)
def node_errors(request, analysis_version, node_id, node_version,
extra_filters):
try:
node = get_node_subclass_or_404(request.user,
node_id,
version=node_version)
except NodeOutOfDateException:
return HttpResponseRedirect(
reverse("node_load", kwargs={"node_id": node_id}))
context = {
"analysis_version": analysis_version,
"node_id": node_id,
"node_version": node_version,
"node": node,
"errors": node.get_errors(flat=True),
"extra_filters": extra_filters,
"status": node.status
}
template = 'analysis/node_data/node_errors.html'
return render(request, template, context)
def __init__(self, user, node_id, node_version, extra_filters,
variant_column, significant_figures):
super().__init__()
self.node = get_node_subclass_or_404(user,
node_id,
version=node_version)
grid = VariantGrid(user, self.node, extra_filters)
cm = grid.get_column_colmodel(variant_column)
grid_column_name = cm["label"]
field_formatters = grid.get_field_formatters()
self.formatter = field_formatters.get(variant_column)
self.extra_filters = extra_filters
self.variant_column = variant_column
self.significant_figures = significant_figures
self.grid_column_name = grid_column_name
self._overrides["labels"]["label"] = grid_column_name
self.extra_config.update({'sortname': 'Counts', 'sortorder': 'desc'})
# Only want to
variantgrid_column = VariantGridColumn.objects.filter(
variant_column=variant_column).first()
if variantgrid_column:
self.extra_config["create_filter_child_links"] = True
def node_debug(request, analysis_version, node_id, node_version,
extra_filters):
node = get_node_subclass_or_404(request.user,
node_id,
version=node_version)
model_name = node._meta.label
node_serializers = AnalysisNodeSerializer.get_node_serializers()
serializer_klass = node_serializers.get(model_name, AnalysisNodeSerializer)
serializer = serializer_klass(node, context={"request": request})
context = {
"node": node,
"node_data": dict(sorted(serializer.data.items()))
}
if node.valid:
grid = VariantGrid(request.user, node, extra_filters)
try:
node_sql_, grid_sql = get_node_sql(grid)
context['node_sql'] = node_sql_
context['grid_sql'] = grid_sql
except EmptyResultSet:
pass
return render(request, "analysis/node_editors/grid_editor_debug_tab.html",
context)
def __init__(self, user, node_id, version):
self.node = get_node_subclass_or_404(user, node_id, version=version)
super().__init__()
def node_data(request, node_id):
node = get_node_subclass_or_404(request.user, node_id)
return JsonResponse(get_rendering_dict(node))
