def testMMTF(self):
'''Styled MMTF export/import'''
S = 0b10 # 1 << 1 spheres
D = 0b1000000000 # 1 << 9 dots
B = 2 # blue
R = 4 # red
cmd.fragment('gly')
cmd.color(B)
cmd.color(R, 'elem C')
cmd.show_as('spheres')
cmd.show_as('dots', 'elem C')
with testing.mktemp('.mmtf') as filename:
cmd.save(filename)
cmd.delete('*')
cmd.load(filename)
color_list = []
reps_list = []
cmd.iterate('*', 'color_list.append(color)', space=locals())
cmd.iterate('*', 'reps_list.append(reps)', space=locals())
self.assertEqual(color_list, [B, R, R, B, B, B, B])
self.assertEqual(reps_list, [S, D, D, S, S, S, S])
def testSaveRef(self, format):
# for rms_cur (not all formats save all identifiers)
m = -1
cmd.set('retain_order')
cmd.fragment('ala', 'm1')
cmd.copy('m2', 'm1')
cmd.copy('m3', 'm1')
cmd.rotate('y', 90, 'm2')
cmd.align('m3', 'm2')
# with ref=m3
with testing.mktemp('.' + format) as filename:
cmd.save(filename, 'm2', ref='m3')
cmd.load(filename, 'm4')
self.assertAlmostEqual(cmd.rms_cur('m4', 'm1', matchmaker=m), 0.00, delta=1e-2)
self.assertAlmostEqual(cmd.rms_cur('m4', 'm2', matchmaker=m), 1.87, delta=1e-2)
# without ref
with testing.mktemp('.' + format) as filename:
cmd.save(filename, 'm2')
cmd.load(filename, 'm5')
self.assertAlmostEqual(cmd.rms_cur('m5', 'm2', matchmaker=m), 0.00, delta=1e-2)
self.assertAlmostEqual(cmd.rms_cur('m5', 'm1', matchmaker=m), 1.87, delta=1e-2)
def testMultifilesave(self):
import glob
for name in ['ala', 'gly', 'his', 'arg']:
cmd.fragment(name)
# multistate
for i in range(2, 11):
cmd.create('ala', 'ala', 1, i)
for fmt in ['{}-{:02}.cif', '{}-{state}.cif']:
with testing.mkdtemp() as dirname:
cmd.multifilesave(os.path.join(dirname, fmt), 'ala', 0)
filenames = [os.path.basename(p) for p in glob.glob(os.path.join(dirname, '*.cif'))]
self.assertEqual(len(filenames), 10)
self.assertTrue('ala-03.cif' in filenames)
with testing.mkdtemp() as dirname:
cmd.multifilesave(os.path.join(dirname, '{}.pdb'), 'a* g*')
filenames_full = sorted(glob.glob(os.path.join(dirname, '*.pdb')))
filenames = [os.path.basename(p) for p in filenames_full]
self.assertEqual(filenames, ['ala.pdb', 'arg.pdb', 'gly.pdb'])
cmd.delete('*')
cmd.load(filenames_full[0])
self.assertEqual(cmd.count_atoms(), 10)
cmd.delete('*')
cmd.load(filenames_full[1])
self.assertEqual(cmd.count_atoms(), 24)
def testglTF(self):
'''glTF export'''
cmd.fragment('gly')
with testing.mktemp('.gltf') as filename:
self.assertEqual(cmd.save(filename), 0)
cmd.delete('*')
def test(self):
cmd.viewport(100, 100)
# make map
cmd.fragment('gly', 'm1')
cmd.set('gaussian_b_floor', 30)
cmd.set('mesh_width', 5)
cmd.map_new('map')
cmd.delete('m1')
# make mesh
cmd.isomesh('mesh', 'map')
# check mesh presence by color
meshcolor = 'red'
cmd.color(meshcolor, 'mesh')
self.ambientOnly()
self.assertImageHasColor(meshcolor)
# continue without map
cmd.delete('map')
with testing.mktemp('.pse') as filename:
cmd.save(filename)
cmd.delete('*')
self.assertImageHasNotColor(meshcolor)
cmd.load(filename)
self.assertImageHasColor(meshcolor)
def test(self):
cmd.fragment('ala')
cmd.ray(100, 100)
img = self.get_imagearray() # cmd.png without optional arguments
# bug was: ray tracing twice, second time would not be 100x100
self.assertEqual(img.shape[:2], (100, 100))
def testMultifilesave(self):
import glob
for name in ['ala', 'gly', 'his', 'arg']:
cmd.fragment(name)
# multistate
for i in range(2, 11):
cmd.create('ala', 'ala', 1, i)
for fmt in ['{}-{:02}.cif', '{}-{state}.cif']:
with testing.mkdtemp() as dirname:
cmd.multifilesave(os.path.join(dirname, fmt), 'ala', 0)
filenames = [os.path.basename(p) for p in glob.glob(os.path.join(dirname, '*.cif'))]
self.assertEqual(len(filenames), 10)
self.assertTrue('ala-03.cif' in filenames)
with testing.mkdtemp() as dirname:
cmd.multifilesave(os.path.join(dirname, '{}.pdb'), 'a* g*')
filenames_full = sorted(glob.glob(os.path.join(dirname, '*.pdb')))
filenames = [os.path.basename(p) for p in filenames_full]
self.assertEqual(filenames, ['ala.pdb', 'arg.pdb', 'gly.pdb'])
cmd.delete('*')
cmd.load(filenames_full[0])
self.assertEqual(cmd.count_atoms(), 10)
cmd.delete('*')
cmd.load(filenames_full[1])
self.assertEqual(cmd.count_atoms(), 24)
def test(self):
cmd.viewport(100, 100)
# make map
cmd.fragment('gly', 'm1')
cmd.set('gaussian_b_floor', 30)
cmd.set('mesh_width', 5)
cmd.map_new('map')
cmd.delete('m1')
# make mesh
cmd.isomesh('mesh', 'map')
# check mesh presence by color
meshcolor = 'red'
cmd.color(meshcolor, 'mesh')
self.ambientOnly()
self.assertImageHasColor(meshcolor)
# continue without map
cmd.delete('map')
with testing.mktemp('.pse') as filename:
cmd.save(filename)
cmd.delete('*')
self.assertImageHasNotColor(meshcolor)
cmd.load(filename)
self.assertImageHasColor(meshcolor)
def testMMTF(self):
'''Styled MMTF export/import'''
S = 0b10 # 1 << 1 spheres
D = 0b1000000000 # 1 << 9 dots
B = 2 # blue
R = 4 # red
cmd.fragment('gly')
cmd.color(B)
cmd.color(R, 'elem C')
cmd.show_as('spheres')
cmd.show_as('dots', 'elem C')
with testing.mktemp('.mmtf') as filename:
cmd.save(filename)
cmd.delete('*')
cmd.load(filename)
color_list = []
reps_list = []
cmd.iterate('*', 'color_list.append(color)', space=locals())
cmd.iterate('*', 'reps_list.append(reps)', space=locals())
self.assertEqual(color_list, [B, R, R, B, B, B, B])
self.assertEqual(reps_list, [S, D, D, S, S, S, S])
def testSaveRef(self, format):
# for rms_cur (not all formats save all identifiers)
m = -1
cmd.set('retain_order')
cmd.fragment('ala', 'm1')
cmd.copy('m2', 'm1')
cmd.copy('m3', 'm1')
cmd.rotate('y', 90, 'm2')
cmd.align('m3', 'm2')
# with ref=m3
with testing.mktemp('.' + format) as filename:
cmd.save(filename, 'm2', ref='m3')
cmd.load(filename, 'm4')
self.assertAlmostEqual(cmd.rms_cur('m4', 'm1', matchmaker=m), 0.00, delta=1e-2)
self.assertAlmostEqual(cmd.rms_cur('m4', 'm2', matchmaker=m), 1.87, delta=1e-2)
# without ref
with testing.mktemp('.' + format) as filename:
cmd.save(filename, 'm2')
cmd.load(filename, 'm5')
self.assertAlmostEqual(cmd.rms_cur('m5', 'm2', matchmaker=m), 0.00, delta=1e-2)
self.assertAlmostEqual(cmd.rms_cur('m5', 'm1', matchmaker=m), 1.87, delta=1e-2)
def test_colors(self):
cmd.fragment('gly')
pymol.util.colors("jmol")
stored.colors = set()
cmd.iterate('elem C', 'stored.colors.add(color)')
colors = [get_color_tuple(c, 3) for c in stored.colors]
self.assertEqual(colors, [(0.567, 0.567, 0.567)])
def test(self):
cmd.viewport(100,100)
cmd.set('gaussian_b_floor', 20)
cmd.set('ambient', 1)
cmd.set('specular', 0)
cmd.set('mesh_color', 'blue')
cmd.set('dot_color', 'green')
cmd.fragment('gly')
cmd.map_new('map1')
cmd.disable('*')
cmd.isomesh('o1', 'map1')
cmd.color('red', 'o1')
cmd.show('cell')
self._check_colors('red', 'blue')
cmd.delete('o1')
cmd.isodot('o1', 'map1')
cmd.color('red', 'o1')
self._check_colors('green')
cmd.delete('o1')
cmd.gradient('o1', 'map1')
cmd.color('yellow', 'o1')
self._check_colors('yellow')
cmd.delete('o1')
def testIdAtom(self):
cmd.fragment('gly', 'm1')
self.assertEqual(cmd.id_atom('ID 3'), 3)
self.assertEqual(cmd.id_atom('ID 3', 1), ('m1', 3))
cmd.feedback("disable", "cmd", "errors")
self.assertRaises(CmdException, cmd.id_atom, 'ID 3+4')
self.assertRaises(CmdException, cmd.id_atom, 'ID 100')
def testGetType(self):
cmd.fragment('gly', 'm1')
self.assertEqual(cmd.get_type('m1'), 'object:molecule')
cmd.ramp_new('ramp1', 'none')
self.assertEqual(cmd.get_type('ramp1'), 'object:ramp')
cmd.select('s1', 'elem C')
self.assertEqual(cmd.get_type('s1'), 'selection')
def testPairFit(self):
cmd.fragment('trp')
cmd.fragment('his')
# 1 atom
sele = ('trp and guide', 'his and guide')
pos = list(map(cmd.get_atom_coords, sele))
vec = cpv.sub(*pos)
mat_ref = [
1.0, 0.0, 0.0, -vec[0],
0.0, 1.0, 0.0, -vec[1],
0.0, 0.0, 1.0, -vec[2],
0.0, 0.0, 0.0, 1.0]
rms = cmd.pair_fit(*sele)
self.assertEqual(rms, 0.0)
mat = cmd.get_object_matrix('trp')
self.assertArrayEqual(mat, mat_ref, 1e-4)
# 2 atoms
sele += ('trp & name CB', 'his & name CB')
rms = cmd.pair_fit(*sele)
self.assertAlmostEqual(rms, 0.0082, delta=1e-4)
# 4 atoms
sele += ('trp & name CG', 'his & name CG',
'trp & name CD1', 'his & name CD2')
rms = cmd.pair_fit(*sele)
self.assertAlmostEqual(rms, 0.0713, delta=1e-4)
def testNumeric(self):
cmd.fragment('ala')
cmd.alter_state(1, 'all', 'p.x, p.y, p.index = x, y, index')
cmd.select('sele_p_x', 'p.x < 0')
cmd.select('sele_p_y', 'p.y > 0')
cmd.select('sele_p_i', 'p.index = 3')
cmd.select('sele_x', 'x < 0.0')
cmd.select('sele_y', 'y > 0.0')
cmd.select('sele_i', 'index 3')
counts = [
cmd.count_atoms('sele_p_x'),
cmd.count_atoms('sele_x'),
cmd.count_atoms('sele_x & sele_p_x'),
]
self.assertEqual(counts[0], 8)
self.assertEqual(counts[0], counts[1])
self.assertEqual(counts[0], counts[2])
counts = [
cmd.count_atoms('sele_p_y'),
cmd.count_atoms('sele_y'),
cmd.count_atoms('sele_y & sele_p_y'),
]
self.assertEqual(counts[0], 6)
self.assertEqual(counts[0], counts[1])
self.assertEqual(counts[0], counts[2])
counts = [
cmd.count_atoms('sele_i'),
cmd.count_atoms('sele_p_i'),
cmd.count_atoms('sele_i & sele_p_i'),
]
self.assertEqual(counts[0], 1)
self.assertEqual(counts[0], counts[1])
self.assertEqual(counts[0], counts[2])
def testByRing(self):
cmd.fragment('trp')
self.assertEqual(cmd.count_atoms('byring name CB'), 0)
self.assertEqual(cmd.count_atoms('byring name CG'), 5)
self.assertEqual(cmd.count_atoms('byring name CD2'), 9)
self.assertEqual(cmd.count_atoms('byring name CE3'), 6)
self.assertEqual(cmd.count_atoms('byring all'), 9)
def test_msms_surface():
eps = 1e-3
cmd.reinitialize()
cmd.fragment('ala', 'm1')
# default
psico.msms.msms_surface(name='surf1')
extent = cmd.get_extent('surf1')
assert extent[0] == approx([-2.705, -3.208, -2.413], rel=eps)
assert extent[1] == approx([3.530, 2.907, 2.676], rel=eps)
# global solvent_radius
cmd.set('solvent_radius', 3.5)
psico.msms.msms_surface(name='surf2')
extent = cmd.get_extent('surf2')
assert extent[0] == approx([-2.705, -3.169, -2.436], rel=eps)
assert extent[1] == approx([3.530, 2.907, 2.676], rel=eps)
# object-level solvent_radius
cmd.set('solvent_radius', 2.8, 'm1')
psico.msms.msms_surface(name='surf3')
extent = cmd.get_extent('surf3')
assert extent[0] == approx([-2.705, -3.161, -2.427], rel=eps)
assert extent[1] == approx([3.530, 2.907, 2.676], rel=eps)
# modified atom radii
cmd.alter('m1', 'vdw = 3.0')
psico.msms.msms_surface(name='surf4')
extent = cmd.get_extent('surf4')
assert extent[0] == approx([-4.605, -5.162, -4.418], rel=eps)
assert extent[1] == approx([5.030, 4.861, 4.681], rel=eps)
def testCifMissing(self):
N = 7
cmd.fragment('gly', 'm1')
cmd.alter('all', '(chain, segi, resv, alt) = ("?", ".", 5, "")')
s = cmd.get_str('cif')
self.assertTrue("'?'" in s or '"?"' in s) # chain
self.assertTrue("'.'" in s or '"."' in s) # segi
self.assertTrue(' ? ' in s) # e.g. pdbx_PDB_ins_code
self.assertTrue(' . ' in s) # e.g. label_alt_id
cmd.delete('*')
cmd.set('cif_keepinmemory')
cmd.load(s, 'm2', format='cifstr')
self.assertEqual(['?'], cmd.get_chains())
self.assertEqual(cmd.count_atoms('segi .'), N)
self.assertEqual(cmd.count_atoms('alt ""'), N) # no alt
self.assertEqual(cmd.count_atoms('resi 5'), N) # no ins_code
from pymol.querying import cif_get_array
self.assertEqual(cif_get_array("m2", "_atom_site.type_symbol"), list('NCCOHHH'))
self.assertEqual(cif_get_array("m2", "_atom_site.id", "i"), list(range(1, N + 1)))
self.assertEqual(cif_get_array("m2", "_atom_site.auth_asym_id"), ['?'] * N)
self.assertEqual(cif_get_array("m2", "_atom_site.label_asym_id"), ['.'] * N)
self.assertEqual(cif_get_array("m2", "_atom_site.pdbx_pdb_ins_code"), [None] * N)
self.assertEqual(cif_get_array("m2", "_atom_site.label_alt_id"), [None] * N)
def testLoadCoords(self):
import numpy
cmd.fragment('gly', 'm1')
coords = cmd.get_coords('m1')
coords += 5.0
cmd.load_coords(coords, 'm1')
self.assertTrue(numpy.allclose(coords, cmd.get_coords('m1')))
def testPairFit(self):
cmd.fragment('trp')
cmd.fragment('his')
# 1 atom
sele = ('trp and guide', 'his and guide')
pos = list(map(cmd.get_atom_coords, sele))
vec = cpv.sub(*pos)
mat_ref = [
1.0, 0.0, 0.0, -vec[0], 0.0, 1.0, 0.0, -vec[1], 0.0, 0.0, 1.0,
-vec[2], 0.0, 0.0, 0.0, 1.0
]
rms = cmd.pair_fit(*sele)
self.assertEqual(rms, 0.0)
mat = cmd.get_object_matrix('trp')
self.assertArrayEqual(mat, mat_ref, 1e-4)
# 2 atoms
sele += ('trp & name CB', 'his & name CB')
rms = cmd.pair_fit(*sele)
self.assertAlmostEqual(rms, 0.0082, delta=1e-4)
# 4 atoms
sele += ('trp & name CG', 'his & name CG', 'trp & name CD1',
'his & name CD2')
rms = cmd.pair_fit(*sele)
self.assertAlmostEqual(rms, 0.0713, delta=1e-4)
def test_h_add_state(self):
nheavy = 4
nhydro = 5
nfull = nheavy + nhydro
cmd.fragment('gly', 'm1')
cmd.remove('hydro')
self.assertEqual(nheavy, cmd.count_atoms())
cmd.h_add()
self.assertEqual(nfull, cmd.count_atoms())
# multi-state
cmd.remove('hydro')
cmd.create('m1', 'm1', 1, 2)
cmd.create('m1', 'm1', 1, 3)
cmd.h_add(state=2)
self.assertEqual(nfull, cmd.count_atoms())
self.assertEqual(nheavy, cmd.count_atoms('state 1'))
self.assertEqual(nfull, cmd.count_atoms('state 2'))
self.assertEqual(nheavy, cmd.count_atoms('state 3'))
# discrete multi-state
cmd.remove('hydro')
cmd.create('m2', 'm1', 1, 1, discrete=1)
cmd.create('m2', 'm2', 1, 2, discrete=1)
cmd.create('m2', 'm2', 1, 3, discrete=1)
self.assertEqual(nheavy * 3, cmd.count_atoms('m2'))
cmd.h_add('m2 & state 2') # TODO , state=2)
self.assertEqual(nfull + nheavy * 2, cmd.count_atoms('m2'))
self.assertEqual(nheavy, cmd.count_atoms('m2 & state 1'))
self.assertEqual(nfull, cmd.count_atoms('m2 & state 2'))
self.assertEqual(nheavy, cmd.count_atoms('m2 & state 3'))
cmd.h_add('m2')
self.assertEqual(nfull * 3, cmd.count_atoms('m2'))
def testIgnoreCase(self):
# check defaults
self.assertEqual(cmd.get_setting_int('ignore_case'), 1)
self.assertEqual(cmd.get_setting_int('ignore_case_chain'), 0)
# data
natoms = 10
cmd.fragment('ala', 'm1')
cmd.copy('m2', 'm1')
cmd.alter('m1', 'chain, segi = "C", "S"')
cmd.alter('m2', 'chain, segi = "c", "s"')
cmd.alter('m2', 'resn, name = resn.lower(), name.lower()')
self.assertEqual(cmd.count_atoms('chain C'), natoms)
self.assertEqual(cmd.count_atoms('segi S'), natoms)
self.assertEqual(cmd.count_atoms('chain c'), natoms)
self.assertEqual(cmd.count_atoms('segi s'), natoms)
self.assertEqual(cmd.count_atoms('resn ALA'), natoms * 2)
self.assertEqual(cmd.count_atoms('resn ala'), natoms * 2)
self.assertEqual(cmd.count_atoms('name CA'), 2)
self.assertEqual(cmd.count_atoms('name ca'), 2)
cmd.set('ignore_case_chain')
self.assertEqual(cmd.count_atoms('chain C'), natoms * 2)
self.assertEqual(cmd.count_atoms('segi S'), natoms * 2)
self.assertEqual(cmd.count_atoms('chain c'), natoms * 2)
self.assertEqual(cmd.count_atoms('segi s'), natoms * 2)
cmd.set('ignore_case', 0)
self.assertEqual(cmd.count_atoms('resn ALA'), natoms)
self.assertEqual(cmd.count_atoms('resn ala'), natoms)
self.assertEqual(cmd.count_atoms('name CA'), 1)
self.assertEqual(cmd.count_atoms('name ca'), 1)
def test_colors(self):
cmd.fragment('gly')
pymol.util.colors("jmol")
stored.colors = set()
cmd.iterate('elem C', 'stored.colors.add(color)')
colors = [get_color_tuple(c, 3) for c in stored.colors]
self.assertEqual(colors, [(0.567, 0.567, 0.567)])
def testGetObjectMatrix(self):
identity = (1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0)
mat_x90 = (1.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 0.0, 1.0)
cmd.fragment('ala', 'm1')
cmd.fragment('gly', 'm2')
# default/identity
mat = cmd.get_object_matrix('m1', incl_ttt=1)
self.assertTrue(isinstance(mat, tuple))
self.assertArrayEqual(mat, identity, delta=1e-6)
mat = cmd.get_object_matrix('m1', incl_ttt=0)
self.assertArrayEqual(mat, identity, delta=1e-6)
# TTT
cmd.rotate('x', 90, object='m1', camera=0, object_mode=0)
mat = cmd.get_object_matrix('m1', incl_ttt=1)
self.assertArrayEqual(mat, mat_x90, delta=1e-6)
mat = cmd.get_object_matrix('m1', incl_ttt=0)
self.assertArrayEqual(mat, identity, delta=1e-6)
# state matrix
cmd.rotate('x', 90, object='m2', camera=0, object_mode=1)
mat = cmd.get_object_matrix('m2', incl_ttt=1)
self.assertArrayEqual(mat, mat_x90, delta=1e-6)
mat = cmd.get_object_matrix('m2', incl_ttt=0)
self.assertArrayEqual(mat, mat_x90, delta=1e-6)
def testSaveSelection(self, format, pymol_version):
if pymol_version > testing.PYMOL_VERSION[1]:
self.skipTest("version %f" % (pymol_version))
cmd.fragment('trp', 'm1')
cmd.fragment('glu', 'm2')
n_O = cmd.count_atoms('elem O')
n_N = cmd.count_atoms('elem N')
with testing.mktemp('.' + format) as filename:
cmd.set('raise_exceptions',
0) # 1.7.6 save xyz doesn't set r=DEFAULT_SUCCESS
cmd.save(filename, 'elem O+N')
cmd.set('raise_exceptions', 1)
if format == 'mae' and not pymol.invocation.options.incentive_product:
format = 'cms'
cmd.delete('*')
cmd.load(filename, 'm2', discrete=1,
format=format) # avoid merging of atoms
self.assertEqual(n_O, cmd.count_atoms('elem O'))
self.assertEqual(n_N, cmd.count_atoms('elem N'))
self.assertEqual(n_O + n_N, cmd.count_atoms())
def testIdentify(self):
cmd.fragment('gly', 'm1')
cmd.select('s1', 'ID 3+4')
r = cmd.identify('s1')
self.assertItemsEqual(r, [3, 4])
r = cmd.identify('s1', 1)
self.assertItemsEqual(r, [('m1', 3), ('m1', 4)])
def testIterateState(self):
cmd.fragment('ala')
cmd.create('ala', 'ala', 1, 2)
self.assertEqual(2, cmd.count_states())
v_count = cmd.count_atoms('all')
expr = 'v_xyz.append(((model,index), (x,y,z)))'
# current state
v_xyz = []
cmd.iterate_state(-1, 'all', expr, space=locals())
self.assertEqual(len(v_xyz), v_count)
# all states
v_xyz = []
cmd.iterate_state(0, 'all', expr, space=locals())
self.assertEqual(len(v_xyz), v_count * 2)
# atomic=0
stored.v_xyz = []
cmd.iterate_state(1, 'all', 'stored.v_xyz.append((x,y,z))', atomic=0)
self.assertEqual(len(stored.v_xyz), v_count)
space = {'self': self, 'NameError': NameError, 'v_list': []}
cmd.iterate_state(1, 'all',
'v_list.append(self.assertRaises(NameError, lambda: (model, index)))',
space=space)
self.assertEqual(len(space['v_list']), v_count)
def testStereo(self):
cmd.fragment('ala')
cmd.remove('hydro')
# default: S configuration
labels = []
cmd.iterate('name CA', 'labels.append(stereo)', space=locals())
self.assertEqual(labels, ['S'])
# load R configuration (moves CB)
ala_conf_R = {
'N': (-0.67690, -1.23030, -0.49050),
'CA': (-0.00090, 0.06370, -0.49050),
'C': (1.49910, -0.11030, -0.49050),
'O': (2.03010, -1.22730, -0.50150),
# 'CB' : (-0.50890, 0.85570, 0.72650), # S configuration
'CB': (-0.33784, 0.82664, -1.78310), # R configuration
}
cmd.alter_state(1,
'ala',
'(x,y,z) = ala_conf_R.get(name)',
space=locals())
labels = []
cmd.iterate('name CA', 'labels.append(stereo)', space=locals())
self.assertEqual(labels, ['R'])
def testIsolevel(self):
cmd.viewport(100, 100)
cmd.fragment('gly', 'm1')
cmd.set('gaussian_b_floor', 30)
cmd.set('mesh_width', 5)
cmd.map_new('map')
cmd.delete('m1')
# make mesh
cmd.isodot('dot', 'map')
cmd.isodot('dot', 'map', source_state=1, state=-2)
## check mesh presence by color
meshcolor = 'red'
cmd.color(meshcolor, 'dot')
self.ambientOnly()
self.assertImageHasColor(meshcolor)
cmd.frame(2)
self.assertEqual(cmd.get_state(), 2)
self.assertImageHasColor(meshcolor)
for contourlvl in range(7):
cmd.isolevel('dot', contourlvl)
self.assertImageHasColor(meshcolor)
cmd.isolevel('dot', 10)
self.assertImageHasNotColor(meshcolor)
def testFloatType(self, val1, val2):
cmd.fragment('ala')
cmd.set_property('float_property_1', val1, 'ala')
cmd.set_property('float_property_2', val2, 'ala')
self.assertAlmostEqual(cmd.get_property('float_property_1', 'ala'),
val1)
self.assertAlmostEqual(cmd.get_property('float_property_2', 'ala'),
val2)
# test setting boolean type by string
cmd.set_property('float_property_1',
str(val1),
'ala',
proptype=PROPERTY_FLOAT)
cmd.set_property('float_property_2',
str(val1),
'ala',
proptype=PROPERTY_FLOAT)
cmd.set_property('float_property_3',
str(val1),
'ala',
proptype=PROPERTY_FLOAT)
cmd.set_property('float_property_4',
str(val2),
'ala',
proptype=PROPERTY_FLOAT)
self.assertAlmostEqual(cmd.get_property('float_property_1', 'ala'),
val1)
self.assertAlmostEqual(cmd.get_property('float_property_2', 'ala'),
val1) # overwritting
self.assertAlmostEqual(cmd.get_property('float_property_3', 'ala'),
val1)
self.assertAlmostEqual(cmd.get_property('float_property_4', 'ala'),
val2)
def testTrilines(self, trilines):
cmd.viewport(100, 100)
cmd.set('use_shaders', True)
self.ambientOnly()
cmd.set('dynamic_width', 0)
cmd.set('line_width', 5)
cmd.set('line_smooth', 0)
cmd.fragment('ethylene')
cmd.show_as('lines')
cmd.color('white')
cmd.orient()
cmd.set('trilines', trilines)
# check percentage of covered pixels
img = self.get_imagearray()
npixels = img.shape[0] * img.shape[1]
covered = numpy.count_nonzero(img[..., :3])
ratio = covered / float(npixels)
msg = "covered=%d npixels=%d ratio=%f" % (covered, npixels, ratio)
self.assertTrue(0.14 < ratio < 0.165, msg)
def testIgnoreCase(self):
# check defaults
self.assertEqual(cmd.get_setting_int('ignore_case'), 1)
self.assertEqual(cmd.get_setting_int('ignore_case_chain'), 0)
# data
natoms = 10
cmd.fragment('ala', 'm1')
cmd.copy('m2', 'm1')
cmd.alter('m1', 'chain, segi = "C", "S"')
cmd.alter('m2', 'chain, segi = "c", "s"')
cmd.alter('m2', 'resn, name = resn.lower(), name.lower()')
self.assertEqual(cmd.count_atoms('chain C'), natoms)
self.assertEqual(cmd.count_atoms('segi S'), natoms)
self.assertEqual(cmd.count_atoms('chain c'), natoms)
self.assertEqual(cmd.count_atoms('segi s'), natoms)
self.assertEqual(cmd.count_atoms('resn ALA'), natoms * 2)
self.assertEqual(cmd.count_atoms('resn ala'), natoms * 2)
self.assertEqual(cmd.count_atoms('name CA'), 2)
self.assertEqual(cmd.count_atoms('name ca'), 2)
cmd.set('ignore_case_chain')
self.assertEqual(cmd.count_atoms('chain C'), natoms * 2)
self.assertEqual(cmd.count_atoms('segi S'), natoms * 2)
self.assertEqual(cmd.count_atoms('chain c'), natoms * 2)
self.assertEqual(cmd.count_atoms('segi s'), natoms * 2)
cmd.set('ignore_case', 0)
self.assertEqual(cmd.count_atoms('resn ALA'), natoms)
self.assertEqual(cmd.count_atoms('resn ala'), natoms)
self.assertEqual(cmd.count_atoms('name CA'), 1)
self.assertEqual(cmd.count_atoms('name ca'), 1)
def testAA(self):
'''
Make a black/white image and check if gray pixels are found with
antialias_shader=1/2
'''
cmd.viewport(100, 100)
cmd.set('use_shaders', True)
self.ambientOnly()
cmd.fragment('gly')
cmd.show_as('spheres')
cmd.color('white')
cmd.zoom()
# b/w image, we expect only two color values
img = self.get_imagearray()
self.assertNumColorsEqual(img, 2)
for aa in (1, 2):
cmd.set('antialias_shader', aa)
# smoothed edges, we expect more than two color values
img = self.get_imagearray()
self.assertTrue(len(numpy.unique(img[..., :3])) > 2)
def testStickBall(self, use_shader):
'''
Test some stick_ball* settings
'''
cmd.viewport(100, 100)
cmd.set('use_shaders', use_shader)
self.ambientOnly()
cmd.set('stick_ball')
cmd.set('stick_ball_ratio', 2.0)
cmd.set('stick_ball_color', 'blue')
cmd.set('stick_color', 'red')
cmd.fragment('gly')
cmd.orient()
cmd.color('green')
cmd.show_as('sticks')
img = self.get_imagearray()
self.assertImageHasColor('blue', img)
self.assertImageHasColor('red', img)
self.assertImageHasNotColor('green', img)
def testShow(self):
cmd.fragment('ala')
self.assertEqual(cmd.count_atoms('rep sticks'), 0)
cmd.show('sticks')
self.assertEqual(cmd.count_atoms('rep sticks'), 10)
cmd.hide('lines', 'not elem C')
self.assertEqual(cmd.count_atoms('rep lines'), 3)
def test_set_dihedral(self):
cmd.fragment('ala')
angle = 45.0
atoms = ('ID 7', 'ID 2', 'ID 1', 'ID 9')
cmd.set_dihedral(*atoms, angle=angle)
v = cmd.get_dihedral(*atoms)
self.assertAlmostEqual(v, angle, 4)
def test_color_deep(self):
cmd.viewport(100, 70)
self.ambientOnly()
cmd.fragment('trp', 'm1')
cmd.orient('m1')
cmd.show_as('sticks')
cmd.show('spheres', 'name C')
cmd.set('stick_color', 'blue', 'm1')
cmd.set('stick_color', 'red', 'name CH2+CZ3+CE3+CD2')
cmd.set('sphere_color', 'yellow', 'name C')
cmd.color('green')
img = self.get_imagearray()
self.assertImageHasColor('blue', img)
self.assertImageHasColor('red', img)
self.assertImageHasColor('yellow', img)
self.assertImageHasNotColor('green', img)
cmd.color_deep('green')
img = self.get_imagearray()
self.assertImageHasNotColor('blue', img)
self.assertImageHasNotColor('red', img)
self.assertImageHasNotColor('yellow', img)
self.assertImageHasColor('green', img)
def testIsosurface(self):
cmd.viewport(100, 100)
cmd.fragment('gly', 'm1')
cmd.set('gaussian_b_floor', 30)
cmd.set('mesh_width', 5)
cmd.map_new('map')
cmd.delete('m1')
# make mesh
cmd.isosurface('surface', 'map')
cmd.isosurface('surface', 'map', source_state=1, state=-2)
## check mesh presence by color
meshcolor = 'red'
cmd.color(meshcolor, 'surface')
self.ambientOnly()
self.assertImageHasColor(meshcolor)
cmd.frame(2)
self.assertEqual(cmd.get_state(), 2)
self.assertImageHasColor(meshcolor)
with testing.mktemp('.pse') as filename:
cmd.save(filename)
cmd.delete('*')
self.assertImageHasNotColor(meshcolor)
cmd.load(filename)
self.assertImageHasColor(meshcolor)
cmd.frame(2)
self.assertEqual(cmd.get_state(), 2)
self.assertImageHasColor(meshcolor)
def testIntegerType(self, val1, val2):
cmd.fragment('ala')
cmd.set_property('int_property_1', val1, 'ala')
cmd.set_property('int_property_2', val2, 'ala')
self.assertEqual(cmd.get_property('int_property_1', 'ala'), val1)
self.assertEqual(cmd.get_property('int_property_2', 'ala'), val2)
# test setting boolean type by string
cmd.set_property('int_property_1',
str(val1),
'ala',
proptype=PROPERTY_INT)
cmd.set_property('int_property_2',
str(val1),
'ala',
proptype=PROPERTY_INT)
cmd.set_property('int_property_3',
str(val1),
'ala',
proptype=PROPERTY_INT)
cmd.set_property('int_property_4',
str(val2),
'ala',
proptype=PROPERTY_INT)
self.assertEqual(cmd.get_property('int_property_1', 'ala'), val1)
self.assertEqual(cmd.get_property('int_property_2', 'ala'),
val1) # overwritting
self.assertEqual(cmd.get_property('int_property_3', 'ala'), val1)
self.assertEqual(cmd.get_property('int_property_4', 'ala'), val2)
def testTrilines(self, trilines):
cmd.viewport(100, 100)
cmd.set('use_shaders', True)
self.ambientOnly()
cmd.set('dynamic_width', 0)
cmd.set('line_width', 5)
cmd.set('line_smooth', 0)
cmd.fragment('ethylene')
cmd.show_as('lines')
cmd.color('white')
cmd.orient()
cmd.set('trilines', trilines)
# check percentage of covered pixels
img = self.get_imagearray()
npixels = img.shape[0] * img.shape[1]
covered = numpy.count_nonzero(img[...,:3])
ratio = covered / float(npixels)
msg = "covered=%d npixels=%d ratio=%f" % (covered, npixels, ratio)
self.assertTrue(0.14 < ratio < 0.165, msg)
def testBooleanType(self):
cmd.fragment('ala')
cmd.set_property('bool_property_1', True, 'ala')
cmd.set_property('bool_property_2', False, 'ala')
self.assertEqual(cmd.get_property('bool_property_1', 'ala'), True)
self.assertEqual(cmd.get_property('bool_property_2', 'ala'), False)
# test setting boolean type by string
cmd.set_property('bool_property_1',
"True",
'ala',
proptype=PROPERTY_BOOLEAN)
cmd.set_property('bool_property_2',
"True",
'ala',
proptype=PROPERTY_BOOLEAN)
cmd.set_property('bool_property_3',
"True",
'ala',
proptype=PROPERTY_BOOLEAN)
cmd.set_property('bool_property_4',
"False",
'ala',
proptype=PROPERTY_BOOLEAN)
self.assertEqual(cmd.get_property('bool_property_1', 'ala'), True)
self.assertEqual(cmd.get_property('bool_property_2', 'ala'),
True) # overwritting
self.assertEqual(cmd.get_property('bool_property_3', 'ala'), True)
self.assertEqual(cmd.get_property('bool_property_4', 'ala'), False)
def testAA(self):
'''
Make a black/white image and check if gray pixels are found with
antialias_shader=1/2
'''
cmd.viewport(100, 100)
cmd.set('use_shaders', True)
self.ambientOnly()
cmd.fragment('gly')
cmd.show_as('spheres')
cmd.color('white')
cmd.zoom()
# b/w image, we expect only two color values
img = self.get_imagearray()
self.assertTrue(len(numpy.unique(img[...,:3])) == 2)
for aa in (1, 2):
cmd.set('antialias_shader', aa)
# smoothed edges, we expect more than two color values
img = self.get_imagearray()
self.assertTrue(len(numpy.unique(img[...,:3])) > 2)
def testStickBall(self, use_shader):
'''
Test some stick_ball* settings
'''
cmd.viewport(100, 100)
cmd.set('use_shaders', use_shader)
self.ambientOnly()
cmd.set('stick_ball')
cmd.set('stick_ball_ratio', 2.0)
cmd.set('stick_ball_color', 'blue')
cmd.set('stick_color', 'red')
cmd.fragment('gly')
cmd.orient()
cmd.color('green')
cmd.show_as('sticks')
img = self.get_imagearray()
self.assertImageHasColor('blue', img)
self.assertImageHasColor('red', img)
self.assertImageHasNotColor('green', img)
def testCifMissing(self):
N = 7
cmd.fragment('gly', 'm1')
cmd.alter('all', '(chain, segi, resv, alt) = ("?", ".", 5, "")')
s = cmd.get_str('cif')
self.assertTrue("'?'" in s or '"?"' in s) # chain
self.assertTrue("'.'" in s or '"."' in s) # segi
self.assertTrue(' ? ' in s) # e.g. pdbx_PDB_ins_code
self.assertTrue(' . ' in s) # e.g. label_alt_id
cmd.delete('*')
cmd.set('cif_keepinmemory')
cmd.load(s, 'm2', format='cifstr')
self.assertEqual(['?'], cmd.get_chains())
self.assertEqual(cmd.count_atoms('segi .'), N)
self.assertEqual(cmd.count_atoms('alt ""'), N) # no alt
self.assertEqual(cmd.count_atoms('resi 5'), N) # no ins_code
from pymol.querying import cif_get_array
self.assertEqual(cif_get_array("m2", "_atom_site.type_symbol"),
list('NCCOHHH'))
self.assertEqual(cif_get_array("m2", "_atom_site.id", "i"),
list(range(1, N + 1)))
self.assertEqual(cif_get_array("m2", "_atom_site.auth_asym_id"),
['?'] * N)
self.assertEqual(cif_get_array("m2", "_atom_site.label_asym_id"),
['.'] * N)
self.assertEqual(cif_get_array("m2", "_atom_site.pdbx_pdb_ins_code"),
[None] * N)
self.assertEqual(cif_get_array("m2", "_atom_site.label_alt_id"),
[None] * N)
def testLoadCoords(self):
import numpy
cmd.fragment('gly', 'm1')
coords = cmd.get_coords('m1')
coords += 5.0
cmd.load_coords(coords, 'm1')
self.assertTrue(numpy.allclose(coords, cmd.get_coords('m1')))
def test(self):
cmd.fragment('ala')
cmd.ray(100, 100)
img = self.get_imagearray() # cmd.png without optional arguments
# bug was: ray tracing twice, second time would not be 100x100
self.assertEqual(img.shape[:2], (100,100))
def testCOLLADA(self):
cmd.fragment('gly')
for rep in ['spheres', 'sticks', 'surface']:
cmd.show_as(rep)
with testing.mktemp('.dae') as filename:
cmd.save(filename)
contents = file_get_contents(filename)
self.assertTrue('<COLLADA' in contents)
def _test_cba(self, fun, expected_color):
cmd.fragment('gly')
cmd.color('white')
fun('*')
stored.colors = set()
cmd.iterate('elem C', 'stored.colors.add(color)')
colors = [get_color_tuple(c, 3) for c in stored.colors]
self.assertEqual(colors, [expected_color])
def testPop(self):
cmd.fragment("ala")
cmd.select("src", "ala")
# iterate across the 10 atoms in ala
cnt = 0
while cmd.pop("tmp","src"):
cnt+=1
self.assertEquals(cnt,10)
def testGetSession(self):
cmd.fragment('ala')
x = cmd.count_atoms()
s = cmd.get_session()
cmd.reinitialize()
cmd.set_session(s)
self.assertEqual(['ala'], cmd.get_names())
self.assertEqual(x, cmd.count_atoms())
def test_invert(self):
cmd.fragment('ala')
xyzfix = get_coord_list('ID 1-7')
xyzmov = get_coord_list('ID 0+8+9')
cmd.edit('ID 1', 'ID 2', 'ID 3')
cmd.invert()
self.assertEqual(xyzfix, get_coord_list('ID 1-7'))
self.assertNotEqual(xyzmov, get_coord_list('ID 0+8+9'))
def testMappend(self):
self.prep_movie()
cmd.fragment("ala")
cmd.mappend(5,"delete *")
cmd.mappend(5,"frame 1")
cmd.frame(5)
self.assertEquals(len(cmd.get_names()),0)
self.assertEquals(cmd.get_frame(),1)
def testVRML(self):
cmd.fragment('gly')
for rep in ['spheres', 'sticks', 'surface']:
cmd.show_as(rep)
with testing.mktemp('.wrl') as filename:
cmd.save(filename)
contents = file_get_contents(filename)
self.assertTrue(contents.startswith('#VRML V2'))
def testScene(self):
cmd.fragment('ala', 'm1')
cmd.fragment('gly', 'm2')
cmd.create('m2', 'm2', 1, 2)
cmd.create('m2', 'm2', 1, 3)
cmd.create('m2', 'm2', 1, 4)
# store
cmd.show_as('sticks', 'm1')
cmd.show_as('spheres', 'm2')
cmd.color('blue', 'm1')
cmd.color('yellow', 'm2')
view_001 = cmd.get_view()
cmd.scene('new', 'store', 'hello world')
# store
cmd.frame(3)
cmd.show_as('lines')
cmd.color('red')
cmd.turn('x', 45)
view_002 = cmd.get_view()
cmd.scene('new', 'store')
# we actually don't know the auto naming counter
# self.assertEqual(cmd.get_scene_list(), ['001', '002'])
names = cmd.get_scene_list()
# recall
cmd.scene(names[0], 'recall', animate=0)
self.assertArrayEqual(view_001, cmd.get_view(), delta=1e-3)
self.assertEqual(cmd.count_atoms('m1'), cmd.count_atoms('color blue'))
self.assertEqual(cmd.count_atoms('m1'), cmd.count_atoms('rep sticks'))
self.assertEqual(cmd.count_atoms('m2'), cmd.count_atoms('color yellow'))
self.assertEqual(cmd.count_atoms('m2'), cmd.count_atoms('rep spheres'))
self.assertNotEqual(cmd.get_wizard(), None)
self.assertEqual(cmd.get_state(), 1)
# recall
cmd.scene(names[1], 'recall', animate=0)
self.assertArrayEqual(view_002, cmd.get_view(), delta=1e-3)
self.assertEqual(0, cmd.count_atoms('color blue'))
self.assertEqual(0, cmd.count_atoms('rep sticks'))
self.assertEqual(cmd.count_atoms(), cmd.count_atoms('color red'))
self.assertEqual(cmd.count_atoms(), cmd.count_atoms('rep lines'))
self.assertEqual(cmd.get_wizard(), None)
self.assertEqual(cmd.get_state(), 3)
# with movie (not playing) it must not recall the state
cmd.mset('1-4')
cmd.frame(1)
cmd.scene(names[1], 'recall', animate=0)
self.assertEqual(cmd.get_state(), 1)
# rename and delete
cmd.scene('F2', 'store')
cmd.scene(names[0], 'rename', new_key='F1')
cmd.scene(names[1], 'delete')
self.assertEqual(cmd.get_scene_list(), ['F1', 'F2'])
def test_torsion(self):
cmd.fragment('ala')
delta = 10
atoms = ('ID 7', 'ID 2', 'ID 1', 'ID 9')
d1 = cmd.get_dihedral(*atoms)
cmd.edit(*atoms[1:3])
cmd.torsion(delta)
d2 = cmd.get_dihedral(*atoms)
self.assertAlmostEqual(d1 + delta, d2, 4)
def build(object_name, sequence, first_residue = "1"):
if len(sequence):
code = sequence[0]
cmd.fragment(aa_dict[code],object_name)
cmd.alter(object_name,'resi="%s"'%first_residue)
cmd.edit(object_name+" and name C")
for code in sequence[1:]:
editor.attach_amino_acid("pk1",aa_dict[code])
cmd.edit()
