bioforge 3.1.0__tar.gz → 3.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bioforge
-Version: 3.1.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.1.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.1.0"
+__version__ = "3.2.0"
 __author__  = "Aarón Aranda Torrijos"
 
 __all__ = [

{bioforge-3.1.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
@@ -337,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)."""
 
@@ -363,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.1.0 → bioforge-3.2.0}/bioforge.egg-info/PKG-INFO

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