def __init__ (self, ref_file, alt_files, simple_selection):
self.selection = SelectionParser(simple_selection)
self.ref_struct = PDBParser(PERMISSIVE=True).get_structure('ref', ref_file)[0]
assert self.ref_struct, self.logger.error("Can't parse the ref file %s".format(ref_file))
if self.selection.generic_numbers != [] or self.selection.helices != []:
if not check_gn(self.ref_struct):
gn_assigner = GenericNumbering(structure=self.ref_struct)
self.ref_struct = gn_assigner.assign_generic_numbers()
self.alt_structs = []
for alt_id, alt_file in enumerate(alt_files):
try:
tmp_struct = PDBParser(PERMISSIVE=True).get_structure(alt_id, alt_file)[0]
if self.selection.generic_numbers != [] or self.selection.helices != []:
if not check_gn(tmp_struct):
gn_assigner = GenericNumbering(structure=tmp_struct)
self.alt_structs.append(gn_assigner.assign_generic_numbers())
self.alt_structs[-1].id = alt_id
else:
self.alt_structs.append(tmp_struct)
except Exception as e:
logger.warning("Can't parse the file {!s}\n{!s}".format(alt_id, e))
self.selector = CASelector(self.selection, self.ref_struct, self.alt_structs)
def post(self, request):
root, ext = os.path.splitext(request.FILES['pdb_file'].name)
generic_numbering = GenericNumbering(StringIO(request.FILES['pdb_file'].file.read().decode('UTF-8',"ignore")))
out_struct = generic_numbering.assign_generic_numbers()
out_stream = StringIO()
io = PDBIO()
io.set_structure(out_struct)
io.save(out_stream)
print(len(out_stream.getvalue()))
# filename="{}_GPCRdb.pdb".format(root)
return Response(out_stream.getvalue())
def post(self, request, *args, **kwargs):
context = super(PDBClean, self).get_context_data(**kwargs)
self.posted = True
pref = True
water = False
hets = False
if 'pref_chain' not in request.POST.keys():
pref = False
if 'water' in request.POST.keys():
water = True
if 'hets' in request.POST.keys():
hets = True
# get simple selection from session
simple_selection = request.session.get('selection', False)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
out_stream = BytesIO()
io = PDBIO()
zipf = zipfile.ZipFile(out_stream, 'w', zipfile.ZIP_DEFLATED)
if selection.targets != []:
for selected_struct in [x for x in selection.targets if x.type == 'structure']:
struct_name = '{}_{}.pdb'.format(selected_struct.item.protein_conformation.protein.parent.entry_name, selected_struct.item.pdb_code.index)
if hets:
lig_names = [x.pdb_reference for x in StructureLigandInteraction.objects.filter(structure=selected_struct.item, annotated=True)]
else:
lig_names = None
gn_assigner = GenericNumbering(structure=PDBParser(QUIET=True).get_structure(struct_name, StringIO(selected_struct.item.get_cleaned_pdb(pref, water, lig_names)))[0])
tmp = StringIO()
io.set_structure(gn_assigner.assign_generic_numbers())
request.session['substructure_mapping'] = gn_assigner.get_substructure_mapping_dict()
io.save(tmp)
zipf.writestr(struct_name, tmp.getvalue())
del gn_assigner, tmp
for struct in selection.targets:
selection.remove('targets', 'structure', struct.item.id)
# export simple selection that can be serialized
simple_selection = selection.exporter()
request.session['selection'] = simple_selection
request.session['cleaned_structures'] = out_stream
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 render(request, self.template_name, context)
def post(self, request):
root, ext = os.path.splitext(request.FILES['pdb_file'].name)
generic_numbering = GenericNumbering(
StringIO(request.FILES['pdb_file'].file.read().decode(
'UTF-8', "ignore")))
out_struct = generic_numbering.assign_generic_numbers()
out_stream = StringIO()
io = PDBIO()
io.set_structure(out_struct)
io.save(out_stream)
print(len(out_stream.getvalue()))
# filename="{}_GPCRdb.pdb".format(root)
return Response(out_stream.getvalue())
def __init__(self, pdb_file=None, pdb_filename=None):
#pdb_file can be either a name/path or a handle to an open file
self.pdb_file = pdb_file
self.pdb_filename = pdb_filename
self.pdb_seq = {}
self.blast = BlastSearch()
self.pdb_struct = self.parse_pdb()
if not check_gn(self.pdb_struct):
gn_assigner = GenericNumbering(structure=self.pdb_struct)
self.pdb_struct = gn_assigner.assign_generic_numbers()
self.target = Protein.objects.get(pk=gn_assigner.prot_id_list[0])
else:
self.target = Protein.objects.get(pk=self.identify_receptor())
def __init__(self, pdb_file=None, pdb_filename=None):
#pdb_file can be either a name/path or a handle to an open file
self.pdb_file = pdb_file
self.pdb_filename = pdb_filename
self.pdb_seq = {}
self.blast = BlastSearch()
self.pdb_struct = self.parse_pdb()
if not check_gn(self.pdb_struct):
gn_assigner = GenericNumbering(structure=self.pdb_struct)
self.pdb_struct = gn_assigner.assign_generic_numbers()
self.target = Protein.objects.get(pk=gn_assigner.prot_id_list[0])
else:
self.target = Protein.objects.get(pk=self.identify_receptor())
def __init__(self, ref_file, alt_files, simple_selection):
self.selection = SelectionParser(simple_selection)
self.ref_struct = PDBParser(PERMISSIVE=True).get_structure(
'ref', ref_file)[0]
assert self.ref_struct, self.logger.error(
"Can't parse the ref file %s".format(ref_file))
if self.selection.generic_numbers != [] or self.selection.helices != []:
if not check_gn(self.ref_struct):
gn_assigner = GenericNumbering(structure=self.ref_struct)
self.ref_struct = gn_assigner.assign_generic_numbers()
self.alt_structs = []
for alt_id, alt_file in enumerate(alt_files):
try:
tmp_struct = PDBParser(PERMISSIVE=True).get_structure(
alt_id, alt_file)[0]
if self.selection.generic_numbers != [] or self.selection.helices != []:
if not check_gn(tmp_struct):
gn_assigner = GenericNumbering(structure=tmp_struct)
self.alt_structs.append(
gn_assigner.assign_generic_numbers())
self.alt_structs[-1].id = alt_id
else:
self.alt_structs.append(tmp_struct)
except Exception as e:
logger.warning("Can't parse the file {!s}\n{!s}".format(
alt_id, e))
self.selector = CASelector(self.selection, self.ref_struct,
self.alt_structs)
def post (self, request, *args, **kwargs):
generic_numbering = GenericNumbering(StringIO(request.FILES['pdb_file'].file.read().decode('UTF-8',"ignore")))
out_struct = generic_numbering.assign_generic_numbers()
out_stream = StringIO()
io = PDBIO()
io.set_structure(out_struct)
io.save(out_stream)
if len(out_stream.getvalue()) > 0:
request.session['gn_outfile'] = out_stream
request.session['gn_outfname'] = request.FILES['pdb_file'].name
self.success = True
else:
self.input_file = request.FILES['pdb_file'].name
self.success = False
context = super(GenericNumberingResults, self).get_context_data(**kwargs)
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 render(request, self.template_name, context)
def get(self, request, *args, **kwargs):
if self.kwargs['substructure'] == 'select':
return HttpResponseRedirect('/structure/superposition_workflow_selection')
io = PDBIO()
out_stream = BytesIO()
zipf = zipfile.ZipFile(out_stream, 'w')
simple_selection = self.request.session.get('selection', False)
selection = Selection()
if simple_selection:
selection.importer(simple_selection)
self.alt_substructure_mapping = {}
#reference
if 'ref_file' in request.session.keys():
self.request.session['ref_file'].file.seek(0)
ref_struct = PDBParser(PERMISSIVE=True, QUIET=True).get_structure('ref', StringIO(self.request.session['ref_file'].file.read().decode('UTF-8')))[0]
gn_assigner = GenericNumbering(structure=ref_struct)
gn_assigner.assign_generic_numbers()
self.ref_substructure_mapping = gn_assigner.get_substructure_mapping_dict()
ref_name = self.request.session['ref_file'].name
elif selection.reference != []:
ref_struct = PDBParser(PERMISSIVE=True, QUIET=True).get_structure('ref', StringIO(selection.reference[0].item.get_cleaned_pdb()))[0]
gn_assigner = GenericNumbering(structure=ref_struct)
gn_assigner.assign_generic_numbers()
self.ref_substructure_mapping = gn_assigner.get_substructure_mapping_dict()
ref_name = '{}_{}_ref.pdb'.format(selection.reference[0].item.protein_conformation.protein.parent.entry_name, selection.reference[0].item.pdb_code.index)
alt_structs = {}
for alt_id, st in self.request.session['alt_structs'].items():
st.seek(0)
alt_structs[alt_id] = PDBParser(PERMISSIVE=True, QUIET=True).get_structure(alt_id, st)[0]
gn_assigner = GenericNumbering(structure=alt_structs[alt_id])
gn_assigner.assign_generic_numbers()
self.alt_substructure_mapping[alt_id] = gn_assigner.get_substructure_mapping_dict()
if self.kwargs['substructure'] == 'full':
io.set_structure(ref_struct)
tmp = StringIO()
io.save(tmp)
zipf.writestr(ref_name, tmp.getvalue())
for alt_name in self.request.session['alt_structs']:
tmp = StringIO()
io.set_structure(alt_structs[alt_name])
io.save(tmp)
zipf.writestr(alt_name, tmp.getvalue())
elif self.kwargs['substructure'] == 'substr':
consensus_gn_set = CASelector(SelectionParser(selection), ref_struct, alt_structs.values()).get_consensus_gn_set()
io.set_structure(ref_struct)
tmp = StringIO()
io.save(tmp, GenericNumbersSelector(consensus_gn_set))
zipf.writestr(ref_name, tmp.getvalue())
for alt_name in self.request.session['alt_structs']:
tmp = StringIO()
io.set_structure(alt_structs[alt_name])
io.save(tmp, GenericNumbersSelector(consensus_gn_set))
zipf.writestr(alt_name, tmp.getvalue())
elif self.kwargs['substructure'] == 'custom':
io.set_structure(ref_struct)
tmp = StringIO()
io.save(tmp, SubstructureSelector(self.ref_substructure_mapping, parsed_selection=SelectionParser(selection)))
zipf.writestr(ref_name, tmp.getvalue())
for alt_name in self.request.session['alt_structs']:
tmp = StringIO()
io.set_structure(alt_structs[alt_name])
io.save(tmp, SubstructureSelector(self.alt_substructure_mapping[alt_name], parsed_selection=SelectionParser(selection)))
zipf.writestr(alt_name, tmp.getvalue())
zipf.close()
if len(out_stream.getvalue()) > 0:
response = HttpResponse(content_type="application/zip")
response['Content-Disposition'] = 'attachment; filename="Superposed_structures.zip"'
response.write(out_stream.getvalue())
if 'ref_file' in request.FILES:
request.session['ref_file'] = request.FILES['ref_file']
if 'alt_files' in request.FILES:
request.session['alt_files'] = request.FILES.getlist('alt_files')
return response
