def __init__(self, parent, enableUi, File=""): f = QGLFormat() f.setStencil(True) f.setRgba(True) f.setDepth(True) f.setDoubleBuffer(True) QGLWidget.__init__(self, f, parent=parent) self.setMinimumSize(500, 500) self._enableUi = enableUi self.pymol = pymol2.PyMOL() # _pymolPool.getInstance() self.pymol.start() self.cmd = self.pymol.cmd # self.toPymolName = self.pymol.toPymolName ### Attribute Error self._pymolProcess() if not self._enableUi: self.pymol.cmd.set("internal_gui", 0) self.pymol.cmd.set("internal_feedback", 0) self.pymol.cmd.button("double_left", "None", "None") self.pymol.cmd.button("single_right", "None", "None") self.pymol.cmd.load(File) self.pymol.reshape(self.width(), self.height()) self._timer = QtCore.QTimer() self._timer.setSingleShot(True) self._timer.timeout.connect(self._pymolProcess) self.resizeGL(self.width(), self.height()) #globalSettings.settingsChanged.connect(self._updateGlobalSettings) self._updateGlobalSettings()
def _get_attachment_from_pdbblock(self) -> Union[None, Chem.Mol]: """ Yes, yes, I see the madness in using pymol to get an atom for rdkit to make a pose for pyrosetta. Hence why `find_attachment` will replace it. todo `_get_attachment_from_pdbblock` --> `find_attachment` """ self.journal.debug(f'{self.long_name} - getting attachemnt atom') if not self.covalent_resn: return None else: if isinstance(self.covalent_resi, str): resi, chain = re.match('(\d+)(\w)', self.covalent_resi).groups() resi = int(resi) else: resi = self.covalent_resi chain = None with pymol2.PyMOL() as pymol: pymol.cmd.read_pdbstr(self.apo_pdbblock, 'prot') if self.covalent_resn == 'CYS': name = 'SG' else: raise NotImplementedError('only done for cys atm') try: if chain is not None: pdb = pymol.cmd.get_pdbstr( f'resi {resi} and name {name} and chain {chain}') else: pdb = pymol.cmd.get_pdbstr( f'resi {resi} and name {name}') except: pdb = pymol.cmd.get_pdbstr(f'resi {resi} and name {name}') return Chem.MolFromPDBBlock(pdb)
def make_pse(self, filename: str = 'combo.pse'): """ Save a pse in the relevant folder. :param filename: :return: """ assert '.pse' in filename, f'{filename} not .pse file' with pymol2.PyMOL() as pymol: for hit in self.hits: hit_name = hit.GetProp('_Name') pymol.cmd.read_molstr(Chem.MolToMolBlock(hit), hit_name) if hit_name in self.fragmenstein.unmatched: pymol.cmd.color('black', f'element C and {hit_name}') else: pymol.cmd.color('white', f'element C and {hit_name}') if self.fragmenstein.positioned_mol is not None: pymol.cmd.read_molstr(Chem.MolToMolBlock(self.fragmenstein.positioned_mol), 'placed') pymol.cmd.color('magenta', f'element C and placed') if self.minimised_mol is not None: pymol.cmd.read_molstr(Chem.MolToMolBlock(self.minimised_mol), 'minimised') pymol.cmd.color('green', f'element C and minimised') if self.minimised_pdbblock is not None: pymol.cmd.read_pdbstr(self.minimised_pdbblock, 'min_protein') pymol.cmd.color('gray50', f'element C and min_protein') pymol.cmd.hide('sticks', 'min_protein') if self.unminimised_pdbblock is not None: pymol.cmd.read_pdbstr(self.unminimised_pdbblock, 'unmin_protein') pymol.cmd.color('gray20', f'element C and unmin_protein') pymol.cmd.hide('sticks', 'unmin_protein') pymol.cmd.disable('unmin_protein') pymol.cmd.zoom('byres (placed expand 4)') pymol.cmd.show('line', 'byres (placed around 4)') pymol.cmd.save(os.path.join(self.work_path, self.long_name, filename))
def make_pse(self, filename='test.pse'): assert '.pse' in filename, 'Must be a pymol pse extension!' with pymol2.PyMOL() as pymol: tints = iter([ 'wheat', 'palegreen', 'lightblue', 'paleyellow', 'lightpink', 'palecyan', 'lightorange', 'bluewhite' ]) #pymol.cmd.bg_color('white') for h, hit in enumerate(self.hits): pymol.cmd.read_molstr(Chem.MolToMolBlock(hit, kekulize=False), f'hit{h}') pymol.cmd.color(next(tints), f'hit{h} and name C*') pymol.cmd.read_molstr( Chem.MolToMolBlock(self.scaffold, kekulize=False), f'scaffold') pymol.cmd.color('tv_blue', f'scaffold and name C*') pymol.cmd.read_molstr( Chem.MolToMolBlock(self.chimera, kekulize=False), f'chimera') pymol.cmd.color('cyan', f'chimera and name C*') pymol.cmd.read_molstr( Chem.MolToMolBlock(self.positioned_mol, kekulize=False), f'followup') pymol.cmd.color('tv_green', f'followup and name C*') pymol.cmd.hide('sticks') pymol.cmd.hide('cartoon') # there should not be.... pymol.cmd.show('lines', 'not polymer') pymol.cmd.show('sticks', 'followup or chimera') pymol.cmd.save(filename)
def dehydrate_file(self, infile: str, outfile: str, water=False, ligand=False): """ Create a mutant protein based on a list of mutations on a PDB file path. :param infile: str :param outfile: str the file to save the mod as. :param mutations: list of string in the single letter format (A234P) without "p.". :param chain: str chain id in the pdb loaded. :return: **PyMOL session**: self-contained. """ with pymol2.PyMOL() as self.pymol: self.pymol.cmd.set('fetch_path', self.temp_folder) self.pymol.cmd.load(infile) if water: self.pymol.cmd.remove('solvent') if ligand: self.pymol.cmd.remove(' or '.join( [f'resn {l}' for l in self.boring_ligand])) self.pymol.cmd.save(outfile) self.pymol.cmd.delete('all') return 1
def create_animations(user_rand): try: # pymol.finish_launching(['pymol', '-q']) # pymol: -q quiet launch, -c no gui, -e fullscreen # cmd = pymol.cmd p1 = pymol2.PyMOL() p1.start() cmd = p1.cmd # load input cmd.reinitialize() sleep(0.5) cmd.load(temp + user_rand + "/file_upload_pdb.pdb") cmd.load_traj(temp + user_rand + "/file_upload_dcd.dcd") # create the animations: update_simulation_status('Creates the animations', user_rand) create_movies_from_different_angles( cmd, user_rand, temp + user_rand + "/file_upload_pdb.pdb", temp + user_rand + "/file_upload_dcd.dcd") # create movies in media/movies folder # complete simulation: update_simulation_status('Done!', user_rand) except Exception as e: # mainly for "pymol.CmdException" print(str(e)) update_simulation_status( 'An error occurred while creating the animations. Please try again later.', user_rand) return
def sdf_to_pdb(self, infile: str, reffile: str) -> str: """ A special class method to convert a sdf to pdb but with the atom index shifted so that the pdb can be cat'ed. :param infile: sdf file :param reffile: pdb file for the indices. :return: PDB block **PyMOL session**: self-contained. """ with pymol2.PyMOL() as self.pymol: self.pymol.cmd.set('fetch_path', self.temp_folder) combofile = infile.replace('.sdf', '_combo.pdb') minusfile = infile.replace('.sdf', '_ref.pdb') self.pymol.cmd.load(infile, 'ligand') self.pymol.cmd.alter('all', 'chain="Z"') self.pymol.cmd.load(reffile, 'apo') self.pymol.cmd.alter('all', 'segi=""') self.pymol.cmd.sort() self.pymol.cmd.create('combo', 'apo or ligand') self.pymol.cmd.save(combofile, 'combo') self.pymol.cmd.save(minusfile, 'apo') with open(minusfile) as fh: ref = fh.readlines() with open(combofile) as fh: combo = fh.readlines() ligand = ''.join([ line for line in combo if line not in ref and line.strip() != '' ]) os.remove(combofile) os.remove(minusfile) return ligand
def load_mem_pose(filename, opm_filename, params_paths=None): with pymol2.PyMOL() as pymol: # pymol.cmd.load('SLC38A3_phyre.pdb', 'S38A3') pymol.cmd.load(filename, 'S38A3') # pymol.cmd.remove('resi 1-68 or resi 245-282 or resi 494-504') # pymol.cmd.remove('resi 138-207 or resi 318-392') map_pdbblock = pymol.cmd.get_pdbstr() pymol.cmd.load(opm_filename, 'OPM') pymol.cmd.align('S38A3', 'OPM') pymol.cmd.remove('resn MEM') # make sure its not there! pymol.cmd.delete('OPM') holo_pdbblock = pymol.cmd.get_pdbstr('polymer') lig_pdbblock = pymol.cmd.get_pdbstr('not polymer') # pymol.cmd.save('test.pdb') pose = pyrosetta.Pose() if params_paths: pyrosetta.generate_nonstandard_residue_set(pose, params_paths) # pyrosetta.rosetta.core.import_pose.pose_from_file(pose, 'phyre.gln_Na.PO4.loop_r.pdb') pyrosetta.rosetta.core.import_pose.pose_from_pdbstring(pose, holo_pdbblock) addmem = pyrosetta.rosetta.protocols.membrane.AddMembraneMover( 'from_structure') addmem.apply(pose) pyrosetta.rosetta.protocols.membrane.AqueousPoreFinder().apply(pose) ligpose = pyrosetta.Pose() pyrosetta.generate_nonstandard_residue_set(ligpose, params_paths) # pyrosetta.rosetta.core.import_pose.pose_from_file(pose, 'phyre.gln_Na.PO4.loop_r.pdb') pyrosetta.rosetta.core.import_pose.pose_from_pdbstring( ligpose, lig_pdbblock) pose.append_pose_by_jump(ligpose, pose.total_residue()) return pose
def is_satisfactory(self, resi: int): with pymol2.PyMOL() as pymol: pymol.cmd.read_pdbstr(self.coordinates, 'given_protein') residex = defaultdict(list) note = 'custom protein' for atom in pymol.cmd.get_model('name CA').atom: residex[atom.chain].append(atom.resi) if len(residex) == 1 and 'A' not in residex: note += ' - chain moved to A' pymol.cmd.alter('given_protein', 'chain="A"') pymol.cmd.sort() move = list(residex.values())[0] residex = {'A': move} self.coordinates = pymol.cmd.get_pdbstr() if not self.chain_definitions: self.chain_definitions = [{ 'chain': chain, 'uniprot': "XXX", 'x': min(residex[chain]), 'y': max(residex[chain]), 'offset': 0, 'range': f'0-9999', 'name': self.code, 'description': note } for chain in residex] assert pymol.cmd.select( 'given_protein'), 'Given protein had no valid data to load' assert pymol.cmd.select('chain A'), 'Given protein has no chain A' assert pymol.cmd.select( f'chain A and resi {resi}' ), f'Given protein has no residue {resi} in chain A' for name in ('N', 'CA', 'C'): assert pymol.cmd.select(f'chain A and resi {resi} and name {name}'), \ f'Given protein has no {name} atom in residue {resi} in chain A'
def distance_hits(cls, pdb_filenames: List[str], target_resi: int, target_chain: str, target_atomname: str, ligand_resn='LIG') -> List[float]: """ See closest hit for info. :param pdb_filenames: :param target_resi: :param target_chain: :param target_atomname: :param ligand_resn: :return: """ distances = [] with pymol2.PyMOL() as pymol: for hit in pdb_filenames: pymol.cmd.load(hit) distances.append(min( [pymol.cmd.distance(f'chain {target_chain} and resi {target_resi} and name {target_atomname}', f'resn {ligand_resn} and name {atom.name}') for atom in pymol.cmd.get_model(f'resn {ligand_resn}').atom])) pymol.cmd.delete('*') return distances
def change_relative_position(x1, y1, z1, x2, y2, z2, degXY_1, degYZ_1, degXY_2, degYZ_2, user_rand): """ Save PDB file that represents the 2 PDB files after you change the positions and running pdb_fixer """ # change positions filename_1, filename_2, pdb, temp = '_1_', '_2_', '.pdb', 'media/files/' + user_rand + '/' filename_1_movement, filename_2_movement = filename_1 + '__movement', filename_2 + '__movement' translate_pdb(temp + filename_1 + pdb, temp + filename_1_movement + pdb, x1, y1, z1, degXY_1, degYZ_1) translate_pdb(temp + filename_2 + pdb, temp + filename_2_movement + pdb, x2, y2, z2, degXY_2, degYZ_2) # fix pdb fix_pdb(temp + filename_1_movement + pdb) fix_pdb(temp + filename_2_movement + pdb) # merge to single pdb file # pymol.finish_launching(['pymol', '-q']) # pymol: -q quiet launch, -c no gui, -e fullscreen # cmd = pymol.cmd while (not (os.path.isfile(temp + "both_1_2" + pdb))): p1 = pymol2.PyMOL() p1.start() cmd = p1.cmd cmd.reinitialize() sleep(0.5) cmd.load(temp + filename_1_movement + pdb) cmd.load(temp + filename_2_movement + pdb) cmd.zoom() cmd.save(temp + "both_1_2" + pdb)
def make_steps_pse(self, filename: str='step.pse'): assert '.pse' in filename, f'{filename} not .pse file' with pymol2.PyMOL() as pymol: for hit in self.hits: pymol.cmd.read_molstr(Chem.MolToMolBlock(hit, kekulize=False), hit.GetProp('_Name')) for i, mod in enumerate(self.modifications): pymol.cmd.read_molstr(Chem.MolToMolBlock(mod, kekulize=False), f'step{i}') pymol.cmd.save(os.path.join(self.work_path, self.long_name, filename))
def make_pse(self, filename='test.pse', extra_mols: Optional[Chem.Mol] = None): """ This is specifically for debugging the full fragment merging mode. For general use. Please use the Victor method ``make_pse``. :param filename: :return: """ assert '.pse' in filename, 'Must be a pymol pse extension!' import pymol2 with pymol2.PyMOL() as pymol: tints = iter([ 'wheat', 'palegreen', 'lightblue', 'paleyellow', 'lightpink', 'palecyan', 'lightorange', 'bluewhite' ]) # pymol.cmd.bg_color('white') for h, hit in enumerate(self.hits): pymol.cmd.read_molstr(Chem.MolToMolBlock(hit, kekulize=False), f'hit{h}') pymol.cmd.color(next(tints), f'hit{h} and name C*') if 'scaffold' in self.modifications: pymol.cmd.read_molstr( Chem.MolToMolBlock(self.modifications['scaffold'], kekulize=False), f'scaffold') pymol.cmd.color('tv_blue', f'scaffold and name C*') if 'chimera' in self.modifications: pymol.cmd.read_molstr( Chem.MolToMolBlock(self.modifications['chimera'], kekulize=False), f'chimera') pymol.cmd.color('cyan', f'chimera and name C*') if self.positioned_mol: pymol.cmd.read_molstr( Chem.MolToMolBlock(self.positioned_mol, kekulize=False), f'followup') pymol.cmd.color('tv_green', f'followup and name C*') if self.mol_options: for i, mol in enumerate(self.mol_options): pymol.cmd.read_molstr( Chem.MolToMolBlock(mol, kekulize=False), f'opt{i}') pymol.cmd.color('grey50', f'opt{i} and name C*') pymol.cmd.hide('sticks') pymol.cmd.hide('cartoon') # there should not be.... pymol.cmd.show('lines', 'not polymer') if 'chimera' in self.modifications: pymol.cmd.show('sticks', 'chimera') if self.positioned_mol: pymol.cmd.show('sticks', 'followup') if extra_mols: for mol in extra_mols: name = mol.GetProp('_Name') pymol.cmd.read_molstr( Chem.MolToMolBlock(mol, kekulize=False), name) pymol.cmd.color('magenta', f'{name} and name C*') pymol.cmd.save(filename)
def chain_removal_block(self, block: str, chains: List): """ ** PyMOL session **: self - contained. """ with pymol2.PyMOL() as self.pymol: self.pymol.cmd.read_pdbstr(block, 'blockprotein') for chain in chains: self.pymol.cmd.remove(f'chain {chain}') self.raw_pdb = self.pymol.cmd.get_pdbstr() return self
def fix_pdb(in_filename, out_filename=None): with pymol2.PyMOL() as pymol: pymol.cmd.load(in_filename, 'S38A3') pymol.cmd.alter('chain A', 'resv+=69-1') pymol.cmd.sort() pymol.cmd.alter('chain A and resi 245-9999', 'resv+=283-245') pymol.cmd.sort() if out_filename is not None: pymol.cmd.save(out_filename) return pymol.cmd.get_pdbstr()
def make_steps_pse(self, filename: str = 'step.pse'): import pymol2 assert '.pse' in filename, f'{filename} not .pse file' with pymol2.PyMOL() as pymol: for hit in self.hits: pymol.cmd.read_molstr(Chem.MolToMolBlock(hit, kekulize=False), hit.GetProp('_Name')) for label, mod in self.modifications: pymol.cmd.read_molstr(Chem.MolToMolBlock(mod, kekulize=False), re.sub('[^\w_]', '_', label)) pymol.cmd.save( os.path.join(self.work_path, self.long_name, filename))
def testMultiInstance(self): import pymol import pymol2 p1 = pymol2.PyMOL() p2 = pymol2.PyMOL() p3 = pymol # singleton p1.start() p2.start() p1.cmd.fragment('ala') p2.cmd.fragment('trp') p3.cmd.fragment('ile') # singleton self.assertEqual(p1.cmd.count_atoms(), 10) self.assertEqual(p2.cmd.count_atoms(), 24) self.assertEqual(p3.cmd.count_atoms(), 19) # singleton p1.stop() p2.stop()
def correct_file(cls, filename: str, write: bool = True): import pymol2 with pymol2.PyMOL() as pymol: pymol.cmd.load(filename, 'prot') ss = cls().parse_pymol(pymol.cmd) with open(filename, 'r') as fh: block = fh.read() if write: with open(filename, 'w') as fh: fh.write(ss + block) return ss + block
def __init__(self): self.glarea = self.create_glarea() self.pymol = pymol2.PyMOL(self.glarea) self.slab = 50 self.zoom = 1.0 self.angle = 0.0 self.sprite = None self.zfactor = 0.005 self.Zero_pointerx = 0 self.Zero_pointery = 0 self.ZeroX = 0 self.ZeroY = 0 self.clicado = False
def __init__(self, parent, enable_ui, filename="", unit_cell=False): f = QGLFormat() f.setStencil(True) f.setRgba(True) f.setDepth(True) f.setDoubleBuffer(True) QGLWidget.__init__(self, f, parent=parent) self.setMinimumSize(250, 250) self._enable_ui = enable_ui # set pymol invocation options self.pymol = pymol2.PyMOL() # _pymolPool.getInstance() self.pymol.invocation.options.quiet = 1 del (self.pymol._COb, self.pymol.cmd) self.pymol._COb = _cmd._new(self.pymol, self.pymol.invocation.options) self.pymol.cmd = pymol2.cmd2.Cmd(self.pymol, self.pymol._COb) self.pymol.start() # other initialisation self.cmd = self.pymol.cmd self.model_name = os.path.basename(os.path.splitext(filename)[0]) self.zoom_level = 1 # self.toPymolName = self.pymol.toPymolName ### Attribute Error self._pymolProcess() if not self._enable_ui: self.pymol.cmd.set("internal_gui", 0) self.pymol.cmd.set("internal_feedback", 0) self.pymol.cmd.button("double_left", "None", "None") self.pymol.cmd.button("single_right", "None", "None") #self.pymol.start() self.pymol.cmd.bg_color(color="white") self.load(filename) self.pymol.cmd.do("set antialias, 1") self.pymol.cmd.do("set ray_trace_mode, 1") self.pymol.cmd.do("show_as spheres") self.pymol.cmd.do("set sphere_mode, 4") self.pymol.cmd.do("set internal_gui=0") self.pymol.cmd.do("zoom center, {}".format(self.zoom_level)) self._show_cell(unit_cell) self.pymol.reshape(self.width(), self.height()) self.pymol.cmd.viewport(self.width(), self.height()) self._timer = QtCore.QTimer() self._timer.setSingleShot(True) self._timer.timeout.connect(self._pymolProcess) self.resizeGL(self.width(), self.height()) #globalSettings.settingsChanged.connect(self._updateGlobalSettings) self._updateGlobalSettings()
def create_apo(cls, template_pdbfilename: str): with pymol2.PyMOL() as pymol: pymol.cmd.load(template_pdbfilename) pymol.cmd.remove('solvent') pymol.cmd.remove( 'resn DMS' ) # should run it through P Curran\s list of artefacts! apo = pymol.cmd.get_pdbstr('not resn LIG') pose = pyrosetta.Pose() pyrosetta.rosetta.core.import_pose.pose_from_pdbstring(pose, apo) scorefxn = pyrosetta.get_fa_scorefxn() relax = pyrosetta.rosetta.protocols.relax.FastRelax(scorefxn, 5) relax.apply(pose) pose.dump_pdb(cls.apo_pdbfilename)
def combine(self, probe_name: str, probe_resn: str = 'MMX') -> PDBBlocks: """ The probe_resn needs to be untaken by PDB codes for rosetta. see ``replace`` for more. Adding -load_PDB_components false during the first initialisation of pyrosetta circumvents this, but means that native ligands need to declared. :param probe_name: :param probe_resn: :return: """ with pymol2.PyMOL() as pymol: pymol.cmd.read_pdbstr(self.template.no_ligand, 'nolig') pymol.cmd.load(f'{probe_name}.pdb') return self.fill_PDBBlocks(pymol, probe_resn)
def chain_removal_file(self, infile, outfile, chains): """ Create a mutant protein based on a list of mutations on a PDB file path. :param infile: str :param outfile: str the file to save the mod as. :param chains: lsit of str chain id in the pdb loaded. :return: **PyMOL session**: self-contained. """ with pymol2.PyMOL() as self.pymol: self.pymol.cmd.set('fetch_path', self.temp_folder) self.pymol.cmd.load(infile) self._chain_removal(outfile, chains) return 1
def create_simulation(self): # pymol.finish_launching(['pymol', '-q']) # pymol: -q quiet launch, -c no gui, -e fullscreen # self.cmd = pymol.cmd p1 = pymol2.PyMOL() p1.start() self.cmd = p1.cmd # define input files to 'create_simulation_pdb': if self.num_of_proteins == '2': input_coor_name = 'both_1_2' else: input_coor_name = '_1_' try: # run OpenMM: input_coor_name = self.temp + input_coor_name + pdb fix_pdb(input_coor_name) scr(input_coor_name, self.temperature, self.time_step_number, self.user_rand) # save the DCD file using PyMOL self.cmd.reinitialize() sleep(0.5) self.cmd.load(input_coor_name) self.cmd.load_traj(self.temp + 'trajectory.dcd') except Exception as e: # mainly for "pymol.CmdException" print(str(e)) update_simulation_status( 'An error occurred while creating the simulation. Please try again later.', self.user_rand) return try: # create the animations: update_simulation_status('Creates the animations', self.user_rand) create_movies_from_different_angles( self.cmd, self.user_rand, input_coor_name, self.temp + 'trajectory.dcd') # create movies in media/movies folder except Exception as e: # mainly for "pymol.CmdException" print(str(e)) update_simulation_status( 'An error occurred while creating the animations. Please try again later.', self.user_rand) return # complete simulation: update_simulation_status('Done!', self.user_rand)
def make_pse(self, filename: str = 'combo.pse', extra_mols: Optional[Chem.Mol] = None): """ Save a pse in the relevant folder. This is the Victor one. """ assert '.pse' in filename, f'{filename} not .pse file' if extra_mols is None: extra_mols = [] # ------------------------ import pymol2 with pymol2.PyMOL() as pymol: for hit in self.hits: hit_name = hit.GetProp('_Name') pymol.cmd.read_molstr(Chem.MolToMolBlock(hit), hit_name) if self.monster is None: pymol.cmd.color('grey50', f'element C and {hit_name}') elif hit_name in self.monster.unmatched: pymol.cmd.color('black', f'element C and {hit_name}') else: pymol.cmd.color('white', f'element C and {hit_name}') if self.monster is not None and self.monster.positioned_mol is not None: pymol.cmd.read_molstr( Chem.MolToMolBlock(self.monster.positioned_mol), 'placed') pymol.cmd.color('magenta', f'element C and placed') pymol.cmd.zoom('byres (placed expand 4)') pymol.cmd.show('line', 'byres (placed around 4)') if self.minimised_mol is not None: pymol.cmd.read_molstr(Chem.MolToMolBlock(self.minimised_mol), 'minimised') pymol.cmd.color('green', f'element C and minimised') if self.minimised_pdbblock is not None: pymol.cmd.read_pdbstr(self.minimised_pdbblock, 'min_protein') pymol.cmd.color('gray50', f'element C and min_protein') pymol.cmd.hide('sticks', 'min_protein') if self.unminimised_pdbblock is not None: pymol.cmd.read_pdbstr(self.unminimised_pdbblock, 'unmin_protein') pymol.cmd.color('gray20', f'element C and unmin_protein') pymol.cmd.hide('sticks', 'unmin_protein') pymol.cmd.disable('unmin_protein') for mol in extra_mols: name = mol.GetProp('_Name') pymol.cmd.read_molstr(Chem.MolToMolBlock(mol, kekulize=False), name) pymol.cmd.color('magenta', f'{name} and name C*') pymol.cmd.save( os.path.join(self.work_path, self.long_name, filename))
def pdb_and_dcd_match(pdb_file_name, dcd_file_name, user_rand): # pymol.finish_launching(['pymol', '-q']) # pymol: -q quiet launch, -c no gui, -e fullscreen # cmd = pymol.cmd p1 = pymol2.PyMOL() p1.start() cmd = p1.cmd try: cmd.reinitialize() sleep(0.5) cmd.load(temp + user_rand + '/' + pdb_file_name) cmd.load_traj(temp + user_rand + '/' + dcd_file_name) return True except Exception as e: print(str(e)) return False
def dehydrate_block(self, block: str, water: bool = False, ligand: bool = False): """ **PyMOL session**: self-contained. """ with pymol2.PyMOL() as self.pymol: self.pymol.cmd.read_pdbstr(block, 'blockprotein') if water: self.pymol.cmd.remove('solvent') if ligand: self.pymol.cmd.remove(' or '.join( [f'resn {l}' for l in self.boring_ligand])) self.raw_pdb = self.pymol.cmd.get_pdbstr() return self
def render_mrc_pdb_overlays(mrc_filename: str = None, result_folder: str = 'test_folder') -> None: if mrc_filename is None: mrc_filename = glob.glob(os.path.join(result_folder, '*.mrc'))[0] filename_density = os.path.join(result_folder, mrc_filename) pymol = pymol2.PyMOL() pymol.start() for pdb_filename in glob.glob(os.path.join(result_folder, '*.pdb')): root_file, _ = os.path.splitext(pdb_filename) pymol.cmd.do('reinitialize') pymol.cmd.do('bg_color white') pymol.cmd.do('hide all') pymol.cmd.do('show cartoon') pymol.cmd.do('load %s' % filename_density) pymol.cmd.do('load %s' % pdb_filename) pymol.cmd.do("matrix_copy %s, %s" % (pdb_filename, filename_density)) pymol.cmd.do('png %s' % root_file + ".png")
def prepare_template(self) -> PDBBlocks: """ Part of instatiation for ``self.template``. :return: a PDBBlocks namedtuple (all, no_ligand, only_ligand). """ with pymol2.PyMOL() as pymol: if len(self.code) == 4: pymol.cmd.fetch(self.code) elif '.pdb' in self.code: # file. pymol.cmd.load(self.code) else: raise ValueError pymol.cmd.remove('solvent') pymol.cmd.h_add('*') pymol.cmd.alter('all', 'segi=""') pymol.cmd.sort() return self.fill_PDBBlocks(pymol, self.ref_resn)
def __init__(self, parent, enableUi=True, File="", play=False, sequence=False): #enableUi=True f = QGLFormat() f.setStencil(True) f.setRgba(True) f.setDepth(True) f.setDoubleBuffer(True) self.play = play self.nFrames = 0 QGLWidget.__init__(self, f, parent=parent) self.setMinimumSize(200, 150) self._enableUi = enableUi self.pymol = pymol2.PyMOL() # _pymolPool.getInstance() self.pymol.start() self.cmd = self.pymol.cmd self.toPymolName = self.pymol.toPymolName ### Attribute Error self._pymolProcess() if not self._enableUi: self.pymol.cmd.set("internal_gui", 0) self.pymol.cmd.set("internal_feedback", 1) self.pymol.cmd.button("double_left", "None", "None") self.pymol.cmd.button("single_right", "None", "None") self.pymol.cmd.set("internal_gui_mode", "0") self.pymol.cmd.set("internal_feedback", "0") if sequence: self.pymol.cmd.set("seq_view", "1") if File is not "": self.nFrames += 1 self.pymol.cmd.load(File, 'p', self.nFrames) self.pymol.reshape(self.width(), self.height()) self._timer = QtCore.QTimer() self._timer.setSingleShot(True) self._timer.timeout.connect(self._pymolProcess) self.resizeGL(self.width(), self.height()) #globalSettings.settingsChanged.connect(self._updateGlobalSettings) self._updateGlobalSettings()