From 997f083dd0b659ca7fb499d20f1d4629a2a031f8 Mon Sep 17 00:00:00 2001 From: Seth Stadick Date: Fri, 30 Oct 2026 06:47:52 -0400 Subject: [PATCH] fix: annotate zero-depth positions with reference bases Fill reference bases after assembling all output positions so --keep-zeros emits consistent TSV columns, including on entirely uncovered contigs. Exercise serialized BAM and CRAM output in both coordinate modes, with and without zero retention. The keep-zeros cases reproduce the CSV error before this fix and pass afterward. Implemented with Amp; pending human review. Amp-Thread-ID: https://ampcode.com/threads/T-01a18c50-92d6-73c8-af62-326ba8f97fd3 Co-authored-by: Amp --- CHANGELOG.md | 1 + src/commands/base_depth.rs | 122 +++++++++++++++++++++++++++++++++---- 2 files changed, 112 insertions(+), 11 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 32143b3..b7b3f1e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,7 @@ ## Unreleased - Performance: reuse one indexed BAM/CRAM reader per worker thread in `base-depth` and both `only-depth` modes instead of reopening the input for every region ([#110](https://github.com/sstadick/perbase/issues/110)). +- Fix: populate `REF_BASE` for uncovered positions in `base-depth --keep-zeros` when a reference is supplied, avoiding inconsistent TSV column counts. ## 1.4.0 diff --git a/src/commands/base_depth.rs b/src/commands/base_depth.rs index 1187715..8302a71 100644 --- a/src/commands/base_depth.rs +++ b/src/commands/base_depth.rs @@ -268,16 +268,6 @@ impl RegionProcessor for BaseProcessor { self.min_base_quality_score, ) }; - // Add the ref base if reference is available - if let Some(buffer) = &self.ref_buffer { - let seq = buffer - .seq(&pos.ref_seq) - .expect("Fetched reference sequence"); - pos.ref_base = Some(char::from( - *seq.get(pos.pos as usize) - .expect("Input SAM does not match reference"), - )); - } if pileup_depth > (self.max_depth_warnings_cutoff) { pos.near_max_depth = true; } @@ -289,7 +279,7 @@ impl RegionProcessor for BaseProcessor { }) .collect(); - if self.keep_zeros { + let mut result = if self.keep_zeros { let mut new_result = vec![]; let name = PileupPosition::compact_refseq(&header, tid); let mut pos = start; @@ -309,7 +299,23 @@ impl RegionProcessor for BaseProcessor { new_result } else { result + }; + + // Annotate all output positions, including uncovered bases added above. + if let Some(buffer) = &self.ref_buffer + && let Some(first) = result.first() + { + let seq = buffer + .seq(&first.ref_seq) + .expect("Fetched reference sequence"); + for pos in &mut result { + pos.ref_base = Some(char::from( + *seq.get((pos.pos - self.coord_base) as usize) + .expect("Input SAM does not match reference"), + )); + } } + result }) } } @@ -326,6 +332,100 @@ mod tests { use std::{collections::HashMap, path::PathBuf}; use tempfile::{TempDir, tempdir}; + #[rstest] + fn reference_bases_in_output( + #[values("bam", "cram")] format: &str, + #[values(false, true)] zero_base: bool, + #[values(false, true)] keep_zeros: bool, + ) { + let dir = tempdir().unwrap(); + let reference = dir.path().join("reference.fa"); + std::fs::write(&reference, ">chr1\nACGTACGTAA\n>chr2\nTTGCAATGCC\n").unwrap(); + rust_htslib::faidx::build(&reference).unwrap(); + let mut header = bam::Header::new(); + for name in ["chr1", "chr2"] { + header.push_record( + bam::header::HeaderRecord::new(b"SQ") + .push_tag(b"SN", name) + .push_tag(b"LN", 10) + .push_tag(b"UR", reference.to_str().unwrap()), + ); + } + let reads = dir.path().join(format!("reads.{format}")); + let mut writer = bam::Writer::from_path( + &reads, + &header, + if format == "bam" { + bam::Format::Bam + } else { + bam::Format::Cram + }, + ) + .unwrap(); + writer.set_reference(&reference).unwrap(); + let view = bam::HeaderView::from_header(&header); + for pos in [3, 7] { + let record = Record::from_sam( + &view, + format!("read{pos}\t0\tchr1\t{pos}\t60\t2M\t*\t0\t0\tGT\tII").as_bytes(), + ) + .unwrap(); + writer.write(&record).unwrap(); + } + drop(writer); + bam::index::build(&reads, None, bam::index::Type::Bai, 1).unwrap(); + let output = dir.path().join("output.tsv"); + let mut args = vec![ + "base-depth", + reads.to_str().unwrap(), + "-r", + reference.to_str().unwrap(), + "-o", + output.to_str().unwrap(), + "-t", + "3", + "-c", + "3", + "-C", + "0.001", + ]; + if zero_base { + args.push("-z"); + } + if keep_zeros { + args.push("-k"); + } + BaseDepth::from_iter_safe(args).unwrap().run().unwrap(); + + let mut reader = csv::ReaderBuilder::new() + .delimiter(b'\t') + .from_path(output) + .unwrap(); + let headers = reader.headers().unwrap().clone(); + let ref_base = headers.iter().position(|h| h == "REF_BASE").unwrap(); + let depth = headers.iter().position(|h| h == "DEPTH").unwrap(); + let rows = reader + .records() + .collect::, _>>() + .unwrap(); + let mut expected = vec![]; + for (name, sequence) in [("chr1", "ACGTACGTAA"), ("chr2", "TTGCAATGCC")] { + for (pos, base) in sequence.chars().enumerate() { + let expected_depth = u32::from(name == "chr1" && [2, 3, 6, 7].contains(&pos)); + if keep_zeros || expected_depth > 0 { + expected.push((name, pos + usize::from(!zero_base), base, expected_depth)); + } + } + } + assert_eq!(rows.len(), expected.len()); + for (row, (name, pos, base, expected_depth)) in rows.iter().zip(expected) { + assert_eq!(&row[0], name); + assert_eq!(row[1].parse::().unwrap(), pos); + assert_eq!(&row[ref_base], base.to_string()); + assert_eq!(row[depth].parse::().unwrap(), expected_depth); + } + } + #[fixture] fn read_filter() -> DefaultReadFilter { DefaultReadFilter::new(0, 512, 0)