jbrowse-plugin-graphgenomeviewer 7.2.0 → 7.2.1

package/src/RgfaTabixAdapter/rgfaCut.ts

@@ -1,139 +0,0 @@
-import {
-  addLink,
-  anchoredCut,
-  closingLinks,
-  closingSpans,
-  formatSubgraph,
-  parseLinkLine,
-  parseSegmentRow,
-} from './rgfaBed.ts'
-import { getLines } from '../tabixRange.ts'
-
-import type { RgfaLink, RgfaSegment, StableSpan } from './rgfaBed.ts'
-import type { TabixIndexedFile } from '@gmod/tabix'
-
-// What a hop follows: alleles, never the backbone. A rank-0 segment reached
-// through a link is flanking backbone, usually outside the window, so querying
-// its links walks the reference away from the region, brings back more backbone,
-// and closes nothing. Every segment that closes a bubble is an allele interior,
-// and an allele interior is rank > 0 in both index formats (rGFA's SR tag, and
-// pggb's rank 0-or-1 against the anchor path). Reached backbone still becomes a
-// node and its edge still draws; it is only not walked through.
-//
-// This is gfabase's rule, arrived at from the other end. `gfabase sub` expands
-// from a seed either to the whole connected component (`--connected`, which its
-// own README calls overkill) or with `--cutpoints 1`, which takes the biconnected
-// component by *stopping at cutpoints*, the segments every end-to-end walk of
-// the chromosome must traverse. In a reference-anchored pangenome the cutpoints
-// are the backbone, and rank is what the index already states about it, so
-// `rank > 0` is that stopping rule without a connectivity index to build. The
-// third tool is the same shape again: `gfatools view -R` maps the region onto its
-// precomputed bubble decomposition and returns whole overlapping bubbles
-// (gfa_query_by_reg), which is complete for the same reason. Bandage's own
-// `--distance` is a node-step radius, but Bandage holds the entire graph in
-// memory, so its scope is a drawing filter rather than a fetch strategy.
-//
-// Measured with this rule: the E. coli paa window converges at one hop (17
-// segments at 1 and at 2), so the cut closes and stays closed. HPRC's amylase
-// window keeps growing (63 at 0, 78 at 1, 92 at 2) because its alleles have
-// alleles, and wall-clock is flat across all three, since a hop's queries go out
-// together and the remote index dominates.
-//
-// The exact version, when a graph ships a bubble index beside its segments:
-// gfatools' bubble rows carry the member segment ids of every bubble, so the
-// bubbles overlapping the region state which segments a complete cut must
-// contain. That turns the hop count into a termination condition rather than a
-// setting, and MinigraphBubbleAdapter already parses those rows.
-function offReference(segments: RgfaSegment[]) {
-  return segments.filter(segment => segment.rank > 0)
-}
-
-export interface RgfaFiles {
-  segments: TabixIndexedFile
-  links: TabixIndexedFile
-}
-
-async function linksOver(
-  file: TabixIndexedFile,
-  span: StableSpan,
-  signal?: AbortSignal,
-) {
-  const found: RgfaLink[] = []
-  await getLines(file, span.refName, span.start, span.end, {
-    signal,
-    lineCallback: line => {
-      found.push(parseLinkLine(line))
-    },
-  })
-  return found
-}
-
-/**
- * The graph around a window of one stable sequence, as GFA text. The window's
- * own segments come from the segment file; the link file supplies the edges
- * incident to them *and* the coordinates of the segments on the other end,
- * which typically sit on a different stable sequence (a rank>0 bubble) and so
- * are not reachable by any coordinate query on this window.
- *
- * `hops` is extra rounds of link-following past the window's own segments and
- * their immediate neighbours, each costing one tabix query per off-reference
- * segment newly reached. After the last round, one more read per stretch of
- * stable sequence the cut holds closes it (closingSpans), so an allele reached
- * from both ends draws whole. The view asks for one hop; a hopless cut stays
- * as cheap as it was. `signal` goes to every one of those queries, so a cut
- * the view has replaced stops.
- */
-export async function rgfaCut(
-  files: RgfaFiles,
-  window: StableSpan,
-  { hops = 0, signal }: { hops?: number; signal?: AbortSignal } = {},
-) {
-  const segments = new Map<string, RgfaSegment>()
-  const links = new Map<string, RgfaLink>()
-  const layout = { anchored: false }
-  await getLines(files.segments, window.refName, window.start, window.end, {
-    signal,
-    lineCallback: line => {
-      const row = parseSegmentRow(line)
-      layout.anchored ||= row.anchored
-      segments.set(row.segment.id, row.segment)
-    },
-  })
-  // An anchored index files every allele and every link under the reference
-  // interval its bubble hangs from, so one read of each file holds the whole
-  // graph under the window and there is nothing to hop to or close.
-  if (layout.anchored) {
-    const cut = anchoredCut(
-      segments,
-      await linksOver(files.links, window, signal),
-      window,
-    )
-    return formatSubgraph(cut.segments, cut.links)
-  }
-  const addLinksOver = async (span: StableSpan) =>
-    (await linksOver(files.links, span, signal)).flatMap(link =>
-      addLink(segments, links, link),
-    )
-  let frontier = offReference(await addLinksOver(window))
-  for (let hop = 0; hop < hops; hop++) {
-    // One hop's queries are independent of each other, so they go out
-    // together rather than one round-trip at a time, and the output is sorted
-    // at the end regardless of the order they arrive in.
-    const reached = await Promise.all(frontier.map(addLinksOver))
-    frontier = offReference(reached.flat())
-  }
-  if (hops > 0) {
-    const spans = closingSpans(
-      [...segments.values()],
-      new Set(frontier.map(segment => segment.id)),
-      window,
-    )
-    const found = await Promise.all(
-      spans.map(span => linksOver(files.links, span, signal)),
-    )
-    for (const link of closingLinks(found.flat(), segments, spans)) {
-      addLink(segments, links, link)
-    }
-  }
-  return formatSubgraph(segments, links)
-}

package/src/RgfaTabixAdapter/walkRowRuns.test.ts

@@ -1,192 +0,0 @@
-import { gfaTables } from '@jbrowse/bandage-core/gfa/gfaTables'
-import { walkRows } from '@jbrowse/bandage-core/layout/walkRows'
-import { loadGraph } from '@jbrowse/bandage-core/pipeline'
-
-import { walkRowRuns, walkRowsOf } from './walkRowRuns.ts'
-
-import type { GraphTables } from '@jbrowse/bandage-core/gfa/graphTables'
-import type { WalkRow } from '@jbrowse/bandage-core/layout/walkRows'
-
-// GRCh38 runs 0..4 over chr1:0-5000, a kb a node, with node 5 (300 bp) an
-// expansion off it. The repeat is node 2, chr1:2000-3000. A has the
-// reference's left flank from 0 and ends inside the repeat, B the same from
-// 1000, and C runs against the reference from its right flank and ends
-// inside too, each off the reference. D's contig ends on the repeat's node
-// and E's on the left flank.
-const tables: GraphTables = {
-  nodes: {
-    names: ['0', '1', '2', '3', '4', '5'],
-    lengths: Int32Array.of(1000, 1000, 1000, 1000, 1000, 300),
-    refs: Int32Array.of(0, 0, 0, 0, 0, 1),
-    starts: Float64Array.of(0, 1000, 2000, 3000, 4000, 0),
-    ranks: Int32Array.of(0, 0, 0, 0, 0, 1),
-    refNames: ['chr1', 'alt'],
-  },
-  links: {
-    from: new Int32Array(0),
-    to: new Int32Array(0),
-    strands: new Uint8Array(0),
-  },
-  walks: {
-    names: ['GRCh38#0#chr1', 'A#1#a', 'B#1#b', 'C#1#c', 'D#1#d', 'E#1#e'],
-    starts: Float64Array.of(0, 0, 0, 0, 0, 0),
-    ends: Float64Array.of(5000, 3300, 2300, 2300, 3000, 2000),
-    offsets: Int32Array.of(0, 5, 9, 12, 15, 18, 20),
-    steps: Int32Array.of(
-      ...[0, 1, 2, 3, 4],
-      ...[0, 1, 2, 5],
-      ...[1, 2, 5],
-      ...[4, 3, 5],
-      ...[0, 1, 2],
-      ...[0, 1],
-    ),
-    reversed: Uint8Array.of(
-      ...[0, 0, 0, 0, 0],
-      ...[0, 0, 0, 0],
-      ...[0, 0, 0],
-      ...[1, 1, 1],
-      ...[0, 0, 0],
-      ...[0, 0],
-    ),
-  },
-}
-const repeat = { start: 2000, end: 3000 }
-
-test('a walk that ends inside the repeat measures from the flank it enters by', () => {
-  const rows = walkRowsOf(walkRowRuns(tables, repeat)!).rows
-  const byLabel = Object.fromEntries(rows.map(r => [r.label, r]))
-  expect(byLabel['A#1']).toMatchObject({ bp: 1300, complete: false })
-  expect(byLabel['B#1']).toMatchObject({ bp: 1300, complete: false })
-  expect(byLabel['C#1']).toMatchObject({ bp: 300, complete: false })
-  for (const label of ['A#1', 'B#1', 'C#1']) {
-    expect(byLabel[label]!.stop).toEqual({ contigEnds: false, shortBp: 0 })
-  }
-  expect(byLabel['D#1']).toMatchObject({
-    bp: 1000,
-    complete: false,
-    stop: { contigEnds: true, shortBp: 0 },
-  })
-  expect(byLabel['E#1']).toMatchObject({
-    bp: 0,
-    complete: false,
-    stop: { contigEnds: true, shortBp: 0 },
-  })
-  expect(byLabel['A#1']!.axis).toEqual({
-    contig: 'a',
-    start: 2000,
-    reversed: false,
-  })
-  expect(byLabel['C#1']!.axis).toEqual({
-    contig: 'c',
-    start: 2300,
-    reversed: true,
-  })
-})
-
-test('walkRows measures and stops the same walks', () => {
-  for (const region of [repeat, { start: 2500, end: 3000 }]) {
-    const fields = ({ label, bp, complete, stop }: WalkRow) => ({
-      label,
-      bp,
-      complete,
-      stop,
-    })
-    const ours = walkRowsOf(walkRowRuns(tables, region)!).rows.map(fields)
-    const theirs = walkRows(loadGraph(tables, 'cut'), region)!.rows.map(fields)
-    expect(ours).toEqual(theirs)
-  }
-  const short = walkRowsOf(
-    walkRowRuns(tables, { start: 2500, end: 3000 })!,
-  ).rows.find(r => r.label === 'E#1')!
-  expect(short.stop).toEqual({ contigEnds: true, shortBp: 500 })
-})
-
-test('walks named without a haplotype field are rows of their own, on their contigs', () => {
-  const twoPart: GraphTables = {
-    ...tables,
-    walks: {
-      ...tables.walks,
-      names: ['GRCh38#0#chr1', 'A#a', 'A#b', 'C#1#c', 'D#1#d', 'E#1#e'],
-    },
-  }
-  const rows = walkRowsOf(walkRowRuns(twoPart, repeat)!).rows
-  expect(
-    rows
-      .filter(r => r.sample === 'A')
-      .map(({ name, label, haplotype, axis }) => ({
-        name,
-        label,
-        haplotype,
-        contig: axis?.contig,
-      }))
-      .sort((x, y) => x.name.localeCompare(y.name)),
-  ).toEqual([
-    { name: 'A#a', label: 'A', haplotype: undefined, contig: 'a' },
-    { name: 'A#b', label: 'A', haplotype: undefined, contig: 'b' },
-  ])
-})
-
-test('a reference cut into pieces is one reference row, as walkRows reads it', () => {
-  const split: GraphTables = {
-    ...tables,
-    walks: {
-      names: ['GRCh38#0#chr1', 'GRCh38#0#chr1', 'A#1#a'],
-      starts: Float64Array.of(0, 3000, 0),
-      ends: Float64Array.of(2000, 5000, 5000),
-      offsets: Int32Array.of(0, 2, 4, 9),
-      steps: Int32Array.of(...[0, 1], ...[3, 4], ...[0, 1, 2, 3, 4]),
-      reversed: new Uint8Array(9),
-    },
-  }
-  const region = { start: 2200, end: 2800 }
-  const fields = ({ label, bp, offReferenceBp, complete }: WalkRow) => ({
-    label,
-    bp,
-    offReferenceBp,
-    complete,
-  })
-  const ours = walkRowsOf(walkRowRuns(split, region)!)
-  const graph = loadGraph(split, 'cut')
-  const theirs = walkRows({ ...graph, referencePath: 'GRCh38#0#chr1' }, region)!
-  expect(ours.rows.map(fields)).toEqual(theirs.rows.map(fields))
-  expect(fields(ours.reference)).toEqual(fields(theirs.reference))
-  expect(ours.rows.map(r => r.label)).toEqual(['A#1'])
-  expect(ours.rows[0]).toMatchObject({ bp: 1000, complete: true })
-})
-
-test("a gap's parts cross from the worker with their causes, as walkRows splits them", () => {
-  const S = [1, 2, 3, 4, 5, 6, 7].map(id => `S\t${id}\t*\tLN:i:1000`)
-  const L = [1, 2, 3, 4, 5, 6].map(id => `L\t${id}\t+\t${id + 1}\t+\t0M`)
-  const text = [
-    'H\tVN:Z:1.1',
-    ...S,
-    ...L,
-    'W\tGRCh38\t0\tchr1\t0\t7000\t>1>2>3>4>5>6>7\tws:Z:end\twe:Z:end',
-    'W\tA\t1\ta\t0\t3000\t>1>2>3\tws:Z:end\twe:Z:break,bp=600,trimmed=400',
-    'W\tA\t1\ta\t4000\t7000\t>5>6>7\tws:Z:break,bp=600\twe:Z:end',
-    'W\tB\t1\tb\t0\t3000\t<7<6<5\tws:Z:end\twe:Z:elsewhere,chunk=GRCh38#0#chr1:20316160',
-    'W\tB\t1\tb\t4000\t7000\t<3<2<1\tws:Z:break,bp=300\twe:Z:end',
-  ].join('\n')
-  const region = { start: 1000, end: 6000 }
-  const gaps = (rows: WalkRow[]) =>
-    rows.map(r => [
-      r.label,
-      r.runs
-        .filter(run => run.gap)
-        .map(({ bp, cause, chunk }) => ({ bp, cause, chunk })),
-    ])
-  const ours = walkRowsOf(walkRowRuns(gfaTables(text)!, region)!).rows
-  const graph = loadGraph(text, 'cut', { referencePath: 'GRCh38#0#chr1' })
-  expect(gaps(ours)).toEqual(gaps(walkRows(graph, region)!.rows))
-  const chunk = { refName: 'GRCh38#0#chr1', start: 20316160 }
-  expect(Object.fromEntries(gaps(ours))).toEqual({
-    'A#1': [
-      { bp: 400, cause: undefined, chunk: undefined },
-      { bp: 600, cause: 'missing', chunk: undefined },
-    ],
-    'B#1': [
-      { bp: 300, cause: 'missing', chunk: undefined },
-      { bp: 700, cause: 'elsewhere', chunk },
-    ],
-  })
-})