import os
import sys
import pymol
from pymol import cmd, testing, stored

pdbstr = '''ATOM      1  N   GLY    22      -1.195   0.201  -0.206  1.00  0.00           N  
ATOM      2  CA  GLY    22       0.230   0.318  -0.502  1.00  0.00           C  
ATOM      3  C   GLY    22       1.059  -0.390   0.542  1.00  0.00           C  
ATOM      4  O   GLY    22       0.545  -0.975   1.499  1.00  0.00           O  
ATOM      5  H   GLY    22      -1.558  -0.333   0.660  1.00  0.00           H  
ATOM      6 3HA  GLY    22       0.482   1.337  -0.514  0.00  0.00           H  
ATOM      7  HA  GLY    22       0.434  -0.159  -1.479  1.00  0.00           H  
END
'''

molstr = '''glycine
  ChemPy            3D                             0

  7  6  0  0  1  0  0  0  0  0999 V2000
   -1.1946    0.2011   -0.2061 N   0  0  0  0  0  0  0  0  0  0  0  0
    0.2304    0.3181   -0.5021 C   0  0  0  0  0  0  0  0  0  0  0  0
    1.0594   -0.3899    0.5419 C   0  0  0  0  0  0  0  0  0  0  0  0
    0.5454   -0.9749    1.4989 O   0  0  0  0  0  0  0  0  0  0  0  0
   -1.5576   -0.3329    0.6599 H   0  0  0  0  0  0  0  0  0  0  0  0
    0.4824    1.3374   -0.5137 H   0  0  0  0  0  0  0  0  0  0  0  0
    0.4344   -0.1589   -1.4791 H   0  0  0  0  0  0  0  0  0  0  0  0
  1  2  1  0  0  0  0
  1  5  1  0  0  0  0
  2  3  1  0  0  0  0
  2  6  1  0  0  0  0
  2  7  1  0  0  0  0
  3  4  2  0  0  0  0
M  END
'''

mmodstr = '''     7  gly
  34     2 1     5 1     0 0     0 0     0 0     0 0   -1.195000    0.201000   -0.206000    22G   38  0.00000  0.00000 GLY   N
   3     1 1     3 1     6 1     7 1     0 0     0 0    0.230000    0.318000   -0.502000    22G    2  0.00000  0.00000 GLY   CA
   7     2 1     4 2     0 0     0 0     0 0     0 0    1.059000   -0.390000    0.542000    22G    2  0.00000  0.00000 GLY   C
  15     3 2     0 0     0 0     0 0     0 0     0 0    0.545000   -0.975000    1.499000    22G   75  0.00000  0.00000 GLY   O
  44     1 1     0 0     0 0     0 0     0 0     0 0   -1.558000   -0.333000    0.660000    22G   21  0.00000  0.00000 GLY   H
  41     2 1     0 0     0 0     0 0     0 0     0 0    0.482000    1.337000   -0.514000    22G   21  0.00000  0.00000 GLY  3HA
  41     2 1     0 0     0 0     0 0     0 0     0 0    0.434000   -0.159000   -1.479000    22G   21  0.00000  0.00000 GLY   HA
'''


def _get_free_port() -> int:
    import socket
    with socket.socket() as s:
        s.bind(("", 0))
        return s.getsockname()[1]


class TestImporting(testing.PyMOLTestCase):

    @testing.requires('network')
    def testFetch(self):
        with testing.mkdtemp() as fetch_path:
            names = []
            cmd.set('fetch_path', fetch_path)
            cmd.set('fetch_host', 'pdb pdbe')

            cmd.fetch('1avy', '1avy1', type='pdb1')
            names += ['1avy1']
            self.assertItemsEqual(cmd.get_names(), names)
            self.assertEqual(cmd.count_states('1avy1'), 3)

            if testing.PYMOL_VERSION_TUPLE < (2, 0):
                self.skipTest('upstream download URL has changed')

            cmd.fetch('1avy', type='2fofc')
            names += ['1avy_2fofc']
            self.assertItemsEqual(cmd.get_names(), names)
            self.assertEqual(cmd.get_type('1avy_2fofc'), 'object:map')

    def testFetchLocal(self):
        try:
            import urllib.parse as urlparse
        except ImportError:
            import urlparse

        if os.getenv('GITHUB_ACTIONS') and sys.platform == 'win32':
            self.skipTest('Temporarily skip this test in GHA')
            return

        # PyMOL 1.8.6 adds full URLs, remove them
        pdbpaths = pymol.importing.hostPaths['pdb']
        if isinstance(pdbpaths, list):
            pdbpaths[:] = [p for p in pdbpaths if '://' not in p]

        with testing.mkdtemp() as fetch_path:
            names = []
            cmd.set('fetch_path', fetch_path)
            cmd.set('fetch_host', urlparse.urlunsplit(['file', '',
                self.datafile('pdb.mirror'), '', '']))

            cmd.fetch('1avy', type='pdb')
            names += ['1avy']
            self.assertItemsEqual(cmd.get_names(), names)

            cmd.fetch('1avyB', type='pdb')
            names += ['1avyB']
            self.assertItemsEqual(cmd.get_names(), names)
            self.assertEqual(cmd.get_chains('1avyB'), ['B'])

            cmd.fetch('1aq5', type='pdb', multiplex=1)
            names += ['1aq5_%04d' % (i+1) for i in range(20)]
            self.assertItemsEqual(cmd.get_names(), names)

    def testFinishObject(self):
        # Disclaimer: I don't know the relevance of load(..., finish=0) and
        # finish_object(), but it does call ObjectMoleculeUpdateIDNumbers
        # so I'll just test that.
        cmd.load(self.datafile("1ehz-5.pdb"), "m1", finish=0)
        cmd.alter('all', 'ID = -1')
        self.assertEqual(cmd.identify('last all'), [-1])
        cmd.finish_object('m1')
        self.assertEqual(cmd.identify('last all'), [224])
        # non-existing object name should throw
        self.assertRaises(pymol.CmdException, lambda: cmd.finish_object('m2'))

    def testLoad_append_state(self):
        filename = self.datafile("1ehz-5.pdb")
        cmd.load(filename)
        cmd.load(filename, format="pdb")
        self.assertEqual(cmd.get_names(), ["1ehz-5"])
        self.assertEqual(cmd.count_atoms(), 112)
        self.assertEqual(cmd.count_states(), 2)

    def testLoad_replace_state(self):
        filename = self.datafile("1ehz-5.pdb")
        cmd.load(filename)
        cmd.load(filename, state=1)
        self.assertEqual(cmd.get_names(), ["1ehz-5"])
        self.assertEqual(cmd.count_atoms(), 112)
        self.assertEqual(cmd.count_states(), 1)

    def testLoad_state_skip(self):
        filename = self.datafile("1ehz-5.pdb")
        cmd.load(filename)
        cmd.load(filename, state=3)
        self.assertEqual(cmd.count_states(), 3)

    def testLoad_no_zoom(self):
        view = cmd.get_view()
        cmd.load(self.datafile("1ehz-5.pdb"), zoom=0)
        self.assertEqual(view, cmd.get_view())

    @testing.requires('incentive')
    def testLoad_mimic(self):
        filename = self.datafile("repr.mae")
        cmd.load(filename, "m0", mimic=0)
        cmd.load(filename, "m1", mimic=1)
        self.assertFalse(
            cmd.get_setting_boolean("stick_ball", "m0.x_ballstick", state=1))
        self.assertTrue(
            cmd.get_setting_boolean("stick_ball", "m1.x_ballstick", state=1))

    @testing.requires_version('1.7.3.0')
    def testLoad_idx(self):
        cmd.load(self.datafile('desmond/Bace_mapper_20143_3a51a59_e85111a_solvent_11_replica0-out.idx'), state=1)
        self.assertEqual(cmd.count_states(), 209)
        self.assertEqual(cmd.count_atoms(), 2482)

    def testLoad_pqr(self):
        cmd.load(self.datafile('example.pqr'))
        charges = []
        radii = []
        n = cmd.iterate('all', 'charges.append(partial_charge);radii.append(elec_radius)', space=locals())
        self.assertEqual(n, 191)
        self.assertTrue(any(x != 0.0 for x in charges))
        self.assertTrue(any(x != 0.0 for x in radii))

    @testing.requires_version('2.2')
    def testLoad_pqr_various(self):
        import glob
        pqrdir = self.datafile('pqr')
        extent_expect = {
            19: [[1999.32, 2998.77, -901.70], [2008.4, 3006.35, -898.02]],
            36: [[1998.629, 2998.033, -902.509], [2008.765, 3006.347, -898.022]],
        }
        for filename in glob.glob(os.path.join(pqrdir, '*.pqr')):
            cmd.load(filename)
            n_atom = cmd.count_atoms()
            extent = cmd.get_extent()
            self.assertArrayEqual(extent, extent_expect[n_atom], delta=1e-2, msg=filename)
            if 'chain' in os.path.basename(filename):
                self.assertEqual(cmd.get_chains(), ['A'])
            else:
                self.assertEqual(cmd.get_chains(), [''])
            cmd.delete('*')

    @testing.foreach.product(
            ['sdf', 'mol2', 'xyz', 'pdb', 'mmd'],
            [0, 1],
            )
    def testLoad_multi(self, ext, discrete):
        '''
        Load multi-state files with discrete=0/1 and multiplex=0/1
        '''
        N = 10
        filename = self.datafile('ligs3d.' + ext)

        # mutiplex=0
        cmd.load(filename, discrete=discrete, multiplex=0)
        if testing.PYMOL_VERSION_TUPLE >= (1, 7):
            self.assertEqual(cmd.count_discrete('*'), discrete)
        self.assertEqual(cmd.count_states(), N)
        self.assertEqual(len(cmd.get_object_list()), 1)

        if ext in ['mmd']:
            return

        # mutiplex=1
        cmd.delete('*')
        cmd.load(filename, discrete=discrete, multiplex=1)
        if testing.PYMOL_VERSION_TUPLE >= (1, 7):
            self.assertEqual(cmd.count_discrete('*'), discrete * N)
        self.assertEqual(cmd.count_states(), 1)
        self.assertEqual(len(cmd.get_object_list()), N)

    @testing.foreach(
            ['.ccp4', True],
            ['.brix', True],
            ['.spi', False],
            )
    @testing.requires_version('1.7.3.0')
    def testLoad_map(self, ext, check_extent):
        filename = self.datafile('emd_1155' + ext)
        if not os.path.exists(filename):
            self.skipTest("missing " + filename)

        cmd.load(filename, 'map1')
        field = cmd.get_volume_field('map1', copy=0)
        self.assertEqual(field.shape, (141, 91, 281))

        if check_extent:
            extent = cmd.get_extent('map1')
            self.assertArrayEqual(extent, [[0.0, 0.0, 0.0], [2296.0, 1476.0, 4592.0]], delta=1e-2)

    @testing.requires_version('1.7.3.0')
    def testLoad_cube(self):
        cmd.load(self.datafile('h2o-elf.cube'))
        extent = cmd.get_extent('h2o-elf')
        self.assertArrayEqual(extent, [
            [  -0.075,  -0.075,  -0.075],
            [   5.925,   5.925,   5.925]], delta=1e3)
        field = cmd.get_volume_field('h2o-elf', copy=0)
        self.assertEqual(field.shape, (40, 40, 40))
        self.assertAlmostEqual(field.mean(), 0.06915, delta=1e-4)

    def _testLoad_dx(self, filename):
        cmd.load(self.datafile(filename), 'map1')
        extent = cmd.get_extent('map1')
        self.assertArrayEqual(extent, [[1.0, 2.0, 3.0], [5.0, 7.0, 9.0]], delta=1e-2)

    def testLoad_dx(self):
        self._testLoad_dx('mapaligned.dx')
        self._testLoad_dx('mapnumeric.dx')

    @testing.requires_version('2.1')
    def testLoad_dx_skewed(self):
        self._testLoad_dx('mapskewed.dx')

    @testing.requires_version('2.5')
    def testLoad_dxstr(self):
        with open(self.datafile('mapaligned.dx'), 'rb') as handle:
            cmd.load_raw(handle.read(), 'dx', 'map1')
        extent = cmd.get_extent('map1')
        self.assertArrayEqual(extent, [[1.0, 2.0, 3.0], [5.0, 7.0, 9.0]], delta=1e-2)

    def testLoadBrick(self):
        cmd.load_brick
        self.skipTest("TODO")

    def testLoadCallback(self):
        cmd.load_callback
        self.skipTest("TODO")

    def testLoadCgo(self):
        cmd.load_cgo
        self.skipTest("TODO")

    def testLoadEmbedded(self):
        cmd.load(self.datafile("embed.p1m"))
        self.assertEqual(6, cmd.count_atoms())
        self.assertEqual(2, cmd.count_atoms('elem O'))

    def testLoadMap(self):
        cmd.load_map
        self.skipTest("TODO")

    def testLoadModel(self):
        cmd.fragment('gly')
        m = cmd.get_model()
        cmd.delete('*')
        cmd.load_model(m, 'm1')
        self.assertEqual(7, cmd.count_atoms())

    def testLoadObject(self):
        cmd.load_object
        self.skipTest("TODO")

    def testLoadRaw(self):
        cmd.load_raw(open(self.datafile("sampletrajectory.pdb")).read(), "pdb")
        self.assertEqual(115, cmd.count_atoms())

    @testing.requires_version('2.3.3')
    def testLoadRawMMTF(self):
        import gzip
        with gzip.open(self.datafile("3njw.mmtf.gz")) as handle:
            cmd.load_raw(handle.read(), "mmtf")
        self.assertEqual(169, cmd.count_atoms())

    @testing.requires_version('2.5')
    def testLoadRawGRO(self):
        cmd.load_raw(open(self.datafile("sampletrajectory.gro")).read(), "gro")
        self.assertEqual(115, cmd.count_atoms())

    @testing.requires_version('2.4')
    def testLoadMMTFStr(self):
        # deprecated
        import gzip
        with gzip.open(self.datafile("3njw.mmtf.gz")) as handle:
            cmd.load(handle.read(), "m1", format="mmtfstr")
        self.assertEqual(169, cmd.count_atoms())

    @testing.foreach(
            ['.pdb', '.dcd'],
            ['.pdb', '.crd'],
            ['.gro', '.xtc'],
            )
    @testing.requires_version('1.7.3.0')
    def testLoadTraj(self, topext, trjext):
        pdbfile = self.datafile("sampletrajectory" + topext)
        dcdfile = self.datafile("sampletrajectory" + trjext)

        cmd.load(pdbfile)
        cmd.load_traj(dcdfile, state=0)
        self.assertEqual(11, cmd.count_states())
        cmd.delete('*')

        cmd.load(pdbfile)
        cmd.load_traj(dcdfile, state=1, interval=2, max=3)
        self.assertEqual(3, cmd.count_states())
        cmd.delete('*')

        cmd.load(pdbfile)
        cmd.load_traj(dcdfile, state=1, start=3, stop=5)
        self.assertEqual(3, cmd.count_states())
        cmd.delete('*')

        cmd.load(pdbfile)
        cmd.load_traj(dcdfile, state=1, stop=9, average=3)
        self.assertEqual(3, cmd.count_states())
        cmd.delete('*')

    # Changed in PyMOL 2.5: Default is now state=1 instead of state=0
    @testing.requires_version('2.5')
    def testLoadTraj_default_state_1(self):
        cmd.load(self.datafile("sampletrajectory.pdb"))
        cmd.load_traj(self.datafile("sampletrajectory.dcd"))
        self.assertEqual(10, cmd.count_states())

    # via ObjectMoleculeLoadTRJFile
    @testing.requires_version('1.7')
    def testLoadTraj_selection_trj(self):
        base = self.datafile("sampletrajectory")
        cmd.load(base + ".pdb")
        cmd.load_traj(base + ".crd", selection="backbone", format="trj", state=0)
        self.assertEqual(55, cmd.count_atoms('state 10'))

    # via PlugIOManager
    @testing.requires_version('2.4')
    def testLoadTraj_selection(self):
        base = self.datafile("sampletrajectory")
        cmd.load(base + ".gro")
        cmd.load_traj(base + ".xtc", selection="backbone", state=0)
        self.assertEqual(55, cmd.count_atoms('state 10'))

    @testing.requires_version('1.8.5')
    def testLoadCharmmCor(self):
        # http://www.ks.uiuc.edu/Research/vmd/plugins/molfile/corplugin.html
        for fmt in ['', 'cor']:
            cmd.load(self.datafile("charmm.crd"), format=fmt)
            self.assertEqual(81, cmd.count_atoms(), 'fmt: ' + fmt)
            cmd.delete('*')

    def testLoadTOP(self):
        '''
        Data files from:
        http://ambermd.org/tutorials/basic/tutorial2/section6.htm
        '''
        cmd.load(self.datafile("TRPcage.top"))
        cmd.load_traj(self.datafile("heat1.crd"), "TRPcage", format="trj", state=0)
        self.assertEqual(304, cmd.count_atoms())
        self.assertEqual(10, cmd.count_states())

    @testing.requires_version('1.7.5')
    def testLoadPSF(self):
        cmd.load(self.datafile("ubiquitin.psf"))
        self.assertEqual(26190, cmd.count_atoms())
        self.assertEqual(0, cmd.count_states())

    @testing.requires_version('1.7.5')
    def testLoadVaspCHGCAR(self):
        cmd.load(self.datafile("vasp.CHGCAR"), 'vasp.CHGCAR')
        self.assertEqual(cmd.get_type('vasp.CHGCAR'), 'object:map')
        extend = cmd.get_extent('vasp.CHGCAR')
        self.assertArrayEqual(extend, [[0.0, 0.0, 0.0], [6.5, 6.5, 7.7]], delta=1e-2)

    @testing.requires_version('1.7.5')
    def testLoadVaspOUTCAR(self):
        cmd.load(self.datafile("vasp.OUTCAR"))
        self.assertEqual(2, cmd.count_atoms())
        self.assertEqual(11, cmd.count_states())

    @testing.requires_version('1.7.5')
    def testLoadVaspPOSCAR(self):
        cmd.load(self.datafile("vasp.POSCAR"))
        self.assertEqual(2, cmd.count_atoms())
        self.assertEqual(1, cmd.count_states())

    @testing.requires_version('1.8.5.0')
    def testLoadMSMSSurface(self):
        cmd.load(self.datafile('surface.face'))
        e = cmd.get_extent('surface')
        self.assertArrayEqual(e, [
            [28.003,  25.573,  12.883],
            [34.238,  31.434,  17.835]], delta=1e-3)

    @testing.requires_version('1.7')  # broken before
    def testReadMmodstr(self):
        cmd.read_mmodstr(mmodstr, 'm1')
        self.assertEqual(7, cmd.count_atoms())

    def testReadMolstr(self):
        cmd.read_molstr(molstr, 'm1')
        self.assertEqual(7, cmd.count_atoms())

    def testReadPdbstr(self):
        cmd.read_pdbstr(pdbstr, 'm1')
        self.assertEqual(7, cmd.count_atoms())

        cmd.read_pdbstr(pdbstr, 'm1')
        self.assertEqual(2, cmd.count_states())

    def testReadSdfstr(self):
        sdfstr = molstr + '$$$$\n'

        cmd.read_sdfstr(sdfstr, 'm1')
        self.assertEqual(7, cmd.count_atoms())

    @testing.requires_version('1.8.3.1')
    def testLoadSDFV3000(self):
        cmd.load(self.datafile("v3000.sdf"))
        self.assertEqual(12, cmd.count_atoms())
        self.assertEqual( 1, cmd.count_atoms('formal_charge = +1'))
        self.assertEqual( 1, cmd.count_atoms('formal_charge = -1'))
        self.assertEqual( 6, cmd.count_atoms('elem C'))
        self.assertEqual( 6, cmd.count_atoms('elem H'))
        self.assertEqual( 4, cmd.count_atoms('(first elem H) extend 2'))

    def testReadXplorstr(self):
        cmd.read_xplorstr
        self.skipTest("TODO")

    def testSetSession(self):
        # see TestExporting.testGetSession
        pass

    def testSpace(self):
        cmd.space('pymol', 0.5)
        cmd.space('cmyk', 0.7)
        cmd.space('rgb')
        # CmdException before 2.5, now QuietException (from Shortcut)
        self.assertRaises((pymol.CmdException, cmd.QuietException),
                          lambda: cmd.space('no-such-space'))
        pymol_data = os.environ['PYMOL_DATA']
        os.environ['PYMOL_DATA'] = '/no/such/dir'
        pymol_path = os.environ['PYMOL_PATH']  # PyMOL 1.x
        os.environ['PYMOL_PATH'] = '/no/such/dir'  # PyMOL 1.x
        try:
            self.assertRaises(pymol.CmdException, lambda: cmd.space('cmyk'))
        finally:
            os.environ['PYMOL_DATA'] = pymol_data
            os.environ['PYMOL_PATH'] = pymol_path  # PyMOL 1.x

    @testing.requires_version('1.7.3.0')
    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')))

    @testing.requires_version('1.7.3.0')
    def testLoadCoordset(self):
        import numpy
        cmd.fragment('gly', 'm1')
        coords = cmd.get_coordset('m1')
        cmd.load_coordset(coords, 'm1', state=2)
        self.assertEqual(2, cmd.count_states('m1'))

        # data manipulation with copy=0
        cmd.get_coordset('m1', copy=0)[:] += 5.0
        self.assertTrue(numpy.allclose(coords + 5.0, cmd.get_coords('m1')))

    @testing.requires_version('1.7.7')
    def testLoadPDBML(self):
        cmd.load(self.datafile("1ubq.xml.gz"))
        self.assertEqual(660, cmd.count_atoms())
        symmetry = cmd.get_symmetry()
        self.assertArrayEqual(symmetry[:6], [50.84, 42.77, 28.95, 90.0, 90.0, 90.0], delta=1e-4)
        self.assertEqual(symmetry[6], 'P 21 21 21')

    @testing.requires_version('1.7.7')
    def testLoadCML(self):
        cmd.load(self.datafile("GLY.cml"))
        self.assertEqual(10, cmd.count_atoms())

    @testing.requires_version('1.7.7')
    def testLoadPDBQT(self):
        cmd.set('retain_order')
        cmd.load(self.datafile("NSC7810.pdbqt"))
        charges = []
        n = cmd.iterate('all', 'charges.append(partial_charge)', space=locals())
        self.assertEqual(n, 26)
        charges_expected = [0.002, 0.012, -0.024, 0.012, 0.002, 0.019, 0.052,
                0.002, -0.013, 0.013, -0.013, 0.002, 0.013, -0.024, 0.052,
                0.012, 0.012, 0.002, 0.002, 0.019, 0.21, -0.644, -0.644,
                0.21, -0.644, -0.644]
        self.assertArrayEqual(charges, charges_expected, delta=1e-4)

    @testing.requires_version('2.6')
    def testLoadPLY(self):
        cmd.load(self.datafile("test_PHE_pentamer.ply.gz"))
        e = cmd.get_extent('test_PHE_pentamer')
        self.assertArrayEqual(e, [[-3.141,-3.036,-2.809], [15.920, 10.425, 8.680]], delta=1e-3)

    @testing.requires_version('1.8.4')
    def testLoadMMTF(self):
        cmd.load(self.datafile("3njw.mmtf.gz"))
        self.assertEqual(169, cmd.count_atoms())
        self.assertEqual(36, cmd.count_atoms('ss S'))
        self.assertEqual(25, cmd.count_atoms('solvent'))
        self.assertEqual(25, cmd.count_atoms('not polymer'))
        symmetry = cmd.get_symmetry()
        self.assertArrayEqual(symmetry[:6], [19.465, 21.432, 29.523, 90.0, 90.0, 90.0], delta=1e-4)
        self.assertEqual(symmetry[6], 'P 21 21 21')

    @testing.requires_version('2.6')
    def testLoadMMTF_polymer(self):
        cmd.load(self.datafile("1x8x.mmtf.gz"))
        self.assertEqual(2780, cmd.count_atoms())
        self.assertEqual(2544, cmd.count_atoms('polymer'))
        self.assertEqual(218, cmd.count_atoms('solvent'))
        self.assertEqual(13, cmd.count_atoms('organic'))
        self.assertEqual(5, cmd.count_atoms('inorganic'))

    @testing.requires_version('1.8.4')
    def testLoadMMTFEmpty(self):
        cmd.load(self.datafile("mmtf/empty-all0.mmtf"))
        self.assertEqual(cmd.count_states(), 0)
        cmd.delete('*')

        cmd.load(self.datafile("mmtf/empty-numModels1.mmtf.gz"))
        self.assertEqual(cmd.count_atoms(), 0)
        self.assertEqual(cmd.get_names(), ["empty-numModels1"])
        cmd.delete('*')

        cmd.load(self.datafile("mmtf/empty-numChains1.mmtf.gz"))
        self.assertEqual(cmd.count_atoms(), 0)
        self.assertEqual(cmd.get_names(), ["empty-numChains1"])
        cmd.delete('*')

        cmd.load(self.datafile("mmtf/empty-mmtfVersion99999999.mmtf"))
        self.assertEqual(cmd.get_names(), [])
        cmd.delete('*')

    @testing.requires_version('2.3.3')
    def testLoadMMTFMissingOptionalGroupTypeFields(self):
        cmd.load(self.datafile("mmtf/missing-optional-grouptype-fields.mmtf.gz"))
        self.assertEqual(cmd.count_atoms(), 17)
        self.assertEqual(len(cmd.get_bonds()), 7)

    @testing.foreach(
            ['', '*',                   True],
            ['', 'pdb_header',          True],
            ['', 'x pdb_header y',      True],
            ['', 'other',               False],
            ['',                None,   False],
            ['other',           None,   False],
            ['pdb_header',      None,   True],
            ['x pdb_header y',  None,   True],
            ['*',               None,   True],
            )
    @testing.requires_version('1.8.4')
    @testing.requires('incentive')
    def testPdbHeader(self, load_object_props_default, object_props, truth):
        cmd.set('load_object_props_default', load_object_props_default)
        cmd.load(self.datafile('1rx1.pdb'), 'm1', object_props=object_props)
        self.assertEqual(truth, 'pdb_header' in (cmd.get_property_list('m1') or ()))

    @testing.requires_version('2.4')
    @testing.requires(
        'network'
    )  # doesn't use external network, but is very slow while being connected to VPN
    def testLoadPWG(self):
        if sys.version_info[0] < 3:
            import urllib2
        else:
            import urllib.request as urllib2

        content_index = b'Hello World\n'
        port = _get_free_port()
        baseurl = 'http://localhost:%d' % port

        def urlread(url):
            handle = urllib2.urlopen(url, timeout=3.0)
            try:
                return handle.info(), handle.read()
            finally:
                handle.close()

        with testing.mkdtemp() as rootdir:
            filename = os.path.join(rootdir, 'index.html')
            with open(filename, 'wb') as handle:
                handle.write(content_index)

            filename = os.path.join(rootdir, 'start.pwg')
            with open(filename, 'w') as handle:
                handle.write('root %s\n' % rootdir)
                handle.write('port %d\n' % port)
                handle.write('header add Test-Key Test-Value\n') # new in 2.4
            cmd.load(filename)

            header, content = urlread(baseurl)
            self.assertEqual(header['Test-Key'], 'Test-Value')
            self.assertEqual(content, content_index)

            # Warning: can't call locking functions here, will dead-lock
            # get_version is non-locking since 1.7.4

            header, content = urlread(baseurl + '/apply/pymol.cmd.get_version')
            content = content.decode('ascii', errors='ignore')
            self.assertTrue(content, cmd.get_version()[0] in content)

    @testing.requires_version('2.1')
    def testChemCompCartnUse(self):
        xyz_model = (1., 2., 3.)
        xyz_ideal = (4., 5., 6.)
        xyz_short = (7., 8., 9.)

        for (value, xyz) in [
                (0x00, xyz_ideal),
                (0x01, xyz_ideal),
                (0x02, xyz_model),
                (0x03, xyz_ideal),
                (0x04, xyz_short),
                (0x05, xyz_ideal),
                (0x06, xyz_model),
                (0x07, xyz_ideal),
            ]:
            cmd.set('chem_comp_cartn_use', value)
            cmd.load(self.datafile('chem_comp-fe.cif'), 'm1')
            self.assertArrayEqual(xyz, cmd.get_coords('m1').reshape(-1))
            cmd.delete('*')

    @testing.requires_version('2.1')
    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)

    @testing.requires_version('2.4')
    def testCifAltAtomId(self):
        cmd.load(self.datafile('sia-alt-id.cif'), 'm1')
        self.assertEqual(cmd.count_atoms('bound_to name C1'), 3)
        self.assertEqual(cmd.count_atoms('(bound_to name C1) and name C3'), 0)

    @testing.requires_version('2.5')
    def testCifErrorHandling(self):
        with self.assertRaisesRegex(pymol.CmdException,
                                    'Parsing CIF file failed: expected key'):
            cmd.load_raw('data_foo _k.a 1 2 3', 'cif', 'm1')
        with self.assertRaisesRegex(pymol.CmdException,
                                    'Parsing CIF file failed: truncated loop'):
            cmd.load_raw('data_foo loop_ _k.a _k.b 1 2 3', 'cif', 'm2')