ont-bed-generator 0.4.0__py3-none-any.whl

ont_bed_generator/__init__.py

@@ -0,0 +1,25 @@
+"""ont_bed_generator — BED file generation for Oxford Nanopore adaptive sampling.
+
+Standalone reimplementation (standard library only) of the Galaxy workflow
+"Adaptative ONT BED file generation".
+"""
+from __future__ import annotations
+
+from .intervals import build_extended, merge_stranded
+from .io_inputs import GffIndex, read_entrez_map, read_genelist, read_genome
+from .io_outputs import write_bed, write_targets
+from .model import DEFAULT_FLANK, GeneSpec, GffGene, Locus, Resolution
+from .resolve import resolve
+
+# Version is derived from git tags by hatch-vcs (see pyproject.toml).
+try:
+    from ._version import __version__
+except Exception:  # pragma: no cover - source tree without a build/tag
+    __version__ = "0+unknown"
+
+__all__ = [
+    "GeneSpec", "GffGene", "Locus", "Resolution", "DEFAULT_FLANK",
+    "read_genome", "read_genelist", "read_entrez_map", "GffIndex",
+    "resolve", "build_extended", "merge_stranded",
+    "write_targets", "write_bed", "__version__",
+]

ont_bed_generator/__main__.py

@@ -0,0 +1,7 @@
+"""Enable `python -m ont_bed_generator ...`."""
+from __future__ import annotations
+
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

ont_bed_generator/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.4.0'
+__version_tuple__ = version_tuple = (0, 4, 0)
+
+__commit_id__ = commit_id = None

ont_bed_generator/cli.py

@@ -0,0 +1,76 @@
+"""Command-line interface."""
+from __future__ import annotations
+
+import argparse
+import sys
+
+from . import __version__
+from .intervals import build_extended, merge_stranded
+from .io_inputs import GffIndex, read_entrez_map, read_genelist, read_genome
+from .io_outputs import write_bed, write_targets
+from .model import DEFAULT_FLANK
+from .resolve import resolve
+
+
+def build_parser() -> argparse.ArgumentParser:
+    ap = argparse.ArgumentParser(
+        prog="ont-bed-generator",
+        description="Generate targets.bed and merged-extended.bed for ONT adaptive sampling.")
+    ap.add_argument("--genelist", required=True, help="genelist TSV")
+    ap.add_argument("--gff", required=True,
+                    help="GFF3, gene features (Name= + Dbxref=GeneID:)")
+    ap.add_argument("--genome", required=True,
+                    help="chrom<TAB>size (used for telomere clamping; line order irrelevant)")
+    ap.add_argument("--out-targets", default="targets.bed")
+    ap.add_argument("--out-merged", default="merged-extended.bed")
+    ap.add_argument("--flank", type=int, default=DEFAULT_FLANK,
+                    help=f"default per-strand flank (default {DEFAULT_FLANK})")
+    ap.add_argument("--entrez-map",
+                    help="external SYMBOL<TAB>ENTREZID table (takes priority)")
+    ap.add_argument("--strict", action="store_true",
+                    help="exit with code 1 if any symbol is invalid/ambiguous")
+    ap.add_argument("--version", action="version",
+                    version=f"%(prog)s {__version__}")
+    return ap
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+
+    try:
+        sizes = read_genome(args.genome)
+        specs = read_genelist(args.genelist)
+        gff = GffIndex.load(args.gff)
+        entrez_map = read_entrez_map(args.entrez_map) if args.entrez_map else None
+    except (OSError, ValueError) as exc:
+        print(f"[error] {exc}", file=sys.stderr)
+        return 2
+
+    res = resolve(specs, gff, entrez_map)
+
+    n_targets = write_targets(res.loci, args.out_targets)
+    merged = merge_stranded(build_extended(res.loci, sizes, args.flank))
+    n_merged = write_bed(merged, args.out_merged)
+
+    e = sys.stderr
+    print(f"[ok] {len(specs)} input symbols", file=e)
+    print(f"[ok] {n_targets} loci -> {args.out_targets}", file=e)
+    print(f"[ok] {n_merged} merged intervals -> {args.out_merged}", file=e)
+    if res.ambiguous:
+        print(f"[ambiguous] {len(res.ambiguous)} symbol(s) mapping to multiple "
+              f"GeneIDs (dropped):", file=e)
+        for sym, gids in res.ambiguous:
+            print(f"    {sym} -> GeneID {', '.join(gids)}", file=e)
+    if res.invalid:
+        print(f"[invalid] {len(res.invalid)} symbol(s) not found "
+              f"(fix them in the source genelist):", file=e)
+        for sym in res.invalid:
+            print(f"    {sym}", file=e)
+
+    if args.strict and (res.invalid or res.ambiguous):
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

ont_bed_generator/intervals.py

@@ -0,0 +1,70 @@
+"""Per-strand extension, clamping to chromosome bounds, per-strand merging."""
+from __future__ import annotations
+
+from collections import defaultdict
+
+from .model import DEFAULT_FLANK, BedRow, Locus
+from .ordering import chrom_sort_key
+
+
+def build_extended(
+    loci: list[Locus],
+    sizes: dict[str, int],
+    flank: int = DEFAULT_FLANK,
+) -> list[BedRow]:
+    """Two BED6 intervals per locus (+ / -), extended then clamped.
+
+    "+" strand : [ start - flank - Left ,  end ]
+    "-" strand : [ start          ,  end + flank + Right ]
+    then clamped to [0, chrom_size] (equivalent to `bedtools slop -b 0`).
+    """
+    out: list[BedRow] = []
+    for lo in loci:
+        size = sizes.get(lo.chrom)
+        if size is None:
+            raise ValueError(f"chromosome missing from genome file: {lo.chrom}")
+
+        def clamp(x: int, _s: int = size) -> int:
+            return max(0, min(x, _s))
+
+        out.append((lo.chrom, clamp(lo.start - flank - lo.left),
+                    clamp(lo.end), lo.name, lo.extended, "+"))
+        out.append((lo.chrom, clamp(lo.start),
+                    clamp(lo.end + flank + lo.right), lo.name, lo.extended, "-"))
+    return out
+
+
+def merge_stranded(intervals: list[BedRow]) -> list[BedRow]:
+    """Merge per (chrom, strand): overlapping or book-ended (distance 0).
+
+    names = sorted union joined by commas;
+    score = minimum of the Extended_region flags;
+    strand = preserved.
+    Final sort: canonical karyotypic order, then start, end, strand.
+    """
+    groups: dict[tuple[str, str], list[BedRow]] = defaultdict(list)
+    for iv in intervals:
+        groups[(iv[0], iv[5])].append(iv)
+
+    merged: list[BedRow] = []
+    for (chrom, strand), ivs in groups.items():
+        ivs.sort(key=lambda x: (x[1], x[2]))
+        start = end = 0
+        names: set[str] = set()
+        score = 0
+        has_open = False
+        for _c, s, e, name, sc, _st in ivs:
+            if not has_open:
+                start, end, names, score, has_open = s, e, {name}, sc, True
+            elif s <= end:
+                end = max(end, e)
+                names.add(name)
+                score = min(score, sc)
+            else:
+                merged.append((chrom, start, end, ",".join(sorted(names)), score, strand))
+                start, end, names, score = s, e, {name}, sc
+        if has_open:
+            merged.append((chrom, start, end, ",".join(sorted(names)), score, strand))
+
+    merged.sort(key=lambda x: (chrom_sort_key(x[0]), x[1], x[2], x[5]))
+    return merged

ont_bed_generator/io_inputs.py

@@ -0,0 +1,128 @@
+"""Input readers: genome sizes, genelist, GFF, external Entrez table."""
+from __future__ import annotations
+
+import gzip
+from collections import defaultdict
+from typing import IO
+
+from .model import GeneSpec, GffGene
+
+
+def _open(path: str) -> IO[str]:
+    """Open a text file, transparently handling gzip-compressed (.gz) input."""
+    if str(path).endswith(".gz"):
+        return gzip.open(path, "rt")
+    return open(path)
+
+
+def read_genome(path: str) -> dict[str, int]:
+    """Return chromosome sizes {name: length} (used for telomere clamping)."""
+    sizes: dict[str, int] = {}
+    with _open(path) as fh:
+        for line in fh:
+            line = line.rstrip("\n")
+            if not line or line.startswith("#"):
+                continue
+            fields = line.split("\t")
+            sizes[fields[0]] = int(fields[1])
+    if not sizes:
+        raise ValueError(f"empty/unreadable genome file: {path}")
+    return sizes
+
+
+def _field_int(fields: list[str], i: int) -> int:
+    """Parse an integer from a TSV field, defaulting to 0 when absent/empty."""
+    if len(fields) > i and fields[i].strip():
+        try:
+            return int(fields[i].strip())
+        except ValueError:
+            return 0
+    return 0
+
+
+def _is_header_row(fields: list[str]) -> bool:
+    """A header has a header-word first cell, or non-numeric size columns."""
+    if fields[0].strip().lower() in {"gene", "symbol", "gene_symbol", "genes"}:
+        return True
+    return any(c.strip() and not c.strip().isdigit() for c in fields[1:3])
+
+
+def read_genelist(path: str) -> list[GeneSpec]:
+    """Read the genelist TSV: columns Gene, Left_extension_bp, Right_extension_bp.
+
+    A gene counts as an extended region iff Left or Right is non-zero, so no
+    separate flag column is needed; a bare `Gene` line (no extension columns) is
+    valid and gets only the default flank. A header row, if present, is detected
+    and skipped.
+    """
+    specs: list[GeneSpec] = []
+    with _open(path) as fh:
+        rows = [line.rstrip("\n") for line in fh]
+    start = 1 if rows and _is_header_row(rows[0].split("\t")) else 0
+    for line in rows[start:]:
+        if not line:
+            continue
+        fields = line.split("\t")
+        symbol = fields[0].strip()   # chomp whitespace/tabs (Excel habit)
+        if not symbol:
+            continue
+        left = _field_int(fields, 1)
+        right = _field_int(fields, 2)
+        specs.append(GeneSpec(symbol, left, right))
+    return specs
+
+
+def _attrs(s: str) -> dict[str, str]:
+    d: dict[str, str] = {}
+    for field in s.rstrip(";").split(";"):
+        if "=" in field:
+            k, _, v = field.partition("=")
+            d[k.strip()] = v.strip()
+    return d
+
+
+class GffIndex:
+    """Index of GFF `gene` features, keyed on Entrez (GeneID)."""
+
+    def __init__(self) -> None:
+        self.geneid_to_features: dict[str, list[GffGene]] = defaultdict(list)
+        self.name_to_geneids: dict[str, set[str]] = defaultdict(set)
+
+    @classmethod
+    def load(cls, path: str) -> GffIndex:
+        idx = cls()
+        with _open(path) as fh:
+            for line in fh:
+                if line.startswith("#") or not line.strip():
+                    continue
+                fields = line.rstrip("\n").split("\t")
+                if len(fields) < 9 or fields[2] != "gene":
+                    continue
+                a = _attrs(fields[8])
+                entrez = None
+                for tok in a.get("Dbxref", "").split(","):
+                    if tok.startswith("GeneID:"):
+                        entrez = tok.split(":", 1)[1]
+                        break
+                name = a.get("Name") or a.get("gene") or ""
+                g = GffGene(fields[0], int(fields[3]), int(fields[4]), entrez, name)
+                # Without a GeneID, fall back to a synthetic key so nothing is lost.
+                key = entrez if entrez is not None else f"NONAME:{name}:{fields[0]}:{fields[3]}"
+                idx.geneid_to_features[key].append(g)
+                if name:
+                    idx.name_to_geneids[name].add(key)
+        return idx
+
+
+def read_entrez_map(path: str) -> dict[str, str]:
+    """External SYMBOL<TAB>ENTREZID table (e.g. an org.Hs.eg.db export)."""
+    m: dict[str, str] = {}
+    with _open(path) as fh:
+        for line in fh:
+            line = line.rstrip("\n")
+            if not line or line.startswith("#"):
+                continue
+            fields = line.split("\t")
+            if len(fields) >= 2 and fields[0].strip() and fields[1].strip():
+                m[fields[0].strip()] = fields[1].strip()
+    return m

ont_bed_generator/io_outputs.py

@@ -0,0 +1,30 @@
+"""Output BED writers."""
+from __future__ import annotations
+
+from .model import BedRow, Locus
+from .ordering import chrom_sort_key
+
+
+def write_targets(loci: list[Locus], path: str) -> int:
+    """targets.bed: (chrom, start, end, Name, 0, .), deduplicated, sorted."""
+    seen: set[tuple[str, int, int, str]] = set()
+    rows: list[BedRow] = []
+    for lo in loci:
+        key = (lo.chrom, lo.start, lo.end, lo.name)
+        if key in seen:
+            continue
+        seen.add(key)
+        rows.append((lo.chrom, lo.start, lo.end, lo.name, 0, "."))
+    rows.sort(key=lambda x: (chrom_sort_key(x[0]), x[1], x[2], x[3]))
+    with open(path, "w") as fh:
+        for r in rows:
+            fh.write("\t".join(map(str, r)) + "\n")
+    return len(rows)
+
+
+def write_bed(rows: list[BedRow], path: str) -> int:
+    """Write a list of already-ordered BED tuples."""
+    with open(path, "w") as fh:
+        for r in rows:
+            fh.write("\t".join(map(str, r)) + "\n")
+    return len(rows)

ont_bed_generator/model.py

@@ -0,0 +1,56 @@
+"""Data structures and constants."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+DEFAULT_FLANK = 10000
+
+# A BED6 row: (chrom, start, end, name, score, strand).
+BedRow = tuple[str, int, int, str, int, str]
+
+
+@dataclass
+class GeneSpec:
+    """One genelist row: symbol plus per-side extension sizes (bp)."""
+    symbol: str
+    left: int
+    right: int
+
+    @property
+    def extended(self) -> int:
+        """Derived flag: a region is 'extended' if it has a custom L/R size."""
+        return 1 if (self.left or self.right) else 0
+
+
+@dataclass
+class GffGene:
+    """A GFF `gene` feature (1-based, inclusive coordinates)."""
+    chrom: str
+    start1: int
+    end: int
+    entrez: str | None
+    name: str
+
+
+@dataclass
+class Locus:
+    """A resolved locus in BED coordinates (0-based, half-open)."""
+    chrom: str
+    start: int
+    end: int
+    name: str          # canonical GFF Name=
+    left: int
+    right: int
+
+    @property
+    def extended(self) -> int:
+        """Derived flag: a region is 'extended' if it has a custom L/R size."""
+        return 1 if (self.left or self.right) else 0
+
+
+@dataclass
+class Resolution:
+    """Result of symbol -> loci resolution, with diagnostics."""
+    loci: list[Locus]
+    ambiguous: list[tuple[str, list[str]]]   # (symbol, [GeneID...])
+    invalid: list[str]

ont_bed_generator/ordering.py

@@ -0,0 +1,20 @@
+"""Canonical karyotypic ordering of chromosome names.
+
+Organism-agnostic: numbered autosomes first in numeric order (chr1, chr2, ...,
+chr9, chr10, ...), then sex chromosomes (X, Y; also Z, W for other clades), then
+the mitochondrion (M / MT), then any remaining contigs alphabetically. No
+hard-coded per-organism list, so it works for human, mouse, etc.
+"""
+from __future__ import annotations
+
+
+def chrom_sort_key(chrom: str) -> tuple[int, int, str]:
+    """Sort key placing chromosome names in canonical karyotypic order."""
+    name = chrom[3:] if chrom.lower().startswith("chr") else chrom
+    if name.isdigit():
+        return (0, int(name), "")
+    special = {"X": 0, "Y": 1, "Z": 2, "W": 3, "M": 4, "MT": 4}
+    rank = special.get(name.upper())
+    if rank is not None:
+        return (1, rank, "")
+    return (2, 0, name)

ont_bed_generator/resolve.py

@@ -0,0 +1,57 @@
+"""Resolve official gene symbols to loci, using the GFF Entrez key.
+
+Policy: official HGNC symbols only (verifiable via
+https://www.genenames.org/tools/multi-symbol-checker/). No synonym fallback,
+no renaming. A symbol that is not found is reported, never guessed.
+"""
+from __future__ import annotations
+
+from .io_inputs import GffIndex
+from .model import GeneSpec, Locus, Resolution
+
+
+def resolve(
+    specs: list[GeneSpec],
+    gff: GffIndex,
+    entrez_map: dict[str, str] | None = None,
+) -> Resolution:
+    loci: list[Locus] = []
+    ambiguous: list[tuple[str, list[str]]] = []
+    invalid: list[str] = []
+    seen: set[tuple[str, int, int, str]] = set()
+
+    for spec in specs:
+        # External table first, then GFF Name=, otherwise invalid.
+        if entrez_map is not None and spec.symbol in entrez_map:
+            geneids = {entrez_map[spec.symbol]}
+        elif spec.symbol in gff.name_to_geneids:
+            geneids = set(gff.name_to_geneids[spec.symbol])
+        else:
+            invalid.append(spec.symbol)
+            continue
+
+        # A Name mapping to several distinct GeneIDs is ambiguous (e.g. tRNAs).
+        if len(geneids) > 1:
+            ambiguous.append((spec.symbol, sorted(geneids)))
+            continue
+
+        gid = next(iter(geneids))
+        recs = gff.geneid_to_features.get(gid, [])
+        if not recs:
+            invalid.append(spec.symbol)
+            continue
+
+        # Collect by GeneID: handles PAR genes (chrX+chrY) and IG/TCR loci.
+        for g in recs:
+            start0 = g.start1 - 1
+            out_name = g.name or spec.symbol
+            key = (g.chrom, start0, g.end, out_name)
+            if key in seen:
+                continue
+            seen.add(key)
+            loci.append(
+                Locus(g.chrom, start0, g.end, out_name,
+                      spec.left, spec.right)
+            )
+
+    return Resolution(loci, ambiguous, invalid)

ont_bed_generator-0.4.0.dist-info/METADATA

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: ont-bed-generator
+Version: 0.4.0
+Summary: Generate BED files for Oxford Nanopore adaptive sampling from a gene list and a RefSeq GFF3.
+Project-URL: Homepage, https://github.com/Institut-Leucemie/ont-bed-generator
+Project-URL: Issues, https://github.com/Institut-Leucemie/ont-bed-generator/issues
+Author: Christophe Antoniewski
+License: MIT License
+        
+        Copyright (c) 2026 Christophe Antoniewski
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: adaptive-sampling,bed,bioinformatics,genomics,nanopore
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: mypy>=1.8; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+![CI](https://github.com/Institut-Leucemie/ont-bed-generator/actions/workflows/ci.yml/badge.svg)
+
+# ont-bed-generator
+
+Generate **BED** files for **Oxford Nanopore adaptive sampling** from a gene
+list and a RefSeq GFF3. Standalone reimplementation (Python standard library
+only, **no runtime dependencies**) of the Galaxy workflow "Adaptative ONT BED
+file generation" (which replaced BED-Craft).
+
+Given a list of target genes and a GFF3 annotation, the tool produces:
+
+- `targets.bed` — the raw locus of each gene (BED6);
+- `merged-extended.bed` — two intervals per locus (`+` / `-` strands),
+  extended, clamped to chromosome bounds, then merged per strand.
+
+## Installation
+
+```bash
+# from source
+git clone https://github.com/CHANGE-ME/ont-bed-generator.git
+cd ont-bed-generator
+pip install .
+```
+
+Conda development environment (includes `bedtools`, used only by the parity
+test):
+
+```bash
+conda env create -f environment.yml   # or: mamba/micromamba env create -f environment.yml
+conda activate ont-bed-generator
+```
+
+## Usage
+
+```bash
+ont-bed-generator \
+    --genelist genelist.tsv \
+    --gff annotation.genes.gff3 \
+    --genome hs1.len \
+    --out-targets targets.bed \
+    --out-merged  merged-extended.bed
+# or: python -m ont_bed_generator --genelist ... --gff ... --genome ...
+```
+
+### Inputs
+
+1. **genelist TSV** — columns `Gene | Left_extension_bp | Right_extension_bp`,
+   with an (auto-detected) header row. Coordinates come from the GFF, so no
+   chromosome column is needed; a gene is treated as an extended region when
+   Left or Right is non-zero (no separate flag). A bare `Gene` line (no
+   extensions) is valid and gets only the default flank. Symbols must be
+   **official HGNC symbols** (check them with the
+   [multi-symbol checker](https://www.genenames.org/tools/multi-symbol-checker/)).
+2. **GFF3** — a RefSeq GFF3 whose `gene` features carry `Name=` and
+   `Dbxref=GeneID:`. The **full NCBI annotation works as-is**: the tool reads
+   only `gene` features and ignores everything else, so pre-extracting them is
+   just an optional speed-up. Gzip-compressed (`.gz`) input is read transparently
+   (this applies to every input file). Example (T2T-CHM13v2.0 / hs1):
+   ```bash
+   curl -sO https://ftp.ncbi.nlm.nih.gov/genomes/all/GCF/009/914/755/GCF_009914755.1_T2T-CHM13v2.0/GCF_009914755.1_T2T-CHM13v2.0_genomic.gff.gz
+   ```
+3. **genome sizes** — `chrom<TAB>size`, one line per chromosome. Used for
+   telomere clamping only; the line order does not matter (output BEDs are
+   sorted in canonical karyotypic order).
+   ```bash
+   curl -sO https://hgdownload.soe.ucsc.edu/goldenPath/hs1/bigZips/hs1.chrom.sizes
+   ```
+
+### Symbol resolution
+
+Official symbol → GeneID (GFF `Name=`, or external `--entrez-map`) → collect
+**all** loci carrying that GeneID. The Entrez key handles pseudoautosomal
+regions (one GeneID on chrX and chrY yields two loci) and IG/TCR loci. A symbol
+that is not found, or that maps to several GeneIDs, is **reported** (on stderr),
+never guessed. `--strict` returns a non-zero exit code if any symbol is invalid
+or ambiguous.
+
+## Development
+
+```bash
+pip install -e '.[dev]'
+pytest            # unit tests (+ bedtools parity if bedtools is present)
+ruff check .
+mypy
+```
+
+Versioning is driven by git tags (`hatch-vcs`): a release is
+`git tag vX.Y.Z && git push --tags`.
+
+## Intentional differences from the original Galaxy workflow
+
+- The workflow patched non-official symbols (`MKL1→MKLN1`, a bug — MKLN1 is a
+  different gene; `LYL→LYL1`). Here **no patching**: such symbols are reported
+  for correction at the source.
+- The Galaxy output contained a missing merge (`bedtools merge` on
+  genome-order-sorted input without `-g`). This tool performs the correct merge.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

ont_bed_generator-0.4.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+ont_bed_generator/__init__.py,sha256=GxYbBZcGwEmx2yLF00gEtNzgDVkYMAXJudwOBu5457I,983
+ont_bed_generator/__main__.py,sha256=1LIX2JyZNpgID3NtRHryuTXQyfmXtYkGx9hldLKFCj4,163
+ont_bed_generator/_version.py,sha256=HGBlVvZpQ8N2kh1n_LY5PM4s9ljcIgdbOCgXN-uFje4,520
+ont_bed_generator/cli.py,sha256=4ADDCfmCiMK1vwCcSbtLOpfRVoGWZUjXAie3yGmpwcI,3021
+ont_bed_generator/intervals.py,sha256=FdoLq7ly9zn-YvLrF-gbNvjq2uYumxdi_4NfxsY_OdU,2508
+ont_bed_generator/io_inputs.py,sha256=jiPtSlU3ts0NPiJZURZYzMMqyXa9o9AHaPSwMjEo8Mw,4581
+ont_bed_generator/io_outputs.py,sha256=mGvpBjFIeK_-aiLGsEn2a66XtmzxGVL6lo5Krjhh-LI,986
+ont_bed_generator/model.py,sha256=v7UCDq1f9tc1djOKa3u204ZrOaK43Rigbavhwkq3zZg,1330
+ont_bed_generator/ordering.py,sha256=Qg_aAzrRvouvwKkJCIL16_D_HWw_Y5FQK9Y0BB88QvY,829
+ont_bed_generator/resolve.py,sha256=p_sOeydkmzz9yhLtQdyGFOzD4vQ7tthxZeUaPhacPos,1908
+ont_bed_generator-0.4.0.dist-info/METADATA,sha256=D538rs_9dc0_cHkYPj1mO3n5S4_LukYQrGigqhoeucY,5984
+ont_bed_generator-0.4.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+ont_bed_generator-0.4.0.dist-info/entry_points.txt,sha256=jlNxteDDrU4hh28868TgbjiGA5pWR6qTUWIoh9KXy4k,65
+ont_bed_generator-0.4.0.dist-info/licenses/LICENSE,sha256=gkFcMpjwos6A_Izro6rCt9XZSwO61RFAZuj0_O2_bj0,1079
+ont_bed_generator-0.4.0.dist-info/RECORD,,

ont_bed_generator-0.4.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

ont_bed_generator-0.4.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ont-bed-generator = ont_bed_generator.cli:main

ont_bed_generator-0.4.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Christophe Antoniewski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.