prismalign 0.2.1__tar.gz → 0.2.2__tar.gz

{prismalign-0.2.1/prismalign.egg-info → prismalign-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prismalign
-Version: 0.2.1
+Version: 0.2.2
 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
@@ -29,19 +29,19 @@ or a custom 3rd channel) using a **HISAT-3N-style** strategy:
 
 1. build a *converted* reference index (`scheme.ref_from → ref_to`)
 2. transform each read per color channel and align it to the converted index
-   via a pluggable backend (**bwamem** by default; a built-in **native C
-   k-mer backend**; **WFA2-lib**; **minimap2/mappy** optional)
+   via a pluggable backend (**bwamem** by default; **WFA2-lib**;
+   **minimap2/mappy**; **minibwa**, all optional)
 3. **re-score every hit against the *original* reference** so that real
    conversions are rewarded (not counted as mismatches), emitting a
    color-correct `MD` plus per-channel `Y`/`Z` counts in BAM tags.
 
-All per-read kernels are **C** (bwamem / WFA2-lib / the built-in k-mer
-aligner); the Python layer is a thin, friendly wrapper.
+All per-read heavy kernels are native C (BWA-MEM / WFA2-lib / minimap2 /
+minibwa); the Python layer is a thin, friendly wrapper.
 
 ## Install
 
 ```bash
-pip install -e .              # bwamem + built-in C k-mer backends
+pip install -e .              # bwamem + built-in WFA2 C backends
 pip install -e "./[mappy]"    # + minimap2 backend
 ```
 
@@ -55,7 +55,7 @@ ps.map_reads("reads.fq", "ref.fa", "out.bam",
              scheme="MK", backend="bwamem", threads=4)
 
 # object API / reuse
-with ps.NColorMapper(scheme=ps.BS, backend="python") as mapper:
+with ps.NColorMapper(scheme=ps.BS, backend="bwamem") as mapper:
     mapper.map_file("reads.fq", ref_files=["ref.fa"], output_files=["bs.bam"])
 ```
 
@@ -103,24 +103,16 @@ against the original reference is engine-side), so adding one is easy:
 
 | backend | engine | notes |
 |---------|--------|-------|
-| `bwamem` | BWA-MEM via the `bwamem` package | default, fast C backend |
-| `python` | **native C k-mer kernel** (`python/pyalign.c`) | fast built-in reference aligner (~150x the old pure-Python one); no extra deps |
-| `wfa2` | **WFA2-lib** (vendored v2.3.6, MIT) compiled in-process | exact gapped (indel-aware) wavefront alignment; no CLI wrapper |
-| `mappy` | minimap2 via `mappy` | official minimap2 Python binding |
-| `minibwa` | **lh3/minibwa** (bwa-mem successor) via **PyO3 pip binding `minibwa`** (fg-labs) | ~2-3x faster than bwa-mem; `pip install minibwa` |
-| `sam` | generic SAM-emitting mapper (subprocess) | wrap `bwa`, `bwa-mem2`, `bowtie2`, `hisat2`, … via a command template |
-| `strobealign` | **ksahlin/strobealign** (Rust, ultra-fast short reads) | `.sti` index, SAM out; subprocess |
-
-> **Direct vs CLI backends.** `bwamem`, `minibwa`, `mappy`, `wfa2` and `python`
-> are direct/in-process (native bindings / compiled C). The *only* CLI
-> (subprocess) backends are `sam` (generic) and `strobealign` (ultra-fast short
-> reads — no Rust→Python binding). `wfa2` reuses `PythonBackend`'s k-mer seeding
-> to anchor a diagonal and runs WFA2's exact gap-affine alignment for true
-> I/D CIGARs — the same "one core algorithm" as wfmash/gem3, minus the CLI
-> layer. On exact / simple-mismatch reads every backend's output is identical;
-> on gapped reads WFA2 may pick a *different-but-equally-valid* split of the
-> M-runs around an indel than BWA (same position and I/D set), so byte-identity
-> applies to the mapping, not to the exact CIGAR representation.
+| `bwamem` | BWA-MEM via the `bwamem` package | default, fast C backend (SE + PE) |
+| `minibwa` | **lh3/minibwa** (bwa-mem successor) via **PyO3 pip binding `minibwa`** (fg-labs) | ~2-3x faster than bwa-mem; `pip install minibwa` (SE + PE) |
+| `mappy` | minimap2 via `mappy` | official minimap2 Python binding (SE + PE) |
+| `wfa2` | **WFA2-lib** (vendored v2.3.6, MIT) compiled in-process | exact gapped (indel-aware) wavefront alignment; SE only |
+
+> **Note on external-tool adapters.** `--backend` selects the four *native*
+> in-process backends above. To wrap an aligner prismalign has no binding for
+> (e.g. `bwa-mem2`, `bowtie2`, `hisat-3n`, `strobealign`), use
+> `prismalign.adapters` (`SamAdapter`, `BwaMem2Adapter`, `Bowtie2Adapter`,
+> `StrobealignAdapter`) — these are *not* `--backend`-selectable.
 >
 > Full inventory — including **where each Python wrapper lives** — is in
 > [`docs/backends.md`](docs/backends.md).
@@ -135,6 +127,12 @@ against the original reference is engine-side), so adding one is easy:
   is cached in memory for small contigs (RNA/transcript references), so only
   one indexed read per contig.
 
-## Limitations (v0.0.1)
+## Limitations (v0.2.x)
 
-* paired-end needs the `bwamem` backend (`python`/`mappy` backends are SE-only)
+* paired-end is supported natively by the `bwamem`, `mappy` and `minibwa`
+  backends; `wfa2` is single-end for now (the subprocess `sam`/
+  `strobealign`/`bowtie2`/`bwa_mem2` *adapters* are also SE).
+* hierarchical (layered) mapping uses the `PLAIN` identity scheme for
+  non-converted short-RNA references. `minibwa` is the fastest native backend
+  but needs standard (non-free-threaded) CPython ≤ 3.13, so on 3.14t `mappy`
+  is the fastest available.

{prismalign-0.2.1 → prismalign-0.2.2}/README.md

@@ -8,19 +8,19 @@ or a custom 3rd channel) using a **HISAT-3N-style** strategy:
 
 1. build a *converted* reference index (`scheme.ref_from → ref_to`)
 2. transform each read per color channel and align it to the converted index
-   via a pluggable backend (**bwamem** by default; a built-in **native C
-   k-mer backend**; **WFA2-lib**; **minimap2/mappy** optional)
+   via a pluggable backend (**bwamem** by default; **WFA2-lib**;
+   **minimap2/mappy**; **minibwa**, all optional)
 3. **re-score every hit against the *original* reference** so that real
    conversions are rewarded (not counted as mismatches), emitting a
    color-correct `MD` plus per-channel `Y`/`Z` counts in BAM tags.
 
-All per-read kernels are **C** (bwamem / WFA2-lib / the built-in k-mer
-aligner); the Python layer is a thin, friendly wrapper.
+All per-read heavy kernels are native C (BWA-MEM / WFA2-lib / minimap2 /
+minibwa); the Python layer is a thin, friendly wrapper.
 
 ## Install
 
 ```bash
-pip install -e .              # bwamem + built-in C k-mer backends
+pip install -e .              # bwamem + built-in WFA2 C backends
 pip install -e "./[mappy]"    # + minimap2 backend
 ```
 
@@ -34,7 +34,7 @@ ps.map_reads("reads.fq", "ref.fa", "out.bam",
              scheme="MK", backend="bwamem", threads=4)
 
 # object API / reuse
-with ps.NColorMapper(scheme=ps.BS, backend="python") as mapper:
+with ps.NColorMapper(scheme=ps.BS, backend="bwamem") as mapper:
     mapper.map_file("reads.fq", ref_files=["ref.fa"], output_files=["bs.bam"])
 ```
 
@@ -82,24 +82,16 @@ against the original reference is engine-side), so adding one is easy:
 
 | backend | engine | notes |
 |---------|--------|-------|
-| `bwamem` | BWA-MEM via the `bwamem` package | default, fast C backend |
-| `python` | **native C k-mer kernel** (`python/pyalign.c`) | fast built-in reference aligner (~150x the old pure-Python one); no extra deps |
-| `wfa2` | **WFA2-lib** (vendored v2.3.6, MIT) compiled in-process | exact gapped (indel-aware) wavefront alignment; no CLI wrapper |
-| `mappy` | minimap2 via `mappy` | official minimap2 Python binding |
-| `minibwa` | **lh3/minibwa** (bwa-mem successor) via **PyO3 pip binding `minibwa`** (fg-labs) | ~2-3x faster than bwa-mem; `pip install minibwa` |
-| `sam` | generic SAM-emitting mapper (subprocess) | wrap `bwa`, `bwa-mem2`, `bowtie2`, `hisat2`, … via a command template |
-| `strobealign` | **ksahlin/strobealign** (Rust, ultra-fast short reads) | `.sti` index, SAM out; subprocess |
-
-> **Direct vs CLI backends.** `bwamem`, `minibwa`, `mappy`, `wfa2` and `python`
-> are direct/in-process (native bindings / compiled C). The *only* CLI
-> (subprocess) backends are `sam` (generic) and `strobealign` (ultra-fast short
-> reads — no Rust→Python binding). `wfa2` reuses `PythonBackend`'s k-mer seeding
-> to anchor a diagonal and runs WFA2's exact gap-affine alignment for true
-> I/D CIGARs — the same "one core algorithm" as wfmash/gem3, minus the CLI
-> layer. On exact / simple-mismatch reads every backend's output is identical;
-> on gapped reads WFA2 may pick a *different-but-equally-valid* split of the
-> M-runs around an indel than BWA (same position and I/D set), so byte-identity
-> applies to the mapping, not to the exact CIGAR representation.
+| `bwamem` | BWA-MEM via the `bwamem` package | default, fast C backend (SE + PE) |
+| `minibwa` | **lh3/minibwa** (bwa-mem successor) via **PyO3 pip binding `minibwa`** (fg-labs) | ~2-3x faster than bwa-mem; `pip install minibwa` (SE + PE) |
+| `mappy` | minimap2 via `mappy` | official minimap2 Python binding (SE + PE) |
+| `wfa2` | **WFA2-lib** (vendored v2.3.6, MIT) compiled in-process | exact gapped (indel-aware) wavefront alignment; SE only |
+
+> **Note on external-tool adapters.** `--backend` selects the four *native*
+> in-process backends above. To wrap an aligner prismalign has no binding for
+> (e.g. `bwa-mem2`, `bowtie2`, `hisat-3n`, `strobealign`), use
+> `prismalign.adapters` (`SamAdapter`, `BwaMem2Adapter`, `Bowtie2Adapter`,
+> `StrobealignAdapter`) — these are *not* `--backend`-selectable.
 >
 > Full inventory — including **where each Python wrapper lives** — is in
 > [`docs/backends.md`](docs/backends.md).
@@ -114,6 +106,12 @@ against the original reference is engine-side), so adding one is easy:
   is cached in memory for small contigs (RNA/transcript references), so only
   one indexed read per contig.
 
-## Limitations (v0.0.1)
+## Limitations (v0.2.x)
 
-* paired-end needs the `bwamem` backend (`python`/`mappy` backends are SE-only)
+* paired-end is supported natively by the `bwamem`, `mappy` and `minibwa`
+  backends; `wfa2` is single-end for now (the subprocess `sam`/
+  `strobealign`/`bowtie2`/`bwa_mem2` *adapters* are also SE).
+* hierarchical (layered) mapping uses the `PLAIN` identity scheme for
+  non-converted short-RNA references. `minibwa` is the fastest native backend
+  but needs standard (non-free-threaded) CPython ≤ 3.13, so on 3.14t `mappy`
+  is the fastest available.

{prismalign-0.2.1 → prismalign-0.2.2}/prismalign/__init__.py

@@ -17,7 +17,7 @@ Quick start
         references="genome.fa",
         output="out.bam",
         scheme="MK",        # or "BS", "SLAM", "A2G", "KM", "THREE"
-        backend="bwamem",   # "python" (native C), "wfa2", "mappy", "minibwa", ...
+        backend="bwamem",    # "minibwa"(fast, opt-in), "mappy", "wfa2"
         threads=4,          # ordered parallel pool, byte-identical to 1
     )
 
@@ -34,20 +34,26 @@ How it works (HISAT-3N-style "convert, then map"):
 """
 
 from . import colorops, schemes
+from . import em as _em
+from .em import em_allocate, EMResult, nm_from_md, read_nm
 from .engine import NColorMapper, score_to_mapq
+from . import adapters
+from .adapters import (
+    SamAdapter,
+    StrobealignAdapter,
+    Bowtie2Adapter,
+    BwaMem2Adapter,
+)
 from .backends import (
     RawHit,
     Backend,
     BwaMemBackend,
-    PythonBackend,
     MappyBackend,
     MinibwaBackend,
-    SamBinaryBackend,
     Wfa2Backend,
-    StrobealignBackend,
     get_backend,
 )
-from .schemes import MK, KM, BS, SLAM, A2G, THREE, ColorScheme, ColorChannel
+from .schemes import MK, KM, BS, SLAM, A2G, THREE, PLAIN, ColorScheme, ColorChannel
 
 # Single source of truth is pyproject.toml; never hardcode here.
 try:
@@ -70,15 +76,23 @@ __all__ = [
     "schemes",
     "RawHit",
     "Backend",
-    # backends
+    # EM expression-weighted multimapping allocation
+    "em_allocate",
+    "EMResult",
+    "nm_from_md",
+    "read_nm",
+    # native backends
     "get_backend",
     "BwaMemBackend",
-    "PythonBackend",
     "MappyBackend",
     "MinibwaBackend",
-    "SamBinaryBackend",
     "Wfa2Backend",
-    "StrobealignBackend",
+    # external-tool adapters (not selectable via --backend)
+    "adapters",
+    "SamAdapter",
+    "StrobealignAdapter",
+    "Bowtie2Adapter",
+    "BwaMem2Adapter",
     # schemes
     "MK",
     "KM",
@@ -86,6 +100,7 @@ __all__ = [
     "SLAM",
     "A2G",
     "THREE",
+    "PLAIN",
     "ColorScheme",
     "ColorChannel",
 ]
@@ -146,8 +161,8 @@ def map_reads(
     scheme : str
         Color scheme name: MK (default), KM, BS, SLAM, A2G, THREE.
     backend : str
-        "bwamem" (default), "python", "wfa2", "mappy", "minibwa", "sam",
-        "strobealign".
+        "bwamem" (default), "minibwa" (fast, opt-in), "mappy", "wfa2". To wrap
+        an external SAM-emitting tool, use ``prismalign.adapters`` instead.
     threads : int
         Worker processes for the ordered parallel pool (output identical to 1).
     batch_size : int

prismalign-0.2.2/prismalign/adapters/__init__.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+"""prismalign.adapters — external-tool adapters (NOT native alignment backends).
+
+These are subprocess wrappers that adapt an **external** SAM-emitting aligner's
+output to prismalign's ``Backend`` protocol (``align(seq) -> [RawHit]``), so the
+engine — and its color re-scoring against the *original* reference — works on
+them unchanged. They are deliberately **separate from ``prismalign.backends``**
+(the native in-process engines: bwamem, minibwa, mappy, wfa2) and are *not*
+selectable via ``--backend``; construct one directly when you need to wrap a
+tool prismalign has no binding for (e.g. ``bwa-mem2``, ``bowtie2``,
+``hisat-3n``, ``strobealign``).
+
+Every adapter still conforms to the ``Backend`` interface, so it can be passed
+to an ``NColorMapper`` via ``backend_kwargs``/a custom ``get_backend`` override.
+"""
+
+from .sam import SamAdapter, _cigar_refspan, _sam_to_rawhits
+from .strobealign import StrobealignAdapter
+from .bowtie2 import Bowtie2Adapter
+from .bwa_mem2 import BwaMem2Adapter
+
+__all__ = [
+    "SamAdapter",
+    "StrobealignAdapter",
+    "Bowtie2Adapter",
+    "BwaMem2Adapter",
+    "_cigar_refspan",
+    "_sam_to_rawhits",
+]

prismalign-0.2.2/prismalign/adapters/bowtie2/__init__.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""prismalign.adapters.bowtie2 — subprocess adapter for the bowtie2 binary.
+
+bowtie2 is a universal short-read aligner (present in nearly every conda env).
+It is a *plain* aligner (no conversion chemistry), so prismalign does all
+conversion itself — use it with any scheme (MK/BS/SLAM/...): prismalign builds
+a converted reference, converts each read, and this adapter maps the converted
+read to the converted index. Re-scoring against the original reference is
+engine-side as usual.
+
+Needs the ``bowtie2`` + ``bowtie2-build`` binaries on PATH (or ``BOWTIE2_BIN``).
+A bowtie2 index is created on demand from the (converted) reference FASTA if
+missing/stale.
+"""
+
+import os
+
+from ..sam import SamAdapter
+
+
+class Bowtie2Adapter(SamAdapter):
+    """bowtie2 via subprocess (plain aligner; conversion is engine-side).
+
+    Parameters
+    ----------
+    fasta_path : str
+        The (converted) reference FASTA the engine hands us.
+    bin : str, optional
+        Path to the ``bowtie2`` binary (default ``$BOWTIE2_BIN`` or
+        ``bowtie2`` on PATH). The index builder is ``<bin>-build``.
+    preset : str, optional
+        bowtie2 preset flags, e.g. ``"--very-sensitive"`` (default
+        ``"--end-to-end"``).
+    extra_args : str, optional
+        Extra bowtie2 flags, e.g. ``"-p 4"``.
+    """
+
+    name = "bowtie2"
+
+    def __init__(self, fasta_path, bin=None, build_bin=None, preset="--end-to-end", extra_args=""):
+        self.bin = bin or os.environ.get("BOWTIE2_BIN", "bowtie2")
+        self.build_bin = build_bin or self.bin + "-build"
+        self.preset = preset or "--end-to-end"
+        self.extra_args = extra_args or ""
+        self._idx_ready = False
+        super().__init__(fasta_path, command_template="", parse_conversion_tags=())
+
+    def _ensure_index(self):
+        """Build the bowtie2 index from the reference FASTA if missing/stale."""
+        import subprocess
+
+        base = os.path.splitext(self.fasta_path)[0]
+        suffixes = (".1.bt2", ".2.bt2", ".rev.1.bt2", ".rev.2.bt2")
+        fa_mtime = os.path.getmtime(self.fasta_path)
+        fresh = all(
+            os.path.exists(base + s) and os.path.getmtime(base + s) >= fa_mtime
+            for s in suffixes
+        )
+        if not fresh:
+            build = subprocess.run(
+                [self.build_bin, "-f", self.fasta_path, base],
+                capture_output=True, text=True,
+            )
+            if build.returncode != 0:
+                raise RuntimeError(f"bowtie2-build failed: {build.stderr[:500]}")
+        self.command_template = (
+            f"{self.bin} -x {base} {self.preset} {self.extra_args} -U {{reads}} -S -"
+        )
+        self._idx_ready = True
+
+    def align(self, seq: str, min_mapq: int = 0) -> list:
+        self._ensure_index()
+        return super().align(seq, min_mapq=min_mapq)

prismalign-0.2.2/prismalign/adapters/bwa_mem2/__init__.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+"""prismalign.adapters.bwa_mem2 — subprocess adapter for the bwa-mem2 binary.
+
+bwa-mem2 is a ~3x faster drop-in replacement for BWA-MEM that emits identical
+SAM. It is a *plain* aligner (no conversion chemistry), so prismalign does all
+conversion itself — use it with any scheme (MK/BS/SLAM/...): prismalign builds
+a converted reference, converts each read, and this adapter maps the converted
+read to the converted index. Re-scoring against the original reference is
+engine-side as usual.
+
+Needs the ``bwa-mem2`` binary on PATH (or ``BWA_MEM2_BIN``). A bwa-mem2 index
+is created on demand from the (converted) reference FASTA if missing/stale.
+"""
+
+import os
+
+from ..sam import SamAdapter
+
+
+class BwaMem2Adapter(SamAdapter):
+    """bwa-mem2 via subprocess (plain aligner; conversion is engine-side).
+
+    Parameters
+    ----------
+    fasta_path : str
+        The (converted) reference FASTA the engine hands us.
+    bin : str, optional
+        Path to the ``bwa-mem2`` binary (default ``$BWA_MEM2_BIN`` or
+        ``bwa-mem2`` on PATH).
+    extra_args : str, optional
+        Extra bwa-mem2 ``mem`` flags, e.g. ``"-t 4"``.
+    )
+    """
+
+    name = "bwa-mem2"
+
+    def __init__(self, fasta_path, bin=None, extra_args=""):
+        self.bin = bin or os.environ.get("BWA_MEM2_BIN", "bwa-mem2")
+        self.extra_args = extra_args or ""
+        self._idx_ready = False
+        super().__init__(fasta_path, command_template="", parse_conversion_tags=())
+
+    def _ensure_index(self):
+        """Build the bwa-mem2 index from the reference FASTA if missing/stale."""
+        import subprocess
+
+        base = os.path.splitext(self.fasta_path)[0]
+        suffixes = (".amb", ".ann", ".bwt.2bit.64", ".pac", ".0123")
+        fa_mtime = os.path.getmtime(self.fasta_path)
+        fresh = all(
+            os.path.exists(base + s) and os.path.getmtime(base + s) >= fa_mtime
+            for s in suffixes
+        )
+        if not fresh:
+            proc = subprocess.run(
+                [self.bin, "index", self.fasta_path],
+                capture_output=True, text=True,
+            )
+            if proc.returncode != 0:
+                raise RuntimeError(
+                    f"bwa-mem2 index failed: {proc.stderr[:500]}"
+                )
+        self.command_template = f"{self.bin} mem {self.extra_args} {{index}} -"
+        self._idx_ready = True
+
+    def align(self, seq: str, min_mapq: int = 0) -> list:
+        self._ensure_index()
+        return super().align(seq, min_mapq=min_mapq)

{prismalign-0.2.1/prismalign/backends → prismalign-0.2.2/prismalign/adapters}/sam/__init__.py

@@ -1,7 +1,12 @@
 #!/usr/bin/env python3
-"""Generic SAM-emitting subprocess binding + SAM parsing helpers."""
+"""prismalign.adapters.sam — generic subprocess adapter for SAM-emitting mappers.
 
-from ..base import Backend, RawHit
+Not a native backend: it wraps any external SAM-emitting aligner (via a command
+template) and adapts its output to prismalign's Backend contract. Plus the
+shared SAM-parsing helpers used by the other subprocess adapters.
+"""
+
+from prismalign.backends.base import Backend, RawHit
 
 
 def _cigar_refspan(cigar: str) -> int:
@@ -86,19 +91,26 @@ def _sam_to_rawhits(lines, parse_conversion_tags=(), default_name="SEQ"):
     return hits
 
 
-class SamBinaryBackend(Backend):
-    """Generic subprocess backend driving any single-end SAM-emitting mapper.
+class SamAdapter(Backend):
+    """Adapter: drive any single-end SAM-emitting mapper as a subprocess.
+
+    This is NOT a native alignment backend — it shells out to an external
+    tool (via a command template) and adapts its SAM output to prismalign's
+    ``Backend`` contract, so the engine can re-score against the original
+    reference as usual. Use it to wrap a mapper prismalign has no binding for
+    (e.g. ``bwa-mem2``, ``bowtie2``, ``hisat-3n``) without writing a new
+    backend.
 
     ``command_template`` is a format string; ``{index}`` is replaced by the
     reference FASTA and ``{reads}`` by ``"-"`` (reads fed on stdin as one
     FASTA record per align() call). Examples::
 
-        bwa:      SamBinaryBackend(ref.fa, "bwa mem {index} -")
-        bwa-mem2: SamBinaryBackend(ref.fa, "bwa-mem2 mem {index} -")
-        hisat-3n: SamBinaryBackend(ref.fa, "hisat-3n -x {index} "
-                                   "--base-change {base_change} -U {reads} -S -")
+        bwa:      SamAdapter(ref.fa, "bwa mem {index} -")
+        bwa-mem2: SamAdapter(ref.fa, "bwa-mem2 mem {index} -")
+        hisat-3n: SamAdapter(ref.fa, "hisat-3n -x {index} "
+                             "--base-change {base_change} -U {reads} -S -")
 
-    ``parse_conversion_tags`` (e.g. ``("Yf","Zf")``) makes the backend carry
+    ``parse_conversion_tags`` (e.g. ``("Yf","Zf")``) makes the adapter carry
     a mapper's own conversion counts into the RawHit so the engine can use
     them instead of re-scoring.
     """

{prismalign-0.2.1/prismalign/backends → prismalign-0.2.2/prismalign/adapters}/strobealign/__init__.py

@@ -1,20 +1,21 @@
 #!/usr/bin/env python3
-"""strobealign binding — subprocess (strobemers, ultra-fast short reads).
+"""prismalign.adapters.strobealign — subprocess adapter (strobemers, fast short reads).
 
-Runs on top of the generic SAM subprocess backend (``sam/``); builds a
-``.sti`` strobemer index on demand (unless present and fresh).
+Wraps the ``strobealign`` binary (a subprocess adapter built on ``.sam``);
+builds a ``.sti`` strobemer index on demand (unless present and fresh).
 """
 
 import os
 
-from ..sam import SamBinaryBackend
+from ..sam import SamAdapter
 
 
-class StrobealignBackend(SamBinaryBackend):
-    """ultra-fast short-read aligner (strobemers) — good fit for converted
-    N-color short reads. Needs the ``strobealign`` binary (bioconda or
-    ``cargo build --release``; also ``STROBEALIGN_BIN``). A ``.sti`` strobemer
-    index is created on demand from the converted reference.
+class StrobealignAdapter(SamAdapter):
+    """ultra-fast short-read aligner (strobemers) via subprocess.
+
+    Needs the ``strobealign`` binary (bioconda or ``cargo build --release``;
+    also ``STROBEALIGN_BIN``). A ``.sti`` strobemer index is created on demand
+    from the converted reference.
     """
 
     name = "strobealign"

{prismalign-0.2.1 → prismalign-0.2.2}/prismalign/backends/__init__.py

@@ -9,19 +9,21 @@ C-extension wrap:
 backend (``name``)   package / C core          what it binds
 ===================  ========================  ================================
 ``bwamem`` (default) ``bwamem/``               BWA-MEM via the ``bwamem`` pkg
-``python``           ``python/`` + ``pyalign.c``built-in C k-mer kernel (ours)
+``minibwa``          ``minibwa/``              lh3/minibwa (bwa-mem successor, C)
+                                             via PyO3 ``minibwa``
+``mappy``            ``mappy/``                minimap2 via ``mappy``
 ``wfa2``             ``wfa2/`` + ``wrap.c`` +  vendored WFA2-lib (gapped, C)
                      ``wfa2lib/``
-``mappy``            ``mappy/``                minimap2 via ``mappy``
-``minibwa``          ``minibwa/``              lh3/minibwa via PyO3 ``minibwa``
-``sam``              ``sam/``                  generic SAM-emitting subprocess
-``strobealign``      ``strobealign/``          strobealign subprocess
 ===================  ========================  ================================
 
-Native C backends we wrote ourselves (``python``/``wfa2``) compile their own
-C into an extension inside the folder — ``prismalign.backends.python.pyalign``
-and ``prismalign.backends.wfa2.wrap`` — because no upstream Python wrapper
-exists for those cores.
+These are the **native in-process** alignment backends. ``wfa2`` is the one we
+compile ourselves (``wrap.c`` + vendored WFA2-lib) because no upstream Python
+wrapper exists for that core; the rest wrap upstream bindings (``bwamem``,
+``minibwa``, ``mappy``).
+
+External-tool wrappers (subprocess adapters for mappers prismalign has no
+binding for — ``bwa-mem2``, ``bowtie2``, ``hisat-3n``, ``strobealign``) live in
+:mod:`prismalign.adapters`, NOT here, and are not selectable via ``--backend``.
 
 The engine only needs a backend to provide ``align(seq) -> [RawHit]``
 (optionally ``align_pe``), construction from a FASTA path (it builds/loads
@@ -33,10 +35,7 @@ from .base import Backend, RawHit, read_fasta
 from .bwamem import BwaMemBackend
 from .mappy import MappyBackend
 from .minibwa import MinibwaBackend
-from .python import PythonBackend
 from .registry import _BACKENDS, get_backend
-from .sam import SamBinaryBackend, _sam_to_rawhits
-from .strobealign import StrobealignBackend
 from .wfa2 import Wfa2Backend
 
 __all__ = [
@@ -44,13 +43,9 @@ __all__ = [
     "Backend",
     "read_fasta",
     "BwaMemBackend",
-    "PythonBackend",
     "Wfa2Backend",
     "MappyBackend",
     "MinibwaBackend",
-    "SamBinaryBackend",
-    "StrobealignBackend",
     "get_backend",
     "_BACKENDS",
-    "_sam_to_rawhits",
 ]

{prismalign-0.2.1 → prismalign-0.2.2}/prismalign/backends/base.py

@@ -64,8 +64,8 @@ class Backend(ABC):
 def read_fasta(fasta_path: str):
     """Yield ``(name, sequence)`` for every contig of a plain FASTA file.
 
-    Shared by the in-process backends (pyalign / wfa2) that parse the
-    converted reference themselves. Sequence lines are uppercased.
+    Used by the in-process ``wfa2`` backend, which parses the converted
+    reference itself. Sequence lines are uppercased.
     """
     seq = []
     name = None