pyseqalignment 0.1.1__tar.gz → 0.1.2__tar.gz

{pyseqalignment-0.1.1/src/pyseqalignment.egg-info → pyseqalignment-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyseqalignment
-Version: 0.1.1
+Version: 0.1.2
 Summary: pySeqAlign -- sequence alignment with Prolog-style distance functions and ILP learning
 Author-email: Andreas Karwath <a.karwath@bham.ac.uk>
 License-Expression: MIT
@@ -64,6 +64,7 @@ pySeqAlign provides Smith-Waterman (local) and Needleman-Wunsch (global) sequenc
   - **Aleph** backend -- classic ILP system (Srinivasan, 2001)
   - **Popper** backend -- modern ILP via learning from failures (Cropper & Morel, 2021)
 - **Pure Python** core -- no C extension required (unlike the legacy version)
+- **Optional fast C++ aligner** -- a pybind11 affine-gap Needleman-Wunsch kernel (`pyseqalign.accel`) for large all-pairs / iterative workloads; identical results to the Python aligner, ~100-270x faster
 
 ## Installation
 
@@ -308,6 +309,35 @@ For reference, other notable systems in the field include:
 - [Metagol](https://github.com/metagol/metagol) -- Meta-Interpretive Learning
 - [DeepStochLog](https://github.com/ML-KULeuven/deepstochlog) -- Neural-symbolic ILP combining logic and neural networks
 
+## Fast C++ aligner (optional)
+
+The pure-Python aligners are fine for typical use. For heavy workloads (e.g.
+boosting that re-aligns thousands of sequence pairs per iteration), an optional
+**C++ affine-gap Needleman-Wunsch** kernel is provided. It is NOT built by default
+(the core stays pure Python); build it once with a C++ compiler + pybind11:
+
+```bash
+pip install pybind11
+src/pyseqalign/cpp/build_cpp_aligner.sh          # or: PY=$(which python) src/.../build_cpp_aligner.sh
+```
+
+This compiles the extension into the `pyseqalign` package. Then:
+
+```python
+from pyseqalign.accel import cpp_available, load
+assert cpp_available()
+cpp = load()                                  # the compiled module
+al = cpp.CppAligner(num_ids, gap_open, gap_extend)
+al.set_matrix(flat_score_matrix)              # (num_ids+1)^2 row-major scores
+r = al.align(query_ids, target_ids)           # r.score, r.query, r.target, r.gap_opens, ...
+```
+
+The kernel implements the same 3-matrix (M/Ix/Iy) affine recurrence as a numeric
+aligner over a dense score matrix, so its results are interchangeable with a
+pure-Python affine Needleman-Wunsch (validated bit-for-bit). If the extension is
+not built, `cpp_available()` is `False` and `load()` raises a helpful error --
+callers should fall back to the Python aligner.
+
 ## Background
 
 **pySeqAlign** is a modern, pure-Python reimplementation that revives the name of one of its own ancestors. It succeeds two legacy libraries behind the ILP 2006 / ICDM 2008 work: the original **pyAlign** (SWIG-wrapped C with YAP Prolog bindings for alignment) and the original **pySeqAlign** (which held the Aleph ILP framework for learning rules from alignment examples). This version is pure Python, with optional SWI-Prolog integration via [Janus](https://www.swi-prolog.org/packs/list?p=janus) (the modern Python-Prolog bridge, replacing the older pyswip).

{pyseqalignment-0.1.1 → pyseqalignment-0.1.2}/README.md

@@ -26,6 +26,7 @@ pySeqAlign provides Smith-Waterman (local) and Needleman-Wunsch (global) sequenc
   - **Aleph** backend -- classic ILP system (Srinivasan, 2001)
   - **Popper** backend -- modern ILP via learning from failures (Cropper & Morel, 2021)
 - **Pure Python** core -- no C extension required (unlike the legacy version)
+- **Optional fast C++ aligner** -- a pybind11 affine-gap Needleman-Wunsch kernel (`pyseqalign.accel`) for large all-pairs / iterative workloads; identical results to the Python aligner, ~100-270x faster
 
 ## Installation
 
@@ -270,6 +271,35 @@ For reference, other notable systems in the field include:
 - [Metagol](https://github.com/metagol/metagol) -- Meta-Interpretive Learning
 - [DeepStochLog](https://github.com/ML-KULeuven/deepstochlog) -- Neural-symbolic ILP combining logic and neural networks
 
+## Fast C++ aligner (optional)
+
+The pure-Python aligners are fine for typical use. For heavy workloads (e.g.
+boosting that re-aligns thousands of sequence pairs per iteration), an optional
+**C++ affine-gap Needleman-Wunsch** kernel is provided. It is NOT built by default
+(the core stays pure Python); build it once with a C++ compiler + pybind11:
+
+```bash
+pip install pybind11
+src/pyseqalign/cpp/build_cpp_aligner.sh          # or: PY=$(which python) src/.../build_cpp_aligner.sh
+```
+
+This compiles the extension into the `pyseqalign` package. Then:
+
+```python
+from pyseqalign.accel import cpp_available, load
+assert cpp_available()
+cpp = load()                                  # the compiled module
+al = cpp.CppAligner(num_ids, gap_open, gap_extend)
+al.set_matrix(flat_score_matrix)              # (num_ids+1)^2 row-major scores
+r = al.align(query_ids, target_ids)           # r.score, r.query, r.target, r.gap_opens, ...
+```
+
+The kernel implements the same 3-matrix (M/Ix/Iy) affine recurrence as a numeric
+aligner over a dense score matrix, so its results are interchangeable with a
+pure-Python affine Needleman-Wunsch (validated bit-for-bit). If the extension is
+not built, `cpp_available()` is `False` and `load()` raises a helpful error --
+callers should fall back to the Python aligner.
+
 ## Background
 
 **pySeqAlign** is a modern, pure-Python reimplementation that revives the name of one of its own ancestors. It succeeds two legacy libraries behind the ILP 2006 / ICDM 2008 work: the original **pyAlign** (SWIG-wrapped C with YAP Prolog bindings for alignment) and the original **pySeqAlign** (which held the Aleph ILP framework for learning rules from alignment examples). This version is pure Python, with optional SWI-Prolog integration via [Janus](https://www.swi-prolog.org/packs/list?p=janus) (the modern Python-Prolog bridge, replacing the older pyswip).

{pyseqalignment-0.1.1 → pyseqalignment-0.1.2}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 # PyPI distribution name (the import package is `pyseqalign`; the name
 # `pyseqalign` was blocked by PyPI's similarity guard vs. an existing project).
 name = "pyseqalignment"
-version = "0.1.1"
+version = "0.1.2"
 description = "pySeqAlign -- sequence alignment with Prolog-style distance functions and ILP learning"
 readme = "README.md"
 license = "MIT"
@@ -66,6 +66,7 @@ where = ["src"]
 "pyseqalign.prolog.knowledge" = ["*.pl"]
 "pyseqalign.learning.aleph_files" = ["*.pl"]
 "pyseqalign.scoring.matrix_data" = ["*"]
+"pyseqalign" = ["cpp/*.cpp", "cpp/*.sh"]   # optional C++ aligner source (build manually)
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

pyseqalignment-0.1.2/src/pyseqalign/accel.py

@@ -0,0 +1,33 @@
+"""Optional fast C++ affine-gap aligner (pybind11).
+
+pySeqAlign's core is pure Python; this accelerated aligner is OPTIONAL. Build it
+with ``src/pyseqalign/cpp/build_cpp_aligner.sh`` (needs a C++ compiler + pybind11).
+
+It implements the same 3-matrix affine Needleman-Wunsch recurrence as a numeric
+kernel over a dense score matrix, so results are interchangeable with a
+pure-Python affine aligner. Exposes ``CppAligner(num_ids, gap_open, gap_extend)``
+with ``set_matrix(flat_row_major)`` and ``align(q, t) -> AlignResult``
+(``.score/.query/.target/.gap_opens/.gap_extensions/.length``).
+"""
+from __future__ import annotations
+
+
+def cpp_available() -> bool:
+    """True if the compiled extension is built and importable."""
+    try:
+        from . import cpp_aligner  # noqa: F401
+        return True
+    except Exception:
+        return False
+
+
+def load():
+    """Return the compiled module (raises a helpful error if not built)."""
+    try:
+        from . import cpp_aligner
+        return cpp_aligner
+    except ImportError as e:  # pragma: no cover
+        raise ImportError(
+            'pySeqAlign C++ aligner not built. Run '
+            'src/pyseqalign/cpp/build_cpp_aligner.sh (needs a C++ compiler + pybind11).'
+        ) from e

pyseqalignment-0.1.2/src/pyseqalign/cpp/build_cpp_aligner.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+# Build the optional fast C++ affine-gap aligner (pybind11) for the active Python.
+# Usage: PY=/path/to/python ./build_cpp_aligner.sh   (default: python3)
+set -e
+PY="${PY:-python3}"
+HERE="$(cd "$(dirname "$0")" && pwd)"
+PYINC=$("$PY" -c "import sysconfig;print(sysconfig.get_path('include'))")
+PBINC=$("$PY" -c "import pybind11;print(pybind11.get_include())")
+SUF=$("$PY" -c "import sysconfig;print(sysconfig.get_config_var('EXT_SUFFIX'))")
+clang++ -O3 -std=c++14 -shared -undefined dynamic_lookup -fPIC \
+  -I"$PYINC" -I"$PBINC" "$HERE/cpp_aligner.cpp" -o "$HERE/../cpp_aligner$SUF"
+echo "built $HERE/../cpp_aligner$SUF"

pyseqalignment-0.1.2/src/pyseqalign/cpp/cpp_aligner.cpp

@@ -0,0 +1,140 @@
+// Fast C++ Needleman-Wunsch affine-gap aligner for pyREAL boosting.
+//
+// Mirrors pyreal.core.nw_affine.NeedlemanWunschAffine EXACTLY (3-matrix M/Ix/Iy
+// DP, same border init, same argmax tie-breaking, same traceback + gap counting)
+// so the Python and C++ backends are interchangeable. Adapted from the pyAlign2
+// AlignerAffine structure, but YAP-free: scores come from a flat distance matrix
+// (the boosting reward matrix), set once per reward update; align() is then a
+// pure numeric kernel callable thousands of times without recomputing scores.
+//
+// Build: see build_cpp_aligner.sh
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <vector>
+#include <limits>
+#include <algorithm>
+#include <stdexcept>
+
+namespace py = pybind11;
+
+static const int M = 0, IX = 1, IY = 2;
+
+struct AlignResult {
+    double score = 0.0;
+    std::vector<int> query;   // aligned query (0 = gap)
+    std::vector<int> target;  // aligned target (0 = gap)
+    int gap_opens = 0;
+    int gap_extensions = 0;
+    int length = 0;
+};
+
+class CppAligner {
+public:
+    // num_ids = number of distinct atom ids (gap id 0 excluded). The score
+    // matrix is (num_ids+1) x (num_ids+1), row-major, indexed by atom id.
+    CppAligner(int num_ids, double gap_open, double gap_extend)
+        : n1_(num_ids + 1), gap_open_(gap_open), gap_extend_(gap_extend),
+          mat_((size_t)(num_ids + 1) * (num_ids + 1), 0.0) {}
+
+    void set_matrix(const std::vector<double>& flat) {
+        if (flat.size() != mat_.size())
+            throw std::runtime_error("score matrix size mismatch");
+        mat_ = flat;
+    }
+
+    inline double score(int a, int b) const { return mat_[(size_t)a * n1_ + b]; }
+
+    AlignResult align(const std::vector<int>& q, const std::vector<int>& t) const {
+        const int n = (int)q.size(), m = (int)t.size();
+        const double NEG = -std::numeric_limits<double>::infinity();
+        const double d = gap_open_, e = gap_extend_;
+
+        // F[k][i][j], B stores (from_k, from_i, from_j)
+        std::vector<double> F((size_t)3 * (n + 1) * (m + 1), NEG);
+        std::vector<int> B((size_t)3 * (n + 1) * (m + 1) * 3, -1);
+        auto Fi = [&](int k, int i, int j) -> double& {
+            return F[((size_t)k * (n + 1) + i) * (m + 1) + j];
+        };
+        auto Bi = [&](int k, int i, int j, int c) -> int& {
+            return B[(((size_t)k * (n + 1) + i) * (m + 1) + j) * 3 + c];
+        };
+        auto setB = [&](int k, int i, int j, int fk, int fi, int fj) {
+            Bi(k, i, j, 0) = fk; Bi(k, i, j, 1) = fi; Bi(k, i, j, 2) = fj;
+        };
+
+        Fi(M, 0, 0) = 0.0;
+        for (int i = 1; i <= n; ++i) {
+            Fi(IX, i, 0) = (i > 1) ? Fi(IX, i - 1, 0) + e : d;
+            setB(IX, i, 0, IX, i - 1, 0);
+        }
+        for (int j = 1; j <= m; ++j) {
+            Fi(IY, 0, j) = (j > 1) ? Fi(IY, 0, j - 1) + e : d;
+            setB(IY, 0, j, IY, 0, j - 1);
+        }
+
+        for (int i = 1; i <= n; ++i) {
+            for (int j = 1; j <= m; ++j) {
+                double s = score(q[i - 1], t[j - 1]);
+                double cm[3] = {Fi(M, i - 1, j - 1) + s, Fi(IX, i - 1, j - 1) + s, Fi(IY, i - 1, j - 1) + s};
+                int bk = argmax3(cm);
+                Fi(M, i, j) = cm[bk]; setB(M, i, j, bk, i - 1, j - 1);
+
+                double cx[3] = {Fi(M, i - 1, j) + d, Fi(IX, i - 1, j) + e, Fi(IY, i - 1, j) + d};
+                bk = argmax3(cx);
+                Fi(IX, i, j) = cx[bk]; setB(IX, i, j, bk, i - 1, j);
+
+                double cy[3] = {Fi(M, i, j - 1) + d, Fi(IY, i, j - 1) + e, Fi(IX, i, j - 1) + d};
+                bk = argmax3(cy);
+                Fi(IY, i, j) = cy[bk]; setB(IY, i, j, bk, i, j - 1);
+            }
+        }
+
+        double ends[3] = {Fi(M, n, m), Fi(IX, n, m), Fi(IY, n, m)};
+        int best = argmax3(ends);
+
+        AlignResult r;
+        r.score = ends[best];
+        int k = best, i = n, j = m, prev_k = -1;
+        while (i > 0 || j > 0) {
+            int fk = Bi(k, i, j, 0), fi = Bi(k, i, j, 1), fj = Bi(k, i, j, 2);
+            if (fi < 0 || fj < 0) break;
+            if (k == M) { r.query.push_back(q[i - 1]); r.target.push_back(t[j - 1]); }
+            else if (k == IX) {
+                r.query.push_back(q[i - 1]); r.target.push_back(0);
+                if (prev_k != IX) r.gap_opens++; else r.gap_extensions++;
+            } else {
+                r.query.push_back(0); r.target.push_back(t[j - 1]);
+                if (prev_k != IY) r.gap_opens++; else r.gap_extensions++;
+            }
+            prev_k = k; k = fk; i = fi; j = fj;
+        }
+        std::reverse(r.query.begin(), r.query.end());
+        std::reverse(r.target.begin(), r.target.end());
+        r.length = (int)r.query.size();
+        return r;
+    }
+
+private:
+    int n1_;
+    double gap_open_, gap_extend_;
+    std::vector<double> mat_;
+
+    static inline int argmax3(const double v[3]) {
+        if (v[0] >= v[1]) return (v[0] >= v[2]) ? 0 : 2;
+        return (v[1] >= v[2]) ? 1 : 2;
+    }
+};
+
+PYBIND11_MODULE(cpp_aligner, mod) {
+    py::class_<AlignResult>(mod, "AlignResult")
+        .def_readonly("score", &AlignResult::score)
+        .def_readonly("query", &AlignResult::query)
+        .def_readonly("target", &AlignResult::target)
+        .def_readonly("gap_opens", &AlignResult::gap_opens)
+        .def_readonly("gap_extensions", &AlignResult::gap_extensions)
+        .def_readonly("length", &AlignResult::length);
+    py::class_<CppAligner>(mod, "CppAligner")
+        .def(py::init<int, double, double>())
+        .def("set_matrix", &CppAligner::set_matrix)
+        .def("align", &CppAligner::align);
+}

{pyseqalignment-0.1.1 → pyseqalignment-0.1.2/src/pyseqalignment.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyseqalignment
-Version: 0.1.1
+Version: 0.1.2
 Summary: pySeqAlign -- sequence alignment with Prolog-style distance functions and ILP learning
 Author-email: Andreas Karwath <a.karwath@bham.ac.uk>
 License-Expression: MIT
@@ -64,6 +64,7 @@ pySeqAlign provides Smith-Waterman (local) and Needleman-Wunsch (global) sequenc
   - **Aleph** backend -- classic ILP system (Srinivasan, 2001)
   - **Popper** backend -- modern ILP via learning from failures (Cropper & Morel, 2021)
 - **Pure Python** core -- no C extension required (unlike the legacy version)
+- **Optional fast C++ aligner** -- a pybind11 affine-gap Needleman-Wunsch kernel (`pyseqalign.accel`) for large all-pairs / iterative workloads; identical results to the Python aligner, ~100-270x faster
 
 ## Installation
 
@@ -308,6 +309,35 @@ For reference, other notable systems in the field include:
 - [Metagol](https://github.com/metagol/metagol) -- Meta-Interpretive Learning
 - [DeepStochLog](https://github.com/ML-KULeuven/deepstochlog) -- Neural-symbolic ILP combining logic and neural networks
 
+## Fast C++ aligner (optional)
+
+The pure-Python aligners are fine for typical use. For heavy workloads (e.g.
+boosting that re-aligns thousands of sequence pairs per iteration), an optional
+**C++ affine-gap Needleman-Wunsch** kernel is provided. It is NOT built by default
+(the core stays pure Python); build it once with a C++ compiler + pybind11:
+
+```bash
+pip install pybind11
+src/pyseqalign/cpp/build_cpp_aligner.sh          # or: PY=$(which python) src/.../build_cpp_aligner.sh
+```
+
+This compiles the extension into the `pyseqalign` package. Then:
+
+```python
+from pyseqalign.accel import cpp_available, load
+assert cpp_available()
+cpp = load()                                  # the compiled module
+al = cpp.CppAligner(num_ids, gap_open, gap_extend)
+al.set_matrix(flat_score_matrix)              # (num_ids+1)^2 row-major scores
+r = al.align(query_ids, target_ids)           # r.score, r.query, r.target, r.gap_opens, ...
+```
+
+The kernel implements the same 3-matrix (M/Ix/Iy) affine recurrence as a numeric
+aligner over a dense score matrix, so its results are interchangeable with a
+pure-Python affine Needleman-Wunsch (validated bit-for-bit). If the extension is
+not built, `cpp_available()` is `False` and `load()` raises a helpful error --
+callers should fall back to the Python aligner.
+
 ## Background
 
 **pySeqAlign** is a modern, pure-Python reimplementation that revives the name of one of its own ancestors. It succeeds two legacy libraries behind the ILP 2006 / ICDM 2008 work: the original **pyAlign** (SWIG-wrapped C with YAP Prolog bindings for alignment) and the original **pySeqAlign** (which held the Aleph ILP framework for learning rules from alignment examples). This version is pure Python, with optional SWI-Prolog integration via [Janus](https://www.swi-prolog.org/packs/list?p=janus) (the modern Python-Prolog bridge, replacing the older pyswip).

{pyseqalignment-0.1.1 → pyseqalignment-0.1.2}/src/pyseqalignment.egg-info/SOURCES.txt

@@ -2,10 +2,13 @@ LICENSE
 README.md
 pyproject.toml
 src/pyseqalign/__init__.py
+src/pyseqalign/accel.py
 src/pyseqalign/core/__init__.py
 src/pyseqalign/core/alignment.py
 src/pyseqalign/core/needleman_wunsch.py
 src/pyseqalign/core/smith_waterman.py
+src/pyseqalign/cpp/build_cpp_aligner.sh
+src/pyseqalign/cpp/cpp_aligner.cpp
 src/pyseqalign/learning/__init__.py
 src/pyseqalign/learning/aleph.py
 src/pyseqalign/learning/base.py