pyjess 0.5.1__cp39-cp39-macosx_11_0_arm64.whl → 0.6.0__cp39-cp39-macosx_11_0_arm64.whl

pyjess/_jess.pyi

@@ -183,6 +183,8 @@ class Query(Generic[_T], Iterator[Hit[_T]]):
     def __next__(self) -> Hit[_T]: ...
 
 class Hit(Generic[_T]):
+    def __getstate__(self) -> Dict[str, object]: ...
+    def __setstate__(self, state: Dict[str, object]) -> None: ...
     @property
     def rmsd(self) -> float: ...
     @property
@@ -219,4 +221,5 @@ class Jess(Generic[_T], Sequence[_T]):
         max_candidates: int = 1000,
         ignore_chain: bool = False,
         best_match: bool = False,
+        reorder: bool = True,
     ) -> Query[_T]: ...

pyjess/_jess.pyx

@@ -329,8 +329,9 @@ cdef class Atom:
                 atom metadata from.
 
         """
-        cdef bytearray b
-        cdef Atom      atom
+        cdef const unsigned char* s
+        cdef bytearray            b
+        cdef Atom                 atom
 
         if isinstance(text, str):
             b = bytearray(text, 'utf-8')
@@ -339,14 +340,15 @@ cdef class Atom:
         if not b.endswith(b'\n'):
             b.append(b'\n')
         b.append(b'\0')
+        s = b
 
         atom = cls.__new__(cls)
-        atom._atom = <_Atom*> malloc(sizeof(_Atom))
-        if atom._atom == NULL:
-            raise MemoryError("Failed to allocate atom")
-
-        if not jess.atom.Atom_parse(atom._atom, b):
-            raise ValueError(f"Failed to parse atom: {text!r}")
+        with nogil:
+            atom._atom = <_Atom*> malloc(sizeof(_Atom))
+            if atom._atom == NULL:
+                raise MemoryError("Failed to allocate atom")
+            if not jess.atom.Atom_parse(atom._atom, <const char*> s):
+                raise ValueError(f"Failed to parse atom: {text!r}")
 
         return atom
 
@@ -1205,7 +1207,7 @@ cdef class Query:
     cdef bint _rewind(self) noexcept nogil:
         self._partial = True
 
-    cdef int _copy_atoms(self, _Template* tpl, Hit hit) except -1 nogil:
+    cdef int _copy_atoms(self, const _Template* tpl, Hit hit) except -1 nogil:
         cdef _Atom** atoms = jess.jess.JessQuery_atoms(self._jq)
         cdef int     count = tpl.count(tpl)
 
@@ -1216,6 +1218,15 @@ cdef class Query:
             memcpy(&hit._atoms[i], atoms[i], sizeof(_Atom))
         return count
 
+    cdef int _copy_superposition(self, _Superposition* sup, Hit hit) noexcept nogil:
+        cdef const double* M = jess.super.Superposition_rotation(sup)
+        cdef const double* c = jess.super.Superposition_centroid(sup, 0)
+        cdef const double* v = jess.super.Superposition_centroid(sup, 1)
+        memcpy(hit._rotation, M, 9*sizeof(double))
+        memcpy(hit._centre[0], c, 3*sizeof(double))
+        memcpy(hit._centre[1], v, 3*sizeof(double))
+        return 0
+
     def __next__(self):
         assert self._jq is not NULL
 
@@ -1227,11 +1238,11 @@ cdef class Query:
         cdef Hit             hit     = Hit.__new__(Hit)
 
         # prepare the hit to be returned
-        hit._sup = NULL
-        hit._atoms = NULL
         hit.rmsd = INFINITY
+        hit._atoms = NULL
         hit._molecule = self.molecule
         hit_tpl = NULL
+        hit_found = False
 
         # search the next hit without the GIL to allow parallel queries.
         with nogil:
@@ -1240,14 +1251,13 @@ cdef class Query:
                 # was obtained with the current template and not with the
                 # previous one
                 tpl = jess.jess.JessQuery_template(self._jq)
-                if hit._sup != NULL and hit_tpl != tpl:
+                if hit_found and hit_tpl != tpl:
                     self._rewind()
                     break
 
                 # load superposition and compute RMSD for the current iteration
                 sup = jess.jess.JessQuery_superposition(self._jq)
                 rmsd = jess.super.Superposition_rmsd(sup)
-                keep_sup = False
 
                 # NB(@althonos): we don't need to compute the E-value to get the
                 #                best match by molecule/template pair since the
@@ -1272,22 +1282,20 @@ cdef class Query:
                                 stacklevel=2,
                             )
                     else:
-                        if hit._sup != NULL:
-                            jess.super.Superposition_free(hit._sup)
                         self._copy_atoms(tpl, hit)
-                        hit._sup = sup
+                        self._copy_superposition(sup, hit)
                         hit.rmsd = rmsd
                         hit_tpl = tpl
+                        hit_found = True
 
                 # free superposition items that are not used in a hit, and
                 # return hits immediately if we are not in best match mode
                 self._candidates += 1
-                if hit._sup != sup:
-                    jess.super.Superposition_free(sup)
-                if hit._sup != NULL and not self.best_match:
+                jess.super.Superposition_free(sup)
+                if hit_found and not self.best_match:
                     break
 
-        if hit._sup == NULL:
+        if not hit_found:
             raise StopIteration
 
         # get the template object for the hit
@@ -1305,7 +1313,8 @@ cdef class Hit:
         molecule (`~pyjess.Molecule`): The query molecule.
 
     """
-    cdef _Superposition* _sup
+    cdef double[9]       _rotation
+    cdef double[2][3]    _centre
     cdef _Atom*          _atoms
 
     cdef readonly double   rmsd
@@ -1313,19 +1322,49 @@ cdef class Hit:
     cdef          Molecule _molecule
 
     def __dealloc__(self):
-        jess.super.Superposition_free(self._sup)
         free(self._atoms)
 
+    def __getstate__(self):
+        return {
+            "rotation": list(self._rotation),
+            "centre": list(self._centre),
+            "atoms": self.atoms(transform=False),
+            "rmsd": self.rmsd,
+            "template": self.template,
+            "molecule": self.molecule(transform=False),
+        }
+
+    def __setstate__(self, state):
+        cdef size_t i
+        cdef size_t count
+        cdef Atom   atom
+
+        self.rmsd = state["rmsd"]
+        self.template = state["template"]
+        self._molecule = state["molecule"]
+        self._rotation = state["rotation"]
+        self._centre = state["centre"]
+
+        # check number of atoms is consistent
+        count = len(self.template)
+        if len(state["atoms"]) != count:
+            raise ValueError(f"unexpected number of atoms: {len(state['atoms'])!r} (expected {count!r})")
+        # allocate or reallocate memory for atoms
+        self._atoms = <_Atom*> realloc(self._atoms, count * sizeof(_Atom))
+        if self._atoms is NULL:
+            raise MemoryError("Failed to allocate hit atoms")
+        # copy atom data
+        for i, atom in enumerate(state["atoms"]):
+            memcpy(&self._atoms[i], atom._atom, sizeof(_Atom))
+
     @property
     def determinant(self):
         """`float`: The determinant of the rotation matrix.
         """
-        assert self._sup is not NULL
-        cdef const double* p
+        cdef const double* p   = self._rotation
         cdef double        det = 0.0
 
         with nogil:
-            p = jess.super.Superposition_rotation(self._sup)
             det += p[0] * (p[4] * p[8] - p[5] * p[7])
             det -= p[1] * (p[3] * p[8] - p[5] * p[6])
             det += p[2] * (p[3] * p[7] - p[4] * p[6])
@@ -1369,7 +1408,6 @@ cdef class Hit:
 
         """
         assert self.template._tpl is not NULL
-        assert self._sup is not NULL
 
         cdef Atom atom
         cdef int  i
@@ -1378,21 +1416,23 @@ cdef class Hit:
         cdef int  count = self.template._tpl.count(self.template._tpl)
         cdef list atoms = []
 
-        cdef const double* M = jess.super.Superposition_rotation(self._sup)
-        cdef const double* c = jess.super.Superposition_centroid(self._sup, 0)
-        cdef const double* v = jess.super.Superposition_centroid(self._sup, 1)
+        cdef const double* M = self._rotation
+        cdef const double* c = self._centre[0]
+        cdef const double* v = self._centre[1]
 
         for k in range(count):
-
             atom = Atom.__new__(Atom)
-            atom._atom = <_Atom*> malloc(sizeof(_Atom))
-            memcpy(atom._atom, &self._atoms[k], sizeof(_Atom))
-
             if transform:
+                atom._atom = <_Atom*> malloc(sizeof(_Atom))
+                memcpy(atom._atom, &self._atoms[k], sizeof(_Atom))
                 for i in range(3):
                     atom._atom.x[i] = v[i]
                     for j in range(3):
                         atom._atom.x[i] += M[3*i + j] * (self._atoms[k].x[j] - c[j])
+            else:
+                atom.owned = True
+                atom.owner = self
+                atom._atom = &self._atoms[k]
 
             atoms.append(atom)
 
@@ -1413,16 +1453,15 @@ cdef class Hit:
 
         """
         assert self.template._tpl is not NULL
-        assert self._sup is not NULL
 
         cdef _Atom*        atom
         cdef Molecule      mol
         cdef size_t        i
         cdef size_t        j
         cdef size_t        k
-        cdef const double* M    = jess.super.Superposition_rotation(self._sup)
-        cdef const double* c    = jess.super.Superposition_centroid(self._sup, 0)
-        cdef const double* v    = jess.super.Superposition_centroid(self._sup, 1)
+        cdef const double* M = self._rotation
+        cdef const double* c = self._centre[0]
+        cdef const double* v = self._centre[1]
 
         if not transform:
             return self._molecule
@@ -1545,6 +1584,7 @@ cdef class Jess:
         int max_candidates = 1000,
         bint ignore_chain = False,
         bint best_match = False,
+        bint reorder = True,
     ):
         """Scan for templates matching the given molecule.
 
@@ -1563,10 +1603,27 @@ cdef class Jess:
                 the atoms to match.
             best_match (`bool`): Pass `True` to return only the best match
                 to each template.
+            reorder (`bool`): Whether to enable template atom reordering
+                to accelerate matching in the scanner algorithm. Pass 
+                `False` to reverse to the original, slower algorithm
+                which matches atoms in the same order as they appear in
+                the template, at the cost
 
         Returns:
             `~pyjess.Query`: An iterator over the query hits.
 
+        Caution:
+            Since ``v0.6.0``, this function uses an optimized variant of
+            the Jess scanning algorithm which minimized the number of steps
+            needed to generate matches, by re-ordering the order the 
+            template atoms are iterated upon. Because of this change,
+            the query may return *exactly* the same matches but in an order 
+            that *differs* from the original Jess version. If you really
+            need results in the original order, set ``reorder`` to `False`.
+
+        .. versionadded:: 0.6.0
+            The ``reorder`` argument, defaulting to `True`.
+
         """
         cdef Query query = Query.__new__(Query)
         query.ignore_chain = ignore_chain
@@ -1580,5 +1637,6 @@ cdef class Jess:
             molecule._mol,
             distance_cutoff,
             max_dynamic_distance,
+            reorder,
         )
         return query

pyjess/tests/__init__.py

@@ -1,5 +1,6 @@
 from . import (
     test_atom,
+    test_hit,
     test_jess,
     test_molecule,
     test_template_atom,
@@ -8,6 +9,7 @@ from . import (
 
 def load_tests(loader, suite, pattern):
     suite.addTests(loader.loadTestsFromModule(test_atom))
+    suite.addTests(loader.loadTestsFromModule(test_hit))
     suite.addTests(loader.loadTestsFromModule(test_jess))
     suite.addTests(loader.loadTestsFromModule(test_molecule))
     suite.addTests(loader.loadTestsFromModule(test_template_atom))

pyjess/tests/test_hit.py

@@ -0,0 +1,33 @@
+import math
+import unittest
+import sys
+import pickle
+
+from .._jess import Template, Molecule, Jess
+from .utils import files
+from . import data
+
+
+class TestHit(unittest.TestCase):
+
+    @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)
+            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))

pyjess/tests/test_jess.py

@@ -204,7 +204,7 @@ class TestJess(unittest.TestCase):
             self.assertAlmostEqual(hit.log_evalue, -2.04, places=1)
 
     @unittest.skipUnless(files, "importlib.resources not available")
-    def test_mcsa_query(self):
+    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])
@@ -213,7 +213,7 @@ class TestJess(unittest.TestCase):
         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))
+        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)
@@ -240,3 +240,74 @@ class TestJess(unittest.TestCase):
                 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)
+

{pyjess-0.5.1.dist-info → pyjess-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pyjess
-Version: 0.5.1
+Version: 0.6.0
 Summary: Cython bindings and Python interface to JESS, a 3D template matching software.
 Keywords: bioinformatics,structure,template,matching
 Author-Email: Martin Larralde <martin.larralde@embl.de>
@@ -93,7 +93,9 @@ during his PhD in the [Thornton group](https://www.ebi.ac.uk/research/thornton/)
 PyJess is a Python module that provides bindings to Jess using
 [Cython](https://cython.org/). It allows creating templates, querying them
 with protein structures, and retrieving the hits using a Python API without
-performing any external I/O.
+performing any external I/O. It's also more than 10x faster than Jess thanks to
+[algorithmic optimizations](https://pyjess.readthedocs.io/en/latest/guide/optimizations.html)
+added to improve the original Jess code while producing consistent results.
 
 
 ## 🔧 Installing
@@ -127,7 +129,8 @@ Jess if you are using it in an academic work, for instance as:
 
 ## 💡 Example
 
-Load templates to be used as references from different template files:
+Load [`Template`](https://pyjess.readthedocs.io/en/latest/api/template.html#pyjess.Template) 
+objects to be used as references from different template files:
 
 ```python
 import pathlib
@@ -135,11 +138,10 @@ import pyjess
 
 templates = []
 for path in sorted(pathlib.Path("vendor/jess/examples").glob("template_*.qry")):
-    with path.open() as file:
-        templates.append(pyjess.Template.load(file, id=path.stem))
+    templates.append(pyjess.Template.load(path, id=path.stem))
 ```
 
-Create a `Jess` instance and use it to query a molecule (a PDB structure)
+Create a [`Jess`](https://pyjess.readthedocs.io/en/latest/api/jess.html#pyjess.Jess) instance and use it to query a [`Molecule`](https://pyjess.readthedocs.io/en/latest/api/molecule.html#pyjess.Molecule) (a PDB structure)
 against the stored templates:
 
 ```python
@@ -161,9 +163,11 @@ for hit in query:
 
 ## 🧶 Thread-safety
 
-Once a `Jess` instance has been created, the templates cannot be edited anymore,
-making the `Jess.query` method re-entrant. This allows querying several
-molecules against the same templates in parallel using a thread pool:
+Once a [`Jess`](https://pyjess.readthedocs.io/en/latest/api/jess.html#pyjess.Jess) 
+instance has been created, the templates cannot be edited anymore,
+making the [`Jess.query`](https://pyjess.readthedocs.io/en/latest/api/jess.html#pyjess.Jess.query) method re-entrant and thread-safe. This allows querying 
+several molecules against the same templates in parallel using e.g a 
+[`ThreadPool`](https://docs.python.org/3/library/multiprocessing.html#multiprocessing.pool.ThreadPool):
 
 ```python
 molecules = []
@@ -177,8 +181,22 @@ with multiprocessing.ThreadPool() as pool:
 *⚠️ Prior to PyJess `v0.2.1`, the Jess code was running some thread-unsafe operations which have now been patched.
 If running Jess in parallel, make sure to use `v0.2.1` or later to use the code patched with re-entrant functions*.
 
-<!-- ## ⏱️ Benchmarks -->
+## ⏱️ Benchmarks
 
+The following table reports the runtime of PyJess to match $n=132$ protein 
+structures to the $m=7607$ templates of 
+[EnzyMM](https://github.com/RayHackett/enzymm), using $J=12$ threads to parallelize.
+
+| Version     | Runtime (s) | Match Speed (N * M / s * J) | Speedup     |
+| ----------- | ----------- | --------------------------- | ----------- |
+| ``v0.4.2``  | 618.1       | 135.4                       | N/A         |
+| ``v0.5.0``  | 586.3       | 142.7                       | x1.05       |
+| ``v0.5.1``  | 365.6       | 228.9                       | x1.69       |
+| ``v0.5.2``  | 327.2       | 255.7                       | x1.88       |
+| ``v0.6.0``  | 54.5        | 1535.4                      | **x11.34**  |
+
+*Benchmarks were run on a quiet [i7-1255U](https://www.intel.com/content/www/us/en/products/sku/226259/intel-core-i71255u-processor-12m-cache-up-to-4-70-ghz/specifications.html) CPU running @4.70GHz with 10 physical cores / 12 logical
+cores.*
 
 ## 💭 Feedback
 
@@ -211,7 +229,7 @@ This library is provided under the [MIT License](https://choosealicense.com/lice
 *This project is in no way not affiliated, sponsored, or otherwise endorsed
 by the JESS authors. It was developed
 by [Martin Larralde](https://github.com/althonos/) during his PhD project
-at the [European Molecular Biology Laboratory](https://www.embl.de/) in
+at the [Leiden University Medical Center](https://www.lumc.nl/en/) in
 the [Zeller team](https://github.com/zellerlab).*
 
 

{pyjess-0.5.1.dist-info → pyjess-0.6.0.dist-info}/RECORD

@@ -1,19 +1,20 @@
-pyjess-0.5.1.dist-info/RECORD,,
-pyjess-0.5.1.dist-info/WHEEL,sha256=Bp5NfjQuMM_4-YV1MlnhqEfxPV5ySj3kUtyINz66rJc,112
-pyjess-0.5.1.dist-info/METADATA,sha256=OMnKlTvBTrR8tfxUFdUJXnJPezgo10GrHWTxap3eG7A,11248
-pyjess-0.5.1.dist-info/licenses/COPYING,sha256=gLCfHtBLTrghVX7GkpmZqoozWMNN46502m_OUiYy01Y,1103
-pyjess/_jess.pyi,sha256=OjbEcgr16eFEnAFbT_zp-jqjd4XME2V_gxuKZJBXVoc,6896
+pyjess-0.6.0.dist-info/RECORD,,
+pyjess-0.6.0.dist-info/WHEEL,sha256=ZF0EG4evfIAXWc5yWRjXEB82QuVPxkr7Vob35_6t9b0,112
+pyjess-0.6.0.dist-info/METADATA,sha256=OG5zbwpmxVLSmlQQ6xvyicRYKB6JrLBkDa-zhmWa6js,12882
+pyjess-0.6.0.dist-info/licenses/COPYING,sha256=gLCfHtBLTrghVX7GkpmZqoozWMNN46502m_OUiYy01Y,1103
+pyjess/_jess.pyi,sha256=3FLL_E4q_fWlThfTwnas56zpdDFoN5z_xYD0aY-0-dk,7045
 pyjess/CMakeLists.txt,sha256=Oa0pniEQx9jXyFCJGyrswn9ahWSSVuW1madyeP6StoI,35
-pyjess/_jess.cpython-39-darwin.so,sha256=PMz1ldrwX9p4DBYE8GP3EY6UqX96arocVLVIs8gaxxM,317240
+pyjess/_jess.cpython-39-darwin.so,sha256=Y7hPhVXLv-U5ugk_prQMf5IMEx8gM0XWwlpLsX1RqWY,334312
 pyjess/__init__.py,sha256=h4XXLdS4FnyVa-MBs_k3eZMG1jWxeiOJnwfBaJA9gyQ,745
 pyjess/.gitignore,sha256=uQBOufp4v50qn0aZKv6zbSo00cjfB-v9KySog7rlmIU,19
-pyjess/_jess.pyx,sha256=kbAp0zWfxliPvzJ9c5G3oeRUKFcxtedo4oav-1uQotQ,50546
+pyjess/_jess.pyx,sha256=5qCasXyFa0e2BfhiFfx5Qlt7xiZeb7CFfwzfFgfVfTs,53007
 pyjess/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyjess/tests/__init__.py,sha256=MdHWtr6A8S4TBWlkoj4olFK2FXAGc5uJdbWtgFrDLpk,528
+pyjess/tests/__init__.py,sha256=ka1wkfXesesZ3f6p5Dg55P4YYyS3R4gKRmhpQRtWVec,599
 pyjess/tests/test_molecule.py,sha256=RHBE0yL_j71nQOwXJ6t_PzkZi4BaFPY5Q0VwKWM6elk,5311
 pyjess/tests/utils.py,sha256=dsaphex7qomJCvSHWnVy79iYDPGiL59xqGAtRoVAeWc,196
+pyjess/tests/test_hit.py,sha256=qN0qcGWHdvM9PZzBLWwuORhAXaZLp9c-CuZgO3GAbr8,1212
 pyjess/tests/test_atom.py,sha256=omNznNbRXMDt2j1plAUlfWPGCfmtkYpj2jysEX1zQuY,4631
-pyjess/tests/test_jess.py,sha256=lTp_KzkbPF5J0nWewO4LJrKeKuXtSlzj114kPG-54zM,10642
+pyjess/tests/test_jess.py,sha256=qNXtgQ9IWJ0NH4MRhFPMQ54ocpLaxwJRP-0lZv_N0Ns,14710
 pyjess/tests/test_template.py,sha256=XMLELYRB4j7xavziZ-ntq15PjhNHNfJJkctUq9BkvEI,4541
 pyjess/tests/test_template_atom.py,sha256=s9tJ_SAgvKeGwbVjaTWY-EtsUeQp3eu4NF5ja3oO_84,3405
 pyjess/tests/data/pdb1lnb.pdb,sha256=E9Jjy4qQ75O1UKIXcVyVJHE1XDNx1Rb7ENPVrehW6N8,270054

{pyjess-0.5.1.dist-info → pyjess-0.6.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: scikit-build-core 0.11.5
+Generator: scikit-build-core 0.11.6
 Root-Is-Purelib: false
 Tag: cp39-cp39-macosx_11_0_arm64