bioforge 3.3.0__tar.gz → 4.0.0__tar.gz

{bioforge-3.3.0 → bioforge-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bioforge
-Version: 3.3.0
+Version: 4.0.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
@@ -562,17 +562,26 @@ 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
+# Single sequence, or a whole multi-contig genome:
+mapper = GenomeAligner({"chr1": chr1_seq, "chr2": chr2_seq, "plasmid": p_seq})
 
 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%}")
+    print(m.target_name, m.strand, m.target_start, f"{m.identity:.1%}")
+
+# Map many reads in parallel (uses processes):
+results = mapper.map_batch(reads, n_processes=0)   # 0 = all cores
 ```
 
-Handles both strands, tolerates mismatches/indels, and reports a mapping
-quality. The chaining dynamic program runs in the C engine (with a NumPy
-fallback).
+Handles multi-chromosome references (reports the contig + local coordinates),
+both strands, aligns the full read, tolerates mismatches/indels, and reports a
+mapping quality. The minimizer and chaining kernels run in the C engine (with
+NumPy fallbacks).
+
+> **Speed, honestly:** indexing is fast, but read mapping is not yet
+> competitive with hand-tuned C mappers like minimap2 — the mapping pipeline is
+> being moved into the C engine. Use BioForge's mapper where its strengths fit:
+> pure-Python/NumPy core, tiny footprint, `pip install` and go, no C toolchain.
 
 ### Full mutation analysis pipeline (DNA + protein)
 

{bioforge-3.3.0 → bioforge-4.0.0}/README.md

@@ -242,17 +242,26 @@ 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
+# Single sequence, or a whole multi-contig genome:
+mapper = GenomeAligner({"chr1": chr1_seq, "chr2": chr2_seq, "plasmid": p_seq})
 
 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%}")
+    print(m.target_name, m.strand, m.target_start, f"{m.identity:.1%}")
+
+# Map many reads in parallel (uses processes):
+results = mapper.map_batch(reads, n_processes=0)   # 0 = all cores
 ```
 
-Handles both strands, tolerates mismatches/indels, and reports a mapping
-quality. The chaining dynamic program runs in the C engine (with a NumPy
-fallback).
+Handles multi-chromosome references (reports the contig + local coordinates),
+both strands, aligns the full read, tolerates mismatches/indels, and reports a
+mapping quality. The minimizer and chaining kernels run in the C engine (with
+NumPy fallbacks).
+
+> **Speed, honestly:** indexing is fast, but read mapping is not yet
+> competitive with hand-tuned C mappers like minimap2 — the mapping pipeline is
+> being moved into the C engine. Use BioForge's mapper where its strengths fit:
+> pure-Python/NumPy core, tiny footprint, `pip install` and go, no C toolchain.
 
 ### Full mutation analysis pipeline (DNA + protein)
 

{bioforge-3.3.0 → bioforge-4.0.0}/bioforge/__init__.py

@@ -36,7 +36,7 @@ from .biocore import (
 from .genomemap import GenomeAligner, Mapping
 from .smart_translator import SmartTranslator
 
-__version__ = "3.3.0"
+__version__ = "4.0.0"
 __author__  = "Aarón Aranda Torrijos"
 
 __all__ = [

{bioforge-3.3.0 → bioforge-4.0.0}/bioforge/engine/engine.c

@@ -1570,8 +1570,9 @@ EXPORT void bio_chain_dp(const int64_t* x, const int64_t* y, int32_t n,
             if (gap > max_gap) continue;
             int64_t mn = (dx < dy) ? dx : dy;
             double match = (double)((mn < (int64_t)k) ? mn : (int64_t)k);
+            /* coste de hueco estilo minimap2: gap_w·|l| + 0.5·log2|l| (l≠0) */
             double cost  = gap_w * (double)gap;
-            if (gap > 0) cost += log2((double)gap + 1.0);
+            if (gap > 0) cost += 0.5 * log2((double)gap);
             double sc = f[j] + match - cost;
             if (sc > best) { best = sc; bp = j; }
         }

{bioforge-3.3.0 → bioforge-4.0.0}/bioforge/genomemap.py

@@ -101,16 +101,17 @@ class Chain(NamedTuple):
 # Parámetros de chaining (razonables; ajustables).
 _MAX_GAP = 5000      # distancia máxima entre anclas consecutivas
 _WINDOW  = 64        # nº de predecesores que se examinan por ancla
-_GAP_W   = 0.2       # peso lineal de la penalización por hueco
+_GAP_COEF = 0.01     # coste lineal de hueco = 0.01·k (fórmula de minimap2)
 _MIN_ANCHORS = 2
 
 
-def _chain_fill_numpy(xs: np.ndarray, ys: np.ndarray, k: int):
+def _chain_fill_numpy(xs: np.ndarray, ys: np.ndarray, k: int, gap_w: float):
     """Fallback NumPy del DP de chaining (idéntico al C bio_chain_dp).
 
     Bucle EXTERNO secuencial (f[i] depende de f[j<i]); bucle INTERNO sobre la
     ventana de predecesores vectorizado. En empate gana el predecesor más
-    cercano (mismo desempate que el C).
+    cercano (mismo desempate que el C). Coste de hueco estilo minimap2:
+    ``gap_w·|l| + 0.5·log2|l|``.
     """
     n = xs.size
     f = np.full(n, float(k), dtype=np.float64)
@@ -130,8 +131,8 @@ def _chain_fill_numpy(xs: np.ndarray, ys: np.ndarray, k: int):
         if not valid.any():
             continue
         match = np.minimum(np.minimum(dx, dy), k).astype(np.float64)
-        logterm = np.where(gap > 0, np.log2(gap + 1.0), 0.0)
-        sc = np.where(valid, f[lo:i] + match - (_GAP_W * gap + logterm), -np.inf)
+        logterm = np.where(gap > 0, 0.5 * np.log2(np.maximum(gap, 1)), 0.0)
+        sc = np.where(valid, f[lo:i] + match - (gap_w * gap + logterm), -np.inf)
         b = sc.size - 1 - int(sc[::-1].argmax())   # empate → predecesor cercano
         if sc[b] > kf:
             f[i], prev[i] = float(sc[b]), lo + b
@@ -153,11 +154,12 @@ def _chain_one(x: np.ndarray, y: np.ndarray, k: int,
     ys = np.ascontiguousarray(y[order], dtype=np.int64)
 
     # Relleno del DP: C si está disponible (10-50× más rápido), si no NumPy.
+    gap_w = _GAP_COEF * k                     # 0.01·k (coste de hueco minimap2)
     if C_CHAIN_AVAILABLE:
-        f, prev = c_chain_dp(xs, ys, k, _MAX_GAP, _WINDOW, _GAP_W)
+        f, prev = c_chain_dp(xs, ys, k, _MAX_GAP, _WINDOW, gap_w)
         prev = prev.astype(np.int64)
     else:
-        f, prev = _chain_fill_numpy(xs, ys, k)
+        f, prev = _chain_fill_numpy(xs, ys, k, gap_w)
 
     # Backtrack de cadenas no solapadas, por score descendente.
     used = np.zeros(n, dtype=bool)
@@ -253,12 +255,19 @@ class Mapping(NamedTuple):
     identity:     float
     chain_score:  float
     cigar:        Optional[str]
+    target_name:  str = "ref"  # nombre del contig/cromosoma al que mapea
 
-    def to_paf(self, query_name: str = "query", target_name: str = "ref") -> str:
-        """Serializa a una línea PAF (el formato de minimap2)."""
+    def to_paf(self, query_name: str = "query",
+               target_name: Optional[str] = None) -> str:
+        """Serializa a una línea PAF (el formato de minimap2).
+
+        Si no se pasa ``target_name``, se usa el del propio mapeo (el contig al
+        que mapeó, útil con referencias multi-cromosoma).
+        """
+        tname = target_name if target_name is not None else self.target_name
         fields = [
             query_name, self.query_len, self.query_start, self.query_end,
-            self.strand, target_name, self.target_len,
+            self.strand, tname, self.target_len,
             self.target_start, self.target_end,
             self.num_matches, self.block_len, self.mapq,
         ]
@@ -298,12 +307,31 @@ def _cigar(aln_ref: str, aln_read: str) -> tuple[str, int, int]:
     return cigar, n_match, int(op.size)
 
 
-def _extend(ref: str, read: str, ch: Chain) -> Optional[Mapping]:
-    """Fase 5: alinea (banded) la región de la cadena y arma el Mapping."""
-    ref_sub = ref[ch.ref_start:ch.ref_end]
-    read_sub = read[ch.read_start:ch.read_end]
-    if ch.strand == 1:
-        read_sub = _revcomp(read_sub)
+def _extend(ref: str, read: str, ch: Chain, k: int,
+            cstart: int, cend: int) -> Optional[Mapping]:
+    """Fase 5: alinea el READ COMPLETO contra la referencia y arma el Mapping.
+
+    La ventana de referencia se sitúa por la diagonal de la cadena
+    (``d`` = posición ref donde cae el inicio del read) y se recorta al contig
+    ``[cstart, cend)``. Así la alineación cubre todo el read (no solo la región
+    de la cadena); si el read sobresale por un borde del contig, esa parte queda
+    recortada (soft-clip) de forma natural.
+    """
+    Lr = len(read)
+    if ch.strand == 0:
+        d = int(np.median(ch.anchor_ref - ch.anchor_read))
+        oriented = read
+    else:
+        # hebra inversa: se alinea revcomp(read) hacia delante; diagonal:
+        d = int(np.median(ch.anchor_ref + ch.anchor_read)) - (Lr - k)
+        oriented = _revcomp(read)
+
+    rs = max(cstart, d)
+    re = min(cend, d + Lr)
+    if re - rs < 1:
+        return None
+    ref_sub = ref[rs:re]
+    read_sub = oriented[rs - d:re - d]        # porción del read dentro de la ventana
     if not ref_sub or not read_sub:
         return None
 
@@ -315,15 +343,20 @@ def _extend(ref: str, read: str, ch: Chain) -> Optional[Mapping]:
         cigar, n_match, block = _cigar(res.aligned_a, res.aligned_b)
         identity = res.identity
     except Exception:                       # noqa: BLE001 — extensión best-effort
-        cigar, n_match, block, identity = None, ch.n_anchors * ch.k, \
-            ch.ref_end - ch.ref_start, 1.0
+        cigar, n_match, block, identity = None, ch.n_anchors * k, re - rs, 1.0
+
+    # coords de query en el read ORIGINAL (hacia delante), aun en hebra inversa
+    if ch.strand == 0:
+        q_start, q_end = rs - d, re - d
+    else:
+        q_start, q_end = Lr - (re - d), Lr - (rs - d)
 
     return Mapping(
-        query_len=len(read),
-        query_start=ch.read_start, query_end=ch.read_end,
+        query_len=Lr,
+        query_start=q_start, query_end=q_end,
         strand="+" if ch.strand == 0 else "-",
         target_len=len(ref),
-        target_start=ch.ref_start, target_end=ch.ref_end,
+        target_start=rs, target_end=re,
         num_matches=n_match, block_len=block,
         mapq=0, identity=identity, chain_score=ch.score, cigar=cigar,
     )
@@ -355,19 +388,74 @@ def _mp_worker(args) -> "list[Mapping]":
 
 
 class GenomeAligner:
-    """Mapeador de reads contra una referencia (seed-chain-align)."""
+    """Mapeador de reads contra una referencia (seed-chain-align).
+
+    La referencia puede ser:
+      • una cadena (un solo contig), o
+      • un dict ``{nombre: secuencia}`` o iterable de ``(nombre, secuencia)``
+        para varios cromosomas/contigs (genomas reales).
+
+    Multi-contig: los contigs se concatenan con separadores de ``N`` (que los
+    minimizers excluyen → ningún k-mer cruza fronteras). Se indexa el conjunto y
+    al mapear la posición global se traduce a (contig, posición local).
+    """
 
-    def __init__(self, reference: str, k: int = 15, w: int = 10,
+    def __init__(self, reference, k: int = 15, w: int = 10,
                  max_occ: Optional[int] = 50, name: str = "ref"):
-        self.reference = reference.upper()
-        self.name = name
+        contigs = self._normalize(reference, name)      # [(nombre, seq), ...]
+        sep = "N" * k                                   # rompe k-meros de frontera
+        parts: list[str] = []
+        self._names: list[str] = []
+        self._starts_list: list[int] = []
+        self._lengths: list[int] = []
+        g = 0
+        for i, (nm, seq) in enumerate(contigs):
+            seq = seq.upper()
+            if i > 0:
+                parts.append(sep); g += len(sep)
+            self._names.append(str(nm))
+            self._starts_list.append(g)
+            self._lengths.append(len(seq))
+            parts.append(seq); g += len(seq)
+
+        self.reference = "".join(parts)                 # concatenado (con N)
+        self._starts = np.array(self._starts_list, dtype=np.int64)
+        self.name = self._names[0] if len(self._names) == 1 else "multi"
         self.index = ReferenceIndex.from_sequence(self.reference, k=k, w=w,
                                                   max_occ=max_occ)
 
+    @staticmethod
+    def _normalize(reference, name: str) -> "list[tuple[str, str]]":
+        if isinstance(reference, str):
+            return [(name, reference)]
+        if isinstance(reference, dict):
+            return list(reference.items())
+        return [(n, s) for n, s in reference]           # iterable de pares
+
     @property
     def k(self) -> int:
         return self.index.k
 
+    @property
+    def n_contigs(self) -> int:
+        return len(self._names)
+
+    def _contig_of(self, gpos: int) -> int:
+        """Índice del contig que contiene la posición global ``gpos``."""
+        i = int(np.searchsorted(self._starts, gpos, side="right")) - 1
+        return max(0, i)
+
+    def _localize(self, mp: Mapping) -> Mapping:
+        """Traduce coords globales de un mapeo a (contig, coords locales)."""
+        ci = self._contig_of(mp.target_start)
+        cstart, clen = self._starts_list[ci], self._lengths[ci]
+        return mp._replace(
+            target_name=self._names[ci],
+            target_len=clen,
+            target_start=mp.target_start - cstart,
+            target_end=min(mp.target_end - cstart, clen),
+        )
+
     def map(self, read: str, min_chain_score: float = 40.0,
             max_hits: int = 5) -> list[Mapping]:
         """Mapea un read → lista de Mapping (primaria primero)."""
@@ -376,9 +464,13 @@ class GenomeAligner:
         chains = chain(anchors, min_score=min_chain_score)[:max_hits]
         mappings: list[Mapping] = []
         for i, ch in enumerate(chains):
-            mp = _extend(self.reference, read, ch)
+            # Contig de la cadena → sus límites acotan la ventana de extensión.
+            ci = self._contig_of(ch.ref_start)
+            cstart = self._starts_list[ci]
+            cend = cstart + self._lengths[ci]
+            mp = _extend(self.reference, read, ch, self.k, cstart, cend)
             if mp is not None:
-                mappings.append(mp._replace(mapq=_mapq(chains, i)))
+                mappings.append(self._localize(mp._replace(mapq=_mapq(chains, i))))
         return mappings
 
     def map_batch(self, reads, n_processes: int = 0,

{bioforge-3.3.0 → bioforge-4.0.0}/bioforge.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bioforge
-Version: 3.3.0
+Version: 4.0.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
@@ -562,17 +562,26 @@ 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
+# Single sequence, or a whole multi-contig genome:
+mapper = GenomeAligner({"chr1": chr1_seq, "chr2": chr2_seq, "plasmid": p_seq})
 
 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%}")
+    print(m.target_name, m.strand, m.target_start, f"{m.identity:.1%}")
+
+# Map many reads in parallel (uses processes):
+results = mapper.map_batch(reads, n_processes=0)   # 0 = all cores
 ```
 
-Handles both strands, tolerates mismatches/indels, and reports a mapping
-quality. The chaining dynamic program runs in the C engine (with a NumPy
-fallback).
+Handles multi-chromosome references (reports the contig + local coordinates),
+both strands, aligns the full read, tolerates mismatches/indels, and reports a
+mapping quality. The minimizer and chaining kernels run in the C engine (with
+NumPy fallbacks).
+
+> **Speed, honestly:** indexing is fast, but read mapping is not yet
+> competitive with hand-tuned C mappers like minimap2 — the mapping pipeline is
+> being moved into the C engine. Use BioForge's mapper where its strengths fit:
+> pure-Python/NumPy core, tiny footprint, `pip install` and go, no C toolchain.
 
 ### Full mutation analysis pipeline (DNA + protein)
 

{bioforge-3.3.0 → bioforge-4.0.0}/tests/test_genomemap.py

@@ -146,6 +146,56 @@ def test_map_batch_igual_que_secuencial():
         assert [m.target_start for m in got] == [m.target_start for m in exp]
 
 
+def test_multicontig_mapea_al_contig_correcto():
+    rng = np.random.default_rng(30)
+    chr1 = "".join("ACGT"[i] for i in rng.integers(0, 4, 40_000))
+    chr2 = "".join("ACGT"[i] for i in rng.integers(0, 4, 25_000))
+    plas = "".join("ACGT"[i] for i in rng.integers(0, 4, 6_000))
+    ga = GenomeAligner({"chr1": chr1, "chr2": chr2, "plasmid": plas}, k=15, w=10)
+    assert ga.n_contigs == 3
+
+    # read de chr2: contig y coords LOCALES correctas
+    mp = ga.map(chr2[12_000:12_500])[0]
+    assert mp.target_name == "chr2"
+    assert mp.target_len == len(chr2)
+    assert mp.target_start - mp.query_start == 12_000     # diagonal local
+    assert mp.identity > 0.99
+
+    # read del plasmid en hebra inversa
+    mp = ga.map(_revcomp(plas[2_000:2_400]))[0]
+    assert mp.target_name == "plasmid"
+    assert mp.strand == "-"
+    assert mp.target_start < 2_400 and mp.target_end > 0
+
+    # el PAF lleva el contig correcto sin pasar target_name
+    assert ga.map(chr1[5_000:5_500])[0].to_paf().split("\t")[5] == "chr1"
+
+
+def test_extension_cubre_el_read_entero():
+    # La extensión alinea el read COMPLETO (no solo la región de la cadena).
+    genoma = _rng_seq(60_000, 33)
+    ga = GenomeAligner(genoma, k=15, w=10)
+    o, Lr = 25_000, 500
+    mp = ga.map(genoma[o : o + Lr])[0]
+    assert mp.query_start == 0            # empieza en el inicio del read…
+    assert mp.query_end == Lr             # …y llega al final
+    assert mp.target_start == o           # posición exacta (no + offset de minimizer)
+    assert mp.identity > 0.99
+    # con mutaciones también cubre el read entero
+    read = _mutate(genoma[o : o + 600], n_mut=12, seed_=2)
+    mp = ga.map(read)[0]
+    assert mp.query_start == 0 and mp.query_end == 600
+
+
+def test_multicontig_lista_de_pares():
+    # también acepta un iterable de (nombre, secuencia)
+    a = _rng_seq(8000, 31)
+    b = _rng_seq(8000, 32)
+    ga = GenomeAligner([("A", a), ("B", b)], k=15, w=10)
+    assert ga.n_contigs == 2
+    assert ga.map(b[3000:3400])[0].target_name == "B"
+
+
 def test_formato_paf():
     genoma = _rng_seq(30_000, 16)
     ga = GenomeAligner(genoma, k=15, w=10)