def read_mmCIF_file(structure_id, filename, hetatm=False, water=False):
"""
Read mmCIF file and create Structure instance based upon it.
Argument:
*structure_id*
structure_id code of mmCIF file
*filename*
name of mmCIF file
*hetatm*
Boolean representing whether the mmCIF file contains hetatom.
Default and recommended is False.
*water*
Boolean representing whether to add water to the structure.
Default and recommended is False.
Return:
Structure Instance
"""
from .Bio.PDB import MMCIFParser as MMCIFParserBiopy
p = MMCIFParserBiopy() #permissive default True
structure = p.get_structure(structure_id, filename)
return mmCIFParser._biommCIF_strcuture_to_TEMpy(
filename, structure, hetatm, water)
def structure_scanning(pdb, ligname, graph, model, edge_map, embed_dim):
"""
Given a PDB structure make a prediction for each residue in the structure:
- chop the structure into candidate sites (for each residue get a sphere..)
- convert residue neighbourhood into graph
- get prediction from model for each
- compare prediction to native ligand.
:returns: `residue_preds` dictionary with residue id as key and fingerprint prediction as value.
"""
from data_processor.build_dataset import get_pocket_graph
parser = MMCIFParser(QUIET=True)
structure = parser.get_structure("", pdb)[0]
residue_preds = {}
residues = list(structure.get_residues())
for residue in tqdm(residues):
if residue.resname in ['A', 'U', 'C', 'G', ligname]:
res_info = ":".join([
"_",
residue.get_parent().id, residue.resname,
str(residue.id[1])
])
pocket_graph = get_pocket_graph(pdb, res_info, graph)
_, dgl_graph = nx_to_dgl(pocket_graph, edge_map, embed_dim)
_, fp_pred = model(dgl_graph)
fp_pred = fp_pred.detach().numpy() > 0.5
residue_preds[(residue.get_parent().id, residue.id[1])] = fp_pred
else:
continue
return residue_preds
def test_dssp_with_mmcif_file_and_nonstandard_residues(self):
"""Test DSSP generation from MMCIF with non-standard residues."""
p = MMCIFParser()
pdbfile = "PDB/1AS5.cif"
model = p.get_structure("1AS5", pdbfile)[0]
dssp = DSSP(model, pdbfile)
self.assertEqual(len(dssp), 24)
def load_test_structure(self, pdb_code):
mmcif_parser = MMCIFParser(QUIET=True)
structure = mmcif_parser.get_structure(
pdb_code, self.TEST_STRUCTURE_DIR / f'{pdb_code}.cif')
return structure, BiopythonToMmcifResidueIds.create(
mmcif_parser._mmcif_dict) # reuse already parsed
def fetch_mmCIF(structure_id, filename,hetatm=False,water= False):
"""
Fetch mmCIF file and create Structure instance based upon it.
Argument:
*structure_id*
structure_id code of mmCIF file
*filename*
name of mmCIF file
*hetatm*
Boolean representing whether the mmCIF file contains hetatom.
*water*
Boolean representing whether to add water to the structure.
Default and recommended is False.
Return:
Structure Instance
"""
from Bio.PDB import MMCIFParser as MMCIFParserBiopy
p=MMCIFParserBiopy()
url = 'http://www.rcsb.org/pdb/files/%s.cif' % structure_id
urllib.urlretrieve(url, filename)
structure=p.get_structure(structure_id, filename)
return mmCIFParser._biommCIF_strcuture_to_TEMpy(filename,structure,hetatm,water)
def test_dssp_with_mmcif_file(self):
"""Test DSSP generation from MMCIF."""
p = MMCIFParser()
pdbfile = "PDB/2BEG.cif"
model = p.get_structure("2BEG", pdbfile)[0]
dssp = DSSP(model, pdbfile)
self.assertEqual(len(dssp), 130)
def cifReader(self, name, file):
try:
parser = MMCIFParser()
structure = parser.get_structure(name, file)
return structure
except:
print("Something went wrong: File not found")
def __get_structure__(self, file_path):
base_name = os.path.basename(file_path)
name, ext = os.path.splitext(base_name)
if 'cif' in ext:
parser = MMCIFParser()
else:
parser = PDBParser()
return parser.get_structure(name, file_path)
def creator(parser=parser):
try:
ret = parser.get_structure(pid, file=dst)
except ValueError as e: # assume it's a .cif
if PARSE_CIF:
parser = MMCIFParser(QUIET=True)
ret = parser.get_structure(pid, dst)
else:
raise e
finally:
self.freemem()
return ret
def load_pdb(path):
# If using PDB
# parser = PDBParser(PERMISSIVE=1)
# if using mmCIF
parser = MMCIFParser()
structure = parser.get_structure('structure 1', path)
return structure
def test_cealigner_nucleic(self):
"""Test aligning 1LCD on 1LCD."""
ref = "PDB/1LCD.cif"
mob = "PDB/1LCD.cif"
parser = MMCIFParser(QUIET=1)
s1 = parser.get_structure("1lcd_ref", ref)
s2 = parser.get_structure("1lcd_mob", mob)
aligner = CEAligner()
aligner.set_reference(s1)
aligner.align(s2)
self.assertAlmostEqual(aligner.rms, 0.0, places=3)
def print_input_file(structure_file, ss2_file=None):
extension = os.path.basename(structure_file).rsplit(".", 1)[-1].lower()
if extension in ("cif", "mmcif"):
from Bio.PDB import MMCIFParser
parser = MMCIFParser()
else:
from Bio.PDB import PDBParser
parser = PDBParser()
struc = parser.get_structure("", structure_file)
seq = ""
coords = []
for chain in struc[0]:
for res in chain:
# Skip hetero and water residues
if res.id[0] != " ":
continue
seq += three_to_one_aas[res.get_resname()]
if res.get_resname() == "GLY":
# Extend vector of length 1 Å from Cα to act as fake centroid
d = res["CA"].get_coord() - res["C"].get_coord() + res["CA"].get_coord() - res["N"].get_coord()
coord_cent = res["CA"].get_coord() + d / np.linalg.norm(d)
else:
# Centroid coordinates of sidechain heavy atoms
atom_coords = []
for atom in res:
if atom.get_name() not in ("N", "CA", "C", "O") and atom.element != "H":
atom_coords.append(atom.get_coord())
coord_cent = np.array(atom_coords).mean(0)
coords.append([res["N"].get_coord(), res["CA"].get_coord(), res["C"].get_coord(), coord_cent])
print(seq)
if ss2_file:
# Extract 3-state secondary structure prediction from PSIPRED ss2 output file
ss_pred = ""
with open(ss2_file) as f:
for line in f:
if len(line.rstrip()) > 0 and not line.startswith("#"):
ss_pred += line.split()[2]
assert len(seq) == len(ss_pred), f"Sequence length is {len(seq)} but SS prediction length is {len(ss_pred)}"
print(ss_pred)
else:
print("C" * len(seq))
def coord_str(coord):
return " ".join([str(round(c, 3)) for c in coord])
for coord_n, coord_ca, coord_c, coord_cent in coords:
print(f"{coord_str(coord_n)} {coord_str(coord_ca)} {coord_str(coord_c)} {coord_str(coord_cent)}")
def get_convert_cifs(url, cif_path, pdb_path):
try:
url_req.urlretrieve(url, cif_path)
except (url_err.URLError, url_err.HTTPError):
print("!!!HTTP or URL error, couldn't get " + url + '.')
return
try:
p = MMCIFParser()
struc = p.get_structure('', cif_path)
io = PDBIO()
io.set_structure(struc)
io.save(pdb_path)
print('^^^SUCCESSFULLY CONVERTED CIF TO PDB')
except TypeError:
print('Problem making pdb file')
def scanning_analyze():
"""
Visualize results of scanning on PDB.
Color residues by prediction score.
1fmn_#0.1:A:FMN:36.nx_annot.p
"""
from data_processor.build_dataset import find_residue, lig_center
model, edge_map, embed_dim = load_model('small_no_rec_2',
'../data/annotated/pockets_nx')
for f in os.listdir("../data/annotated/pockets_nx"):
pdbid = f.split("_")[0]
_, chain, ligname, pos = f.replace(".nx_annot.p", "").split(":")
pos = int(pos)
print(chain, ligname, pos)
graph = pickle.load(open(f'../data/RNA_Graphs/{pdbid}.pickle', 'rb'))
if len(graph.nodes()) > 100:
continue
try:
fp_preds = structure_scanning(
f'../data/all_rna_prot_lig_2019/{pdbid}.cif', ligname, graph,
model, edge_map, embed_dim)
except Exception as e:
print(e)
continue
parser = MMCIFParser(QUIET=True)
structure = parser.get_structure(
"", f"../data/all_rna_prot_lig_2019/{pdbid}.cif")[0]
lig_res = find_residue(structure[chain], pos)
lig_c = lig_center(lig_res.get_atoms())
fp_dict = pickle.load(open("../data/all_ligs_maccs.p", 'rb'))
true_fp = fp_dict[ligname]
dists = []
jaccards = []
decoys = get_decoys()
for res, fp in fp_preds.items():
chain, pos = res
r = find_residue(structure[chain], pos)
r_center = lig_center(r.get_atoms())
dists.append(euclidean(r_center, lig_c))
jaccards.append(mse(true_fp, fp))
plt.title(f)
plt.distplot(dists, jaccards)
plt.xlabel("dist to binding site")
plt.ylabel("dist to fp")
plt.show()
pass
def _biommCIF_strcuture_to_TEMpy(filename,
structure,
hetatm=False,
water=False):
#imported if and when the function is executed.
"""
PRIVATE FUNCTION to convert to Structure Instance
filename = name of mmCIF file
hetatm = Boolean representing whether to add hetatm to the structure.Default and Raccomanded is False.
water = Boolean representing whether to add water to the structure.Default and Raccomanded is False.
"""
from Bio.PDB import MMCIFParser as MMCIFParserBiopy
p = MMCIFParserBiopy()
atomList = []
hetatomList = []
wateratomList = []
footer = ''
header = ''
cif_code = filename.split("/")[-1] #use os.1FAT.cif
structure_id = "%s" % cif_code[:-4]
structure = p.get_structure(structure_id, filename)
residues = structure.get_residues()
for res in residues:
hetfield = res.get_id()[0]
if hetfield[0] == "H":
for atom in res:
BioPyAtom(atom)
hetatomList.append(BioPyAtom(atom))
elif hetfield[0] == "W":
for atom in res:
BioPyAtom(atom)
wateratomList.append(BioPyAtom(atom))
else:
for atom in res:
BioPyAtom(atom)
atomList.append(BioPyAtom(atom))
if hetatm:
atomList = append(atomList, hetatomList)
if water:
atomList = append(atomList, wateratomList)
return BioPy_Structure(atomList,
filename=filename,
header=header,
footer=footer)
def Extract_coordinates_from_PDB(self, PDB_file, type):
''' Returns both the alpha carbon coordinates contained in the PDB file and the residues coordinates for the desired chains'''
from Bio.PDB.PDBParser import PDBParser
from Bio.PDB import MMCIFParser
Name = ntpath.basename(PDB_file).split('.')[0]
try:
parser = PDB.PDBParser()
structure = parser.get_structure('%s' % (Name), PDB_file)
except:
parser = MMCIFParser()
structure = parser.get_structure('%s' % (Name), PDB_file)
############## Iterating over residues to extract all of them even if there is more than 1 chain
if type == 'models':
CoordinatesPerModel = []
for model in structure:
model_coord = []
for chain in model:
for residue in chain:
if is_aa(residue.get_resname(), standard=True):
model_coord.append(residue['CA'].get_coord())
CoordinatesPerModel.append(model_coord)
return CoordinatesPerModel
elif type == 'chains':
CoordinatesPerChain = []
for model in structure:
for chain in model:
chain_coord = []
for residue in chain:
if is_aa(residue.get_resname(), standard=True):
chain_coord.append(residue['CA'].get_coord())
CoordinatesPerChain.append(chain_coord)
return CoordinatesPerChain
elif type == 'all':
alpha_carbon_coordinates = []
for chain in structure.get_chains():
for residue in chain:
if is_aa(residue.get_resname(), standard=True):
# try:
alpha_carbon_coordinates.append(
residue['CA'].get_coord())
# except:
# pass
return alpha_carbon_coordinates
def call_mmcif(f):
'''
Call function for mmcif files
'''
if (".cif") in f:
name = f.split('/')[-1].split('.')[0].upper()
# Open gz files
if ".gz" in f:
f = gzip.open(f, 'rt')
parser = MMCIFParser()
structure = parser.get_structure(name, f)
mmtf_encoder = MMTFEncoder()
pass_data_on(input_data=structure,
input_function=biopythonInputFunction,
output_data=mmtf_encoder)
return (name, mmtf_encoder)
def Write_PDB(self, initialPDB, Rotation, Translation, N):
''' Transform by rotating and translating the atom coordinates from the original PDB file and rewrite it '''
from Bio.PDB.PDBParser import PDBParser
from Bio.PDB import MMCIFParser, PDBIO
Name = ntpath.basename(initialPDB).split('.')[0]
try:
parser = PDB.PDBParser()
structure = parser.get_structure('%s' % (Name), initialPDB)
except:
parser = MMCIFParser()
structure = parser.get_structure('%s' % (Name), initialPDB)
for atom in structure.get_atoms():
atom.transform(Rotation, Translation)
io = PDBIO()
io.set_structure(structure)
io.save("{}_{}".format(N, ntpath.basename(initialPDB)))
def test_cealigner_no_transform(self):
"""Test aligning 7CFN on 6WQA without transforming 7CFN."""
ref = "PDB/6WQA.cif"
mob = "PDB/7CFN.cif"
parser = MMCIFParser(QUIET=1)
s1 = parser.get_structure("6wqa", ref)
s2 = parser.get_structure("7cfn", mob)
s2_original_coords = [list(a.coord) for a in s2.get_atoms()]
aligner = CEAligner()
aligner.set_reference(s1)
aligner.align(s2, transform=False)
s2_coords_final = [list(a.coord) for a in s2.get_atoms()]
self.assertAlmostEqual(aligner.rms, 3.83, places=2)
self.assertEqual(s2_original_coords, s2_coords_final)
def process_structrure(pdb_file_chains, save_dir):
pdb_file, chain_ids = pdb_file_chains
prot = os.path.split(pdb_file)[-1].split(".")[0].upper()
parser = MMCIFParser()
try:
model = parser.get_structure(None, pdb_file)[0]
except PDB.PDBExceptions.PDBConstructionException:
return
for c_id in set(chain_ids):
try:
chain = model[c_id]
except KeyError:
return
seq = []
coords = []
for residue in chain.get_unpacked_list():
if "CA" in residue:
xyz = residue["CA"].get_coord()
if coords and np.allclose(
coords[-1], xyz
): # Ignore residue if too close to the previous one.
continue
aa_c = aa_codes.get(
_aa3to1_dict.get(residue.get_resname(), "-"), 0)
seq.append(aa_c)
coords.append(xyz)
if seq:
npz_filename = os.path.join(save_dir, f"{prot}-{chain.id}.npz")
# if os.path.exists(npz_filename):
# print(f'{prot}-{c_id} exists already!')
# return
np.savez_compressed(npz_filename, seq=seq, coords=coords)
print(f"{npz_filename} saved!")
class WriteTest(unittest.TestCase):
@classmethod
def setUpClass(self):
self.io = MMCIFIO()
self.mmcif_parser = MMCIFParser()
self.pdb_parser = PDBParser()
with warnings.catch_warnings():
warnings.simplefilter("ignore", PDBConstructionWarning)
self.structure = self.pdb_parser.get_structure(
"example", "PDB/1A8O.pdb")
self.mmcif_file = "PDB/1A8O.cif"
self.mmcif_multimodel_pdb_file = "PDB/1SSU_mod.pdb"
self.mmcif_multimodel_mmcif_file = "PDB/1SSU_mod.cif"
def test_mmcifio_write_structure(self):
"""Write a full structure using MMCIFIO."""
struct1 = self.structure
# Write full model to temp file
self.io.set_structure(struct1)
filenumber, filename = tempfile.mkstemp()
os.close(filenumber)
try:
self.io.save(filename)
struct2 = self.mmcif_parser.get_structure("1a8o", filename)
nresidues = len(list(struct2.get_residues()))
self.assertEqual(len(struct2), 1)
self.assertEqual(nresidues, 158)
finally:
os.remove(filename)
def test_mmcifio_write_residue(self):
"""Write a single residue using MMCIFIO."""
struct1 = self.structure
residue1 = list(struct1.get_residues())[0]
# Write full model to temp file
self.io.set_structure(residue1)
filenumber, filename = tempfile.mkstemp()
os.close(filenumber)
try:
self.io.save(filename)
struct2 = self.mmcif_parser.get_structure("1a8o", filename)
nresidues = len(list(struct2.get_residues()))
self.assertEqual(nresidues, 1)
finally:
os.remove(filename)
def test_mmcifio_write_residue_w_chain(self):
"""Write a single residue (chain id == X) using MMCIFIO."""
struct1 = self.structure.copy() # make copy so we can change it
residue1 = list(struct1.get_residues())[0]
# Modify parent id
parent = residue1.parent
parent.id = "X"
# Write full model to temp file
self.io.set_structure(residue1)
filenumber, filename = tempfile.mkstemp()
os.close(filenumber)
try:
self.io.save(filename)
struct2 = self.mmcif_parser.get_structure("1a8o", filename)
nresidues = len(list(struct2.get_residues()))
self.assertEqual(nresidues, 1)
# Assert chain remained the same
chain_id = [c.id for c in struct2.get_chains()][0]
self.assertEqual(chain_id, "X")
finally:
os.remove(filename)
def test_mmcifio_write_residue_wout_chain(self):
"""Write a single orphan residue using MMCIFIO."""
struct1 = self.structure
residue1 = list(struct1.get_residues())[0]
residue1.parent = None # detach residue
# Write full model to temp file
self.io.set_structure(residue1)
filenumber, filename = tempfile.mkstemp()
os.close(filenumber)
try:
self.io.save(filename)
struct2 = self.mmcif_parser.get_structure("1a8o", filename)
nresidues = len(list(struct2.get_residues()))
self.assertEqual(nresidues, 1)
# Assert chain is default: "A"
chain_id = [c.id for c in struct2.get_chains()][0]
self.assertEqual(chain_id, "A")
finally:
os.remove(filename)
def test_mmcifio_write_custom_residue(self):
"""Write a chainless residue using PDBIO."""
res = Residue.Residue((" ", 1, " "), "DUM", "")
atm = Atom.Atom("CA", [0.1, 0.1, 0.1], 1.0, 1.0, " ", "CA", 1, "C")
res.add(atm)
# Ensure that set_structure doesn't alter parent
parent = res.parent
# Write full model to temp file
self.io.set_structure(res)
self.assertIs(parent, res.parent)
filenumber, filename = tempfile.mkstemp()
os.close(filenumber)
try:
self.io.save(filename)
struct2 = self.mmcif_parser.get_structure("res", filename)
latoms = list(struct2.get_atoms())
self.assertEqual(len(latoms), 1)
self.assertEqual(latoms[0].name, "CA")
self.assertEqual(latoms[0].parent.resname, "DUM")
self.assertEqual(latoms[0].parent.parent.id, "A")
finally:
os.remove(filename)
def test_mmcifio_select(self):
"""Write a selection of the structure using a Select subclass."""
# Selection class to filter all alpha carbons
class CAonly(Select):
"""Accepts only CA residues."""
def accept_atom(self, atom):
if atom.name == "CA" and atom.element == "C":
return 1
struct1 = self.structure
# Write to temp file
self.io.set_structure(struct1)
filenumber, filename = tempfile.mkstemp()
os.close(filenumber)
try:
self.io.save(filename, CAonly())
struct2 = self.mmcif_parser.get_structure("1a8o", filename)
nresidues = len(list(struct2.get_residues()))
self.assertEqual(nresidues, 70)
finally:
os.remove(filename)
def test_mmcifio_write_dict(self):
"""Write an mmCIF dictionary out, read it in and compare them."""
d1 = MMCIF2Dict(self.mmcif_file)
# Write to temp file
self.io.set_dict(d1)
filenumber, filename = tempfile.mkstemp()
os.close(filenumber)
try:
self.io.save(filename)
d2 = MMCIF2Dict(filename)
k1 = sorted(d1.keys())
k2 = sorted(d2.keys())
self.assertEqual(k1, k2)
for key in k1:
self.assertEqual(d1[key], d2[key])
finally:
os.remove(filename)
def test_mmcifio_multimodel(self):
"""Write a multi-model, multi-chain mmCIF file."""
pdb_struct = self.pdb_parser.get_structure(
"1SSU_mod_pdb", self.mmcif_multimodel_pdb_file)
mmcif_struct = self.mmcif_parser.get_structure(
"1SSU_mod_mmcif", self.mmcif_multimodel_mmcif_file)
io = MMCIFIO()
for struct in [pdb_struct, mmcif_struct]:
self.io.set_structure(struct)
filenumber, filename = tempfile.mkstemp()
os.close(filenumber)
try:
self.io.save(filename)
struct_in = self.mmcif_parser.get_structure(
"1SSU_mod_in", filename)
self.assertEqual(len(struct_in), 2)
self.assertEqual(len(struct_in[1]), 2)
self.assertEqual(
round(float(struct_in[1]["B"][1]["N"].get_coord()[0]), 3),
6.259)
finally:
os.remove(filename)
def mmcif2pdb(pdb, chain, model=0):
parser = MMCIFParser()
writer = PDB.PDBIO()
remove = False
if not os.path.isfile(pdb) and len(pdb) == 4:
pdb_code = pdb
pdb = os.path.join(tempdir, "{}.cif".format(pdb.lower()))
attempts = 0
while not os.path.isfile(pdb) and attempts < 5:
try:
pdb = PDB.PDBList().retrieve_pdb_file(pdb_code,
pdir=tempdir,
file_format="mmCif")
except (KeyboardInterrupt, SystemExit):
raise
except:
pass
attempts += 1
time.sleep(1)
if not os.path.isfile(pdb):
raise IOError("Cannot download file")
remove = True
name = os.path.splitext(pdb)[0]
try:
structure = parser.get_structure(name, pdb)
except (KeyboardInterrupt, SystemExit):
raise
except:
raise IOError("Unable to open pdb {}".format(pdb))
try:
writer.set_structure(structure)
except (KeyboardInterrupt, SystemExit):
raise
except:
raise IOError("Unable to save pdb {}".format(pdb))
if not isinstance(chain, (list, tuple)):
chain = [chain]
for c in chain:
if c is None:
yield None
continue
#Make chain one character to fit in PDB format
new_pdb = "{}_{}.pdb".format(name, c)
new_chain = c[0]
try:
writer.save(new_pdb, select=SelectChain(new_chain, model))
except (KeyboardInterrupt, SystemExit):
raise
except:
raise IOError("Unable to save pdb {}".format(new_pdb))
if not os.path.isfile(new_pdb):
raise IOError("Cannot extract chain")
yield new_pdb
if remove:
try:
os.remove(pdb)
except OSError:
pass
# Benchmark the parsing of a mmCIF file given as an argument
import sys
import time
from Bio.PDB import MMCIFParser
mmcif_filepath = sys.argv[1]
parser = MMCIFParser()
start = time.time()
parser.get_structure("", mmcif_filepath)
end = time.time()
print(end - start)
def align_proteingbs_seq(conn, xtalsdbpath):
#check PROTEINGBS exists then
seqdbutils.check_tables_exist(conn, ['PROTEINGBS', 'CURATEDXTALS'])
assert (xtalsdbpath.exists()
), f'not finding xtalsdbpath {xtalsdbpath}, check keyword args'
xdbconn = seqdbutils.gracefuldbopen(xtalsdbpath)
seqdbutils.check_tables_exist(xdbconn, ['XTALS'])
xc = xdbconn.cursor()
c = conn.cursor()
mmcparser = MMCIFParser()
ppb = PPBuilder()
aln_registers = []
c.execute('''SELECT * FROM CURATEDXTALS''')
curatedrows = c.fetchall()
for curatedrow in curatedrows:
c.execute('''SELECT * FROM PROTEINGBS WHERE acc=(?)''',
(curatedrow['acc'], ))
pgbrow = c.fetchone()
pgbseq = pickle.loads(pgbrow['pklgbsr']).seq
if (pgbrow['seq_checksum']==curatedrow['pgbsr_seqchecksum'] and \
curatedrow['pgbsr_ccstart'] is not None and curatedrow['pgbsr_ccstop'] is not None and
curatedrow['pgbsr_fullstart'] is not None and curatedrow['pgbsr_fullstop'] is not None):
print(f'skipping previously-completed {curatedrow["pdbid"]}')
continue #skip this one!
print(f'now examining {curatedrow["pdbid"]}')
for enzyme_format in ['cc', 'full']:
aln_register = AlnRegister(enzyme_format, curatedrow['acc'],
curatedrow['pdbid'])
#just copy over cc values to full if possible---
if (enzyme_format=='full' and curatedrow['ntccpos']==curatedrow['ctccpos'] and \
curatedrow['ntfullpos']==curatedrow['ctfullpos']):
aln_register.start = aln_registers[-1].start
aln_register.stop = aln_registers[-1].stop
aln_register.message = 'used cc values for full'
aln_register.success = aln_registers[-1].success
continue
else:
aln_register = do_register_aln(pgbseq, curatedrow,
enzyme_format, aln_register,
'easy')
if not aln_register.success:
#get sequence from pdb file
xc.execute('''SELECT * FROM XTALS WHERE pdbid=(?)''',
(curatedrow['pdbid'], ))
xtalrow = xc.fetchone()
xtalfpath = xtalsdbpath.parent / xtalrow['relpath']
xtalstruct = mmcparser.get_structure(
curatedrow['pdbid'], xtalfpath)
xtalchain = xtalstruct
xtalppchain = ppb.build_peptides(xtalchain)
xtalseqstr = str(xtalppchain[0].get_sequence())
aln_register = do_register_aln(pgbseq,
curatedrow,
enzyme_format,
aln_register,
'xtal',
xtalseqstr=xtalseqstr)
if not aln_register.success:
if curatedrow['enable_fuzzy']:
aln_register = do_register_aln(
pgbseq,
curatedrow,
enzyme_format,
aln_register,
'fuzzy',
xtalseqstr=xtalseqstr)
else:
aln_register.message = '************ * * * * * * * * * * * * * * * * ** * * *********************\n'
aln_register.message += f'-------could not match. Consider setting enable_fuzzy column to yes for {curatedrow["pdbid"]}-------\n'
aln_register.message += '************ * * * * * * * * * * * * * * * * * * * * *******************\n'
aln_registers.append(aln_register)
for aln_register in aln_registers:
print(aln_register.message)
if aln_register.success:
update_tuple = (aln_register.start, aln_register.stop,
pgbrow['seq_checksum'], aln_register.acc)
if aln_register.enzyme_format == 'cc':
c.execute(
'''UPDATE CURATEDXTALS SET pgbsr_ccstart=(?), pgbsr_ccstop=(?), pgbsr_seqchecksum=(?) \
WHERE acc=(?)''', update_tuple)
if aln_register.enzyme_format == 'full':
c.execute(
'''UPDATE CURATEDXTALS SET pgbsr_fullstart=(?), pgbsr_fullstop=(?), pgbsr_seqchecksum=(?) \
WHERE acc=(?)''', update_tuple)
else:
print(
f'+++++------FAILED TO FIND {aln_register.enzyme_format} START,STOP FOR {aln_register.pdbid} ({aln_register.acc})------++++++\n'
)
xdbconn.close()