prismalign 0.2.4__tar.gz → 0.2.6__tar.gz

{prismalign-0.2.4/prismalign.egg-info → prismalign-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prismalign
-Version: 0.2.4
+Version: 0.2.6
 Summary: N-color (2-color / 3-color / 3-nt) nucleotide-conversion alignment engine with pluggable backends
 Author-email: Chang Ye <yech1990@gmail.com>
 License-Expression: GPL-3.0-only

{prismalign-0.2.4 → prismalign-0.2.6}/prismalign/adapters/base.py

@@ -422,7 +422,6 @@ class CliAdapter:
             raise RuntimeError(f"aligner failed: {stderr[:500]}")
         return [by_name[name] for name, _seq, _qual in reads]
 
-    # -- one whole file: prismalign manages the batching itself ---------------
     # -- one whole file: prismalign manages the batching itself ---------------
     def _map_batches(self, batches, threads=None, workers=1):
         """Map batches (an iterable of read-lists) via :meth:`map_batch`.
@@ -436,19 +435,26 @@ class CliAdapter:
             results = list(ex.map(lambda b: self.map_batch(b, threads=threads), batches))
         return [h for r in results for g in r for h in g]
 
-    def map_file(self, fastq_path, batch_size=8192, threads=1, workers=1) -> list:
+    def map_file(self, fastq_path, batch_size=32768, threads=1, workers=1) -> list:
         """Map a whole FASTQ (plain or ``.gz``).
 
-        A thin wrapper: read the file in ``batch_size``-read batches (default
-        8192, a multiple of bwa-mem2's internal 512 batch) and :meth:`map_batch`
-        each. ``workers>1`` processes the batches **concurrently** via a thread
-        pool -- each batch is an **independent tool subprocess**, which is the
-        real throughput lever (bwa-mem2's own ``-t`` saturates on a shared index;
-        separate processes each get their own memory bandwidth).
+        A thin wrapper: read the file in ``batch_size``-read batches and
+        :meth:`map_batch` each (one tool subprocess per batch).
+
+        ``batch_size`` matters a lot (measured with bwa-mem2):
+
+        * it amortizes the **per-invocation** cost (subprocess startup + index
+          load). Even single-threaded, 32768/batch is ~3x faster than 8192/batch
+          because there are far fewer subprocess invocations.
+        * it must be large enough to give the tool's ``-t`` **threads** real work.
+          With a too-small batch (e.g. 8192) bwa-mem2's threads do not engage and
+          ``threads`` buys nothing; at 32768+ ``threads=4`` reaches ~3x and
+          ``threads=8`` ~6x over ``threads=1``.
 
-        For max throughput set ``workers`` to ~cpu/2..cpu and keep ``threads=1``
-        (parallelize via processes, not the tool's threads). Returns the combined
-        ``list[RawHit]``.
+        ``workers>1`` runs the batches **concurrently** (each an independent tool
+        subprocess), so total parallelism is roughly ``workers x threads``. A good
+        default is a handful of workers each with a few threads (e.g. ``workers=2,
+        threads=4`` on 8 cores). Returns the combined ``list[RawHit]``.
         """
         self._ensure_index()
         return self._map_batches(_iter_batches(fastq_path, batch_size), threads, workers)

{prismalign-0.2.4 → prismalign-0.2.6/prismalign.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prismalign
-Version: 0.2.4
+Version: 0.2.6
 Summary: N-color (2-color / 3-color / 3-nt) nucleotide-conversion alignment engine with pluggable backends
 Author-email: Chang Ye <yech1990@gmail.com>
 License-Expression: GPL-3.0-only

{prismalign-0.2.4 → prismalign-0.2.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "prismalign"
-version = "0.2.4"
+version = "0.2.6"
 description = "N-color (2-color / 3-color / 3-nt) nucleotide-conversion alignment engine with pluggable backends"
 authors = [{ name = "Chang Ye", email = "yech1990@gmail.com" }]
 requires-python = ">=3.10"