bioforge 2.3.0__tar.gz → 3.1.0__tar.gz

{bioforge-2.3.0 → bioforge-3.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bioforge
-Version: 2.3.0
+Version: 3.1.0
 Summary: High-performance bioinformatics engine for Edge Computing — 5-bit encoding, vectorised NumPy core, optional C backend
 Author-email: Aarón Aranda Torrijos <noe9601@gmail.com>
 License: # PolyForm Noncommercial License 1.0.0
@@ -554,6 +554,26 @@ for mut in result.mutations:
 # Mutation(kind='substitution', pos_a=18, pos_b=18, sym_a='A', sym_b='T')
 ```
 
+### Map long reads to a genome (Level 4 — seed-chain-align)
+
+Locate reads in a reference far beyond what the O(m·n) aligner can handle,
+minimap2-style: minimizer seeding → chaining (C DP) → banded extension.
+
+```python
+from bioforge import GenomeAligner
+
+mapper = GenomeAligner(reference_sequence, k=15, w=10)   # builds the index once
+
+for m in mapper.map(read):
+    print(m.to_paf())                # standard PAF, one line per mapping
+    # read1  1000  0  1000  +  chr1  4600000  733120  734118  980  998  60 ...
+    print(m.strand, m.target_start, f"{m.identity:.1%}")
+```
+
+Handles both strands, tolerates mismatches/indels, and reports a mapping
+quality. The chaining dynamic program runs in the C engine (with a NumPy
+fallback).
+
 ### Full mutation analysis pipeline (DNA + protein)
 
 ```python
@@ -722,6 +742,29 @@ python check.py
 
 ---
 
+## References & inspiration
+
+BioForge's genome mapper (Level 4) is an **independent, from-scratch
+implementation** of well-established, published algorithms. No third-party
+source code is included or copied — only the *ideas* from the scientific
+literature, which is what publishing them is for. With gratitude to:
+
+- **Minimap2** — Li, H. (2018). *Minimap2: pairwise alignment for nucleotide
+  sequences.* Bioinformatics, 34(18), 3094–3100. The seed-chain-align strategy
+  and the chaining dynamic program that inspired `genomemap.py`.
+  ([paper](https://doi.org/10.1093/bioinformatics/bty191) ·
+  [MIT-licensed source](https://github.com/lh3/minimap2))
+- **Minimizers** — Roberts, M., Hayes, W., Hunt, B. R., Mount, S. M., &
+  Yorke, J. A. (2004). *Reducing storage requirements for biological sequence
+  comparison.* Bioinformatics, 20(18), 3363–3369. The (w, k) minimizer sampling
+  behind `minimizers.py`.
+- **Needleman–Wunsch** (1970) and **Smith–Waterman** (1981) — the classic
+  dynamic-programming alignments behind Level 3.
+
+BioForge is not affiliated with or endorsed by the authors of the above.
+
+---
+
 ## Author
 
 **Aarón Aranda Torrijos** — [github.com/erlanders177](https://github.com/erlanders177)

{bioforge-2.3.0 → bioforge-3.1.0}/README.md

@@ -234,6 +234,26 @@ for mut in result.mutations:
 # Mutation(kind='substitution', pos_a=18, pos_b=18, sym_a='A', sym_b='T')
 ```
 
+### Map long reads to a genome (Level 4 — seed-chain-align)
+
+Locate reads in a reference far beyond what the O(m·n) aligner can handle,
+minimap2-style: minimizer seeding → chaining (C DP) → banded extension.
+
+```python
+from bioforge import GenomeAligner
+
+mapper = GenomeAligner(reference_sequence, k=15, w=10)   # builds the index once
+
+for m in mapper.map(read):
+    print(m.to_paf())                # standard PAF, one line per mapping
+    # read1  1000  0  1000  +  chr1  4600000  733120  734118  980  998  60 ...
+    print(m.strand, m.target_start, f"{m.identity:.1%}")
+```
+
+Handles both strands, tolerates mismatches/indels, and reports a mapping
+quality. The chaining dynamic program runs in the C engine (with a NumPy
+fallback).
+
 ### Full mutation analysis pipeline (DNA + protein)
 
 ```python
@@ -402,6 +422,29 @@ python check.py
 
 ---
 
+## References & inspiration
+
+BioForge's genome mapper (Level 4) is an **independent, from-scratch
+implementation** of well-established, published algorithms. No third-party
+source code is included or copied — only the *ideas* from the scientific
+literature, which is what publishing them is for. With gratitude to:
+
+- **Minimap2** — Li, H. (2018). *Minimap2: pairwise alignment for nucleotide
+  sequences.* Bioinformatics, 34(18), 3094–3100. The seed-chain-align strategy
+  and the chaining dynamic program that inspired `genomemap.py`.
+  ([paper](https://doi.org/10.1093/bioinformatics/bty191) ·
+  [MIT-licensed source](https://github.com/lh3/minimap2))
+- **Minimizers** — Roberts, M., Hayes, W., Hunt, B. R., Mount, S. M., &
+  Yorke, J. A. (2004). *Reducing storage requirements for biological sequence
+  comparison.* Bioinformatics, 20(18), 3363–3369. The (w, k) minimizer sampling
+  behind `minimizers.py`.
+- **Needleman–Wunsch** (1970) and **Smith–Waterman** (1981) — the classic
+  dynamic-programming alignments behind Level 3.
+
+BioForge is not affiliated with or endorsed by the authors of the above.
+
+---
+
 ## Author
 
 **Aarón Aranda Torrijos** — [github.com/erlanders177](https://github.com/erlanders177)

{bioforge-2.3.0 → bioforge-3.1.0}/bioforge/__init__.py

@@ -33,9 +33,10 @@ from .biocore import (
     TranslationError,
     compute_stats,
 )
+from .genomemap import GenomeAligner, Mapping
 from .smart_translator import SmartTranslator
 
-__version__ = "2.3.0"
+__version__ = "3.1.0"
 __author__  = "Aarón Aranda Torrijos"
 
 __all__ = [
@@ -67,6 +68,9 @@ __all__ = [
     "format_alignment",
     "Mutation",
     "AlignmentResult",
+    # Genome mapper (v3.0)
+    "GenomeAligner",
+    "Mapping",
     # Pipeline
     "run",
     "build_report",

{bioforge-2.3.0 → bioforge-3.1.0}/bioforge/aligner.py

@@ -179,6 +179,7 @@ class SequenceAligner:
         seq_b: PackedSequence,
         mode:  Literal['global', 'semi-global'] = 'global',
         band:  int | None = None,
+        detect_mutations: bool = True,
     ) -> AlignmentResult:
         """
         Align seq_a (reference) against seq_b (query) — Needleman-Wunsch.
@@ -238,7 +239,8 @@ class SequenceAligner:
                 raise AlignmentError(f"band debe ser ≥ 1, se recibió {band}.")
             if C_AVAILABLE:
                 return cls._align_banded_c(
-                    codes_a, codes_b, m, n, band, mode, seq_a.seq_type
+                    codes_a, codes_b, m, n, band, mode, seq_a.seq_type,
+                    detect_mutations,
                 )
             # NumPy fallback: banded fill sobre matriz completa
             if m > cls._MAX_SAFE_LEN or n > cls._MAX_SAFE_LEN:
@@ -261,7 +263,8 @@ class SequenceAligner:
             )
 
         if C_AVAILABLE:
-            return cls._align_c(codes_a, codes_b, m, n, mode, seq_a.seq_type)
+            return cls._align_c(codes_a, codes_b, m, n, mode, seq_a.seq_type,
+                                detect_mutations)
 
         H = cls._fill_matrix(codes_a, codes_b, m, n, mode)
         return cls._traceback(H, codes_a, codes_b, m, n, mode, seq_a.seq_type)
@@ -361,6 +364,7 @@ class SequenceAligner:
         band: int,
         mode: str,
         seq_type: SeqType,
+        detect_mutations: bool = True,
     ) -> AlignmentResult:
         decode_bytes = (
             _NUC_DECODE_BYTES if seq_type == SeqType.NUCLEOTIDE else _AA_DECODE_BYTES
@@ -370,7 +374,7 @@ class SequenceAligner:
             int(cls.MATCH), int(cls.MISMATCH), int(cls.GAP),
             band, mode,
         )
-        mutations = cls._detect_mutations(aligned_a, aligned_b)
+        mutations = cls._detect_mutations(aligned_a, aligned_b) if detect_mutations else []
         aln_len   = n_matches + n_mismatches + n_gaps
         identity  = n_matches / aln_len if aln_len else 0.0
         return AlignmentResult(
@@ -389,6 +393,7 @@ class SequenceAligner:
         n: int,
         mode: str,
         seq_type: SeqType,
+        detect_mutations: bool = True,
     ) -> AlignmentResult:
         decode_bytes = (
             _NUC_DECODE_BYTES if seq_type == SeqType.NUCLEOTIDE else _AA_DECODE_BYTES
@@ -398,7 +403,7 @@ class SequenceAligner:
             int(cls.MATCH), int(cls.MISMATCH), int(cls.GAP),
             mode,
         )
-        mutations = cls._detect_mutations(aligned_a, aligned_b)
+        mutations = cls._detect_mutations(aligned_a, aligned_b) if detect_mutations else []
         aln_len   = n_matches + n_mismatches + n_gaps
         identity  = n_matches / aln_len if aln_len else 0.0
         return AlignmentResult(

{bioforge-2.3.0 → bioforge-3.1.0}/bioforge/engine/_loader.py

@@ -17,8 +17,11 @@ _DLL_PATH   = _ENGINE_DIR / ("engine.dll" if sys.platform == "win32" else "engin
 # ── Tipos ctypes frecuentes ────────────────────────────────────────────────────
 _U8P  = ctypes.POINTER(ctypes.c_uint8)
 _I32P = ctypes.POINTER(ctypes.c_int32)
+_I64P = ctypes.POINTER(ctypes.c_int64)
+_F64P = ctypes.POINTER(ctypes.c_double)
 _I32  = ctypes.c_int32
 _I64  = ctypes.c_int64
+_F64  = ctypes.c_double
 _CHARP = ctypes.c_char_p
 
 # ── Carga del DLL ──────────────────────────────────────────────────────────────
@@ -200,10 +203,30 @@ def _check_libdeflate() -> None:
         pass
 
 
+C_CHAIN_AVAILABLE: bool = False
+
+def _check_chain() -> None:
+    """DP de chaining del alineador de genomas (v3). Opcional."""
+    global C_CHAIN_AVAILABLE
+    if not C_AVAILABLE or _lib is None:
+        return
+    try:
+        _lib.bio_chain_dp.restype = None
+        _lib.bio_chain_dp.argtypes = [
+            _I64P, _I64P, _I32,        # x, y, n
+            _I32, _I64, _I32, _F64,    # k, max_gap, window, gap_w
+            _F64P, _I32P,              # f (out), prev (out)
+        ]
+        C_CHAIN_AVAILABLE = True
+    except (AttributeError, OSError):
+        pass
+
+
 _check_parser()
 _check_batch()
 _check_parallel()
 _check_libdeflate()
+_check_chain()
 
 
 # ── Wrappers Python ────────────────────────────────────────────────────────────
@@ -324,6 +347,23 @@ def c_nw_banded(
     )
 
 
+def c_chain_dp(xs: np.ndarray, ys: np.ndarray, k: int,
+               max_gap: int, window: int, gap_w: float):
+    """DP de chaining en C. Rellena y devuelve (f, prev).
+
+    ``xs``/``ys`` deben ser int64 contiguos y estar ordenados por (x, y).
+    """
+    n = int(xs.size)
+    f = np.empty(n, dtype=np.float64)
+    prev = np.empty(n, dtype=np.int32)
+    _lib.bio_chain_dp(
+        xs.ctypes.data_as(_I64P), ys.ctypes.data_as(_I64P), _I32(n),
+        _I32(int(k)), _I64(int(max_gap)), _I32(int(window)), _F64(float(gap_w)),
+        f.ctypes.data_as(_F64P), prev.ctypes.data_as(_I32P),
+    )
+    return f, prev
+
+
 def c_parser_open(path: str) -> int:
     """Abre un archivo FASTA/FASTQ y devuelve un handle opaco (c_void_p)."""
     raw = path.encode("utf-8") if isinstance(path, str) else path

{bioforge-2.3.0 → bioforge-3.1.0}/bioforge/engine/engine.c

@@ -21,6 +21,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdint.h>
+#include <math.h>
 
 /* ── Lectura de archivos: gzip transparente si se compila con -DBIO_USE_ZLIB ──
    zlib gzopen/gzread leen tanto archivos planos como .gz (autodetección del
@@ -1536,3 +1537,45 @@ EXPORT int32_t bio_parse_mem_parallel(
     free(outs);
     return (rc != 0) ? rc : total_rec;
 }
+
+/* ── Chaining DP (alineador v3) ───────────────────────────────────────────────
+   Rellena f[] (mejor score de cadena que TERMINA en i) y prev[] (predecesor)
+   para anclas ordenadas ascendentemente por (x, y). El backtracking y la
+   supresión de solapamientos se hacen en Python (baratos, O(n)).
+
+   x, y     : posiciones de las anclas (ref y coord. de chaining), int64.
+   n        : nº de anclas.  k : peso del ancla (longitud del k-mer).
+   max_gap  : distancia máxima entre anclas encadenables.
+   window   : nº de predecesores examinados por ancla.
+   gap_w    : peso lineal de la penalización por hueco.
+
+   Réplica exacta del DP vectorizado de genomemap.py (misma fórmula y mismo
+   desempate: al iterar j de i-1 hacia abajo con `>` estricto, en empate gana
+   el predecesor MÁS CERCANO). Así el resultado C == fallback NumPy. */
+EXPORT void bio_chain_dp(const int64_t* x, const int64_t* y, int32_t n,
+                         int32_t k, int64_t max_gap, int32_t window,
+                         double gap_w, double* f, int32_t* prev) {
+    for (int32_t i = 0; i < n; i++) {
+        double  best = (double)k;
+        int32_t bp   = -1;
+        int32_t lo   = i - window;
+        if (lo < 0) lo = 0;
+        for (int32_t j = i - 1; j >= lo; j--) {
+            int64_t dx = x[i] - x[j];
+            if (dx > max_gap) break;              /* ordenado → resto aún más lejos */
+            int64_t dy = y[i] - y[j];
+            if (dy <= 0 || dx <= 0 || dy > max_gap) continue;
+            int64_t gap = dx - dy;
+            if (gap < 0) gap = -gap;
+            if (gap > max_gap) continue;
+            int64_t mn = (dx < dy) ? dx : dy;
+            double match = (double)((mn < (int64_t)k) ? mn : (int64_t)k);
+            double cost  = gap_w * (double)gap;
+            if (gap > 0) cost += log2((double)gap + 1.0);
+            double sc = f[j] + match - cost;
+            if (sc > best) { best = sc; bp = j; }
+        }
+        f[i]    = best;
+        prev[i] = bp;
+    }
+}