예제 #1
0
    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)
예제 #2
0
    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)
예제 #3
0
    def test2638(self):
        cmd.set('retain_order')
        cmd.fragment('ala', 'm1')
        n = cmd.count_atoms()

        ##
        ## Make long identifiers
        ##

        chain = [randhex()] * n
        resn = [randhex()] * n
        resv = [randint(10**4, 10**6 - 1)] * n
        names = [randhex(4) + str(i) for i in range(n)]

        identif_str = '(chain, resn, resv, name)'
        identifiers = list(zip(chain, resn, resv, names))
        afterload = []

        cmd.alter('m1',
                  identif_str + ' = _next()',
                  space={'_next': next_decorator(identifiers)})

        ##
        ## Test if cif in/out preserves identifiers
        ##

        with testing.mktemp('.cif') as filename:
            cmd.save(filename, 'm1')
            cmd.load(filename, 'm2')

        cmd.iterate('m2',
                    '_afterload.append(' + identif_str + ')',
                    space={'_afterload': afterload})

        self.assertEqual(identifiers, afterload)

        ##
        ## Test if various formats preserve coordinates
        ##

        coords = cmd.get_coordset('m1')

        for ext in ['.pdb', '.xyz', '.mol2', '.sdf']:
            cmd.delete('m2')

            with testing.mktemp(ext) as filename:
                cmd.save(filename, 'm1')
                cmd.load(filename, 'm2')

            self.assertArrayEqual(coords,
                                  cmd.get_coordset('m2'),
                                  delta=1e-3,
                                  msg='not preserving coordinates: ' + ext)
예제 #4
0
    def test2638(self):
        cmd.set('retain_order')
        cmd.fragment('ala', 'm1')
        n = cmd.count_atoms()

        ##
        ## Make long identifiers
        ##

        chain = [randhex()] * n
        resn = [randhex()] * n
        resv = [randint(10**4, 10**6 - 1)] * n
        names = [randhex(4) + str(i) for i in range(n)]

        identif_str = '(chain, resn, resv, name)'
        identifiers = list(zip(chain, resn, resv, names))
        afterload = []

        cmd.alter('m1', identif_str + ' = _next()',
                space={'_next': next_decorator(identifiers)})

        ##
        ## Test if cif in/out preserves identifiers
        ##

        with testing.mktemp('.cif') as filename:
            cmd.save(filename, 'm1')
            cmd.load(filename, 'm2')

        cmd.iterate('m2', '_afterload.append(' + identif_str + ')',
                space={'_afterload': afterload})

        self.assertEqual(identifiers, afterload)

        ##
        ## Test if various formats preserve coordinates
        ##

        coords = cmd.get_coordset('m1')

        for ext in ['.pdb', '.xyz', '.mol2', '.sdf']:
            cmd.delete('m2')

            with testing.mktemp(ext) as filename:
                cmd.save(filename, 'm1')
                cmd.load(filename, 'm2')

            self.assertArrayEqual(coords, cmd.get_coordset('m2'), delta=1e-3,
                    msg='not preserving coordinates: ' + ext)
예제 #5
0
    def test(self):
        cmd.set('opaque_background')
        with testing.mktemp('tmp.pse') as session_filename:
            with testing.mktemp('bg.png') as bg_image_filename:
                cmd.bg_color('red')
                cmd.png(bg_image_filename)
                cmd.bg_color('blue')
                cmd.set('bg_image_filename', bg_image_filename)
                cmd.save(session_filename)

            cmd.load(session_filename)
        x = cmd.get('bg_image_filename')
        self.assertTrue(x.startswith('data:'))
        self.assertImageHasColor('red', delta=4,
                msg='bg_image_filename=data: not rendered')
예제 #6
0
    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])
예제 #7
0
 def testMAEsaveLoadSessions(self):
     cmd.load(self.datafile('1d_smiles.mae'), '1d_smiles', object_props='*')
     allpropdata = {}
     objs = cmd.get_object_list()
     for obj in objs:
         props = cmd.get_property_list(obj)
         allpropdata[obj] = {}
         for prop in props:
             allpropdata[obj][prop] = cmd.get_property(prop, obj)
     with testing.mktemp('.pse') as psefilename:
         cmd.save(psefilename)
         cmd.load(psefilename)
     # this is to fail the test on purpose
     #        cmd.set_property('i_m_ct_format', 3, '1d_smiles.mol_13')
     objs = cmd.get_object_list()
     for obj in objs:
         props = cmd.get_property_list(obj)
         # test to make sure there are no extra properties or not enough properties
         self.assertEqual(set(props), set(allpropdata[obj].keys()))
         # test to make sure all property values are the same
         for prop in props:
             try:
                 self.assertTrue(allpropdata[obj][prop] == cmd.get_property(prop, obj))
             except:
                 self.fail('properties are not the same: obj=%s prop=%s' % (obj, prop))
예제 #8
0
 def testPseSupport(self):
     cmd.load_callback(callback.Callback(), 'c1')
     with testing.mktemp('tmp.pse') as session_filename:
         cmd.save(session_filename)
         cmd.delete('*')
         cmd.load(session_filename)
         self.assertTrue('c1' in cmd.get_names())
예제 #9
0
 def testMAEsaveLoadSessions(self):
     cmd.load(self.datafile('1d_smiles.mae'), '1d_smiles', object_props='*')
     allpropdata = {}
     objs = cmd.get_object_list()
     for obj in objs:
         props = cmd.get_property_list(obj)
         allpropdata[obj] = {}
         for prop in props:
             allpropdata[obj][prop] = cmd.get_property(prop, obj)
     with testing.mktemp('.pse') as psefilename:
         cmd.save(psefilename)
         cmd.load(psefilename)
     # this is to fail the test on purpose
     #        cmd.set_property('i_m_ct_format', 3, '1d_smiles.mol_13')
     objs = cmd.get_object_list()
     for obj in objs:
         props = cmd.get_property_list(obj)
         # test to make sure there are no extra properties or not enough properties
         self.assertEqual(set(props), set(allpropdata[obj].keys()))
         # test to make sure all property values are the same
         for prop in props:
             try:
                 self.assertTrue(allpropdata[obj][prop] == cmd.get_property(prop, obj))
             except:
                 self.fail('properties are not the same: obj=%s prop=%s' % (obj, prop))
예제 #10
0
    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)
예제 #11
0
    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)
예제 #12
0
    def testMMTFExportEmpty(self):
        with testing.mktemp('.mmtf') as filename:
            cmd.save(filename)
            cmd.load(filename, 'm1')

        self.assertEqual(cmd.count_atoms(), 0)
        self.assertEqual(cmd.get_names(), ['m1'])
예제 #13
0
    def testMMTFExportEmpty(self):
        with testing.mktemp('.mmtf') as filename:
            cmd.save(filename)
            cmd.load(filename, 'm1')

        self.assertEqual(cmd.count_atoms(), 0)
        self.assertEqual(cmd.get_names(), ['m1'])
예제 #14
0
    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])
예제 #15
0
    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())
예제 #16
0
    def testglTF(self):
        '''glTF export'''
        cmd.fragment('gly')

        with testing.mktemp('.gltf') as filename:
            self.assertEqual(cmd.save(filename), 0)
            cmd.delete('*')
예제 #17
0
    def test(self):
        cmd.set('opaque_background')
        with testing.mktemp('tmp.pse') as session_filename:
            with testing.mktemp('bg.png') as bg_image_filename:
                cmd.bg_color('red')
                cmd.png(bg_image_filename)
                cmd.bg_color('blue')
                cmd.set('bg_image_filename', bg_image_filename)
                cmd.save(session_filename)

            cmd.load(session_filename)
        x = cmd.get('bg_image_filename')
        self.assertTrue(x.startswith('data:'))
        self.assertImageHasColor('red',
                                 delta=4,
                                 msg='bg_image_filename=data: not rendered')
예제 #18
0
    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)
예제 #19
0
    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)
예제 #20
0
 def testLog(self):
     with testing.mktemp('.pml') as logfile:
         cmd.log_open(logfile)
         cmd.do('_ color blue')
         cmd.log('hello world')
         cmd.log_close()
         lines = filter(None, map(str.strip, open(logfile)))
         self.assertEqual(lines, ['color blue', 'hello world'])
예제 #21
0
 def testLog(self):
     with testing.mktemp('.pml') as logfile:
         cmd.log_open(logfile)
         cmd.do('_ color blue')
         cmd.log('hello world')
         cmd.log_close()
         lines = [_f for _f in map(str.strip, open(logfile)) if _f]
         self.assertEqual(lines, ['color blue', 'hello world'])
예제 #22
0
 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)
예제 #23
0
 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'))
예제 #24
0
 def testSTL(self):
     cmd.fragment('gly')
     for rep in ['spheres', 'sticks', 'surface']:
         cmd.show_as(rep)
         with testing.mktemp('.stl') as filename:
             cmd.save(filename)
             contents = file_get_contents(filename, 'rb')
             # 80 bytes header
             # 4 bytes (uint32) number of triangles
             self.assertTrue(len(contents) > 84)
예제 #25
0
 def testResume(self):
     with testing.mktemp('.pml') as logfile:
         with open(logfile, 'w') as f:
             print >> f, 'bg yellow'
         cmd.resume(logfile)
         self.assertEqual('yellow', cmd.get('bg_rgb'))
         cmd.log('hello world')
         cmd.log_close()
         lines = filter(None, map(str.strip, open(logfile)))
         self.assertEqual(lines, ['bg yellow', 'hello world'])
예제 #26
0
 def testResume(self):
     with testing.mktemp('.pml') as logfile:
         with open(logfile, 'w') as f:
             print('bg yellow', file=f)
         cmd.resume(logfile)
         self.assertEqual('yellow', cmd.get('bg_rgb'))
         cmd.log('hello world')
         cmd.log_close()
         lines = [_f for _f in map(str.strip, open(logfile)) if _f]
         self.assertEqual(lines, ['bg yellow', 'hello world'])
예제 #27
0
 def testResume(self):
     with testing.mktemp('.pml') as logfile:
         with open(logfile, 'w') as f:
             print('bg yellow', file=f)
         cmd.resume(logfile)
         self.assertEqual('yellow', cmd.get('bg_rgb'))
         cmd.log('hello world')
         cmd.log_close()
         lines = [_f for _f in map(str.strip, open(logfile)) if _f]
         self.assertEqual(lines, ['bg yellow', 'hello world'])
예제 #28
0
 def testPSEBulkExportImport(self, pse_export_version, pse_binary_dump):
     with testing.mktemp('.pse') as filename:
         cmd.load(self.datafile("1oky-frag.pdb"))
         m1 = cmd.get_model()
         cmd.set("pse_export_version", pse_export_version)
         cmd.set("pse_binary_dump", pse_binary_dump)
         cmd.save(filename)
         cmd.reinitialize()
         cmd.load(filename)
         m2 = cmd.get_model()
         self.assertModelsAreSame(m1, m2)
예제 #29
0
    def testMol2FormalChargeAssignment(self):
        cmd.fragment('lys')
        cmd.fragment('lys')

        with testing.mktemp('.mol2') as filename:
            cmd.save(filename, state=0)
            cmd.delete('*')
            cmd.load(filename)

        self.assertEqual(cmd.get_model('name NZ', state=1).atom[0].formal_charge, 1)
        self.assertEqual(cmd.get_model('name NZ', state=2).atom[0].formal_charge, 1)
예제 #30
0
 def testPSEBulkExportImport(self, pse_export_version, pse_binary_dump):
     with testing.mktemp('.pse') as filename:
         cmd.load(self.datafile("1oky-frag.pdb"))
         m1 = cmd.get_model()
         cmd.set("pse_export_version", pse_export_version)
         cmd.set("pse_binary_dump", pse_binary_dump)
         cmd.save(filename)
         cmd.reinitialize()
         cmd.load(filename)
         m2 = cmd.get_model()
         self.assertModelsAreSame(m1, m2)
예제 #31
0
    def testSdfV3000(self):
        cmd.load(self.datafile('1rx1.pdb'))
        with testing.mktemp('.sdf') as filename:
            cmd.save(filename)
            cmd.delete('*')
            cmd.load(filename)
        self.assertEqual(cmd.count_atoms(), 1435)

        # check for capitalized element symbols
        cmd.set('ignore_case', 0)
        self.assertEqual(cmd.count_atoms('elem Ca'), 1)
예제 #32
0
    def testSdfV3000(self):
        cmd.load(self.datafile('1rx1.pdb'))
        with testing.mktemp('.sdf') as filename:
            cmd.save(filename)
            cmd.delete('*')
            cmd.load(filename)
        self.assertEqual(cmd.count_atoms(), 1435)

        # check for capitalized element symbols
        cmd.set('ignore_case', 0)
        self.assertEqual(cmd.count_atoms('elem Ca'), 1)
예제 #33
0
    def testPngExists(self):
        '''
        Save a PNG image with width/height specified and
        check if the file exists.
        '''
        cmd.pseudoatom('m1')
        cmd.show('spheres')

        with testing.mktemp('.png') as filename:
            cmd.png(filename, width=100, height=100, ray=0)
            cmd.draw()
            self.assertTrue(os.path.exists(filename), 'png file not written')
예제 #34
0
 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'])
예제 #35
0
 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'])
예제 #36
0
    def testSaveState(self, format, pymol_version):
        if pymol_version > testing.PYMOL_VERSION[1]:
            self.skipTest("version %f" % (pymol_version))

        # for rms_cur (not all formats save all identifiers)
        m = -1
        cmd.set('retain_order')

        # create a multistate object
        cmd.fragment('ala', 'm1')
        cmd.create('m1', 'm1', 1, 2)
        cmd.create('m1', 'm1', 1, 3)
        cmd.translate([5, 0, 0], 'm1', state=2)
        cmd.translate([0, 5, 0], 'm1', state=3)
        n_states = cmd.count_states('m1')

        with testing.mktemp('.' + format) as filename:
            if format == 'mae' and not pymol.invocation.options.incentive_product:
                format = 'cms'

            # explicit
            for state in range(1, n_states + 1):
                cmd.delete('m2')
                cmd.save(filename, 'm1', state=state)
                cmd.load(filename, 'm2', format=format)
                rms = cmd.rms_cur('m1', 'm2', state, 1, matchmaker=m)
                self.assertAlmostEqual(rms, 0.00, delta=1e-2)

            # current state
            for state in range(1, n_states + 1):
                cmd.frame(state)
                cmd.delete('m2')
                cmd.save(filename, 'm1')
                cmd.load(filename, 'm2', 1, format=format)
                rms = cmd.rms_cur('m1', 'm2', state, 1, matchmaker=m)
                self.assertAlmostEqual(rms, 0.00, delta=1e-2)

            if format in ('mol', 'cms'):
                # no multi support
                return

            # all states
            cmd.delete('m2')
            cmd.save(filename, 'm1', state=0)
            cmd.load(filename, 'm2', 1, discrete=1, multiplex=0)
            self.assertEqual(cmd.count_states('m2'), n_states)
            for state in range(1, n_states + 1):
                rms = cmd.rms_cur('m1',
                                  'm2 and state %d' % state,
                                  state,
                                  state,
                                  matchmaker=m)
                self.assertAlmostEqual(rms, 0.00, delta=1e-2)
예제 #37
0
    def test(self):
        cmd.read_pdbstr(v_pdbstr_anisou, 'm1')

        with testing.mktemp('.mae') as maefilename:
            cmd.save(maefilename, 'm1')
            cmd.delete('*')
            cmd.load(maefilename, 'm1')

        self.assertEqual(cmd.get_pdbstr('m1'), v_pdbstr_anisou)

        cmd.read_pdbstr(v_pdbstr_rotated, 'm2')
        cmd.align('m1', 'm2')

        with testing.mktemp('.mae') as maefilename:
            cmd.save(maefilename, 'm1')
            cmd.delete('*')
            cmd.load(maefilename, 'm1')

        # Attention: Not sure if rotation is numerically stable across
        # platforms. Fuzzy comparison might be needed.
        self.assertEqual(cmd.get_pdbstr('m1'), v_pdbstr_rotated)
예제 #38
0
    def testMol2FormalChargeAssignment(self):
        cmd.fragment('lys')
        cmd.fragment('lys')

        with testing.mktemp('.mol2') as filename:
            cmd.save(filename, state=0)
            cmd.delete('*')
            cmd.load(filename)

        self.assertEqual(
            cmd.get_model('name NZ', state=1).atom[0].formal_charge, 1)
        self.assertEqual(
            cmd.get_model('name NZ', state=2).atom[0].formal_charge, 1)
예제 #39
0
    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)
예제 #40
0
    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)
예제 #41
0
    def testMultisave(self):
        names = ['ala', 'gly', 'his', 'arg']

        for name in names:
            cmd.fragment(name)

        with testing.mktemp('.pdb') as filename:
            cmd.multisave(filename, names[0])                       # new
            cmd.multisave(filename, names[1])                       # new (overwrite)
            cmd.multisave(filename, ' '.join(names[2:]), append=1)  # append
            cmd.delete('*')
            cmd.load(filename)

        self.assertEqual(cmd.get_object_list(), names[1:])
예제 #42
0
    def testMultisave(self):
        names = ['ala', 'gly', 'his', 'arg']

        for name in names:
            cmd.fragment(name)

        with testing.mktemp('.pdb') as filename:
            cmd.multisave(filename, names[0])                       # new
            cmd.multisave(filename, names[1])                       # new (overwrite)
            cmd.multisave(filename, ' '.join(names[2:]), append=1)  # append
            cmd.delete('*')
            cmd.load(filename)

        self.assertEqual(cmd.get_object_list(), names[1:])
예제 #43
0
    def testSaveState(self, format, pymol_version):
        if pymol_version > testing.PYMOL_VERSION[1]:
            self.skipTest("version %f" % (pymol_version))

        # for rms_cur (not all formats save all identifiers)
        m = -1
        cmd.set('retain_order')

        # create a multistate object
        cmd.fragment('ala', 'm1')
        cmd.create('m1', 'm1', 1, 2)
        cmd.create('m1', 'm1', 1, 3)
        cmd.translate([5, 0, 0], 'm1', state=2)
        cmd.translate([0, 5, 0], 'm1', state=3)
        n_states = cmd.count_states('m1')

        with testing.mktemp('.' + format) as filename:
            if format == 'mae' and not pymol.invocation.options.incentive_product:
                format = 'cms'

            # explicit
            for state in range(1, n_states + 1):
                cmd.delete('m2')
                cmd.save(filename, 'm1', state=state)
                cmd.load(filename, 'm2', format=format)
                rms = cmd.rms_cur('m1', 'm2', state, 1, matchmaker=m)
                self.assertAlmostEqual(rms, 0.00, delta=1e-2)

            # current state
            for state in range(1, n_states + 1):
                cmd.frame(state)
                cmd.delete('m2')
                cmd.save(filename, 'm1')
                cmd.load(filename, 'm2', 1, format=format)
                rms = cmd.rms_cur('m1', 'm2', state, 1, matchmaker=m)
                self.assertAlmostEqual(rms, 0.00, delta=1e-2)

            if format in ('mol', 'cms'):
                # no multi support
                return

            # all states
            cmd.delete('m2')
            cmd.save(filename, 'm1', state=0)
            cmd.load(filename, 'm2', 1, discrete=1, multiplex=0)
            self.assertEqual(cmd.count_states('m2'), n_states)
            for state in range(1, n_states + 1):
                rms = cmd.rms_cur('m1', 'm2 and state %d' % state,
                        state, state, matchmaker=m)
                self.assertAlmostEqual(rms, 0.00, delta=1e-2)
예제 #44
0
    def test(self, filename):
        cmd.load(self.datafile(filename), 'map')

        ori = ORIGINS[filename]
        ext = [ori, cpv.add(ori, EDGELENGTHS)]

        self.assertArrayEqual(cmd.get_extent('map'), ext, delta=1e-3)

        with testing.mktemp('.map') as filename:
            cmd.save(filename, 'map')
            cmd.delete('*')
            cmd.load(filename, 'map')

        self.assertArrayEqual(cmd.get_extent('map'), ext, delta=1e-3)
예제 #45
0
 def testSaveAlnNucleic(self):
     cmd.load(self.datafile('1rna.cif'))
     cmd.create('m1', 'chain A and not resi 6-7')
     cmd.create('m2', 'chain B')
     cmd.alter('m1 and resi 1', 'resn = "DT"')  # mimic DNA
     cmd.alter('m2 and resi 20', 'resn = "UNK"')  # mimic nonstd residue
     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', 'TUAUA--UAUAUAA'])
     self.assertEqual(lines[3].split(), ['m2', 'UUAUA?AUAUAUAA'])
예제 #46
0
 def testSaveAlnNucleic(self):
     cmd.load(self.datafile('1rna.cif'))
     cmd.create('m1', 'chain A and not resi 6-7')
     cmd.create('m2', 'chain B')
     cmd.alter('m1 and resi 1', 'resn = "DT"') # mimic DNA
     cmd.alter('m2 and resi 20', 'resn = "UNK"') # mimic nonstd residue
     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', 'TUAUA--UAUAUAA'])
     self.assertEqual(lines[3].split(), ['m2', 'UUAUA?AUAUAUAA'])
예제 #47
0
 def testRun(self, namespace, mod, rw):
     stored.tmp = False
     with testing.mktemp('.py') as filename:
         varname = '_tmp_' + namespace
         with open(filename, 'w') as handle:
             print('from pymol import stored', file=handle)
             if mod:
                 print('stored.tmp = (__name__ == "%s")' % (mod), file=handle)
             else:
                 print('stored.tmp = True', file=handle)
             print(varname + ' = True', file=handle)
         cmd.do('run %s, %s' % (filename, namespace), 0, 0)
         self.assertTrue(stored.tmp)
         if mod:
             self.assertEqual(rw, hasattr(sys.modules[mod], varname))
예제 #48
0
 def testRun(self, namespace, mod, rw):
     stored.tmp = False
     with testing.mktemp('.py') as filename:
         varname = '_tmp_' + namespace
         with open(filename, 'w') as handle:
             print('from pymol import stored', file=handle)
             if mod:
                 print('stored.tmp = (__name__ == "%s")' % (mod),
                       file=handle)
             else:
                 print('stored.tmp = True', file=handle)
             print(varname + ' = True', file=handle)
         cmd.do('run %s, %s' % (filename, namespace), 0, 0)
         self.assertTrue(stored.tmp)
         if mod:
             self.assertEqual(rw, hasattr(sys.modules[mod], varname))
예제 #49
0
    def test_undefined(self):
        cmd.fragment('gly')
        cmd.alter('name C', 'p["s_p_foo"] = "bar"')
        cmd.alter('name N', 'p["r_p_bar"] = 1.234')

        # save/load round-trip
        with testing.mktemp('.mae') as filename:
            cmd.save(filename)
            cmd.delete('*')
            cmd.load(filename, 'm1')

        myprops = {}
        cmd.iterate('all', 'myprops[name] = (p.s_p_foo, p.r_p_bar)', space=locals())

        self.assertEqual(myprops['O'], (None, None))
        self.assertEqual(myprops['C'], ("bar", None))
        self.assertEqual(myprops['N'], (None, 1.234))
예제 #50
0
 def testMAEsaveLoadSessionsWithAtomProperties(self):
     cmd.load(self.datafile('1molecule.mae'), '1molecule', atom_props='*')
     allpropdata = {}
     objs = cmd.get_object_list()
     stored.prop_lookup = {}
     for obj in objs:
         stored.prop_lookup[obj] = {}
         cmd.iterate(obj, "stored.prop_lookup['%s'][index-1] = properties.all" % obj)
     prop_lookup = stored.prop_lookup
     with testing.mktemp('.pse') as psefilename:
         cmd.save(psefilename)
         cmd.load(psefilename)
     stored.prop_lookup = {}
     for obj in objs:
         stored.prop_lookup[obj] = {}
         cmd.iterate(obj, "stored.prop_lookup['%s'][index-1] = properties.all" % obj)
     #test to make sure the properties are exactly the same from the saved session as the loaded session
     self.assertEqual(prop_lookup, stored.prop_lookup)
예제 #51
0
    def testMol2PartialChargeExport(self):
        cmd.fragment('gly')

        charges_pre = []
        cmd.iterate('*', 'charges_pre.append(partial_charge)', space=locals())

        # fragment library has charges, but better check...
        self.assertTrue(sum(abs(c) for c in charges_pre) > 0.0)

        with testing.mktemp('.mol2') as filename:
            cmd.save(filename)
            cmd.delete('*')
            cmd.load(filename)

        charges_post = []
        cmd.iterate('*', 'charges_post.append(partial_charge)', space=locals())

        self.assertArrayEqual(charges_pre, charges_post, delta=1e-2)
예제 #52
0
 def testPngExists(self, sync_in_main_thread, sync_in_thread):
     '''
     Save a PNG image with width/height specified and
     check if the file exists. a valid workaround would
     be to call sync(), but if sync() is called inside the
     thread, then it still doesnt work.  ideally we shouldnt
     need to call sync() at all, the png call should just do
     it
     '''
     cmd.pseudoatom('m1')
     cmd.show('spheres')
     with testing.mktemp('.png') as filename:
         th = threading.Thread(target=self._pngExistsAsync, args=[filename, sync_in_thread])
         th.start()
         th.join()
         if sync_in_main_thread:
             cmd.sync()
         self.assertTrue(os.path.exists(filename), 'png file not written')
예제 #53
0
    def test(self):
        cmd.fragment('gly')

        # atom properties
        cmd.alter('index 2-4', 'p.r_custom_indexhalve = index / 2.0')
        cmd.alter('index 3-5', 'p.neg_index = -index')
        cmd.alter('elem C', 'p["spaced resn name"] = resn + " " + name')

        # object properties
        objprops = [
            ('first', 'Max'),
            ('last', 'Mustermann'),
            ('full name', 'Max Mustermann'),
            ('quoted "name"', 'Max "Mustermann"'),
        ]
        for (key, value) in objprops:
            cmd.set_property(key, value)

        # save/load round-trip
        with testing.mktemp('.mae') as filename:
            cmd.save(filename)
            cmd.delete('*')
            cmd.set('load_object_props_default', '*')
            cmd.set('load_atom_props_default', '*')
            cmd.load(filename, 'm1')

        # type conversions
        cmd.alter('m1', 'p.neg_index = int(p.s_pymol_neg_index or 0)')

        # atom properties
        self.assertEqual(2, cmd.count_atoms('p.neg_index < -3'))
        self.assertEqual(2, cmd.count_atoms('p.r_custom_indexhalve > 1.0'))

        # changed in 2.3.1: undefined (<>) -> None
        resnname = set()
        cmd.iterate('m1', 'resnname.add(p["s_pymol_spaced resn name"] or "")', space=locals())
        self.assertEqual(resnname, set(['GLY C', 'GLY CA', '']))

        # object properties
        for (key, value) in objprops:
            self.assertEqual(cmd.get_property('s_pymol_' + key, 'm1'), value)