pyjess 0.7.0__cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

pyjess/tests/data/template_01.qry

@@ -0,0 +1,11 @@
+ATOM      0  ND1 HIS E 142       4.191  -2.584   4.209
+ATOM      0  NE2 HIS E 142       3.847  -2.332   2.058
+ATOM      0  OE1 GLU E 143       0.491  -4.480  -0.456
+ATOM      0  OE2 GLU E 143       1.864  -5.931   0.301
+ATOM      0  CG  HIS E 146       0.000   0.000   0.000
+ATOM      0  ND1 HIS E 146       0.837   1.123   0.000
+ATOM      0  CD2 HIS E 146       0.809  -1.085   0.000
+ATOM      0  CE1 HIS E 146       2.102   0.717  -0.028
+ATOM      0  NE2 HIS E 146       2.112  -0.611  -0.015
+ATOM      0  OE1 GLU E 166       5.568  -0.214   0.181
+ATOM      0  OE2 GLU E 166       5.790  -0.332   0.398

pyjess/tests/data/template_02.qry

@@ -0,0 +1,11 @@
+ATOM      0  NZ  LYS A1030       1.431  -9.717  -1.722
+ATOM      0  CG  ASP A1132       0.000   0.000   0.000
+ATOM      0  OD1 ASP A1132       0.595   1.085   0.000
+ATOM      0  OD2 ASP A1132       0.609  -1.111   0.000
+ATOM      1  NE  ARG A1136       3.953   0.597  -1.721 K
+ATOM      0  CG  ASN A1137       0.736  -1.869  -4.261
+ATOM      0  OD1 ASN A1137       1.760  -2.435  -4.344
+ATOM      0  ND2 ASN A1137       0.264  -1.477  -3.134
+ATOM      0  CG  ASP A1150      -0.010  -5.408  -2.070
+ATOM      0  OD1 ASP A1150      -0.587  -5.769  -1.153
+ATOM      0  OD2 ASP A1150       1.085  -5.212  -2.011

pyjess/tests/test_atom.py

@@ -0,0 +1,111 @@
+import ctypes
+import unittest
+import pickle
+
+from .._jess import Atom
+
+
+class TestAtom(unittest.TestCase):
+    
+    def _create_atom(self, **kwargs):
+        default = dict(serial=1, name='N', altloc=' ', residue_name='GLN', chain_id='A', residue_number=3, x=8.171, y=-51.403, z=42.886, segment='', insertion_code=' ', occupancy=1.0, temperature_factor=55.63, charge=0, element='N')
+        default.update(kwargs)
+        return Atom(**default)
+
+    def test_load(self):
+        atom = Atom.loads("ATOM     39  CA  PRO A 469     -14.948   2.091  10.228  1.00 27.71           C")
+        self.assertEqual(atom.serial, 39)
+        self.assertEqual(atom.name, 'CA')
+        self.assertEqual(atom.residue_name, 'PRO')
+        self.assertEqual(atom.chain_id, 'A')
+        self.assertEqual(atom.residue_number, 469)
+        self.assertAlmostEqual(atom.x, -14.948, places=3)
+        self.assertAlmostEqual(atom.y, 2.091, places=3)
+        self.assertAlmostEqual(atom.z, 10.228, places=3)
+        self.assertAlmostEqual(atom.occupancy, 1.00, places=2)
+        self.assertAlmostEqual(atom.temperature_factor, 27.71, places=2)
+        self.assertEqual(atom.segment, '')
+        self.assertEqual(atom.element, 'C')
+        self.assertEqual(atom.charge, 0)
+
+    def test_init_consistency(self):
+        loaded = Atom.loads("ATOM     39  CA  PRO A 469     -14.948   2.091  10.228  1.00 27.71           C")
+        created = Atom(
+            serial=loaded.serial,
+            name=loaded.name,
+            residue_name=loaded.residue_name,
+            chain_id=loaded.chain_id,
+            altloc=loaded.altloc,
+            insertion_code=loaded.insertion_code,
+            residue_number=loaded.residue_number,
+            x=loaded.x,
+            y=loaded.y,
+            z=loaded.z,
+            occupancy=loaded.occupancy,
+            temperature_factor=loaded.temperature_factor,
+            element=loaded.element,
+        )
+        self.assertEqual(loaded, created)
+        
+    def test_init_invalid_chain_id(self):
+        self.assertRaises(ValueError, self._create_atom, chain_id="too long")
+
+    def test_init_invalid_name(self):
+        self.assertRaises(ValueError, self._create_atom, name="too long")
+
+    def test_init_invalid_residue_name(self):
+        self.assertRaises(ValueError, self._create_atom, residue_name="too long")
+
+    def test_hash(self):
+        a1 = self._create_atom()
+        a2 = self._create_atom()
+        self.assertEqual(hash(a1), hash(a2))
+        self.assertIsNot(a1, a2)
+        a3 = self._create_atom(x=1.0)
+        self.assertNotEqual(hash(a1), hash(a3))
+
+    def test_eq(self):
+        a1 = self._create_atom()
+        a2 = self._create_atom()
+        self.assertEqual(a1, a2)
+        self.assertIsNot(a1, a2)
+        a3 = self._create_atom(x=1.0)
+        self.assertNotEqual(a1, a3)
+
+    def test_repr_roundtrip(self):
+        atom = self._create_atom()
+        copy = eval(repr(atom))
+        self.assertEqual(atom.serial, copy.serial)
+        self.assertEqual(atom.altloc, copy.altloc)
+        self.assertEqual(atom.name, copy.name)
+        self.assertEqual(atom.residue_name, copy.residue_name)
+        self.assertEqual(atom.residue_number, copy.residue_number)
+        self.assertEqual(atom.element, copy.element)
+        self.assertEqual(atom.insertion_code, copy.insertion_code)
+        self.assertEqual(atom.chain_id, copy.chain_id)
+        self.assertEqual(atom.occupancy, copy.occupancy)
+        self.assertEqual(atom.temperature_factor, copy.temperature_factor)
+        self.assertEqual(atom.charge, copy.charge)
+        self.assertEqual(atom.x, copy.x)
+        self.assertEqual(atom.y, copy.y)
+        self.assertEqual(atom.z, copy.z)
+        self.assertEqual(atom, copy)
+
+    def test_pickle_roundtrip(self):
+        atom = self._create_atom()
+        copy = pickle.loads(pickle.dumps(atom))
+        self.assertEqual(atom.serial, copy.serial)
+        self.assertEqual(atom.altloc, copy.altloc)
+        self.assertEqual(atom.name, copy.name)
+        self.assertEqual(atom.residue_name, copy.residue_name)
+        self.assertEqual(atom.residue_number, copy.residue_number)
+        self.assertEqual(atom.element, copy.element)
+        self.assertEqual(atom.insertion_code, copy.insertion_code)
+        self.assertEqual(atom.chain_id, copy.chain_id)
+        self.assertEqual(atom.occupancy, copy.occupancy)
+        self.assertEqual(atom.temperature_factor, copy.temperature_factor)
+        self.assertEqual(atom.charge, copy.charge)
+        self.assertEqual(atom.x, copy.x)
+        self.assertEqual(atom.y, copy.y)
+        self.assertEqual(atom.z, copy.z)
+        self.assertEqual(atom, copy)

pyjess/tests/test_doctest.py

@@ -0,0 +1,78 @@
+# coding: utf-8
+"""Test doctest contained tests in every file of the module.
+"""
+
+import configparser
+import doctest
+import importlib
+import json
+import gzip
+import os
+import pkgutil
+import re
+import shutil
+import sys
+import types
+import warnings
+from unittest import mock
+
+import pyjess
+
+
+def _load_tests_from_module(tests, module, globs, setUp=None, tearDown=None):
+    """Load tests from module, iterating through submodules."""
+    for attr in (getattr(module, x) for x in dir(module) if not x.startswith("_")):
+        if isinstance(attr, types.ModuleType):
+            suite = doctest.DocTestSuite(
+                attr,
+                globs,
+                setUp=setUp,
+                tearDown=tearDown,
+                optionflags=+doctest.ELLIPSIS,
+            )
+            tests.addTests(suite)
+    return tests
+
+
+def load_tests(loader, tests, ignore):
+    """`load_test` function used by unittest to find the doctests."""
+    _current_cwd = os.getcwd()
+
+    def setUp(self):
+        warnings.simplefilter("ignore")
+        os.chdir(os.path.realpath(os.path.join(__file__, os.path.pardir, "data")))
+
+    def tearDown(self):
+        os.chdir(_current_cwd)
+        warnings.simplefilter(warnings.defaultaction)
+
+    # doctests are not compatible with `green`, so we may want to bail out
+    # early if `green` is running the tests
+    if sys.argv[0].endswith("green"):
+        return tests
+
+    # recursively traverse all library submodules and load tests from them
+    packages = [None, pyjess]
+    for pkg in iter(packages.pop, None):
+        for (_, subpkgname, subispkg) in pkgutil.walk_packages(pkg.__path__):
+            # do not import __main__ module to avoid side effects!
+            if subpkgname == "__main__" or subpkgname.startswith("tests") or subpkgname.startswith("cli"):
+                continue
+            # import the submodule and add it to the tests
+            module = importlib.import_module(".".join([pkg.__name__, subpkgname]))
+            globs = dict(pyjess=pyjess, **module.__dict__)
+            tests.addTests(
+                doctest.DocTestSuite(
+                    module,
+                    globs=globs,
+                    setUp=setUp,
+                    tearDown=tearDown,
+                    optionflags=+doctest.ELLIPSIS,
+                )
+            )
+            # if the submodule is a package, we need to process its submodules
+            # as well, so we add it to the package queue
+            if subispkg and subpkgname != "tests":
+                packages.append(module)
+
+    return tests

pyjess/tests/test_hit.py

@@ -0,0 +1,57 @@
+import math
+import unittest
+import sys
+import pickle
+import textwrap
+
+from .._jess import Template, Molecule, Jess
+from .utils import files
+from . import data
+
+
+class TestHit(unittest.TestCase):
+    
+    maxDiff = None
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    @classmethod
+    def setUpClass(cls):
+        with files(data).joinpath("template_01.qry").open() as f:
+            template = Template.load(f, id="T1")
+            jess = Jess([template])
+        with files(data).joinpath("pdb1lnb.pdb").open() as f:
+            molecule = Molecule.load(f)
+
+        cls.hit = next(jess.query(molecule, 1, 2, 2))
+        
+    def test_pickle(self):
+        hit = pickle.loads(pickle.dumps(self.hit))
+        self.assertIsNot(self.hit, hit)
+        self.assertEqual(self.hit.rmsd, hit.rmsd)
+        self.assertEqual(self.hit.determinant, hit.determinant)
+        self.assertEqual(self.hit.evalue, hit.evalue)
+        self.assertEqual(self.hit.template, hit.template)
+        self.assertListEqual(self.hit.atoms(transform=True), hit.atoms(transform=True))
+        self.assertListEqual(self.hit.atoms(transform=False), hit.atoms(transform=False))
+        self.assertEqual(self.hit.molecule(transform=False), hit.molecule(transform=False))
+
+    def test_dumps(self):
+        expected = textwrap.dedent(
+            """
+            REMARK 1LNB 0.555 T1 Det= 1.0 log(E)~ -2.04
+            ATOM   1112  ND1 HIS E 142       4.157  -2.574   4.091  1.00 10.22
+            ATOM   1115  NE2 HIS E 142       3.805  -2.316   1.890  1.00 16.00
+            ATOM   1123  OE1 GLU E 143       0.480  -4.544  -0.363  1.00 14.72
+            ATOM   1124  OE2 GLU E 143       1.870  -6.097   0.337  1.00 22.48
+            ATOM   1145  CG  HIS E 146       0.031   0.017   0.019  1.00 12.45
+            ATOM   1146  ND1 HIS E 146       0.823   1.160   0.000  1.00 15.79
+            ATOM   1147  CD2 HIS E 146       0.878  -1.064   0.006  1.00 20.85
+            ATOM   1148  CE1 HIS E 146       2.115   0.777  -0.013  1.00 13.50
+            ATOM   1149  NE2 HIS E 146       2.181  -0.553  -0.032  1.00 12.44
+            ATOM   1298  OE1 GLU E 166       6.432  -0.605   1.056  1.00 16.03
+            ATOM   1299  OE2 GLU E 166       4.839   0.070  -0.343  1.00 19.31
+            ENDMDL
+            """
+        ).strip()
+        actual = self.hit.dumps().strip()
+        self.assertMultiLineEqual(actual, expected)

pyjess/tests/test_jess.py

@@ -0,0 +1,374 @@
+import math
+import unittest
+import sys
+import pickle
+
+from .._jess import Template, Molecule, Jess
+from .utils import files
+from . import data
+
+
+class TestJess(unittest.TestCase):
+
+    def test_init_empty(self):
+        jess = Jess()
+        self.assertEqual(len(jess), 0)
+        self.assertFalse(bool(jess))
+
+    def test_query_empty(self):
+        mol = Molecule()
+        jess = Jess()
+        hits = jess.query(mol, 2, 2, 4)
+        self.assertRaises(StopIteration, next, hits)
+
+    def test_hash_empty(self):
+        j1 = Jess()
+        j2 = Jess()
+        self.assertEqual(j1, j2)
+        self.assertEqual(hash(j1), hash(j2))
+        self.assertIsNot(j1, j2)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_copy(self):
+        with files(data).joinpath("template_01.qry").open() as f:
+            template1 = Template.load(f)
+        with files(data).joinpath("template_02.qry").open() as f:
+            template2 = Template.load(f)
+        jess = Jess([template1, template2])
+        copy = jess.copy()
+        self.assertEqual(jess, copy)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_hash(self):
+        with files(data).joinpath("template_01.qry").open() as f:
+            template1 = Template.load(f)
+        with files(data).joinpath("template_02.qry").open() as f:
+            template2 = Template.load(f)
+        j1 = Jess([template1, template2])
+        j2 = Jess([template1, template2])
+        self.assertEqual(hash(j1), hash(j2))
+        self.assertIsNot(j1, j2)
+        j3 = Jess([template1])
+        self.assertNotEqual(hash(j1), hash(j3))
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_eq(self):
+        with files(data).joinpath("template_01.qry").open() as f:
+            template1 = Template.load(f)
+        with files(data).joinpath("template_02.qry").open() as f:
+            template2 = Template.load(f)
+        j1 = Jess([template1, template2])
+        j2 = Jess([template1, template2])
+        self.assertEqual(j1, j2)
+        self.assertIsNot(j1, j2)
+        j3 = Jess([template1])
+        self.assertNotEqual(j1, j3)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_pickle_roundtrip(self):
+        with files(data).joinpath("template_01.qry").open() as f:
+            template1 = Template.load(f)
+        with files(data).joinpath("template_02.qry").open() as f:
+            template2 = Template.load(f)
+        jess = Jess([template1, template2])
+        copy = pickle.loads(pickle.dumps(jess))
+        self.assertEqual(jess, copy)
+
+    @unittest.skipUnless(sys.implementation.name == "cpython", "only available on CPython")
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_sizeof(self):
+        with files(data).joinpath("template_01.qry").open() as f:
+            template = Template.load(f)
+            jess = Jess([template])
+        self.assertGreater(sys.getsizeof(jess), 0)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_getitem(self):
+        with files(data).joinpath("template_01.qry").open() as f:
+            template = Template.load(f)
+            jess = Jess([template])
+
+        self.assertEqual(jess[0], template)
+        self.assertEqual(len(jess[:1]), 1)
+        self.assertEqual(len(jess[1:]), 0)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_multiple_query_split(self):
+        with files(data).joinpath("template_01.qry").open() as f:
+            template1 = Template.load(f)
+        with files(data).joinpath("template_02.qry").open() as f:
+            template2 = Template.load(f)
+        j0 = Jess([template1, template2])
+        j1 = Jess([template1])
+        j2 = Jess([template2])
+
+        with files(data).joinpath("1AMY.pdb").open() as f:
+            molecule = Molecule.load(f)
+
+        h0 = list(j0.query(molecule, 2, 5, 5))
+        h1 = list(j1.query(molecule, 2, 5, 5))
+        h2 = list(j2.query(molecule, 2, 5, 5))
+
+        self.assertEqual(len(h0), len(h1) + len(h2))
+        for hit0, hit1 in zip(h0, (*h1, *h2)):
+            self.assertEqual(hit0.atoms(), hit1.atoms())
+            self.assertEqual(hit0.evalue, hit1.evalue)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_query_template_subclass(self):
+
+        class MyTemplate(Template):
+            pass
+        
+        with files(data).joinpath("template_01.qry").open() as f:
+            template = MyTemplate.load(f)
+            jess = Jess([template])
+        with files(data).joinpath("pdb1lnb.pdb").open() as f:
+            molecule = Molecule.load(f)
+
+        self.assertEqual(jess[0], template)
+        self.assertIsInstance(jess[0], MyTemplate)
+        hits = list(jess.query(molecule, 1, 2, 2))
+        self.assertIsInstance(hits[0].template, MyTemplate)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_query_max_candidates(self):
+        with files(data).joinpath("template_01.qry").open() as f:
+            template = Template.load(f)
+            jess = Jess([template])
+        with files(data).joinpath("pdb1lnb.pdb").open() as f:
+            molecule = Molecule.load(f)
+
+        hits = list(jess.query(molecule, 2, 5, 5))
+        self.assertEqual(len(hits), 3)
+
+        hits = list(jess.query(molecule, 2, 5, 5, max_candidates=3))
+        self.assertEqual(len(hits), 3)
+
+        hits = list(jess.query(molecule, 2, 5, 5, max_candidates=2))
+        self.assertEqual(len(hits), 2)
+
+        hits = list(jess.query(molecule, 2, 5, 5, max_candidates=1))
+        self.assertEqual(len(hits), 1)
+
+        with self.assertRaises(ValueError):
+            hits = list(jess.query(molecule, 2, 5, 5, max_candidates=-1))
+        
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_query(self):
+        with files(data).joinpath("template_01.qry").open() as f:
+            template = Template.load(f)
+            jess = Jess([template])
+        with files(data).joinpath("pdb1lnb.pdb").open() as f:
+            molecule = Molecule.load(f)
+
+        hits = list(jess.query(molecule, 1, 2, 2))
+        self.assertEqual(len(hits), 1)
+        self.assertIs(hits[0].template, template)
+        self.assertAlmostEqual(hits[0].rmsd, 0.555, places=3)
+        self.assertAlmostEqual(hits[0].determinant, 1.0, places=3)
+        self.assertAlmostEqual(hits[0].log_evalue, -2.04, places=1)
+        self.assertAlmostEqual(hits[0].evalue, math.exp(-2.04), places=1)
+
+        hits = list(jess.query(molecule, 2, 5, 3))
+        self.assertEqual(len(hits), 2)
+        self.assertIs(hits[0].template, template)
+        self.assertAlmostEqual(hits[0].rmsd, 0.555, places=3)
+        self.assertAlmostEqual(hits[0].determinant, 1.0, places=3)
+        self.assertAlmostEqual(hits[0].log_evalue, -2.04, places=1)
+        self.assertAlmostEqual(hits[0].evalue, math.exp(-2.04), places=1)
+        self.assertIs(hits[1].template, template)
+        self.assertAlmostEqual(hits[1].rmsd, 1.440, places=3)
+        self.assertAlmostEqual(hits[1].determinant, 1.0, places=3)
+        self.assertAlmostEqual(hits[1].log_evalue, 0.17, places=1)
+        self.assertAlmostEqual(hits[1].evalue, math.exp(0.17), places=1)
+
+        hits = list(jess.query(molecule, 2, 5, 5))
+        self.assertEqual(len(hits), 3)
+        self.assertIs(hits[0].template, template)
+        self.assertAlmostEqual(hits[0].rmsd, 0.555, places=3)
+        self.assertAlmostEqual(hits[0].determinant, 1.0, places=3)
+        self.assertAlmostEqual(hits[0].log_evalue, -2.04, places=1)
+        self.assertAlmostEqual(hits[0].evalue, math.exp(-2.04), places=1)
+        self.assertIs(hits[1].template, template)
+        self.assertAlmostEqual(hits[1].rmsd, 1.440, places=3)
+        self.assertAlmostEqual(hits[1].determinant, 1.0, places=3)
+        self.assertAlmostEqual(hits[1].log_evalue, 0.17, places=1)
+        self.assertAlmostEqual(hits[1].evalue, math.exp(0.17), places=1)
+        self.assertIs(hits[2].template, template)
+        self.assertAlmostEqual(hits[2].rmsd, 1.644, places=3)
+        self.assertAlmostEqual(hits[2].determinant, 1.0, places=3)
+        self.assertAlmostEqual(hits[2].log_evalue, 0.68, places=1)
+        self.assertAlmostEqual(hits[2].evalue, math.exp(0.68), places=1)
+
+        hits = list(jess.query(molecule.conserved(10.0), 1, 2, 2))
+        self.assertEqual(len(hits), 1)
+        self.assertIs(hits[0].template, template)
+        self.assertAlmostEqual(hits[0].rmsd, 0.555, places=3)
+        self.assertAlmostEqual(hits[0].determinant, 1.0, places=3)
+        self.assertAlmostEqual(hits[0].log_evalue, -2.10, places=1)
+        self.assertAlmostEqual(hits[0].evalue, math.exp(-2.10), places=1)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_query_best_match(self):
+        with files(data).joinpath("template_01.qry").open() as f:
+            template = Template.load(f)
+        jess = Jess([template, template, template])
+        with files(data).joinpath("pdb1lnb.pdb").open() as f:
+            molecule = Molecule.load(f)
+
+        hits = list(jess.query(molecule, 2, 5, 5, best_match=True))
+        self.assertEqual(len(hits), 3)
+        for hit in hits:
+            self.assertIs(hit.template, template)
+            self.assertAlmostEqual(hit.rmsd, 0.555, places=3)
+            self.assertAlmostEqual(hit.determinant, 1.0, places=3)
+            self.assertAlmostEqual(hit.log_evalue, -2.04, places=1)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_mcsa_query_no_reorder(self):
+        with files(data).joinpath("1.3.3.tpl").open() as f:
+            template = Template.load(f)
+            jess = Jess([template])
+        with files(data).joinpath("1AMY.pdb").open() as f:
+            molecule = Molecule.load(f)
+        with files(data).joinpath("1AMY+1.3.3.txt").open() as f:
+            results = list(filter(None, f.read().split("REMARK")))
+
+        hits = list(jess.query(molecule, 2, 4, 4, reorder=False))
+        self.assertEqual(len(hits), len(results))
+        for hit, block in zip(hits, results):
+            self.assertIs(hit.template, template)
+
+            lines = block.strip().splitlines()
+            query_id, rmsd, template_id, _, determinant, _, logE = lines[0].split()
+            self.assertEqual(query_id, "1AMY")
+            self.assertAlmostEqual(float(rmsd), hit.rmsd, places=3)
+            self.assertAlmostEqual(float(determinant), hit.determinant, places=1)
+            self.assertAlmostEqual(float(logE), hit.log_evalue, places=1)
+
+            atom_lines = lines[1:-1]
+            atoms = hit.atoms()
+            self.assertEqual(len(atoms), len(atom_lines))
+            for atom, atom_line in zip(atoms, atom_lines):
+                self.assertEqual(atom.serial, int(atom_line[7:12]))
+                self.assertEqual(atom.name, atom_line[13:17].strip())
+                self.assertEqual(atom.residue_name, atom_line[17:21].strip())
+                self.assertEqual(atom.chain_id, atom_line[21:23].strip())
+                self.assertEqual(atom.residue_number, int(atom_line[23:27]))
+                self.assertAlmostEqual(atom.x, float(atom_line[31:39]), places=3)
+                self.assertAlmostEqual(atom.y, float(atom_line[39:47]), places=3)
+                self.assertAlmostEqual(atom.z, float(atom_line[47:55]), places=3)
+                self.assertAlmostEqual(atom.occupancy, float(atom_line[55:61]), places=3)
+                self.assertAlmostEqual(atom.temperature_factor, float(atom_line[61:67]), places=3)
+
+            atoms = hit.atoms(transform=False)
+            self.assertEqual(len(atoms), len(atom_lines))
+            for atom, atom_line in zip(atoms, atom_lines):
+                self.assertEqual(atom.serial, int(atom_line[7:12]))
+                self.assertEqual(atom.name, atom_line[13:17].strip())
+                self.assertEqual(atom.residue_name, atom_line[17:21].strip())
+                self.assertEqual(atom.chain_id, atom_line[21:23].strip())
+                self.assertEqual(atom.residue_number, int(atom_line[23:27]))
+                self.assertAlmostEqual(atom.occupancy, float(atom_line[55:61]), places=3)
+                self.assertAlmostEqual(atom.temperature_factor, float(atom_line[61:67]), places=3)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_mcsa_query_reorder(self):
+        with files(data).joinpath("1.3.3.tpl").open() as f:
+            template = Template.load(f)
+            jess = Jess([template])
+        with files(data).joinpath("1AMY.pdb").open() as f:
+            molecule = Molecule.load(f)
+        with files(data).joinpath("1AMY+1.3.3.txt").open() as f:
+            results = list(filter(None, f.read().split("REMARK")))
+
+        hits = list(jess.query(molecule, 2, 4, 4, reorder=True))
+        self.assertEqual(len(hits), len(results))
+
+        # `reorder=True` means that we may get results in a different order
+        # to Jess, so we need to match the hits in the file by residue number
+        # to make sure we compare them consistently.
+        
+        results_by_serials = {}
+        for block in results:
+            lines = block.strip().splitlines()
+            serials = tuple([ int(line.split()[1]) for line in lines[1:-1] ])
+            results_by_serials[serials] = block
+
+        for hit in hits:
+            self.assertIs(hit.template, template)
+            block = results_by_serials[tuple(atom.serial for atom in hit.atoms(False))]
+
+            lines = block.strip().splitlines()
+            query_id, rmsd, template_id, _, determinant, _, logE = lines[0].split()
+            self.assertEqual(query_id, "1AMY")
+            self.assertAlmostEqual(float(rmsd), hit.rmsd, places=3)
+            self.assertAlmostEqual(float(determinant), hit.determinant, places=1)
+            self.assertAlmostEqual(float(logE), hit.log_evalue, places=1)
+
+            atom_lines = lines[1:-1]
+            atoms = hit.atoms()
+            self.assertEqual(len(atoms), len(atom_lines))
+            for atom, atom_line in zip(atoms, atom_lines):
+                self.assertEqual(atom.serial, int(atom_line[7:12]))
+                self.assertEqual(atom.name, atom_line[13:17].strip())
+                self.assertEqual(atom.residue_name, atom_line[17:21].strip())
+                self.assertEqual(atom.chain_id, atom_line[21:23].strip())
+                self.assertEqual(atom.residue_number, int(atom_line[23:27]))
+                self.assertAlmostEqual(atom.x, float(atom_line[31:39]), places=3)
+                self.assertAlmostEqual(atom.y, float(atom_line[39:47]), places=3)
+                self.assertAlmostEqual(atom.z, float(atom_line[47:55]), places=3)
+                self.assertAlmostEqual(atom.occupancy, float(atom_line[55:61]), places=3)
+                self.assertAlmostEqual(atom.temperature_factor, float(atom_line[61:67]), places=3)
+
+            atoms = hit.atoms(transform=False)
+            self.assertEqual(len(atoms), len(atom_lines))
+            for atom, atom_line in zip(atoms, atom_lines):
+                self.assertEqual(atom.serial, int(atom_line[7:12]))
+                self.assertEqual(atom.name, atom_line[13:17].strip())
+                self.assertEqual(atom.residue_name, atom_line[17:21].strip())
+                self.assertEqual(atom.chain_id, atom_line[21:23].strip())
+                self.assertEqual(atom.residue_number, int(atom_line[23:27]))
+                self.assertAlmostEqual(atom.occupancy, float(atom_line[55:61]), places=3)
+                self.assertAlmostEqual(atom.temperature_factor, float(atom_line[61:67]), places=3)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_ignore_chain_none(self):
+        with files(data).joinpath("4.1.2.tpl").open() as f:
+            template = Template.load(f)
+            jess = Jess([template])
+        with files(data).joinpath("5ayx.EF.pdb").open() as f:
+            molecule = Molecule.load(f)
+        
+        hits = list(jess.query(molecule, 3, 3, 3, ignore_chain=None))
+        self.assertEqual(len(hits), 0)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_ignore_chain_residues(self):
+        with files(data).joinpath("4.1.2.tpl").open() as f:
+            template = Template.load(f)
+            jess = Jess([template])
+        with files(data).joinpath("5ayx.EF.pdb").open() as f:
+            molecule = Molecule.load(f)
+        
+        hits = list(jess.query(molecule, 3, 3, 3, ignore_chain="residues"))
+        self.assertEqual(len(hits), 2)
+        for hit in hits:
+            atoms = hit.atoms(transform=False)
+            for i in range(1, len(atoms)):
+                if atoms[i-1].residue_number == atoms[i].residue_number:
+                    self.assertEqual(atoms[i-1].chain_id, atoms[i].chain_id)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_ignore_chain_atoms(self):
+        with files(data).joinpath("4.1.2.tpl").open() as f:
+            template = Template.load(f)
+            jess = Jess([template])
+        with files(data).joinpath("5ayx.EF.pdb").open() as f:
+            molecule = Molecule.load(f)
+        
+        hits = list(jess.query(molecule, 3, 3, 3, ignore_chain="atoms"))
+        self.assertEqual(len(hits), 7)
+        
+