Datasets:

ryan-superman
/

bio-agent-trajectories

#!/usr/bin/env python3
"""Base-resolution breakpoint detection from an alignment.
A double-strand break leaves two independent signatures in aligned reads:
* *fragment ends* -- reads from the cut molecule terminate exactly at the break, so
  alignment start and end positions pile up there;
* *clip boundaries* -- reads that read through a repaired or chimeric junction align
  partially and are soft-clipped at the break.
Both are measurements. They are reported separately because agreeing on a position is
strong evidence, whereas one signature alone can be produced by ordinary coverage
structure (a capture boundary, a repeat edge, an adapter artefact).
This is deliberately generic: the same statistic locates Cas9 cut sites, viral
integration sites, fusion junctions and structural-variant breakpoints.
"""

from __future__ import annotations

import re
import subprocess
from bisect import bisect_left, bisect_right
from collections import Counter
from pathlib import Path

CIGAR_RE = re.compile(r"(\d+)([MIDNSHP=X])")
# Operations that advance along the reference; used to find where an alignment ends.
REF_CONSUMING = frozenset("MDN=X")
MIN_CLIP = 5  # shorter clips are usually sequencing error, not a junction
POOL = 50     # candidates ranked before truncating, so `k` cannot change the ranking


def scan_sam(lines, *, min_mapq: int = 20, min_clip: int = MIN_CLIP) -> dict:
    """Accumulate breakpoint evidence from SAM records.
    Args:
        lines: Iterable of SAM text lines; headers are ignored.
        min_mapq: Reads below this are dropped, because a breakpoint claim made from
            multi-mapping reads is not a claim about a location.
        min_clip: Minimum soft-clip length counted as a junction.
    Returns:
        Counters keyed by ``(chrom, position)``: ``left_end`` and ``right_end`` for
        alignment termini, ``clip`` for soft-clip boundaries, plus ``n_reads`` scanned.
    """
    left_end: Counter = Counter()   # 1-based position of an alignment's first base
    right_end: Counter = Counter()  # 1-based position of an alignment's last base
    clip: Counter = Counter()
    n = 0
    for line in lines:
        if not line or line[0] == "@":
            continue
        f = line.rstrip("\n").split("\t")
        if len(f) < 6:
            continue
        flag = int(f[1])
        if flag & 0x904:            # unmapped, secondary or supplementary
            continue
        chrom, pos, mapq, cigar = f[2], int(f[3]), int(f[4]), f[5]
        if chrom == "*" or mapq < min_mapq or cigar == "*":
            continue
        n += 1
        ops = CIGAR_RE.findall(cigar)
        span = sum(int(ln) for ln, op in ops if op in REF_CONSUMING)
        end = pos + span - 1
        left_end[(chrom, pos)] += 1
        right_end[(chrom, end)] += 1
        if ops and ops[0][1] == "S" and int(ops[0][0]) >= min_clip:
            clip[(chrom, pos)] += 1
        if ops and ops[-1][1] == "S" and int(ops[-1][0]) >= min_clip:
            clip[(chrom, end)] += 1
    return {"left_end": left_end, "right_end": right_end, "clip": clip, "n_reads": n}


def top_positions(counter: Counter, k: int = 20) -> list[dict]:
    """The `k` most-supported positions, as JSON-ready records."""
    return [{"chrom": c, "pos": p, "reads": n}
            for (c, p), n in counter.most_common(k)]


def consensus(ev: dict, k: int = 20, window: int = 10) -> list[dict]:
    """Positions supported by more than one signature, at base resolution.
    A cut site should show reads ending on its left and reads beginning on its right, so
    a candidate is scored by the summed support of every signature within `window` bases.
    Requiring agreement is what separates a break from a coverage edge.
    Clusters are seeded in descending order of support *at a single base*, so the
    position reported is the cluster's peak rather than any base near it. Seeding from
    each signature's own ranking instead put the reported position up to `window` bases
    off the true break, which is the difference between a right and a wrong answer when
    a coordinate is graded to a few base pairs.
    """
    by_chrom: dict[str, dict[str, list]] = {}
    for name in ("left_end", "right_end", "clip"):
        for (c, p), n in ev[name].items():
            by_chrom.setdefault(c, {}).setdefault(name, []).append((p, n))
    for chrom in by_chrom:
        for name in by_chrom[chrom]:
            by_chrom[chrom][name].sort()

    def near(chrom: str, pos: int, name: str) -> int:
        """Support for `name` within `window` bases of `pos`."""
        entries = by_chrom.get(chrom, {}).get(name)
        if not entries:
            return 0
        lo = bisect_left(entries, (pos - window, 0))
        hi = bisect_right(entries, (pos + window, 1 << 62))
        return sum(n for _, n in entries[lo:hi])

    peak: Counter = Counter()
    for name in ("left_end", "right_end", "clip"):
        peak.update(ev[name])

    # Collect a fixed pool regardless of `k`, then rank, then truncate. Collecting only
    # `k` and ranking those makes the runner-up -- and therefore the reported margin --
    # depend on how many results the caller asked for, which is not a property of the
    # data.
    pool = max(k, POOL)
    kept: list[dict] = []
    for (c, p), _ in peak.most_common():
        if any(c == s["chrom"] and abs(p - s["pos"]) <= window for s in kept):
            continue
        counts = {name: near(c, p, name) for name in ("left_end", "right_end", "clip")}
        kept.append({"chrom": c, "pos": p,
                     "signatures": sum(1 for v in counts.values() if v > 0),
                     "total": sum(counts.values()), **counts})
        if len(kept) >= pool:
            break
    kept.sort(key=lambda d: (-d["signatures"], -d["total"]))
    return kept[:k]


# The floor this tool already declares. Two conditions, not one: `consensus` keeps only
# positions "supported by more than one signature", because agreement is what separates a
# break from a coverage edge, and the blind spot below calls anything under 20 reads a
# candidate rather than a location. `alternatives` is counted against BOTH, so uniqueness
# means "no rival clears the bar this tool itself set".
#
# Counting support alone was wrong and a test caught it. A library with one real break and
# uniform read length piles 40 read starts at `pos - readlen + 1` and 40 read ends at
# `pos + readlen - 1`; each clears 20 reads, and each is a single signature -- a coverage
# edge, which is precisely what the agreement rule exists to reject. Scoring them as
# rivals made a clean, unambiguous cut site non-unique.
SUPPORT_FLOOR = 20
MIN_SIGNATURES = 2

# A rival has to be an alternative *event*, not another view of the same one. Simulation
# missed this because it placed distractors 5 kb apart; the real Cas9 library does not. One
# cut site there produces a peak at chr3:46,373,178 and a shoulder of positions carrying
# three signatures and hundreds of reads within ~130 bp of it, all of them the same break.
# Counting those as rivals made the caller abstain on an answer it had ranked first.
#
# No single junction can produce evidence further away than one read length, so the read
# span the scan actually observed is the independence window. It is measured, not chosen.
DEFAULT_INDEPENDENCE = 150


def competence_for(found: list[dict], independence: int = DEFAULT_INDEPENDENCE):
    """State what a ranked breakpoint list can and cannot establish.
    Factored out of the `biotool breakpoints` command so the shipped rule is the one under
    test. A breakpoint is a claim about a single base, so the margin that matters is how
    far the top candidate stands above the second, not how much total support it has.
    `alternatives` counts rivals that clear this tool's own floor on both axes,
    `MIN_SIGNATURES` and `SUPPORT_FLOOR`. Measured on the variant caller first: a large
    margin arises both when the true answer dominates and when a distractor does, so
    separation between the top two is not the absence of a rival. Generalising the count
    here showed the floor a tool declares can be multi-dimensional, and using only part of
    it invents rivals that the tool's own ranking has already dismissed.
    Args:
        found: Ranked output of `consensus`, best first.
        independence: Minimum distance at which a candidate counts as a separate event.
            Pass the observed read span; the default is a typical short read.
    Returns:
        A `Competence` describing the list.
    """
    from .competence import bounded

    top = found[0]["total"] if found else 0
    runner_up = found[1]["total"] if len(found) > 1 else 0
    lead = found[0] if found else None

    def independent(f: dict) -> bool:
        """Whether `f` describes a different event from the top candidate."""
        return (lead is not None and (f["chrom"] != lead["chrom"]
                                      or abs(f["pos"] - lead["pos"]) > independence))
    return bounded(
        confidence=min(1.0, top / 100.0),
        margin=((top - runner_up) / top) if top else 0.0,
        alternatives=sum(1 for f in found
                         if f["total"] >= SUPPORT_FLOOR
                         and f["signatures"] >= MIN_SIGNATURES
                         and independent(f)),
        ties=sum(1 for f in found[1:]
                 if top and (top - f["total"]) / top < 0.05 and independent(f)),
        blind_spots=((f"fewer than {SUPPORT_FLOOR} reads support the top position; it is "
                      "a candidate, not a location",) if top < SUPPORT_FLOOR else ()),
        remedy="scan without --region, or sequence deeper at the locus",
    )


def scan_bam(bam: Path, *, samtools: str | None = None, region: str | None = None,
             min_mapq: int = 20, min_clip: int = MIN_CLIP) -> dict:
    """Accumulate breakpoint evidence from an indexed BAM.
    Args:
        bam: Sorted, indexed alignment.
        samtools: Binary to use; located if omitted.
        region: Restrict to `chr:start-end`. Omit to scan the whole genome, which is
            what lets the tool find a locus the agent has not already guessed.
        min_mapq: See `scan_sam`.
        min_clip: See `scan_sam`.
    Raises:
        RuntimeError: If samtools is missing or the scan fails.
    """
    from . import references  # local import keeps this module importable standalone

    binary = samtools or references.find_binary("samtools")
    if binary is None:
        raise RuntimeError("samtools is not installed")
    cmd = [binary, "view", str(bam)] + ([region] if region else [])
    with subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                          text=True, errors="replace", bufsize=1 << 20) as proc:
        evidence = scan_sam(proc.stdout, min_mapq=min_mapq, min_clip=min_clip)
        proc.stdout.close()
        err = proc.stderr.read()
    if proc.returncode not in (0, None) and not evidence["n_reads"]:
        raise RuntimeError(f"samtools view failed: {err[-300:]}")
    return evidence

	#!/usr/bin/env python3
	"""Base-resolution breakpoint detection from an alignment.

	A double-strand break leaves two independent signatures in aligned reads:

	* fragment ends -- reads from the cut molecule terminate exactly at the break, so
	alignment start and end positions pile up there;
	* clip boundaries -- reads that read through a repaired or chimeric junction align
	partially and are soft-clipped at the break.

	Both are measurements. They are reported separately because agreeing on a position is
	strong evidence, whereas one signature alone can be produced by ordinary coverage
	structure (a capture boundary, a repeat edge, an adapter artefact).

	This is deliberately generic: the same statistic locates Cas9 cut sites, viral
	integration sites, fusion junctions and structural-variant breakpoints.
	"""

	from __future__ import annotations

	import re
	import subprocess
	from bisect import bisect_left, bisect_right
	from collections import Counter
	from pathlib import Path

	CIGAR_RE = re.compile(r"(\d+)([MIDNSHP=X])")
	# Operations that advance along the reference; used to find where an alignment ends.
	REF_CONSUMING = frozenset("MDN=X")
	MIN_CLIP = 5 # shorter clips are usually sequencing error, not a junction
	POOL = 50 # candidates ranked before truncating, so `k` cannot change the ranking


	def scan_sam(lines, *, min_mapq: int = 20, min_clip: int = MIN_CLIP) -> dict:
	"""Accumulate breakpoint evidence from SAM records.

	Args:
	lines: Iterable of SAM text lines; headers are ignored.
	min_mapq: Reads below this are dropped, because a breakpoint claim made from
	multi-mapping reads is not a claim about a location.
	min_clip: Minimum soft-clip length counted as a junction.

	Returns:
	Counters keyed by ``(chrom, position)``: ``left_end`` and ``right_end`` for
	alignment termini, ``clip`` for soft-clip boundaries, plus ``n_reads`` scanned.
	"""
	left_end: Counter = Counter() # 1-based position of an alignment's first base
	right_end: Counter = Counter() # 1-based position of an alignment's last base
	clip: Counter = Counter()
	n = 0
	for line in lines:
	if not line or line[0] == "@":
	continue
	f = line.rstrip("\n").split("\t")
	if len(f) < 6:
	continue
	flag = int(f[1])
	if flag & 0x904: # unmapped, secondary or supplementary
	continue
	chrom, pos, mapq, cigar = f[2], int(f[3]), int(f[4]), f[5]
	if chrom == "" or mapq < min_mapq or cigar == "":
	continue
	n += 1
	ops = CIGAR_RE.findall(cigar)
	span = sum(int(ln) for ln, op in ops if op in REF_CONSUMING)
	end = pos + span - 1
	left_end[(chrom, pos)] += 1
	right_end[(chrom, end)] += 1
	if ops and ops[0][1] == "S" and int(ops[0][0]) >= min_clip:
	clip[(chrom, pos)] += 1
	if ops and ops[-1][1] == "S" and int(ops[-1][0]) >= min_clip:
	clip[(chrom, end)] += 1
	return {"left_end": left_end, "right_end": right_end, "clip": clip, "n_reads": n}


	def top_positions(counter: Counter, k: int = 20) -> list[dict]:
	"""The `k` most-supported positions, as JSON-ready records."""
	return [{"chrom": c, "pos": p, "reads": n}
	for (c, p), n in counter.most_common(k)]


	def consensus(ev: dict, k: int = 20, window: int = 10) -> list[dict]:
	"""Positions supported by more than one signature, at base resolution.

	A cut site should show reads ending on its left and reads beginning on its right, so
	a candidate is scored by the summed support of every signature within `window` bases.
	Requiring agreement is what separates a break from a coverage edge.

	Clusters are seeded in descending order of support at a single base, so the
	position reported is the cluster's peak rather than any base near it. Seeding from
	each signature's own ranking instead put the reported position up to `window` bases
	off the true break, which is the difference between a right and a wrong answer when
	a coordinate is graded to a few base pairs.
	"""
	by_chrom: dict[str, dict[str, list]] = {}
	for name in ("left_end", "right_end", "clip"):
	for (c, p), n in ev[name].items():
	by_chrom.setdefault(c, {}).setdefault(name, []).append((p, n))
	for chrom in by_chrom:
	for name in by_chrom[chrom]:
	by_chrom[chrom][name].sort()

	def near(chrom: str, pos: int, name: str) -> int:
	"""Support for `name` within `window` bases of `pos`."""
	entries = by_chrom.get(chrom, {}).get(name)
	if not entries:
	return 0
	lo = bisect_left(entries, (pos - window, 0))
	hi = bisect_right(entries, (pos + window, 1 << 62))
	return sum(n for _, n in entries[lo:hi])

	peak: Counter = Counter()
	for name in ("left_end", "right_end", "clip"):
	peak.update(ev[name])

	# Collect a fixed pool regardless of `k`, then rank, then truncate. Collecting only
	# `k` and ranking those makes the runner-up -- and therefore the reported margin --
	# depend on how many results the caller asked for, which is not a property of the
	# data.
	pool = max(k, POOL)
	kept: list[dict] = []
	for (c, p), _ in peak.most_common():
	if any(c == s["chrom"] and abs(p - s["pos"]) <= window for s in kept):
	continue
	counts = {name: near(c, p, name) for name in ("left_end", "right_end", "clip")}
	kept.append({"chrom": c, "pos": p,
	"signatures": sum(1 for v in counts.values() if v > 0),
	"total": sum(counts.values()), **counts})
	if len(kept) >= pool:
	break
	kept.sort(key=lambda d: (-d["signatures"], -d["total"]))
	return kept[:k]


	# The floor this tool already declares. Two conditions, not one: `consensus` keeps only
	# positions "supported by more than one signature", because agreement is what separates a
	# break from a coverage edge, and the blind spot below calls anything under 20 reads a
	# candidate rather than a location. `alternatives` is counted against BOTH, so uniqueness
	# means "no rival clears the bar this tool itself set".
	#
	# Counting support alone was wrong and a test caught it. A library with one real break and
	# uniform read length piles 40 read starts at `pos - readlen + 1` and 40 read ends at
	# `pos + readlen - 1`; each clears 20 reads, and each is a single signature -- a coverage
	# edge, which is precisely what the agreement rule exists to reject. Scoring them as
	# rivals made a clean, unambiguous cut site non-unique.
	SUPPORT_FLOOR = 20
	MIN_SIGNATURES = 2

	# A rival has to be an alternative event, not another view of the same one. Simulation
	# missed this because it placed distractors 5 kb apart; the real Cas9 library does not. One
	# cut site there produces a peak at chr3:46,373,178 and a shoulder of positions carrying
	# three signatures and hundreds of reads within ~130 bp of it, all of them the same break.
	# Counting those as rivals made the caller abstain on an answer it had ranked first.
	#
	# No single junction can produce evidence further away than one read length, so the read
	# span the scan actually observed is the independence window. It is measured, not chosen.
	DEFAULT_INDEPENDENCE = 150


	def competence_for(found: list[dict], independence: int = DEFAULT_INDEPENDENCE):
	"""State what a ranked breakpoint list can and cannot establish.

	Factored out of the `biotool breakpoints` command so the shipped rule is the one under
	test. A breakpoint is a claim about a single base, so the margin that matters is how
	far the top candidate stands above the second, not how much total support it has.

	`alternatives` counts rivals that clear this tool's own floor on both axes,
	`MIN_SIGNATURES` and `SUPPORT_FLOOR`. Measured on the variant caller first: a large
	margin arises both when the true answer dominates and when a distractor does, so
	separation between the top two is not the absence of a rival. Generalising the count
	here showed the floor a tool declares can be multi-dimensional, and using only part of
	it invents rivals that the tool's own ranking has already dismissed.

	Args:
	found: Ranked output of `consensus`, best first.
	independence: Minimum distance at which a candidate counts as a separate event.
	Pass the observed read span; the default is a typical short read.

	Returns:
	A `Competence` describing the list.
	"""
	from .competence import bounded

	top = found[0]["total"] if found else 0
	runner_up = found[1]["total"] if len(found) > 1 else 0
	lead = found[0] if found else None

	def independent(f: dict) -> bool:
	"""Whether `f` describes a different event from the top candidate."""
	return (lead is not None and (f["chrom"] != lead["chrom"]
	or abs(f["pos"] - lead["pos"]) > independence))
	return bounded(
	confidence=min(1.0, top / 100.0),
	margin=((top - runner_up) / top) if top else 0.0,
	alternatives=sum(1 for f in found
	if f["total"] >= SUPPORT_FLOOR
	and f["signatures"] >= MIN_SIGNATURES
	and independent(f)),
	ties=sum(1 for f in found[1:]
	if top and (top - f["total"]) / top < 0.05 and independent(f)),
	blind_spots=((f"fewer than {SUPPORT_FLOOR} reads support the top position; it is "
	"a candidate, not a location",) if top < SUPPORT_FLOOR else ()),
	remedy="scan without --region, or sequence deeper at the locus",
	)


	def scan_bam(bam: Path, *, samtools: str \| None = None, region: str \| None = None,
	min_mapq: int = 20, min_clip: int = MIN_CLIP) -> dict:
	"""Accumulate breakpoint evidence from an indexed BAM.

	Args:
	bam: Sorted, indexed alignment.
	samtools: Binary to use; located if omitted.
	region: Restrict to `chr:start-end`. Omit to scan the whole genome, which is
	what lets the tool find a locus the agent has not already guessed.
	min_mapq: See `scan_sam`.
	min_clip: See `scan_sam`.

	Raises:
	RuntimeError: If samtools is missing or the scan fails.
	"""
	from . import references # local import keeps this module importable standalone

	binary = samtools or references.find_binary("samtools")
	if binary is None:
	raise RuntimeError("samtools is not installed")
	cmd = [binary, "view", str(bam)] + ([region] if region else [])
	with subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
	text=True, errors="replace", bufsize=1 << 20) as proc:
	evidence = scan_sam(proc.stdout, min_mapq=min_mapq, min_clip=min_clip)
	proc.stdout.close()
	err = proc.stderr.read()
	if proc.returncode not in (0, None) and not evidence["n_reads"]:
	raise RuntimeError(f"samtools view failed: {err[-300:]}")
	return evidence