pyjess 0.5.2__tar.gz → 0.7.0a1__tar.gz

{pyjess-0.5.2 → pyjess-0.7.0a1}/.github/workflows/package.yml

@@ -15,6 +15,7 @@ jobs:
       with:
         submodules: true
     - name: Build manylinux wheels
+      if: "!contains(github.ref, 'rc') && !contains(github.ref, 'alpha')"
       uses: pypa/cibuildwheel@v2.21.3
       env:
         CIBW_ARCHS: aarch64
@@ -35,6 +36,7 @@ jobs:
       with:
         submodules: true
     - name: Build manylinux wheels
+      if: "!contains(github.ref, 'rc') && !contains(github.ref, 'alpha')"
       uses: pypa/cibuildwheel@v2.21.3
       env:
         CIBW_ARCHS: x86_64
@@ -55,6 +57,7 @@ jobs:
       with:
         submodules: true
     - name: Build manylinux wheels
+      if: "!contains(github.ref, 'rc') && !contains(github.ref, 'alpha')"
       uses: pypa/cibuildwheel@v2.21.3
       env:
         CIBW_ARCHS: x86_64
@@ -75,6 +78,7 @@ jobs:
       with:
         submodules: true
     - name: Build manylinux wheels
+      if: "!contains(github.ref, 'rc') && !contains(github.ref, 'alpha')"
       uses: pypa/cibuildwheel@v2.21.3
       env:
         CIBW_ARCHS: arm64
@@ -99,6 +103,7 @@ jobs:
       with:
         arch: amd64
     - name: Build manylinux wheels
+      if: "!contains(github.ref, 'rc') && !contains(github.ref, 'alpha')"
       uses: pypa/cibuildwheel@v2.21.3
       env:
         CIBW_ARCHS: AMD64
@@ -187,7 +192,7 @@ jobs:
     environment: GitHub Releases
     runs-on: ubuntu-latest
     permissions: write-all
-    if: "!contains(github.ref, 'rc')"
+    if: "!contains(github.ref, 'rc') && !contains(github.ref, 'alpha')"
     name: Release
     needs: upload
     steps:
@@ -201,7 +206,7 @@ jobs:
   aur:
     environment: Arch User Repository
     runs-on: ubuntu-latest
-    if: "!contains(github.ref, 'rc')"
+    if: "!contains(github.ref, 'rc') && !contains(github.ref, 'alpha')"
     name: Update AUR package
     needs:
     - sdist

{pyjess-0.5.2 → pyjess-0.7.0a1}/CHANGELOG.md

@@ -6,9 +6,33 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 
 ## [Unreleased]
-[Unreleased]: https://github.com/althonos/pyjess/compare/v0.5.2...HEAD
+[Unreleased]: https://github.com/althonos/pyjess/compare/v0.7.0-alpha.1...HEAD
 
 
+## [v0.7.0-alpha.1] - 2025-09-02
+[v0.7.0-alpha.1]: https://github.com/althonos/pyjess/compare/v0.6.0...v0.7.0-alpha.1
+
+### Fixed
+- **breaking**: Incorrect handling of `max_candidates` in `Jess.query`, causing PyJess to erroneously ignore some templates.
+
+### Changed
+- **breaking**: Set the `max_candidates` default value to `None` in `Jess.query`, disabling max candidates filtering by default.
+
+
+## [v0.6.0] - 2025-09-01
+[v0.6.0]: https://github.com/althonos/pyjess/compare/v0.5.2...v0.6.0
+
+### Added
+- Several [algorithmic optimizations](https://pyjess.readthedocs.io/en/v0.6.0/guide/optimizations.html) to Jess, greatly improving runtime:
+  - Use QuickSelect ($O(n)$) instead of QuickSort ($O(nlog(n))$) to select the medians used for space partitioning on k-d tree initialization.
+  - Use approximate intersection on bounding boxes rather than exact code involving multiple annuli when querying the k-d tree for atoms.
+  - **breaking**: Reorder the matching order of template atoms to reduce the amount of backtracking and k-d tree querying performed in the average and worst case.
+- `reorder` argument to `Jess.query` to support disabling template atom reordering if needed for Jess 1-to-1 consistency.
+
+### Changed
+- Hardcode space dimensions to 3 to encourage compilers to unroll loops over dimensions.
+- Recycle memory between templates within a query to reduce total amount of allocation/deallocation in hot paths.
+
 ## [v0.5.2] - 2025-08-26
 [v0.5.2]: https://github.com/althonos/pyjess/compare/v0.5.1...v0.5.2
 

{pyjess-0.5.2 → pyjess-0.7.0a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pyjess
-Version: 0.5.2
+Version: 0.7.0a1
 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.2 → pyjess-0.7.0a1}/README.md

@@ -33,7 +33,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
@@ -67,7 +69,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
@@ -75,11 +78,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
@@ -101,9 +103,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 = []
@@ -117,8 +121,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
 
@@ -151,7 +169,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.2 → pyjess-0.7.0a1}/docs/_static/json/switcher.json

@@ -1,6 +1,11 @@
 [
     {
-        "name": "v0.5 (latest)",
+        "name": "v0.6 (latest)",
+        "version": "0.6.0",
+        "url": "https://pyjess.readthedocs.io/en/v0.6.0/"
+    },
+    {
+        "name": "v0.5",
         "version": "0.5.2",
         "url": "https://pyjess.readthedocs.io/en/v0.5.2/"
     },

{pyjess-0.5.2 → pyjess-0.7.0a1}/docs/guide/index.rst

@@ -13,6 +13,7 @@ This section contains guides and documents about PyJess usage.
    :maxdepth: 1
    :caption: Resources
 
+   Optimizations <optimizations>
    Contribution Guide <contributing>
    Changelog <changes>
    Copyright Notice <copyright>

pyjess-0.7.0a1/docs/guide/optimizations.rst

@@ -0,0 +1,258 @@
+Optimizations
+=============
+
+.. currentmodule:: pyjess
+
+While PyJess started as a Cython wrapper of Jess, it also 
+contains several optimizations to make the code write better
+while maintaining consistency with the original Jess code.
+Some of these optimizations are described below, as well as
+the version where they were introduced.
+
+
+Residue name index
+------------------
+
+.. versionadded:: 0.5.1
+
+Given a `Molecule`, matching a new `Template` to that `Molecule`
+requires generating a set of candidate atoms for each `TemplateAtom`
+of the template according to its `~TemplateAtom.match_mode`. 
+
+In the original Jess code, this is done by a full-scan on each 
+`Atom` of the `Molecule` for each `TemplateAtom` at index ``k``:
+
+.. code:: c
+
+    Atom* A;
+    Molecule* M;
+    Template* T;
+    CandidateSet* S;
+    int n, i;
+
+    n=Molecule_count(M);
+    for(i=0; m<n; m++)
+    {
+        A=(Atom*) Molecule_atom(M,i);
+        if(T->match(T,k,A))
+        {
+            S->atom[S->count]=A;
+            S->count++;
+        }
+    }
+
+However, the most common match modes require the candidate `Atom` to 
+have a `~Atom.residue_name` equal to one of the `TemplateAtom` 
+`~TemplateAtom.residue_names`. To exploit this, and avoid a full-scan,
+we can create an index grouping the atoms of a `Molecule` by their
+`~Atom.residue_name`, and only iterate on atoms with the right 
+`~Atom.residue_name` when building the candidates for a `TemplateAtom`:
+
+.. code:: c
+
+    Atom* A;
+    Molecule* M;
+    Template* T;
+    CandidateSet* S;
+    Atom** atoms;
+
+    for(name=T->residueNames(T,k);name!=NULL;name++)
+    {
+        for(atoms=Molecule_atoms(M,resname);*atoms!=NULL;atoms++)
+        {
+            A=*atoms;
+            if(T->match(T,k,A))
+            {
+                S->atom[S->count]=A;
+                S->count++;
+            }
+        }
+    }
+
+By doing so we greatly reduce the number of calls to ``T->match``, 
+at the cost of computing an index when a new `Molecule` is created.
+This is grealy beneficial for a large number of templates, with an 
+additional :math:`O(n)` memory requirement. 
+
+
+k-d tree generation
+-------------------
+
+.. versionadded:: 0.6.0
+
+Jess uses a `k-d tree <https://en.wikipedia.org/wiki/K-d_tree>`_ data 
+structure to partition the molecule into geometric regions and speed-up the 
+retrieval of atoms in each region. To generate a :math:`k`-d tree from 
+a list of `Atom`, the atoms are recursively partitioned on a single dimension
+around a pivot value, usually the median coordinate for that dimension.
+
+The original Jess code uses ``qsort`` (the `QuickSort <https://en.wikipedia.org/wiki/Quicksort>`_
+implementation of the C standard library) to first sort the atoms on a 
+single dimension, and then takes the middle point:
+
+.. code:: c
+
+    KdTreeNode* N;
+    int* idx;
+    int n;
+
+    qsort(idx,n,sizeof(int),KdTree_compare);
+
+    split = n/2;
+    N->index=idx[split-1];
+    N->type=type;
+
+    type = (type+1)%dim;
+    N->left = KdTreeNode_create(idx,split,type,u,dim);
+    N->right = KdTreeNode_create(&idx[split],n-split,type,u,dim); 
+
+
+While implemented very efficiently, QuickSort has an average runtime
+complexity of :math:`O(nlog(n))`. Given that the algorithm is only used
+here to search for the median, and that the sort order is actually irrelevant, 
+we replaced it with the `QuickSelect <https://en.wikipedia.org/wiki/Quickselect>`_ algorithm,
+which can retrieve the median with an average runtime complexity of :math:`O(n)`.
+
+
+Approximate annulus intersection
+--------------------------------
+
+.. versionadded:: 0.6.0
+
+During the search for matches in a ``Scanner``, Jess takes into account the 
+flexibility of the `Template` by modelling the distance constraints to each 
+`TemplateAtom` using an `annulus <https://en.wikipedia.org/wiki/Annulus_(mathematics)>`_. 
+Then, it queries the :math:`k`-d tree created on the candidate atoms to find
+candidate atoms that are included in this annulus.
+
+In the original Jess, the traversal of the :math:`k`-d tree is done by computing 
+for each internal node of the tree whether the box formed by that node intersect
+the query annulus, and for each leaf whether they are contained in that annulus.
+
+Computing the intersection between a box and an annulus requires computing 
+`Euclidean distances <https://en.wikipedia.org/wiki/Euclidean_distance>`_, 
+and therefore products between real numbers, an operation that is among the 
+slowest even on modern CPUs:
+
+.. code:: c
+
+    Annulus* A;
+    double minBox[d];
+    double maxBox[d];
+
+    double minSum=0.0;
+    double maxSum=0.0;
+    for(i=0; i<d; i++)
+    {
+        double t1 = A->centre[i]-minBox[i];
+        double t2 = A->centre[i]-maxBox[i];
+        t1 *= t1;
+        t2 *= t2;
+
+        if(minBox[i]>A->centre[i] || maxBox[i]<A->centre[i])
+            minSum += min(t1,t2);
+
+        maxSum += max(t1,t2);
+    }
+
+    bool intersects = minSum>(A->outer*A->outer) || maxSum<(A->inner*A->inner);
+
+To speed-up the querying, we approximate the query annulus as a bounding
+box, and instead compute the intersection to the :math:`k`-d tree box 
+to the bounding box, which only requires comparisons:
+
+.. code:: c
+
+    Annulus* A;
+    double minBox[d];
+    double maxBox[d];
+
+    bool intersects = true;
+    for(i=0; i<d; i++)
+    {
+        double dmin = A->centre[i]-A->outer;
+        double dmax = A->centre[i]+A->outer;
+        if( !( dmin <= maxBox[i] && minBox[i] <= dmax ) )
+            intersects = false;
+    }
+
+As this is an approximation, it may wrongly return ``true`` on (literal) corner 
+cases, i.e. when the intersection happens in a corner of the bounding box around
+the annulus. However, given that the :math:`k`-d tree later checks that the 
+points are actually included in the annulus for the leaf nodes, 
+using this implementation will not generate false positives.
+
+
+Reduced backtracking
+--------------------
+
+.. versionadded:: 0.6.0
+
+The ``Scanner`` in Jess iterates on the `Template` atoms and then aligns the
+`Molecule` atoms iteratively. When no more candidate for a `TemplateAtom` can
+be found in a `Molecule`, it backtracks to the previous `TemplateAtom`, and 
+continues this iteration. 
+
+Since every backtracking event triggers the querying of the :math:`k`-d tree, 
+we want to minimize backtracking as much as possible. To do so, we compute 
+an iteration order over the `Template` atoms that minimizes the amount of 
+backtracking required to explore all paths. This can be done quickly by 
+sorting the `TemplateAtom` using the number of `Atom` in the corresponding 
+``CandidateSet``. 
+
+Empirically, this approach reduced the amount of :math:`k`-d tree queries by a 
+factor of 10. It is nevertheless unclear whether an optimal path can be 
+further identified and pre-computed from the candidate `Atom`, possibly by 
+filtering distant atoms first.
+
+.. warning:: 
+
+    Out all the optimizations in this section, this one is the only one 
+    to introduce *slight* behavioral changes in PyJess compared to Jess.
+    Since the order in which candidate atoms are matched have changed, 
+    the order in which a PyJess `Query` yields `Hit` objects differs
+    to that in which Jess reports a match. This only affects the *order*
+    though: all matches are still returned, and are 1-to-1 identical!
+    This can be disabled by running with ``Jess.query(..., reorder=False)``
+    to use the original matching order, at the cost of a longer runtime.
+
+
+
+Type concretization
+-------------------
+
+.. versionadded:: 0.6.0
+
+Jess uses generic code to support multiple types of spatial regions
+using function pointers to implement `virtual method tables <https://en.wikipedia.org/wiki/Virtual_method_table>`_.
+While elegant and functional, the code never really makes uses of 
+the genericity, and therefore the algorithm can be specialized to 
+the appropriate `Region` concrete type (either `Join` or `Annulus`)
+to remove the overhead of calling the function pointers. 
+
+In addition, most of the geometric code is inlined, as it is called in hot paths
+where the compiler can apply auto-vectorization.
+
+
+Dimension concretization
+------------------------
+
+.. versionadded:: 0.6.0
+
+The `Annulus` type is made to be generic over the number of dimensions,
+but in practice it is only used for 3-dimensions. We hardcoded the dimensions
+to encourage the compiler to unroll loops over the `Annulus` dimensions where
+applicable, and to use constant-size arrays rather than dynamic allocation when
+applicable.
+
+
+Scanner memory recycling
+------------------------
+
+.. versionadded:: 0.6.0
+
+The original Jess code performs a lot of allocation/deallocations in hot paths,
+as it creates a new `Scanner` which allocates memory for each `Template` / `Molecule`
+pair to match. Effectively, most of these buffers can actually be reused 
+across `Templates` for a given `Molecule`, provided sufficient bookkeeping. Our
+implementation keeps allocation to a minimum across an entire `Query`.

{pyjess-0.5.2 → pyjess-0.7.0a1}/docs/index.rst

@@ -103,16 +103,17 @@ PyJess is a Python module that provides bindings to Jess using
       Retrieve results as they become availble as dedicated 
       `~pyjess.Hit` objects, and compute statistics on-the-fly.
 
+   .. grid-item-card:: :fas:`gauge-high` Fast
+
+      Compute matches about 10x faster, thanks to
+      several :doc:`algorithmic optimizations <guide/optimizations>`
+      made to the original Jess code.
+
    .. grid-item-card:: :fas:`server` Parallel
 
       Easily run computations in parallel querying thread-safe 
       `~pyjess.Jess` with several `~pyjess.Molecule` in parallel.
 
-   .. grid-item-card:: :fas:`check` Consistent
-
-      Get the same results as Jess, with some additional bug fixes for 
-      edge cases of the original implementation.
-
    .. grid-item-card:: :fas:`toolbox` Feature-complete
 
       Access all the features of the original CLI through the 

{pyjess-0.5.2 → pyjess-0.7.0a1}/include/jess/jess.pxd

@@ -18,10 +18,11 @@ cdef extern from "Jess.h" nogil:
     Jess* Jess_create()
     void Jess_free(Jess*)
     void Jess_addTemplate(Jess*, Template*)
-    JessQuery* Jess_query(Jess*, Molecule*, double, double)
+    JessQuery* Jess_query(Jess*, Molecule*, double, double, bint)
 
     void JessQuery_free(JessQuery*)
     int JessQuery_next(JessQuery*, int)
+    int JessQuery_nextTemplate(JessQuery*)
     Template* JessQuery_template(JessQuery*)
     const Molecule* JessQuery_molecule(JessQuery*)
     Atom** JessQuery_atoms(JessQuery*)