def test_polyala():
cmd.reinitialize()
cmd.fab('EFG', 'm1')
psico.editing.polyala()
assert cmd.count_atoms('name CA') == 3
assert cmd.count_atoms('name CB') == 2
assert cmd.count_atoms('name CG+CD+CD1+CD2+2HG+3HG+1HD+2HD') == 0
def testSimple(self):
cmd.fab('A', 'm1')
cmd.fab('A', 'm2')
v1 = 'foo'
v2 = 'bar'
v3 = 'com'
# single state
cmd.set_property('filename', v1, 'm1')
self.assertTrue('foo' == v1)
self.assertTrue(cmd.get_property('filename', 'm1') == v1)
self.assertTrue(cmd.get_property('filename', 'm2') == None)
# multiple objects
cmd.set_property('filename', v1)
self.assertTrue(cmd.get_property('filename', 'm2') == v1)
# two states
cmd.create('m1', 'm1', 1, 2)
self.assertTrue(cmd.count_states() == 2)
# set for all states
cmd.set_property('filename', v1, 'm1')
self.assertTrue(cmd.get_property('filename', 'm1', 2) == v1)
# set for particular state
cmd.set_property('filename', v2, 'm1', 2)
self.assertTrue(cmd.get_property('filename', 'm1', 1) == v1)
self.assertTrue(cmd.get_property('filename', 'm1', 2) == v2)
# set for current state
cmd.frame(2)
cmd.set_property('filename', v3, 'm1', -1)
self.assertTrue(cmd.get_property('filename', 'm1', 1) == v1)
self.assertTrue(cmd.get_property('filename', 'm1', 2) == v3)
def test_sets_ranges(self):
cmd.fab('ACDEFGHIKL')
cmd.alter('resi 9', 'resi="9A"') # insertion code
self.assertEqual(3, cmd.count_atoms('guide & resi 2-4'))
self.assertEqual(3, cmd.count_atoms('guide & resi 2:4'))
self.assertEqual(2, cmd.count_atoms('guide & resi 2+4'))
self.assertEqual(4, cmd.count_atoms('guide & resi 2-4+6'))
self.assertEqual(6, cmd.count_atoms('guide & resi 2-4+6-8'))
self.assertEqual(0, cmd.count_atoms('guide & resi 9'))
self.assertEqual(1, cmd.count_atoms('guide & resi 9A'))
self.assertEqual(1, cmd.count_atoms('guide & resi 10'))
self.assertEqual(0, cmd.count_atoms('guide & resi 10A'))
self.assertEqual(2, cmd.count_atoms('guide & resi 9-10'))
self.assertEqual(2, cmd.count_atoms('guide & resi 9A-10A'))
self.assertEqual(10 + 9, cmd.count_atoms('name CA+CB'))
self.assertEqual(10 + 9, cmd.count_atoms('name CA+CB+XYZ'))
self.assertEqual(10, cmd.count_atoms('name C'))
self.assertEqual(50, cmd.count_atoms('name C*'))
self.assertEqual(10, cmd.count_atoms('name H'))
self.assertEqual(24, cmd.count_atoms('name H*'))
self.assertEqual(10, cmd.count_atoms('name *H'))
self.assertEqual(74, cmd.count_atoms('name *H*'))
self.assertEqual(20, cmd.count_atoms('name C+N'))
self.assertEqual(23, cmd.count_atoms('name C+N*'))
self.assertEqual(60, cmd.count_atoms('name C*+N'))
self.assertEqual(63, cmd.count_atoms('name C*+N*'))
def test(self):
cmd.fab('AG')
cmd.remove('hydro')
cmd.h_add('resn ALA')
# with this bug: count = 6
self.assertEqual(11, cmd.count_atoms('byres (last hydro)'))
def test_sets_ranges(self):
cmd.fab('ACDEFGHIKL')
cmd.alter('resi 9', 'resi="9A"') # insertion code
self.assertEqual(3, cmd.count_atoms('guide & resi 2-4'))
self.assertEqual(3, cmd.count_atoms('guide & resi 2:4'))
self.assertEqual(2, cmd.count_atoms('guide & resi 2+4'))
self.assertEqual(4, cmd.count_atoms('guide & resi 2-4+6'))
self.assertEqual(6, cmd.count_atoms('guide & resi 2-4+6-8'))
self.assertEqual(0, cmd.count_atoms('guide & resi 9'))
self.assertEqual(1, cmd.count_atoms('guide & resi 9A'))
self.assertEqual(1, cmd.count_atoms('guide & resi 10'))
self.assertEqual(0, cmd.count_atoms('guide & resi 10A'))
self.assertEqual(2, cmd.count_atoms('guide & resi 9-10'))
self.assertEqual(2, cmd.count_atoms('guide & resi 9A-10A'))
self.assertEqual(10 + 9, cmd.count_atoms('name CA+CB'))
self.assertEqual(10 + 9, cmd.count_atoms('name CA+CB+XYZ'))
self.assertEqual(10, cmd.count_atoms('name C'))
self.assertEqual(50, cmd.count_atoms('name C*'))
self.assertEqual(10, cmd.count_atoms('name H'))
self.assertEqual(24, cmd.count_atoms('name H*'))
self.assertEqual(10, cmd.count_atoms('name *H'))
self.assertEqual(74, cmd.count_atoms('name *H*'))
self.assertEqual(20, cmd.count_atoms('name C+N'))
self.assertEqual(23, cmd.count_atoms('name C+N*'))
self.assertEqual(60, cmd.count_atoms('name C*+N'))
self.assertEqual(63, cmd.count_atoms('name C*+N*'))
def testSimple(self):
cmd.fab('A', 'm1')
cmd.fab('A', 'm2')
v1 = 'foo'
v2 = 'bar'
v3 = 'com'
# single state
cmd.set_property('filename', v1, 'm1')
self.assertTrue('foo' == v1)
self.assertTrue(cmd.get_property('filename', 'm1') == v1)
self.assertTrue(cmd.get_property('filename', 'm2') == None)
# multiple objects
cmd.set_property('filename', v1)
self.assertTrue(cmd.get_property('filename', 'm2') == v1)
# two states
cmd.create('m1', 'm1', 1, 2)
self.assertTrue(cmd.count_states() == 2)
# set for all states
cmd.set_property('filename', v1, 'm1')
self.assertTrue(cmd.get_property('filename', 'm1', 2) == v1)
# set for particular state
cmd.set_property('filename', v2, 'm1', 2)
self.assertTrue(cmd.get_property('filename', 'm1', 1) == v1)
self.assertTrue(cmd.get_property('filename', 'm1', 2) == v2)
# set for current state
cmd.frame(2)
cmd.set_property('filename', v3, 'm1', -1)
self.assertTrue(cmd.get_property('filename', 'm1', 1) == v1)
self.assertTrue(cmd.get_property('filename', 'm1', 2) == v3)
def testExportStyle(self):
cmd.fab('ACDEF', 'm1')
cmd.hide()
cmd.show('cartoon', 'resi 1-3')
cmd.show('lines', 'resn CYS')
cmd.show('sticks', 'resn ASP+PHE')
cmd.show('spheres', 'resn GLU')
cmd.set('stick_ball', 1, 'resn PHE')
cmd.set('stick_ball_ratio', 1.5, 'm1')
testlabel = 'Hello "World"'
cmd.label('name SG', repr(testlabel))
with testing.mktemp('.mae') as filename:
cmd.save(filename)
cmd.delete('*')
cmd.load(filename, 'm2')
g_labels = []
cmd.iterate('name SG', 'g_labels.append(label)', space=locals())
cmd.alter('*', 'b = 1 if s.stick_ball else 0')
self._assertCountEqual('rep cartoon & guide', 'resi 1-3 & guide')
self._assertCountEqual('rep lines', 'resn CYS', delta=1)
self._assertCountEqual('rep sticks', 'resn ASP+PHE')
self._assertCountEqual('rep spheres', 'resn GLU')
self._assertCountEqual('b > 0.5', 'resn PHE')
self.assertTrue(cmd.get_setting_float('stick_ball_ratio', 'm2') > 1.1)
self.assertEqual(g_labels[0], testlabel)
def test_select_range():
cmd.reinitialize()
cmd.fab("GASGAGS", "m1")
cmd.select("s1", "resn ALA")
psico.selecting.select_range()
assert 4 == cmd.count_atoms("s1 & guide")
psico.selecting.select_range("s2", "resn SER")
assert 5 == cmd.count_atoms("s2 & guide")
def testAdvanced(self):
cmd.fab('A/123/ ADC B/234/ AFCD')
v = cmd.get_chains()
self.assertEqual(v, ['A', 'B'])
cmd.iterate('last chain B', 'stored.v = (resv, resn)')
self.assertEqual(stored.v, (237, 'ASP'))
def test_stub2ala():
cmd.reinitialize()
cmd.fab('EFG', 'm1')
cmd.remove('not (backbone or name CB)')
psico.editing.stub2ala()
my_values = []
cmd.iterate('guide', 'my_values.append(resn)', space=locals())
assert my_values == ['ALA', 'ALA', 'GLY']
def testAdvanced(self):
cmd.fab('A/123/ ADC B/234/ AFCD')
v = cmd.get_chains()
self.assertEqual(v, ['A', 'B'])
cmd.iterate('last chain B', 'stored.v = (resv, resn)')
self.assertEqual(stored.v, (237, 'ASP'))
def test_split():
cmd.reinitialize()
cmd.fab('ACD', 'm1')
psico.editing.split('byres', 'm1')
assert cmd.count_atoms('entity01') == cmd.count_atoms('m1 & resn ALA')
assert cmd.count_atoms('entity02') == cmd.count_atoms('m1 & resn CYS')
assert cmd.count_atoms('entity03') == cmd.count_atoms('m1 & resn ASP')
psico.editing.split('byres', 'm1', 'foo_')
assert cmd.count_atoms('foo_01') == cmd.count_atoms('m1 & resn ALA')
def test_set_raw_alignment(self):
cmd.fab('ACDEF', 'm1')
cmd.fab('CDE', 'm2')
index_m1 = [('m1', 12), ('m1', 23), ('m1', 35)]
index_m2 = [('m2', 2), ('m2', 13), ('m2', 25)]
raw = [list(t) for t in zip(index_m1, index_m2)]
cmd.set_raw_alignment('aln', raw)
self.assertEqual(cmd.index('m1 & aln'), index_m1)
self.assertEqual(cmd.index('m2 & aln'), index_m2)
def test_set_phipsi():
cmd.reinitialize()
cmd.fab('ACDEF', 'm1')
psico.editing.set_phipsi('all', 160, 160)
psico.editing.set_phipsi('resi 2+4', 120)
psico.editing.set_phipsi('resi 3+4', psi=-140)
assert cmd.get_phipsi('resi 2')['m1', 12] == approx((120., 160.))
assert cmd.get_phipsi('resi 3')['m1', 23] == approx((160., -140.))
assert cmd.get_phipsi('resi 4')['m1', 35] == approx((120., -140.))
def testDir(self):
seq = 'ACD'
resv = 5
cmd.fab(seq, 'm1', resi=resv, dir=-1)
# incentive needs sort, opensource is already sorted
cmd.sort()
cmd.iterate('first m1', 'stored.v = (resv, resn)')
self.assertEqual(stored.v, (resv - 2, 'ASP'))
def test_remove_alt():
cmd.reinitialize()
cmd.fab('AC', 'm1')
cmd.alter('resn ALA', 'alt="A"')
cmd.alter('resn CYS', 'alt="B"')
cmd.create('m2', 'm1')
psico.editing.remove_alt('m1')
psico.editing.remove_alt('m2', keep='B')
assert cmd.count_atoms('m1') == 10
assert cmd.count_atoms('m2') == 11
def test_split_molecules():
cmd.reinitialize()
cmd.fab('ACD', 'm1')
cmd.fab('EFG', 'm2')
cmd.create('m3', 'm1 m2')
psico.editing.split_molecules('m3')
assert cmd.count_atoms('mol_01') == cmd.count_atoms('m1')
assert cmd.count_atoms('mol_02') == cmd.count_atoms('m2')
psico.editing.split_molecules('m3', 'foo_')
assert cmd.count_atoms('foo_01') == cmd.count_atoms('m1')
def testMorphRigimol(self):
cmd.set('suspend_undo')
import epymol.rigimol
cmd.fab('ACD', 'm1')
cmd.create('m1', 'm1', 1, 2)
cmd.rotate('x', 90, 'm1', 2)
steps = 5
cmd.morph('mout', 'm1', refinement=1, steps=steps, method='rigimol')
self.assertEqual(steps, cmd.count_states('mout'))
self.assertEqual(cmd.count_atoms('m1'), cmd.count_atoms('mout'))
def testDir(self):
seq = 'ACD'
resv = 5
cmd.fab(seq, 'm1', resi=resv, dir=-1)
# incentive needs sort, opensource is already sorted
cmd.sort()
cmd.iterate('first m1', 'stored.v = (resv, resn)')
self.assertEqual(stored.v, (resv - 2, 'ASP'))
def testGetFastastr(self):
seq, name = 'ACD', 'm1'
cmd.fab(seq, name)
s = cmd.get_fastastr()
lines = s.split()
self.assertTrue(lines[0] in (
'>' + name,
'>' + name + '_',
))
self.assertEqual(lines[1:], [seq])
def testGetFastastr(self):
seq, name = 'ACD', 'm1'
cmd.fab(seq, name)
s = cmd.get_fastastr()
lines = s.split()
self.assertTrue(lines[0] in (
'>' + name,
'>' + name + '_',
))
self.assertEqual(lines[1:], [seq])
def test_split_chains():
cmd.reinitialize()
cmd.fab('ACD', 'm1', chain='A')
cmd.fab('EFG', 'm2', chain='B')
cmd.create('m3', 'm1 m2')
psico.editing.split_chains('m3')
assert cmd.get_chains('m3_A') == ['A']
assert cmd.get_chains('m3_B') == ['B']
psico.editing.split_chains('m3', 'foo_')
assert cmd.get_chains('foo_0001') == ['A']
def test_set_sequence():
cmd.reinitialize()
cmd.fab('ACD', 'm1')
psico.editing.set_sequence('EFG')
myseq = []
cmd.iterate('guide', 'myseq.append(resn)', space=locals())
assert myseq == ['GLU', 'PHE', 'GLY']
psico.editing.set_sequence('HI', start=2)
myseq = []
cmd.iterate('guide', 'myseq.append(resn)', space=locals())
assert myseq == ['GLU', 'HIS', 'ILE']
def test_update_identifiers():
cmd.reinitialize()
cmd.fab('ACD', 'm1')
cmd.fab('ACD', 'm2')
cmd.remove('m1 and not backbone')
cmd.alter('m1', '(segi, chain) = ("Segi", "Chain")')
psico.editing.update_identifiers('m2', 'm1', identifiers='segi chain')
assert cmd.get_chains('m2') == ['Chain']
my_values = []
cmd.iterate('m2', 'my_values.append(segi)', space=locals())
assert set(my_values) == set(["Segi"])
def testMorphRigimol(self):
cmd.set('suspend_undo')
import epymol.rigimol
cmd.fab('ACD', 'm1')
cmd.create('m1', 'm1', 1, 2)
cmd.rotate('x', 90, 'm1', 2)
steps = 5
cmd.morph('mout', 'm1', refinement=1, steps=steps, method='rigimol')
self.assertEqual(steps, cmd.count_states('mout'))
self.assertEqual(cmd.count_atoms('m1'),
cmd.count_atoms('mout'))
def testSaveAln(self):
cmd.fab('ACDEFGH', 'm1')
cmd.fab('ACDFGH', 'm2')
cmd.align('m1', 'm2', cycles=0, object='aln')
with testing.mktemp('.aln') as filename:
cmd.save(filename)
with open(filename) as handle:
lines = list(handle)
self.assertEqual(lines[0].split(), ['CLUSTAL'])
self.assertEqual(lines[1].split(), [])
self.assertEqual(lines[2].split(), ['m1', 'ACDEFGH'])
self.assertEqual(lines[3].split(), ['m2', 'ACD-FGH'])
def testSaveAln(self):
cmd.fab('ACDEFGH', 'm1')
cmd.fab('ACDFGH', 'm2')
cmd.align('m1', 'm2', cycles=0, object='aln')
with testing.mktemp('.aln') as filename:
cmd.save(filename)
with open(filename) as handle:
lines = list(handle)
self.assertEqual(lines[0].split(), ['CLUSTAL'])
self.assertEqual(lines[1].split(), [])
self.assertEqual(lines[2].split(), ['m1', 'ACDEFGH'])
self.assertEqual(lines[3].split(), ['m2', 'ACD-FGH'])
def testLoadAlnMappingStr(self):
cmd.fab('ACDEFGHIKLMNPQRS', 'm1')
cmd.fab('ACDIKLMNP', 'm2')
from pymol.seqalign import load_aln_multi
load_aln_multi(self.datafile('alignment.aln'), 'aln', mapping=
'seq1 m1 '
'seq2 m2 '
)
self.assertEqual(cmd.count_atoms('guide & aln & m1'), 7)
self.assertEqual(cmd.count_atoms('guide & aln & m2'), 7)
def testLoadAlnMappingDict(self):
cmd.fab('ACDIKLMNP', 'm2')
cmd.fab('GHIKPQRS', 'm3')
from pymol.seqalign import load_aln_multi
load_aln_multi(self.datafile('alignment.aln'), 'aln', mapping={
'seq2': 'm2',
'seq3': 'm3',
})
self.assertEqual(cmd.count_atoms('guide & aln & m2'), 2)
self.assertEqual(cmd.count_atoms('guide & aln & m3'), 2)
def testMMTFExportSele(self):
cmd.fab('ACDE')
with testing.mktemp('.mmtf') as filename:
cmd.save(filename, 'resn CYS+ASP')
cmd.delete('*')
cmd.load(filename)
self.assertEqual(cmd.count_atoms(), 23)
self.assertEqual(cmd.count_atoms('bound_to ASP/CG'), 3)
self.assertEqual(cmd.get_model('ASP/CG ASP/OD1').bond[0].order, 2)
self.assertEqual(cmd.get_model('ASP/CG ASP/OD2').bond[0].order, 1)
self.assertEqual(cmd.get_model('CYS/C ASP/N').bond[0].order, 1)
def test_alphatoall():
cmd.reinitialize()
cmd.fab('ACD', 'm1')
cmd.alter('guide', 'color = resv')
psico.editing.alphatoall('all', 'color')
my_values = []
cmd.iterate('all', 'my_values.append(color)', space=locals())
assert set(my_values) == set([1, 2, 3])
cmd.alter('name N', 'color = resv + 3')
psico.editing.alphatoall('all', 'color', operator='(name N) and')
my_values = []
cmd.iterate('all', 'my_values.append(color)', space=locals())
assert set(my_values) == set([4, 5, 6])
def testMMTFExportSele(self):
cmd.fab('ACDE')
with testing.mktemp('.mmtf') as filename:
cmd.save(filename, 'resn CYS+ASP')
cmd.delete('*')
cmd.load(filename)
self.assertEqual(cmd.count_atoms(), 23)
self.assertEqual(cmd.count_atoms('bound_to ASP/CG'), 3)
self.assertEqual(cmd.get_model('ASP/CG ASP/OD1').bond[0].order, 2)
self.assertEqual(cmd.get_model('ASP/CG ASP/OD2').bond[0].order, 1)
self.assertEqual(cmd.get_model('CYS/C ASP/N').bond[0].order, 1)
def testMorphMulti(self):
cmd.set('suspend_undo')
cmd.fab('ACD', 'm1')
cmd.create('m1', 'm1', 1, 2)
cmd.create('m1', 'm1', 1, 3)
cmd.rotate('x', 90, 'm1', 2)
cmd.rotate('x', 45, 'm1', 3)
steps = 5
cmd.morph('mout', 'm1', None, 0, 0, 0, steps, 'linear')
self.assertEqual(steps * 2, cmd.count_states('mout'))
self.assertEqual(cmd.count_atoms('m1'), cmd.count_atoms('mout'))
cmd.morph('mo2', 'm1', None, 0, -1, 0, steps, 'linear')
self.assertEqual(steps * 3, cmd.count_states('mo2'))
self.assertEqual(cmd.count_atoms('m1'), cmd.count_atoms('mo2'))
def test(self, ribbon_as_cylinders):
cmd.set('ribbon_as_cylinders', ribbon_as_cylinders)
cmd.set('ribbon_width', 8)
cmd.fab('AG')
cmd.color('red', 'resn ALA')
cmd.color('blue', 'resn GLY')
cmd.show_as('ribbon')
cmd.orient()
self.ambientOnly()
cmd.viewport(100, 100)
cmd.draw(100, 100)
img = self.get_imagearray()
self.assertImageHasColor('red', img)
self.assertImageHasColor('blue', img)
def testIdentifiers(self):
seq = 'ACD'
segi = 'foo'
chain = 'F'
resv = 10
cmd.fab(seq, 'm1', 'peptide', resv, chain, segi)
cmd.iterate('first m1', 'stored.v = (segi, chain, resv, resn)')
self.assertEqual(stored.v, (segi, chain, resv, 'ALA'))
cmd.iterate('last m1', 'stored.v = (segi, chain, resv, resn)')
self.assertEqual(stored.v, (segi, chain, resv + 2, 'ASP'))
v = cmd.get_fastastr().splitlines()[1]
self.assertEqual(v, seq)
def testIdentifiers(self):
seq = 'ACD'
segi = 'foo'
chain = 'F'
resv = 10
cmd.fab(seq, 'm1', 'peptide', resv, chain, segi)
cmd.iterate('first m1', 'stored.v = (segi, chain, resv, resn)')
self.assertEqual(stored.v, (segi, chain, resv, 'ALA'))
cmd.iterate('last m1', 'stored.v = (segi, chain, resv, resn)')
self.assertEqual(stored.v, (segi, chain, resv + 2, 'ASP'))
v = cmd.get_fastastr().splitlines()[1]
self.assertEqual(v, seq)
def test(self, ribbon_as_cylinders):
cmd.set('ribbon_as_cylinders', ribbon_as_cylinders)
cmd.set('ribbon_width', 8)
cmd.fab('AG')
cmd.color('red', 'resn ALA')
cmd.color('blue', 'resn GLY')
cmd.show_as('ribbon')
cmd.orient()
self.ambientOnly()
cmd.viewport(100, 100)
cmd.draw(100, 100)
img = self.get_imagearray()
self.assertImageHasColor('red', img)
self.assertImageHasColor('blue', img)
def testFindPairs(self):
# mode 0
cmd.fragment("gly")
pairs = cmd.find_pairs("hydro", "elem O")
pairs_ref = [
(('gly', 5), ('gly', 4)),
(('gly', 6), ('gly', 4)),
(('gly', 7), ('gly', 4)),
]
self.assertEqual(sorted(pairs), pairs_ref)
# mode 1
cmd.fab("GGGGG", "m2", ss=1)
pairs = cmd.find_pairs("m2 & donor", "m2 & acceptor", mode=1)
self.assertEqual(pairs, [(('m2', 29), ('m2', 4))])
def testMorphMulti(self):
cmd.set('suspend_undo')
cmd.fab('ACD', 'm1')
cmd.create('m1', 'm1', 1, 2)
cmd.create('m1', 'm1', 1, 3)
cmd.rotate('x', 90, 'm1', 2)
cmd.rotate('x', 45, 'm1', 3)
steps = 5
cmd.morph('mout', 'm1', None, 0, 0, 0, steps, 'linear')
self.assertEqual(steps * 2, cmd.count_states('mout'))
self.assertEqual(cmd.count_atoms('m1'),
cmd.count_atoms('mout'))
cmd.morph('mo2', 'm1', None, 0, -1, 0, steps, 'linear')
self.assertEqual(steps * 3, cmd.count_states('mo2'))
self.assertEqual(cmd.count_atoms('m1'),
cmd.count_atoms('mo2'))
def testSeleMacro(self):
cmd.fab('GGGGG', 'foo-bar-com')
cmd.fragment('gly', 'foo-com-bar')
self.assertTrue( cmd.count_atoms('/foo-bar-com'))
self.assertTrue( cmd.count_atoms('/foo-bar-com////c*'))
self.assertTrue( cmd.count_atoms('/foo-bar/'))
self.assertTrue( cmd.count_atoms('/foo-bar*/'))
self.assertTrue( cmd.count_atoms('/foo*/'))
self.assertEqual(cmd.count_atoms('/foo-bar-com///2:4/ca'), 3)
self.assertEqual(cmd.count_atoms('/foo-bar-com///2-4/ca'), 3)
self.assertTrue( cmd.count_atoms('foo-bar-com////'))
# test ambiguous prefix
# -1 on failure
cmd.set('raise_exceptions', 0)
self.assertEqual(cmd.count_atoms('/foo/'), -1)
def testSeleMacro(self):
cmd.fab('GGGGG', 'foo-bar-com')
cmd.fragment('gly', 'foo-com-bar')
self.assertTrue(cmd.count_atoms('/foo-bar-com'))
self.assertTrue(cmd.count_atoms('/foo-bar-com////c*'))
self.assertTrue(cmd.count_atoms('/foo-bar/'))
self.assertTrue(cmd.count_atoms('/foo-bar*/'))
self.assertTrue(cmd.count_atoms('/foo*/'))
self.assertEqual(cmd.count_atoms('/foo-bar-com///2:4/ca'), 3)
self.assertEqual(cmd.count_atoms('/foo-bar-com///2-4/ca'), 3)
self.assertTrue(cmd.count_atoms('foo-bar-com////'))
# test ambiguous prefix
# -1 on failure
cmd.set('raise_exceptions', 0)
self.assertEqual(cmd.count_atoms('/foo/'), -1)
def _testTransparency(self, rep, setting_name):
cmd.fab('GGGG')
cmd.remove('resi 2+3')
cmd.select('sele', 'resi 4', 0)
self.ambientOnly()
cmd.viewport(100, 100)
cmd.set('opaque_background')
cmd.set('ray_shadow', 0)
cmd.orient()
cmd.color('0xFF0000')
cmd.show_as(rep)
# all opaque
img = self.get_imagearray()
self.assertImageHasColor('0xFF0000', img)
# object-level transparency
cmd.set(setting_name, 0.4)
img = self.get_imagearray()
self.assertImageHasColor('0x990000', img) # 40%
self.assertImageHasNotColor('0xFF0000', img)
# atom-level full-opaque
cmd.set(setting_name, 0.0, 'sele')
img = self.get_imagearray()
self.assertImageHasColor('0x990000', img) # 40%
self.assertImageHasColor('0xFF0000', img) # 0%
# atom-level semi-transparent
cmd.set(setting_name, 0.6, 'sele')
img = self.get_imagearray()
self.assertImageHasColor('0x990000', img) # 40%
self.assertImageHasColor('0x660000', img, delta=1) # 60%
self.assertImageHasNotColor('0xFF0000', img)
# atom-level full-transparent (expect only two color values)
cmd.set(setting_name, 0.0)
cmd.set(setting_name, 1.0, 'sele')
img = self.get_imagearray()
self.assertImageHasColor('0xFF0000', img)
# need delta=1 with clang, but not with gcc
self.assertNumColorsEqual(img, 2, delta=1)
def _testTransparency(self, rep, setting_name):
cmd.fab('GGGG')
cmd.remove('resi 2+3')
cmd.select('sele', 'resi 4', 0)
self.ambientOnly()
cmd.viewport(100, 100)
cmd.set('opaque_background')
cmd.set('ray_shadow', 0)
cmd.orient()
cmd.color('0xFF0000')
cmd.show_as(rep)
# all opaque
img = self.get_imagearray()
self.assertImageHasColor('0xFF0000', img)
# object-level transparency
cmd.set(setting_name, 0.4)
img = self.get_imagearray()
self.assertImageHasColor('0x990000', img) # 40%
self.assertImageHasNotColor('0xFF0000', img)
# atom-level full-opaque
cmd.set(setting_name, 0.0, 'sele')
img = self.get_imagearray()
self.assertImageHasColor('0x990000', img) # 40%
self.assertImageHasColor('0xFF0000', img) # 0%
# atom-level semi-transparent
cmd.set(setting_name, 0.6, 'sele')
img = self.get_imagearray()
self.assertImageHasColor('0x990000', img) # 40%
self.assertImageHasColor('0x660000', img, delta=1) # 60%
self.assertImageHasNotColor('0xFF0000', img)
# atom-level full-transparent (expect only two color values)
cmd.set(setting_name, 0.0)
cmd.set(setting_name, 1.0, 'sele')
img = self.get_imagearray()
self.assertImageHasColor('0xFF0000', img)
self.assertTrue(len(numpy.unique(img[...,:3])) == 2)
def testBumpsPSE(self):
self.ambientOnly()
cmd.viewport(100, 100)
# expect some clashes in this helix
cmd.fab('AAAAA', 'm1', ss=1)
cmd.orient()
cmd.set('sculpt_vdw_vis_mode', 1)
cmd.set('sculpt_field_mask', 0x020) # cSculptVDW
cmd.sculpt_activate('m1')
cmd.sculpt_iterate('m1', cycles=0)
cmd.show_as('cgo')
img = self.get_imagearray()
self.assertImageHasColor('0xFF3333', img)
with testing.mktemp('.pse') as filename:
cmd.save(filename)
cmd.load(filename)
self.assertImageEqual(img)
def testLoadAlnMatchingIds(self):
cmd.fab('ACDEFGHIKLMNPQRS', 'seq1')
cmd.fab('ACDIKLMNP', 'seq2')
cmd.fab('GHIKPQRS', 'seq3')
cmd.load(self.datafile('alignment.aln'), 'aln')
self.assertEqual(cmd.count_atoms('guide & aln & seq1'), 11)
self.assertEqual(cmd.count_atoms('guide & aln & seq2'), 7)
self.assertEqual(cmd.count_atoms('guide & aln & seq3'), 6)
def test_dss(self):
ss_list = []
cmd.fab('A' * 6, ss=1)
cmd.dss()
cmd.iterate('2-5/CA', 'ss_list.append(ss)', space=locals())
self.assertEqual(ss_list, ['H', 'H', 'H', 'H'])
def testGetFastastr(self):
seq, name = 'ACD', 'm1'
cmd.fab(seq, name)
s = cmd.get_fastastr()
self.assertEqual(s.split(), ['>' + name, seq])
