bioforge 3.0.0__tar.gz → 3.2.0__tar.gz

{bioforge-3.0.0 → bioforge-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bioforge
-Version: 3.0.0
+Version: 3.2.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

{bioforge-3.0.0 → bioforge-3.2.0}/bioforge/__init__.py

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

{bioforge-3.0.0 → bioforge-3.2.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-3.0.0 → bioforge-3.2.0}/bioforge/genomemap.py

@@ -31,6 +31,8 @@ en Python ya es correcto y rápido para el nº de anclas habitual.
 
 from __future__ import annotations
 
+import os
+from multiprocessing import Pool
 from typing import NamedTuple, Optional
 
 import numpy as np
@@ -308,7 +310,8 @@ def _extend(ref: str, read: str, ch: Chain) -> Optional[Mapping]:
     band = min(256, abs(len(ref_sub) - len(read_sub)) + 32)
     try:
         res = SequenceAligner.align(_pack(ref_sub), _pack(read_sub),
-                                    mode="global", band=band)
+                                    mode="global", band=band,
+                                    detect_mutations=False)   # el mapeo no las usa
         cigar, n_match, block = _cigar(res.aligned_a, res.aligned_b)
         identity = res.identity
     except Exception:                       # noqa: BLE001 — extensión best-effort
@@ -336,6 +339,21 @@ def _mapq(chains: list[Chain], i: int) -> int:
     return int(max(0, min(60, round(60 * (1.0 - ratio)))))
 
 
+# ── Workers de multiprocessing (a nivel de módulo → picklables) ─────────────────
+_MP_ALIGNER: "Optional[GenomeAligner]" = None
+
+
+def _mp_init(aligner: "GenomeAligner") -> None:
+    """Inicializador de cada proceso: guarda el índice (se pasa una vez)."""
+    global _MP_ALIGNER
+    _MP_ALIGNER = aligner
+
+
+def _mp_worker(args) -> "list[Mapping]":
+    read, min_chain_score, max_hits = args
+    return _MP_ALIGNER.map(read, min_chain_score, max_hits)
+
+
 class GenomeAligner:
     """Mapeador de reads contra una referencia (seed-chain-align)."""
 
@@ -362,3 +380,31 @@ class GenomeAligner:
             if mp is not None:
                 mappings.append(mp._replace(mapq=_mapq(chains, i)))
         return mappings
+
+    def map_batch(self, reads, n_processes: int = 0,
+                  min_chain_score: float = 40.0,
+                  max_hits: int = 5) -> list[list[Mapping]]:
+        """Mapea muchos reads en PARALELO → lista de listas de Mapping.
+
+        Los reads son independientes (paralelismo perfecto). Usa procesos
+        (multiprocessing) porque el GIL impide que los hilos escalen: el trabajo
+        por read es mayoritariamente Python. El índice se pasa una vez a cada
+        proceso; el orden de salida coincide con el de ``reads``.
+
+        ``n_processes``: 0 = todos los núcleos · 1 = secuencial · N = N procesos.
+
+        Nota (Windows/macOS): el script que lo llame debe estar protegido por
+        ``if __name__ == "__main__":`` (requisito de multiprocessing). Si el
+        arranque de procesos falla, cae a secuencial con gracia.
+        """
+        reads = list(reads)
+        if n_processes == 1 or len(reads) <= 1:
+            return [self.map(r, min_chain_score, max_hits) for r in reads]
+        nt = (os.cpu_count() or 1) if n_processes <= 0 else n_processes
+        args = [(r, min_chain_score, max_hits) for r in reads]
+        chunk = max(1, len(reads) // (nt * 4))
+        try:
+            with Pool(processes=nt, initializer=_mp_init, initargs=(self,)) as pool:
+                return pool.map(_mp_worker, args, chunksize=chunk)
+        except Exception:                       # noqa: BLE001 — fallback secuencial
+            return [self.map(r, min_chain_score, max_hits) for r in reads]

{bioforge-3.0.0 → bioforge-3.2.0}/bioforge.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bioforge
-Version: 3.0.0
+Version: 3.2.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

{bioforge-3.0.0 → bioforge-3.2.0}/tests/test_aligner.py

@@ -44,6 +44,23 @@ def _prot(seq: str, header: str = "h") -> PackedSequence:
 # §1  PROPIEDADES MATEMÁTICAS
 # ══════════════════════════════════════════════════════════════════════════════
 
+def test_detect_mutations_flag():
+    """detect_mutations=False omite la lista de mutaciones sin tocar el resto."""
+    a = "ACGTACGTACGTACGTACGT"
+    b = "ACGTACGTTCGTACGTACGT"          # una sustitución
+    full = SequenceAligner.align(_nuc(a), _nuc(b))
+    fast = SequenceAligner.align(_nuc(a), _nuc(b), detect_mutations=False)
+    assert len(full.mutations) == 1
+    assert fast.mutations == []
+    # todo lo demás idéntico (identidad, score, matches)
+    assert fast.identity == full.identity
+    assert fast.score == full.score
+    assert fast.n_matches == full.n_matches
+    # y también en la ruta banded (la que usa el mapeador)
+    fastb = SequenceAligner.align(_nuc(a), _nuc(b), band=6, detect_mutations=False)
+    assert fastb.mutations == []
+
+
 def test_identical_sequences_perfect_score():
     """Dos secuencias idénticas → score máximo, identidad 1.0, 0 mutaciones."""
     seq = "ATGGTGCACCTGACTCCTGAGGAGAAGTCTGCC"

{bioforge-3.0.0 → bioforge-3.2.0}/tests/test_genomemap.py

@@ -129,6 +129,23 @@ def test_copias_multiples():
 
 # ── Salida PAF ──────────────────────────────────────────────────────────────────
 
+def test_map_batch_igual_que_secuencial():
+    genoma = _rng_seq(30_000, 20)
+    ga = GenomeAligner(genoma, k=15, w=10)
+    reads = [genoma[o : o + 400] for o in (1000, 5000, 12000, 20000)]
+    seq = [ga.map(r) for r in reads]
+
+    # ruta secuencial de la API (n_processes=1)
+    b1 = ga.map_batch(reads, n_processes=1)
+    assert [len(x) for x in b1] == [len(x) for x in seq]
+
+    # ruta paralela (procesos): mismo resultado y mismo orden
+    b2 = ga.map_batch(reads, n_processes=2)
+    assert len(b2) == len(reads)
+    for got, exp in zip(b2, seq, strict=True):
+        assert [m.target_start for m in got] == [m.target_start for m in exp]
+
+
 def test_formato_paf():
     genoma = _rng_seq(30_000, 16)
     ga = GenomeAligner(genoma, k=15, w=10)