seqtree 1.1.0__tar.gz → 1.2.0__tar.gz

{seqtree-1.1.0 → seqtree-1.2.0}/CHANGELOG.md

@@ -3,6 +3,24 @@
 All notable changes to `seqtree`. Dates are release dates. From 1.0.0 the project follows semantic
 versioning: breaking changes need a **major** bump.
 
+## [1.2.0] — 2026-10-17
+
+### Fixed
+
+- Exact exclusion masks matching hits without shrinking model populations or
+  supplied annotation counters, including withheld-label models.
+
+### Added
+
+- Fixed query/reference partitions for native group audits.
+- Bounded sparse grouped radius-hit output with deterministic ordering and explicit memory-cap failures.
+- Optional grouped geometry compatible with the supported nanobind 2.5 floor.
+
+- Generic float64 global-alignment target maxima with numeric annotation CSR,
+  group offsets, explicit matrix symbols and independent candidate edit budgets.
+- Optional aggregate insertion/deletion limits for batched edit histograms;
+  omitted and redundant limits preserve the existing count paths.
+
 ## [1.1.0] — 2026-10-11
 
 ### Added

{seqtree-1.1.0 → seqtree-1.2.0}/CMakeLists.txt

@@ -30,6 +30,7 @@ add_library(seqtree_core STATIC
   src/searcher.cpp
   src/gapblock.cpp
   src/pairwise.cpp
+  src/alignment_max.cpp
   src/distance.cpp
 )
 target_include_directories(seqtree_core PUBLIC include PRIVATE src)

{seqtree-1.1.0 → seqtree-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: seqtree
-Version: 1.1.0
+Version: 1.2.0
 Summary: Fast fuzzy search over biological sequences (C++ core, Python bindings)
 Keywords: sequence-search,fuzzy-matching,CDR3,immunology,bioinformatics,trie
 Author-Email: ISALGO laboratory <mikhail.shugay@gmail.com>
@@ -289,3 +289,14 @@ This repo follows **git-flow**:
 Roadmap (affine gaps, position-specific matrices, succinct memory packing) lives in
 [docs/roadmap.rst](docs/roadmap.rst). Control-set E-values already ship — see the
 [E-value guide](https://antigenomics.github.io/seqtree/evalue.html).
+
+### Floating alignment reductions
+
+`Index.alignment_max_batch` streams unit-cost search candidates through float64
+global alignment and requested numeric-target maxima without a dense pair table.
+It accepts explicit matrix symbols, small group-offset matrices and annotation CSR,
+with separate alignment-selection and final scoring coefficients.
+`Index.edit_histogram_batch(..., max_indels=...)` additionally supports an aggregate
+insertion/deletion cap; its default preserves previous behavior. See the
+[API reference](https://antigenomics.github.io/seqtree/api.html) for array contracts
+and tie, count, exclusion and unsupported-value semantics.

{seqtree-1.1.0 → seqtree-1.2.0}/README.md

@@ -257,3 +257,14 @@ This repo follows **git-flow**:
 Roadmap (affine gaps, position-specific matrices, succinct memory packing) lives in
 [docs/roadmap.rst](docs/roadmap.rst). Control-set E-values already ship — see the
 [E-value guide](https://antigenomics.github.io/seqtree/evalue.html).
+
+### Floating alignment reductions
+
+`Index.alignment_max_batch` streams unit-cost search candidates through float64
+global alignment and requested numeric-target maxima without a dense pair table.
+It accepts explicit matrix symbols, small group-offset matrices and annotation CSR,
+with separate alignment-selection and final scoring coefficients.
+`Index.edit_histogram_batch(..., max_indels=...)` additionally supports an aggregate
+insertion/deletion cap; its default preserves previous behavior. See the
+[API reference](https://antigenomics.github.io/seqtree/api.html) for array contracts
+and tie, count, exclusion and unsupported-value semantics.

seqtree-1.2.0/RELEASE_AUDIT.md

@@ -0,0 +1,12 @@
+# Release audit — 17 October 2026
+
+The requested generic batch/search APIs are implemented. No new native algorithm is needed for the audited downstream requirements.
+
+- Native batch search and edit histograms; aggregate insertion/deletion caps.
+- Float64 global-alignment target reductions, separate candidate/final scoring semantics, fixed populations under exact exclusion.
+- Grouped geometry, fixed audit partitions, bounded deterministic sparse radius hits and optional-geometry compatibility at the supported nanobind floor.
+- Shared CPU allocation checks; one-thread inline execution and explicit over-budget rejection.
+
+Verification on `0852ff5`: **379 passed, 1 Linux-only platform skip** across `test_batch_threads.py`, `test_alignment_max.py`, `test_edit_histogram.py`, `test_grouped_optional_geometry.py` and `test_grouped_sparse_hits.py`. An additional 280 checks cover grouped populations, withholding, paired lanes, offsets, score bins and partitions. Native budget was two CPUs; numerical libraries used one thread. The committed `examples/01_gapped_search.py` runs and its per-query cutoff/search output was inspected. Sphinx builds with `-W`.
+
+The local `dev` commits `0126e00`, `858056b` and `0852ff5` were three commits ahead of the remote at audit start. They are preserved and included when this audited `dev` is pushed. The changelog now covers these capabilities; public API documentation already describes the alignment reductions. [Issue 18](https://github.com/antigenomics/seqtree/issues/18) tracks integration into the release head and the remaining exact-head cross-platform/wheel gate. Publishing remains the maintainer's action; this audit creates no tag or release. Focused checks do not substitute for complete release CI.

{seqtree-1.1.0 → seqtree-1.2.0}/include/seqtree/seqtree.hpp

@@ -3,6 +3,7 @@
 
 #include <cstdint>
 #include <memory>
+#include <optional>
 #include <string>
 #include <string_view>
 #include <tuple>
@@ -104,6 +105,14 @@ private:
     std::vector<uint8_t> masked_;  // [width]
 };
 
+struct AlignmentMaxResult {
+    std::vector<double> scores, raw_similarity, normalized_similarity, pfit, informativeness;
+    std::vector<uint64_t> counts, modeled_counts, aa_counts, exact_counts, candidate_counts, nw_pairs;
+    std::vector<int64_t> best_ref_ids, best_lane_ids;
+    std::vector<uint32_t> gap_counts;
+    std::vector<uint8_t> query_supported;
+};
+
 // Immutable after build. Lock-free for concurrent reads; share one Index across
 // threads, give each thread its own Searcher.
 class Index {
@@ -128,7 +137,18 @@ public:
     // Exact edit-count bins 0..max_total_edits; one reusable hit buffer per worker.
     std::vector<std::vector<uint64_t>> edit_histogram_batch(
         const std::vector<std::string>& queries, const SearchParams&,
-        int threads = 0, bool exclude_exact = false) const;
+        int threads = 0, bool exclude_exact = false, int max_indels = -1) const;
+
+    // Numeric requested-label maxima; float NW selection is independent of candidate scope.
+    AlignmentMaxResult alignment_max_batch(const std::vector<std::string>& queries,
+        const SearchParams&, const std::vector<std::vector<double>>& similarity, const std::string& symbols, int max_indels,
+        const std::vector<uint32_t>& query_target_offsets, const std::vector<uint32_t>& query_target_ids,
+        const std::vector<uint32_t>& reference_target_offsets, const std::vector<uint32_t>& reference_target_ids,
+        const std::vector<int32_t>& target_class_ids, const std::vector<uint32_t>& reference_class_offsets,
+        const std::vector<int32_t>& reference_class_ids, const std::vector<std::vector<int32_t>>& query_group_ids,
+        const std::vector<std::vector<int32_t>>& reference_group_ids, const std::vector<std::vector<std::vector<double>>>& group_offsets,
+        const std::vector<uint64_t>& reference_other_counts, const std::vector<uint64_t>& reference_multiplicities,
+        const std::vector<double>& coefficients, int threads=0, bool exclude_exact=false) const;
 
     // Per-query count of seqtm collisions: how often a reference was re-reached via a
     // different edit path during branch-and-bound (0 for the seqtrie engine / Hamming).
@@ -154,7 +174,7 @@ public:
     ~Searcher();
 
     std::vector<Hit> search(std::string_view query, const SearchParams&);
-    void search_into(std::string_view query, const SearchParams&, std::vector<Hit>& out);
+    void search_into(std::string_view query, const SearchParams&, std::vector<Hit>& out, int max_indels = -1);
     bool search_top(std::string_view query, const SearchParams&, Hit& out);
 
     // seqtm collisions from the most recent search_into on this Searcher.
@@ -228,6 +248,20 @@ std::vector<int32_t> align_dist_matrix(const std::vector<std::string>& queries,
 // Both axes are required; these rows cannot combine with length profiles.
 // Optional group IDs index a nonnegative rectangular penalty table added per pair.
 // Exact exclusion remains encoded junction identity, independent of these groups.
+// Factored nonnegative offsets: paired feature codes, one shared code cost table.
+// Round weight * sum(max(head cost, tail cost)) / depth to nearest, ties even,
+// then multiply by scale. Input descriptors are copied into immutable batch state.
+struct PairedFeatureOffsets {
+    std::vector<std::vector<int32_t>> query_codes, reference_codes, costs;
+    double weight;
+    int32_t scale;
+    PairedFeatureOffsets(std::vector<std::vector<int32_t>> q,
+                         std::vector<std::vector<int32_t>> r,
+                         std::vector<std::vector<int32_t>> c, double w = 1.0, int32_t s = 1)
+        : query_codes(std::move(q)), reference_codes(std::move(r)), costs(std::move(c)),
+          weight(w), scale(s) {}
+};
+
 std::vector<int32_t> gapblock_matrix(const std::vector<std::string>& queries,
                                      const std::vector<std::string>& refs, Alphabet,
                                      const SubstitutionMatrix* matrix, int32_t gap_open,
@@ -238,7 +272,8 @@ std::vector<int32_t> gapblock_matrix(const std::vector<std::string>& queries,
                                      const std::vector<int32_t>& reference_groups = {},
                                      const std::vector<std::vector<int32_t>>& group_distances = {},
         const std::vector<std::vector<int32_t>>& query_weights = {},
-        const std::vector<std::vector<int32_t>>& reference_weights = {});
+        const std::vector<std::vector<int32_t>>& reference_weights = {},
+        const std::optional<PairedFeatureOffsets>& feature_offsets = std::nullopt);
 
 // Exhaustive ball rows in reference order; hit edit fields are unset (zero).
 std::vector<std::vector<Hit>> gapblock_ball_batch(const std::vector<std::string>& queries,
@@ -250,7 +285,8 @@ std::vector<std::vector<Hit>> gapblock_ball_batch(const std::vector<std::string>
         const std::vector<int32_t>& reference_groups = {},
         const std::vector<std::vector<int32_t>>& group_distances = {},
         const std::vector<std::vector<int32_t>>& query_weights = {},
-        const std::vector<std::vector<int32_t>>& reference_weights = {});
+        const std::vector<std::vector<int32_t>>& reference_weights = {},
+        const std::optional<PairedFeatureOffsets>& feature_offsets = std::nullopt);
 
 // Exhaustive bounded reductions using the same gapblock cell. Top-k ties use
 // (penalty, ref_id); paired penalty is max(lane scores). Exact exclusion uses
@@ -267,7 +303,10 @@ gapblock_group_audit_batch(const std::vector<std::string>& queries,
         const std::vector<int32_t>& reference_groups = {},
         const std::vector<std::vector<int32_t>>& group_distances = {},
         const std::vector<std::vector<int32_t>>& query_weights = {},
-        const std::vector<std::vector<int32_t>>& reference_weights = {});
+        const std::vector<std::vector<int32_t>>& reference_weights = {},
+        const std::optional<PairedFeatureOffsets>& feature_offsets = std::nullopt,
+        const std::vector<int32_t>& query_partitions = {},
+        const std::vector<int32_t>& reference_partitions = {});
 
 std::vector<std::vector<Hit>> gapblock_topk_batch(const std::vector<std::string>& queries,
         const std::vector<std::string>& refs, uint32_t k, Alphabet alphabet,
@@ -287,7 +326,8 @@ std::vector<std::vector<uint64_t>> gapblock_count_batch(const std::vector<std::s
         const std::vector<int32_t>& reference_groups = {},
         const std::vector<std::vector<int32_t>>& group_distances = {},
         const std::vector<std::vector<int32_t>>& query_weights = {},
-        const std::vector<std::vector<int32_t>>& reference_weights = {});
+        const std::vector<std::vector<int32_t>>& reference_weights = {},
+        const std::optional<PairedFeatureOffsets>& feature_offsets = std::nullopt, bool shared_thresholds = false);
 std::pair<std::vector<std::vector<uint64_t>>, std::vector<std::vector<uint64_t>>> gapblock_count_mass_batch(const std::vector<std::string>& queries,
         const std::vector<std::string>& refs, const std::vector<std::vector<int32_t>>& thresholds,
         Alphabet alphabet, const SubstitutionMatrix* matrix, int32_t go, int32_t ge,
@@ -297,7 +337,8 @@ std::pair<std::vector<std::vector<uint64_t>>, std::vector<std::vector<uint64_t>>
         const std::vector<int32_t>& reference_groups = {},
         const std::vector<std::vector<int32_t>>& group_distances = {},
         const std::vector<std::vector<int32_t>>& query_weights = {},
-        const std::vector<std::vector<int32_t>>& reference_weights = {});
+        const std::vector<std::vector<int32_t>>& reference_weights = {},
+        const std::optional<PairedFeatureOffsets>& feature_offsets = std::nullopt, bool shared_thresholds = false);
 std::vector<std::vector<uint64_t>> gapblock_paired_count_batch(
         const std::vector<std::string>& qa, const std::vector<std::string>& qb,
         const std::vector<std::string>& ra, const std::vector<std::string>& rb,
@@ -319,7 +360,9 @@ std::pair<std::vector<std::vector<uint64_t>>, std::vector<std::vector<uint64_t>>
         const std::vector<std::vector<int32_t>>& query_weights_alpha = {},
         const std::vector<std::vector<int32_t>>& query_weights_beta = {},
         const std::vector<std::vector<int32_t>>& reference_weights_alpha = {},
-        const std::vector<std::vector<int32_t>>& reference_weights_beta = {});
+        const std::vector<std::vector<int32_t>>& reference_weights_beta = {},
+        const std::optional<PairedFeatureOffsets>& feature_offsets_alpha = std::nullopt,
+        const std::optional<PairedFeatureOffsets>& feature_offsets_beta = std::nullopt, bool shared_thresholds = false);
 
 // ---------------------------------------------------------------------------------------
 // Plain string edit distances on raw characters, unit costs. Deliberately alphabet-agnostic:
@@ -341,4 +384,53 @@ std::vector<int32_t> hamming_matrix(const std::vector<std::string>& a,
 std::vector<int32_t> levenshtein_matrix(const std::vector<std::string>& a,
                                         const std::vector<std::string>& b, int threads = 0);
 
+// Generic label histograms over one prepared native query/reference population.
+struct GroupedGeometry {
+    std::vector<PairedFeatureOffsets> additional_features;
+    std::optional<std::vector<int32_t>> gap_prior;
+    std::string alignment_mode = "gapblock";
+    int32_t alignment_scale = 1;
+    uint32_t trim_left = 0, trim_right = 0;
+    int32_t score_quantum = 1;
+    bool return_hits = false;
+    size_t max_hit_bytes = 64*1024*1024;
+    std::optional<std::vector<int32_t>> query_target_ids;
+    std::optional<std::vector<int64_t>> query_reference_ids;
+    std::vector<std::vector<int32_t>> weights, group_distances, query_weights, reference_weights;
+    std::vector<int32_t> query_groups, reference_groups;
+    std::optional<PairedFeatureOffsets> features;
+};
+struct CountBuffer {
+    std::vector<uint32_t> data;
+    std::vector<size_t> shape;
+};
+struct GroupedCountChunk {
+    size_t start = 0, stop = 0;
+    CountBuffer counts, sizes, exact_counts;
+    CountBuffer hits{{},{0,3}};
+};
+class GroupedCountBatch {
+public:
+    GroupedCountBatch(const std::vector<std::string>& qa, const std::vector<std::string>& ra,
+        std::vector<int32_t> thresholds, std::vector<uint32_t> target_offsets,
+        std::vector<uint32_t> target_ids, std::vector<int32_t> target_peptides,
+        std::vector<int32_t> exclusive_peptides, std::vector<int32_t> query_genes,
+        std::vector<int32_t> reference_genes, size_t chunk_size, Alphabet alphabet,
+        const SubstitutionMatrix* matrix, int32_t go, int32_t ge, std::vector<int32_t> prior,
+        uint32_t width, int threads, bool exclude_exact, const GroupedGeometry& alpha,
+        const std::optional<GroupedGeometry>& beta = std::nullopt,
+        const std::vector<std::string>& qb = {}, const std::vector<std::string>& rb = {},
+        std::optional<std::vector<int32_t>> query_withheld_peptides = std::nullopt,
+        std::vector<uint32_t> reference_peptide_offsets = {},
+        std::vector<int32_t> reference_peptide_ids = {});
+    std::optional<GroupedCountChunk> next();
+    size_t query_count() const;
+    size_t reference_count() const;
+    size_t target_count() const;
+    size_t peptide_count() const;
+private:
+    struct Impl;
+    std::shared_ptr<Impl> impl_;
+};
+
 }  // namespace seqtree

{seqtree-1.1.0 → seqtree-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "seqtree"
-version = "1.1.0"
+version = "1.2.0"
 description = "Fast fuzzy search over biological sequences (C++ core, Python bindings)"
 readme = "README.md"
 requires-python = ">=3.10"