def SelectAlignableSegments(request):
"""Adds all alignable segments to the selection"""
selection_type = request.GET['selection_type']
# get simple selection from session
simple_selection = request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
# get all segments
segments = ProteinSegment.objects.filter(partial=False, slug__startswith='TM')
for segment in segments:
selection_object = SelectionItem(segment.category, segment)
# add the selected item to the selection
selection.add(selection_type, segment.category, selection_object)
# export simple selection that can be serialized
simple_selection = selection.exporter()
# add simple selection to session
request.session['selection'] = simple_selection
return render(request, 'common/selection_lists.html', selection.dict(selection_type))
def SelectionAnnotation(request):
"""Updates the selected level of annotation"""
protein_source = request.GET['protein_source']
if protein_source == 'All':
pss = ProteinSource.objects.all()
else:
pss = ProteinSource.objects.filter(name=protein_source)
# get simple selection from session
simple_selection = request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
# reset the annotation selection
selection.clear('annotation')
# add the selected items to the selection
for ps in pss:
selection_object = SelectionItem('annotation', ps)
selection.add('annotation', 'annotation', selection_object)
# export simple selection that can be serialized
simple_selection = selection.exporter()
# add simple selection to session
request.session['selection'] = simple_selection
return render(request, 'common/selection_filters_annotation.html', selection.dict('annotation'))
def SelectionSchemesToggle(request):
"""Updates the selected numbering schemes arbitrary selections"""
numbering_scheme_id = request.GET['numbering_scheme_id']
gns = ResidueNumberingScheme.objects.filter(pk=numbering_scheme_id)
# get simple selection from session
simple_selection = request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
# add the selected items to the selection
for gn in gns:
exists = selection.remove('numbering_schemes', 'numbering_schemes', numbering_scheme_id)
if not exists:
selection_object = SelectionItem('numbering_schemes', gn)
selection.add('numbering_schemes', 'numbering_schemes', selection_object)
# export simple selection that can be serialized
simple_selection = selection.exporter()
# add simple selection to session
request.session['selection'] = simple_selection
# add all species objects to context (for comparison to selected species)
context = selection.dict('numbering_schemes')
context['gns'] = ResidueNumberingScheme.objects.exclude(slug=settings.DEFAULT_NUMBERING_SCHEME)
return render(request, 'common/selection_filters_numbering_schemes.html', context)
def SelectionSpeciesToggle(request):
"""Updates the selected species arbitrary selections"""
species_id = request.GET['species_id']
all_sps = Species.objects.all()
sps = Species.objects.filter(pk=species_id)
# get simple selection from session
simple_selection = request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
# add the selected items to the selection
for sp in sps:
exists = selection.remove('species', 'species', species_id)
if not exists:
selection_object = SelectionItem('species', sp)
selection.add('species', 'species', selection_object)
# export simple selection that can be serialized
simple_selection = selection.exporter()
# add simple selection to session
request.session['selection'] = simple_selection
# add all species objects to context (for comparison to selected species)
context = selection.dict('species')
context['sps'] = Species.objects.all()
return render(request, 'common/selection_filters_species_selector.html', context)
def get_context_data(self, **kwargs):
"""get context from parent class (really only relevant for child classes of this class, as TemplateView does
not have any context variables)"""
context = super().get_context_data(**kwargs)
# get selection from session and add to context
# get simple selection from session
simple_selection = self.request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
# on the first page of a workflow, clear the selection (or dont' import from the session)
if self.step is not 1:
if simple_selection:
selection.importer(simple_selection)
context['selection'] = {}
context['selection']['tree_settings'] = selection.tree_settings
for selection_box, include in self.selection_boxes.items():
if include:
context['selection'][selection_box] = selection.dict(selection_box)['selection'][selection_box]
# get attributes of this class and add them to the context
attributes = inspect.getmembers(self, lambda a:not(inspect.isroutine(a)))
for a in attributes:
if not(a[0].startswith('__') and a[0].endswith('__')):
context[a[0]] = a[1]
return context
def SelectResidueGroup(request):
"""Receives a selection request, updates the active residue group, and returns the updated selection"""
selection_type = request.GET['selection_type']
group_id = int(request.GET['group_id'])
# get simple selection from session
simple_selection = request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
# update the selected group
selection.active_site_residue_group = group_id
# export simple selection that can be serialized
simple_selection = selection.exporter()
# add simple selection to session
request.session['selection'] = simple_selection
# context
context = selection.dict(selection_type)
# amino acid groups
amino_acid_groups = {
'amino_acid_groups': definitions.AMINO_ACID_GROUPS,
'amino_acid_group_names': definitions.AMINO_ACID_GROUP_NAMES }
context.update(amino_acid_groups)
# template to load
template = 'common/selection_lists_sitesearch.html'
return render(request, template, context)
def TargetDetails(request, **kwargs):
if 'slug' in kwargs:
slug = kwargs['slug']
if slug.count('_') == 0 :
ps = AssayExperiment.objects.filter(protein__family__parent__parent__parent__slug=slug, ligand__properities__web_links__web_resource__slug = 'chembl_ligand')
elif slug.count('_') == 1 and len(slug) == 7:
ps = AssayExperiment.objects.filter(protein__family__parent__parent__slug=slug, ligand__properities__web_links__web_resource__slug = 'chembl_ligand')
elif slug.count('_') == 2:
ps = AssayExperiment.objects.filter(protein__family__parent__slug=slug, ligand__properities__web_links__web_resource__slug = 'chembl_ligand')
#elif slug.count('_') == 3:
elif slug.count('_') == 1 and len(slug) != 7:
ps = AssayExperiment.objects.filter(protein__entry_name = slug, ligand__properities__web_links__web_resource__slug = 'chembl_ligand')
if slug.count('_') == 1 and len(slug) == 7:
f = ProteinFamily.objects.get(slug=slug)
else:
f = slug
context = {
'target':f
}
else:
simple_selection = request.session.get('selection', False)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
if selection.targets != []:
prot_ids = [x.item.id for x in selection.targets]
ps = AssayExperiment.objects.filter(protein__in=prot_ids, ligand__properities__web_links__web_resource__slug = 'chembl_ligand')
context = {
'target': ', '.join([x.item.entry_name for x in selection.targets])
}
ps = ps.values('standard_type',
'standard_relation',
'standard_value',
'assay_description',
'assay_type',
#'standard_units',
'pchembl_value',
'ligand__id',
'ligand__properities_id',
'ligand__properities__web_links__index',
#'ligand__properities__vendors__vendor__name',
'protein__species__common_name',
'protein__entry_name',
'ligand__properities__mw',
'ligand__properities__logp',
'ligand__properities__rotatable_bonds',
'ligand__properities__smiles',
'ligand__properities__hdon',
'ligand__properities__hacc','protein'
).annotate(num_targets = Count('protein__id', distinct=True))
for record in ps:
record['purchasability'] = 'Yes' if len(LigandVendorLink.objects.filter(lp=record['ligand__properities_id']).exclude(vendor__name__in=['ZINC', 'ChEMBL', 'BindingDB', 'SureChEMBL', 'eMolecules', 'MolPort', 'PubChem'])) > 0 else 'No'
context['proteins'] = ps
return render(request, 'target_details.html', context)
def ToggleFamilyTreeNode(request):
"""Opens/closes a node in the family selection tree"""
action = request.GET['action']
type_of_selection = request.GET['type_of_selection']
node_id = request.GET['node_id']
parent_tree_indent_level = int(request.GET['tree_indent_level'])
tree_indent_level = []
for i in range(parent_tree_indent_level + 1):
tree_indent_level.append(0)
parent_tree_indent_level = tree_indent_level[:]
del parent_tree_indent_level[-1]
# session
simple_selection = request.session.get('selection')
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
ppf = ProteinFamily.objects.get(pk=node_id)
if action == 'expand':
pfs = ProteinFamily.objects.filter(parent=node_id)
# species filter
species_list = []
for species in selection.species:
species_list.append(species.item)
# annotation filter
protein_source_list = []
for protein_source in selection.annotation:
protein_source_list.append(protein_source.item)
if species_list:
ps = Protein.objects.order_by('id').filter(
family=ppf,
species__in=(species_list),
source__in=(protein_source_list)).order_by('source_id', 'id')
else:
ps = Protein.objects.order_by('id').filter(
family=ppf,
source__in=(protein_source_list)).order_by('source_id', 'id')
action = 'collapse'
else:
pfs = ps = {}
action = 'expand'
return render(
request, 'common/selection_tree.html', {
'action': action,
'type_of_selection': type_of_selection,
'ppf': ppf,
'pfs': pfs,
'ps': ps,
'parent_tree_indent_level': parent_tree_indent_level,
'tree_indent_level': tree_indent_level,
})
def ResiduesUpload(request):
"""Receives a file containing generic residue positions along with numbering scheme and adds those to the selection."""
# get simple selection from session
simple_selection = request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
selection_type = 'segments'
if request.FILES == {}:
return render(request, 'common/selection_lists.html', '')
#Overwriting the existing selection
selection.clear(selection_type)
#The excel file
o = []
workbook = xlrd.open_workbook(
file_contents=request.FILES['xml_file'].read())
worksheets = workbook.sheet_names()
for worksheet_name in worksheets:
worksheet = workbook.sheet_by_name(worksheet_name)
for row in worksheet.get_rows():
if len(row) < 2:
continue
try:
if row[0].value == 'residue':
position = ResidueGenericNumberEquivalent.objects.get(
label=row[2].value, scheme__slug=row[1].value)
o.append(position)
elif row[0].value == 'helix':
o.append(ProteinSegment.objects.get(slug=row[2].value))
except Exception as msg:
print(msg)
continue
for obj in o:
# add the selected item to the selection
if obj.__class__.__name__ == 'ResidueGenericNumberEquivalent':
selection_subtype = 'residue'
else:
selection_subtype = 'helix'
selection_object = SelectionItem(selection_subtype, obj)
selection.add(selection_type, selection_subtype, selection_object)
# export simple selection that can be serialized
simple_selection = selection.exporter()
# add simple selection to session
request.session['selection'] = simple_selection
return render(request, 'common/selection_lists.html',
selection.dict(selection_type))
def SelectionGproteinToggle(request):
"""Updates the selected g proteins arbitrary selections"""
g_protein_id = request.GET['g_protein_id']
preferred = request.GET['preferred']
all_gprots = ProteinGProtein.objects.all()
gprots = ProteinGProtein.objects.filter(pk=g_protein_id)
print("'{}'".format(ProteinGProtein.objects.get(pk=g_protein_id).name))
# get simple selection from session
simple_selection = request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
# add the selected items to the selection
for gprot in gprots:
if preferred == 'true':
exists = selection.remove('pref_g_proteins', 'g_protein',
g_protein_id)
else:
exists = selection.remove('g_proteins', 'g_protein', g_protein_id)
if not exists:
selection_object = SelectionItem('g_protein', gprot)
if preferred == 'true':
selection.add('pref_g_proteins', 'g_protein', selection_object)
else:
selection.add('g_proteins', 'g_protein', selection_object)
# export simple selection that can be serialized
simple_selection = selection.exporter()
# add simple selection to session
request.session['selection'] = simple_selection
# add all species objects to context (for comparison to selected species)
if preferred == 'true':
context = selection.dict('pref_g_proteins')
else:
context = selection.dict('g_proteins')
context['gprots'] = ProteinGProtein.objects.all()
if preferred == 'true':
print(request.session['selection'])
return render(request,
'common/selection_filters_pref_gproteins_selector.html',
context)
else:
return render(request,
'common/selection_filters_gproteins_selector.html',
context)
def SelectionGproteinPredefined(request):
"""Updates the selected g proteins to predefined sets (Gi/Go and all)"""
g_protein = request.GET['g_protein']
preferred = request.GET['preferred']
# get simple selection from session
simple_selection = request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
all_gprots = ProteinGProtein.objects.all()
gprots = False
if g_protein == 'All':
gprots = []
if g_protein != 'All' and g_protein:
gprots = ProteinGProtein.objects.filter(name=g_protein)
if gprots != False:
# reset the g proteins selection
if preferred == 'true':
selection.clear('pref_g_proteins')
else:
selection.clear('g_proteins')
# add the selected items to the selection
for gprot in gprots:
selection_object = SelectionItem('g_protein', gprot)
if preferred == 'true':
selection.add('pref_g_proteins', 'g_protein', selection_object)
else:
selection.add('g_proteins', 'g_protein', selection_object)
# export simple selection that can be serialized
simple_selection = selection.exporter()
# add simple selection to session
request.session['selection'] = simple_selection
# add all species objects to context (for comparison to selected species)
if preferred == 'true':
context = selection.dict('pref_g_proteins')
else:
context = selection.dict('g_proteins')
context['gprots'] = ProteinGProtein.objects.all()
if preferred == 'true':
return render(request, 'common/selection_filters_pref_gproteins.html',
context)
else:
return render(request, 'common/selection_filters_gproteins.html',
context)
def signature_selection(request):
# create full selection and import simple selection (if it exists)
simple_selection = request.session.get('selection', False)
selection_pos = Selection()
selection_pos.importer(deepcopy(simple_selection))
selection_pos.clear('targets')
selection_neg = Selection()
selection_neg.importer(deepcopy(simple_selection))
selection_neg.clear('targets')
if 'group1' in request.POST and 'group2' in request.POST:
up_names = request.POST['group1'].split('\r')
for up_name in up_names:
try:
selection_object = SelectionItem(
'protein',
Protein.objects.get(entry_name=up_name.strip().lower()))
selection_pos.add('targets', 'protein', selection_object)
except:
continue
down_names = request.POST['group2'].split('\r')
for down_name in down_names:
try:
selection_object = SelectionItem(
'protein',
Protein.objects.get(entry_name=down_name.strip().lower()))
selection_neg.add('targets', 'protein', selection_object)
except:
continue
# Set both the positive and negative target selections
request.session['targets_pos'] = selection_pos.exporter()
request.session['selection'] = selection_neg.exporter()
return JsonResponse({"response": "ok"})
else:
return JsonResponse({"response": "error"})
def UpdateSiteResidueFeatures(request):
"""Updates the selected features of a site residue"""
selection_type = request.GET['selection_type']
selection_subtype = request.GET['selection_subtype']
selection_id = request.GET['selection_id']
o = []
if selection_type == 'reference' or selection_type == 'targets':
if selection_subtype == 'protein':
o.append(Protein.objects.get(pk=selection_id))
elif selection_subtype == 'protein_set':
selection_subtype = 'protein'
pset = ProteinSet.objects.get(pk=selection_id)
for protein in pset.proteins.all():
o.append(protein)
elif selection_subtype == 'family':
o.append(ProteinFamily.objects.get(pk=selection_id))
elif selection_subtype == 'set':
o.append(ProteinSet.objects.get(pk=selection_id))
elif selection_subtype == 'structure':
o.append(Protein.objects.get(entry_name=selection_id.lower()))
elif selection_type == 'segments':
if selection_subtype == 'residue':
o.append(
ResidueGenericNumberEquivalent.objects.get(pk=selection_id))
elif selection_subtype == 'residue_with_properties': # used in site search
o.append(
ResidueGenericNumberEquivalent.objects.get(pk=selection_id))
else:
o.append(ProteinSegment.objects.get(pk=selection_id))
# get simple selection from session
simple_selection = request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
for obj in o:
# add the selected item to the selection
selection_object = SelectionItem(selection_subtype, obj)
selection.add(selection_type, selection_subtype, selection_object)
# export simple selection that can be serialized
simple_selection = selection.exporter()
# add simple selection to session
request.session['selection'] = simple_selection
return render(request, 'common/selection_lists.html',
selection.dict(selection_type))
def TargetPurchasabilityDetails(request, **kwargs):
simple_selection = request.session.get('selection', False)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
if selection.targets != []:
prot_ids = [x.item.id for x in selection.targets]
ps = AssayExperiment.objects.filter(protein__in=prot_ids, ligand__properities__web_links__web_resource__slug = 'chembl_ligand')
context = {
'target': ', '.join([x.item.entry_name for x in selection.targets])
}
ps = ps.values('standard_type',
'standard_relation',
'standard_value',
'assay_description',
'assay_type',
'standard_units',
'pchembl_value',
'ligand__id',
'ligand__properities_id',
'ligand__properities__web_links__index',
'ligand__properities__vendors__vendor__id',
'ligand__properities__vendors__vendor__name',
'protein__species__common_name',
'protein__entry_name',
'ligand__properities__mw',
'ligand__properities__logp',
'ligand__properities__rotatable_bonds',
'ligand__properities__smiles',
'ligand__properities__hdon',
'ligand__properities__hacc','protein'
).annotate(num_targets = Count('protein__id', distinct=True))
purchasable = []
for record in ps:
try:
if record['ligand__properities__vendors__vendor__name'] in ['ZINC', 'ChEMBL', 'BindingDB', 'SureChEMBL', 'eMolecules', 'MolPort', 'PubChem', 'IUPHAR/BPS Guide to PHARMACOLOGY']:
continue
tmp = LigandVendorLink.objects.filter(vendor=record['ligand__properities__vendors__vendor__id'], lp=record['ligand__properities_id'])[0]
record['vendor_id'] = tmp.vendor_external_id
record['vendor_link'] = tmp.url
purchasable.append(record)
except:
continue
context['proteins'] = purchasable
return render(request, 'target_purchasability_details.html', context)
def SetTreeSelection(request):
"""Adds all alignable segments to the selection"""
option_no = request.GET['option_no']
option_id = request.GET['option_id']
# get simple selection from session
simple_selection = request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
selection.tree_settings[int(option_no)]=option_id
simple_selection = selection.exporter()
# add simple selection to session
request.session['selection'] = simple_selection
return render(request, 'common/tree_options.html', selection.dict('tree_settings'))
def get_context_data(self, **kwargs):
"""get context from parent class (really only relevant for children of this class, as TemplateView does
not have any context variables)"""
context = super().get_context_data(**kwargs)
# get selection from session and add to context
# get simple selection from session
simple_selection = self.request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
# on the first page of a workflow, clear the selection (or dont' import from the session)
if self.step is not 1:
if simple_selection:
selection.importer(simple_selection)
# default species selection
if self.default_species:
sp = Species.objects.get(common_name=self.default_species)
o = SelectionItem('species', sp)
selection.species = [o]
# update session
simple_selection = selection.exporter()
self.request.session['selection'] = simple_selection
context['selection'] = {}
for selection_box, include in self.selection_boxes.items():
if include:
context['selection'][selection_box] = selection.dict(
selection_box)['selection'][selection_box]
if self.filters:
context['selection']['species'] = selection.species
context['selection']['annotation'] = selection.annotation
context['selection']['g_proteins'] = selection.g_proteins
context['selection']['pref_g_proteins'] = selection.pref_g_proteins
# get attributes of this class and add them to the context
attributes = inspect.getmembers(self,
lambda a: not (inspect.isroutine(a)))
for a in attributes:
if not (a[0].startswith('__') and a[0].endswith('__')):
context[a[0]] = a[1]
return context
def preserve_targets(request):
request.session['targets_pos'] = deepcopy(request.session.get('selection', False))
# get simple selection from session
simple_selection = request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
selection.clear('targets')
# export simple selection that can be serialized
simple_selection = selection.exporter()
# add simple selection to session
request.session['selection'] = simple_selection
return redirect('/seqsign/negativegroupselection',)
def SelectResidueFeature(request):
"""Receives a selection request, add a feature selection to an item, and returns the updated selection"""
selection_type = request.GET['selection_type']
selection_subtype = request.GET['selection_subtype']
selection_id = int(request.GET['selection_id'])
feature = request.GET['feature']
# get simple selection from session
simple_selection = request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
# process selected object
if selection_type == 'segments' and selection_subtype == 'site_residue':
for obj in selection.segments:
if int(obj.item.id) == selection_id:
obj.properties['feature'] = feature
obj.properties['amino_acids'] = ','.join(
definitions.AMINO_ACID_GROUPS[feature])
break
# export simple selection that can be serialized
simple_selection = selection.exporter()
# add simple selection to session
request.session['selection'] = simple_selection
# context
context = selection.dict(selection_type)
# amino acid groups
amino_acid_groups = {
'amino_acid_groups': definitions.AMINO_ACID_GROUPS,
'amino_acid_group_names': definitions.AMINO_ACID_GROUP_NAMES
}
context.update(amino_acid_groups)
# template to load
template = 'common/selection_lists_sitesearch.html'
return render(request, template, context)
def RemoveResidueGroup(request):
"""Receives a selection request, removes a residue group, and returns the updated selection"""
selection_type = request.GET['selection_type']
group_id = int(request.GET['group_id'])
# get simple selection from session
simple_selection = request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
# find all positions in the group and delete them
for position in selection.segments:
if position.type == 'site_residue':
if position.properties['site_residue_group'] == group_id:
selection.remove(selection_type, position.type,
position.item.id)
else:
if position.properties['site_residue_group'] > group_id:
position.properties['site_residue_group'] -= 1
# export simple selection that can be serialized
simple_selection = selection.exporter()
# add simple selection to session
request.session['selection'] = simple_selection
# context
context = selection.dict(selection_type)
# amino acid groups
amino_acid_groups = {
'amino_acid_groups': definitions.AMINO_ACID_GROUPS,
'amino_acid_group_names': definitions.AMINO_ACID_GROUP_NAMES
}
context.update(amino_acid_groups)
# template to load
template = 'common/selection_lists_sitesearch.html'
return render(request, template, context)
def SelectionSchemesPredefined(request):
"""Updates the selected numbering_schemes to predefined sets (GPCRdb and All)"""
numbering_schemes = request.GET['numbering_schemes']
# get simple selection from session
simple_selection = request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
all_gns = ResidueNumberingScheme.objects.exclude(
slug=settings.DEFAULT_NUMBERING_SCHEME)
gns = False
if numbering_schemes == 'All':
print(len(selection.numbering_schemes), all_gns.count())
if len(selection.numbering_schemes) == all_gns.count():
gns = []
else:
gns = all_gns
# reset the species selection
selection.clear('numbering_schemes')
# add the selected items to the selection
for gn in gns:
selection_object = SelectionItem('numbering_schemes', gn)
selection.add('numbering_schemes', 'numbering_schemes',
selection_object)
# export simple selection that can be serialized
simple_selection = selection.exporter()
# add simple selection to session
request.session['selection'] = simple_selection
# add all species objects to context (for comparison to selected species)
context = selection.dict('numbering_schemes')
context['gns'] = all_gns
return render(request, 'common/selection_filters_numbering_schemes.html',
context)
def SelectAlignableSegments(request):
"""Adds all alignable segments to the selection"""
selection_type = request.GET['selection_type']
# get simple selection from session
simple_selection = request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
# get all segments
# get all segments
if "protein_type" in request.GET:
gsegments = definitions.G_PROTEIN_SEGMENTS
preserved = Case(*[
When(slug=pk, then=pos)
for pos, pk in enumerate(gsegments['Structured'])
])
segments = ProteinSegment.objects.filter(
slug__in=gsegments['Structured'],
partial=False).order_by(preserved)
else:
segments = ProteinSegment.objects.filter(partial=False,
slug__startswith='TM')
for segment in segments:
selection_object = SelectionItem(segment.category, segment)
# add the selected item to the selection
selection.add(selection_type, segment.category, selection_object)
# export simple selection that can be serialized
simple_selection = selection.exporter()
# add simple selection to session
request.session['selection'] = simple_selection
return render(request, 'common/selection_lists.html',
selection.dict(selection_type))
def ReadTargetInput(request):
"""Receives the data from the input form nd adds the listed targets to the selection"""
# get simple selection from session
simple_selection = request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
selection_type = 'targets'
selection_subtype = 'protein'
if request.POST == {}:
return render(request, 'common/selection_lists.html', '')
o = []
up_names = request.POST['input-targets'].split('\r')
for up_name in up_names:
try:
o.append(Protein.objects.get(entry_name=up_name.strip().lower()))
except:
continue
for obj in o:
# add the selected item to the selection
selection_object = SelectionItem(selection_subtype, obj)
selection.add(selection_type, selection_subtype, selection_object)
# export simple selection that can be serialized
simple_selection = selection.exporter()
# add simple selection to session
request.session['selection'] = simple_selection
# context
context = selection.dict(selection_type)
return render(request, 'common/selection_lists.html', context)
def SelectionSpeciesPredefined(request):
"""Updates the selected species to predefined sets (Human and all)"""
species = request.GET['species']
# get simple selection from session
simple_selection = request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
all_sps = Species.objects.all()
sps = False
if species == 'All':
sps = []
if species != 'All' and species:
sps = Species.objects.filter(common_name=species)
if sps != False:
# reset the species selection
selection.clear('species')
# add the selected items to the selection
for sp in sps:
selection_object = SelectionItem('species', sp)
selection.add('species', 'species', selection_object)
# export simple selection that can be serialized
simple_selection = selection.exporter()
# add simple selection to session
request.session['selection'] = simple_selection
# add all species objects to context (for comparison to selected species)
context = selection.dict('species')
context['sps'] = all_sps
return render(request, 'common/selection_filters_species.html', context)
def ClearSelection(request):
"""Clears all selected items of the selected type from the session"""
selection_type = request.GET['selection_type']
# get simple selection from session
simple_selection = request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
# remove the selected item to the selection
selection.clear(selection_type)
# export simple selection that can be serialized
simple_selection = selection.exporter()
# add simple selection to session
request.session['selection'] = simple_selection
return render(request, 'common/selection_lists.html', selection.dict(selection_type))
def RemoveFromSelection(request):
"""Removes one selected item from the session"""
selection_type = request.GET['selection_type']
selection_subtype = request.GET['selection_subtype']
selection_id = request.GET['selection_id']
# get simple selection from session
simple_selection = request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
# remove the selected item to the selection
selection.remove(selection_type, selection_subtype, selection_id)
# export simple selection that can be serialized
simple_selection = selection.exporter()
# add simple selection to session
request.session['selection'] = simple_selection
# context
context = selection.dict(selection_type)
# template to load
if selection_subtype == 'site_residue':
template = 'common/selection_lists_sitesearch.html'
amino_acid_groups = {
'amino_acid_groups': definitions.AMINO_ACID_GROUPS,
'amino_acid_group_names': definitions.AMINO_ACID_GROUP_NAMES
}
context.update(amino_acid_groups)
else:
template = 'common/selection_lists.html'
return render(request, template, context)
def SelectRange(request):
"""Adds generic numbers within the given range"""
selection_type = request.GET['selection_type']
selection_subtype = request.GET['selection_subtype']
range_start = request.GET['range_start']
range_end = request.GET['range_end']
# get simple selection from session
simple_selection = request.session.get('selection', False)
# create full selection and import simple selection (if it exists)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
# process selected object
o = []
if selection_type == 'segments' and selection_subtype == 'residue':
residue_nums = ResidueGenericNumberEquivalent.objects.all()
for resn in residue_nums:
if range_start < float(resn.label.replace('x','.')) < range_end:
o.append(resn)
def TargetDetailsCompact(request, **kwargs):
if 'slug' in kwargs:
slug = kwargs['slug']
if slug.count('_') == 0:
ps = AssayExperiment.objects.filter(
protein__family__parent__parent__parent__slug=slug,
ligand__properities__web_links__web_resource__slug=
'chembl_ligand')
elif slug.count('_') == 1 and len(slug) == 7:
ps = AssayExperiment.objects.filter(
protein__family__parent__parent__slug=slug,
ligand__properities__web_links__web_resource__slug=
'chembl_ligand')
elif slug.count('_') == 2:
ps = AssayExperiment.objects.filter(
protein__family__parent__slug=slug,
ligand__properities__web_links__web_resource__slug=
'chembl_ligand')
#elif slug.count('_') == 3:
elif slug.count('_') == 1 and len(slug) != 7:
ps = AssayExperiment.objects.filter(
protein__entry_name=slug,
ligand__properities__web_links__web_resource__slug=
'chembl_ligand')
if slug.count('_') == 1 and len(slug) == 7:
f = ProteinFamily.objects.get(slug=slug)
else:
f = slug
context = {'target': f}
else:
simple_selection = request.session.get('selection', False)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
if selection.targets != []:
prot_ids = [x.item.id for x in selection.targets]
ps = AssayExperiment.objects.filter(
protein__in=prot_ids,
ligand__properities__web_links__web_resource__slug=
'chembl_ligand')
context = {
'target':
', '.join([x.item.entry_name for x in selection.targets])
}
ps = ps.prefetch_related('protein',
'ligand__properities__web_links__web_resource',
'ligand__properities__vendors__vendor')
d = {}
for p in ps:
if p.ligand not in d:
d[p.ligand] = {}
if p.protein not in d[p.ligand]:
d[p.ligand][p.protein] = []
d[p.ligand][p.protein].append(p)
ligand_data = []
for lig, records in d.items():
links = lig.properities.web_links.all()
chembl_id = [
x for x in links if x.web_resource.slug == 'chembl_ligand'
][0].index
vendors = lig.properities.vendors.all()
purchasability = 'No'
for v in vendors:
if v.vendor.name not in [
'ZINC', 'ChEMBL', 'BindingDB', 'SureChEMBL', 'eMolecules',
'MolPort', 'PubChem'
]:
purchasability = 'Yes'
for record, vals in records.items():
per_target_data = vals
protein_details = record
"""
A dictionary of dictionaries with a list of values.
Assay_type
|
-> Standard_type [list of values]
"""
tmp = defaultdict(list)
tmp_count = 0
for data_line in per_target_data:
tmp["Bind" if data_line.assay_type == 'b' else "Funct"].append(
data_line.pchembl_value)
tmp_count += 1
values = list(itertools.chain(*tmp.values()))
ligand_data.append({
'ligand_id':
chembl_id,
'protein_name':
protein_details.entry_name,
'species':
protein_details.species.common_name,
'record_count':
tmp_count,
'assay_type':
', '.join(tmp.keys()),
'purchasability':
purchasability,
#Flattened list of lists of dict keys:
'low_value':
min(values),
'average_value':
sum(values) / len(values),
'high_value':
max(values),
'standard_units':
', '.join(
list(set([x.standard_units for x in per_target_data]))),
'smiles':
lig.properities.smiles,
'mw':
lig.properities.mw,
'rotatable_bonds':
lig.properities.rotatable_bonds,
'hdon':
lig.properities.hdon,
'hacc':
lig.properities.hacc,
'logp':
lig.properities.logp,
})
context['ligand_data'] = ligand_data
return render(request, 'target_details_compact.html', context)
def SelectionAutocomplete(request):
if request.is_ajax():
q = request.GET.get('term')
type_of_selection = request.GET.get('type_of_selection')
results = []
# session
simple_selection = request.session.get('selection')
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
# species filter
species_list = []
for species in selection.species:
species_list.append(species.item)
# annotation filter
protein_source_list = []
for protein_source in selection.annotation:
protein_source_list.append(protein_source.item)
# find proteins
ps = Protein.objects.filter(Q(name__icontains=q)
| Q(entry_name__icontains=q)
| Q(family__name__icontains=q),
species__in=(species_list),
source__in=(protein_source_list))[:10]
for p in ps:
p_json = {}
p_json['id'] = p.id
p_json['label'] = p.name + " [" + p.species.common_name + "]"
p_json['slug'] = p.entry_name
p_json['type'] = 'protein'
p_json['category'] = 'Targets'
results.append(p_json)
# find protein aliases
pas = ProteinAlias.objects.prefetch_related('protein').filter(
name__icontains=q,
protein__species__in=(species_list),
protein__source__in=(protein_source_list))[:10]
for pa in pas:
pa_json = {}
pa_json['id'] = pa.protein.id
pa_json[
'label'] = pa.protein.name + " [" + pa.protein.species.common_name + "]"
pa_json['slug'] = pa.protein.entry_name
pa_json['type'] = 'protein'
pa_json['category'] = 'Targets'
if pa_json not in results:
results.append(pa_json)
# protein families
if type_of_selection == 'targets' or type_of_selection == 'browse':
# find protein families
pfs = ProteinFamily.objects.filter(name__icontains=q).exclude(
slug='000')[:10]
for pf in pfs:
pf_json = {}
pf_json['id'] = pf.id
pf_json['label'] = pf.name
pf_json['slug'] = pf.slug
pf_json['type'] = 'family'
pf_json['category'] = 'Target families'
results.append(pf_json)
data = json.dumps(results)
else:
data = 'fail'
mimetype = 'application/json'
return HttpResponse(data, mimetype)
def SelectionAutocomplete(request):
if request.is_ajax():
q = request.GET.get('term')
type_of_selection = request.GET.get('type_of_selection')
selection_only_receptors = request.GET.get('selection_only_receptors')
referer = request.META.get('HTTP_REFERER')
if 'gproteinselection' in str(referer) or 'signprot' in str(referer) and not 'ginterface' in str(referer):
exclusion_slug = '00'
else:
exclusion_slug = '100'
results = []
# session
simple_selection = request.session.get('selection')
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
# species filter
species_list = []
for species in selection.species:
species_list.append(species.item)
# annotation filter
protein_source_list = []
for protein_source in selection.annotation:
protein_source_list.append(protein_source.item)
# find proteins
if type_of_selection!='navbar':
ps = Protein.objects.filter(Q(name__icontains=q) | Q(entry_name__icontains=q),
species__in=(species_list),
source__in=(protein_source_list)).exclude(family__slug__startswith=exclusion_slug)[:10]
else:
ps = Protein.objects.filter(Q(name__icontains=q) | Q(entry_name__icontains=q) | Q(family__name__icontains=q),
species__common_name='Human', source__name='SWISSPROT').exclude(family__slug__startswith=exclusion_slug)[:10]
for p in ps:
p_json = {}
p_json['id'] = p.id
p_json['label'] = p.name + " [" + p.species.common_name + "]"
p_json['slug'] = p.entry_name
p_json['type'] = 'protein'
p_json['category'] = 'Targets'
results.append(p_json)
if type_of_selection!='navbar':
# find protein aliases
pas = ProteinAlias.objects.prefetch_related('protein').filter(name__icontains=q,
protein__species__in=(species_list),
protein__source__in=(protein_source_list)).exclude(protein__family__slug__startswith=exclusion_slug)[:10]
for pa in pas:
pa_json = {}
pa_json['id'] = pa.protein.id
pa_json['label'] = pa.protein.name + " [" + pa.protein.species.common_name + "]"
pa_json['slug'] = pa.protein.entry_name
pa_json['type'] = 'protein'
pa_json['category'] = 'Targets'
if pa_json not in results:
results.append(pa_json)
# protein families
if (type_of_selection == 'targets' or type_of_selection == 'browse' or type_of_selection == 'gproteins') and selection_only_receptors!="True":
# find protein families
pfs = ProteinFamily.objects.filter(name__icontains=q).exclude(slug='000').exclude(slug__startswith=exclusion_slug)[:10]
for pf in pfs:
pf_json = {}
pf_json['id'] = pf.id
pf_json['label'] = pf.name
pf_json['slug'] = pf.slug
pf_json['type'] = 'family'
pf_json['category'] = 'Target families'
results.append(pf_json)
data = json.dumps(results)
else:
data = 'fail'
mimetype = 'application/json'
return HttpResponse(data, mimetype)
def TargetDetailsCompact(request, **kwargs):
if 'slug' in kwargs:
slug = kwargs['slug']
if slug.count('_') == 0:
ps = AssayExperiment.objects.filter(
protein__family__parent__parent__parent__slug=slug,
ligand__properities__web_links__web_resource__slug=
'chembl_ligand')
elif slug.count('_') == 1 and len(slug) == 7:
ps = AssayExperiment.objects.filter(
protein__family__parent__parent__slug=slug,
ligand__properities__web_links__web_resource__slug=
'chembl_ligand')
elif slug.count('_') == 2:
ps = AssayExperiment.objects.filter(
protein__family__parent__slug=slug,
ligand__properities__web_links__web_resource__slug=
'chembl_ligand')
#elif slug.count('_') == 3:
elif slug.count('_') == 1 and len(slug) != 7:
ps = AssayExperiment.objects.filter(
protein__entry_name=slug,
ligand__properities__web_links__web_resource__slug=
'chembl_ligand')
if slug.count('_') == 1 and len(slug) == 7:
f = ProteinFamily.objects.get(slug=slug)
else:
f = slug
context = {'target': f}
else:
simple_selection = request.session.get('selection', False)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
if selection.targets != []:
prot_ids = [x.item.id for x in selection.targets]
ps = AssayExperiment.objects.filter(
protein__in=prot_ids,
ligand__properities__web_links__web_resource__slug=
'chembl_ligand')
context = {
'target':
', '.join([x.item.entry_name for x in selection.targets])
}
ligands = [x.ligand for x in ps.distinct('ligand')]
record_count = ps.values('protein', ).annotate(num_records=Count(
'protein__entry_name')).order_by('protein__entry_name')
ligand_data = []
for lig in ligands:
ligand_records = ps.filter(ligand=lig).order_by('protein__entry_name')
for record in record_count:
per_target_data = ligand_records.filter(protein=record['protein'])
if list(per_target_data) == []:
continue
protein_details = Protein.objects.get(pk=record['protein'])
"""
A dictionary of dictionaries with a list of values.
Assay_type
|
-> Standard_type [list of values]
"""
tmp = defaultdict(list)
tmp_count = 0
for data_line in per_target_data:
tmp["Bind" if data_line.assay_type == 'b' else "Funct"].append(
data_line.pchembl_value)
tmp_count += 1
values = list(itertools.chain(*tmp.values()))
ligand_data.append({
'ligand_id':
lig.properities.web_links.filter(
web_resource__slug='chembl_ligand')[0].index,
'protein_name':
protein_details.entry_name,
'species':
protein_details.species.common_name,
'record_count':
tmp_count,
'assay_type':
', '.join(tmp.keys()),
'purchasability':
'Yes' if len(
LigandVendorLink.objects.filter(
lp=lig.properities).exclude(vendor__name__in=[
'ZINC', 'ChEMBL', 'BindingDB', 'SureChEMBL',
'eMolecules', 'MolPort', 'PubChem'
])) > 0 else 'No',
#Flattened list of lists of dict keys:
'low_value':
min(values),
'average_value':
sum(values) / len(values),
'high_value':
max(values),
'standard_units':
', '.join(
list(set([x.standard_units for x in per_target_data]))),
'smiles':
lig.properities.smiles,
'mw':
lig.properities.mw,
'rotatable_bonds':
lig.properities.rotatable_bonds,
'hdon':
lig.properities.hdon,
'hacc':
lig.properities.hacc,
'logp':
lig.properities.logp,
})
context['ligand_data'] = ligand_data
return render(request, 'target_details_compact.html', context)
