In bigwigaverageoverbed, when a chromosome is not in the bigwig, return 0

Author: jackh726

bigtools/src/utils/cli/bigwigaverageoverbed.rs

@@ -8,11 +8,11 @@ use crossbeam_channel::TryRecvError;
 
 use crate::bed::bedparser::{parse_bed, BedFileStream, StreamingBedValues};
 use crate::utils::file_view::FileView;
-use crate::utils::misc::{stats_for_bed_item, Name};
+use crate::utils::misc::{name_for_bed_item, stats_for_bed_item, BigWigAverageOverBedEntry, Name};
 use crate::utils::reopen::{Reopen, ReopenableFile};
 use crate::utils::split_file_into_chunks_by_size;
 use crate::utils::streaming_linereader::StreamingLineReader;
-use crate::{BBIFileRead, BigWigRead};
+use crate::{BBIFileRead, BBIReadError, BigWigRead};
 
 #[derive(Clone, Debug, PartialEq, Parser)]
 #[command(
@@ -129,8 +129,24 @@ pub fn bigwigaverageoverbed(
                     Some(Ok(entry)) => entry,
                 };
 
-                let entry = match stats_for_bed_item(name, chrom, entry, inbigwig) {
+                let name = match name_for_bed_item(name, chrom, &entry) {
+                    Ok(name) => name,
+                    Err(e) => {
+                        return Err(e.into());
+                    }
+                };
+
+                let entry = match stats_for_bed_item(chrom, entry, inbigwig) {
                     Ok(stats) => stats,
+                    Err(BBIReadError::InvalidChromosome(..)) => BigWigAverageOverBedEntry {
+                        bases: 0,
+                        max: 0.0,
+                        min: 0.0,
+                        mean: 0.0,
+                        mean0: 0.0,
+                        size: 0,
+                        sum: 0.0,
+                    },
                     Err(e) => {
                         return Err(e.into());
                     }
@@ -152,7 +168,7 @@ pub fn bigwigaverageoverbed(
                         entry.size, entry.bases, entry.sum, entry.mean0, entry.mean
                     ),
                 };
-                writeln!(&mut tmp, "{}\t{}", entry.name, stats)?
+                writeln!(&mut tmp, "{}\t{}", name, stats)?
             }
 
             Ok(tmp)
@@ -259,7 +275,14 @@ pub fn bigwigaverageoverbed(
                 )
             })??;
 
-            let entry = match stats_for_bed_item(name, chrom, entry, &mut inbigwig) {
+            let name = match name_for_bed_item(name, chrom, &entry) {
+                Ok(name) => name,
+                Err(e) => {
+                    return Err(e.into());
+                }
+            };
+
+            let entry = match stats_for_bed_item(chrom, entry, &mut inbigwig) {
                 Ok(stats) => stats,
                 Err(e) => return Err(e.into()),
             };
@@ -280,7 +303,7 @@ pub fn bigwigaverageoverbed(
                     entry.size, entry.bases, entry.sum, entry.mean0, entry.mean
                 ),
             };
-            writeln!(&mut bedoutwriter, "{}\t{}", entry.name, stats)?
+            writeln!(&mut bedoutwriter, "{}\t{}", name, stats)?
         }
     }
 

bigtools/src/utils/misc.rs

@@ -16,7 +16,6 @@ pub enum Name {
 }
 
 pub struct BigWigAverageOverBedEntry {
-    pub name: String,
     pub size: u32,
     pub bases: u32,
     pub sum: f64,
@@ -27,22 +26,44 @@ pub struct BigWigAverageOverBedEntry {
 }
 
 #[derive(Error, Debug)]
-pub enum StatsError {
-    #[error("{}", .0)]
-    BBIReadError(#[from] BBIReadError),
-    #[error("{}", .0)]
-    InvalidNameCol(String),
+#[error("{}", self.0)]
+pub struct InvalidNameColError(String);
+
+pub fn name_for_bed_item(
+    name: Name,
+    chrom: &str,
+    entry: &BedEntry,
+) -> Result<String, InvalidNameColError> {
+    let start = entry.start;
+    let end = entry.end;
+
+    Ok(match name {
+        Name::Column(col) => match col {
+            0 => chrom.to_string(),
+            1 => start.to_string(),
+            2 => end.to_string(),
+            _ => {
+                let mut cols = entry.rest.split('\t');
+                let v = cols.nth(col - 3);
+                match v {
+                        Some(v) => v.to_string(),
+                        None => return Err(InvalidNameColError(format!("Invalid name column option. Number of columns ({}) is less than the value specified ({}).", entry.rest.split('\t').collect::<Vec<_>>().len() + 3, col+1))),
+                    }
+            }
+        },
+        Name::Interval => format!("{}:{}-{}", chrom, start, end),
+        Name::None => format!("{}\t{}\t{}\t{}", chrom, start, end, entry.rest),
+    })
 }
 
 /// Returns a `BigWigAverageOverBedEntry` for a bigWig over a given interval.
 /// If there are no values for the given region, then `f64::NAN` is given for
 /// `mean`, `min`, and `max`, and `0` is given for `mean0`.
 pub fn stats_for_bed_item<R: BBIFileRead>(
-    name: Name,
     chrom: &str,
     entry: BedEntry,
     bigwig: &mut BigWigRead<R>,
-) -> Result<BigWigAverageOverBedEntry, StatsError> {
+) -> Result<BigWigAverageOverBedEntry, BBIReadError> {
     let start = entry.start;
     let end = entry.end;
 
@@ -73,26 +94,7 @@ pub fn stats_for_bed_item<R: BBIFileRead>(
         (sum / f64::from(bases), min, max)
     };
 
-    let name = match name {
-        Name::Column(col) => match col {
-            0 => chrom.to_string(),
-            1 => start.to_string(),
-            2 => end.to_string(),
-            _ => {
-                let mut cols = entry.rest.split('\t');
-                let v = cols.nth(col - 3);
-                match v {
-                        Some(v) => v.to_string(),
-                        None => return Err(StatsError::InvalidNameCol(format!("Invalid name column option. Number of columns ({}) is less than the value specified ({}).", entry.rest.split('\t').collect::<Vec<_>>().len() + 3, col+1))),
-                    }
-            }
-        },
-        Name::Interval => format!("{}:{}-{}", chrom, start, end),
-        Name::None => format!("{}\t{}\t{}\t{}", chrom, start, end, entry.rest),
-    };
-
     Ok(BigWigAverageOverBedEntry {
-        name,
         size,
         bases,
         sum,
@@ -106,21 +108,23 @@ pub fn stats_for_bed_item<R: BBIFileRead>(
 #[derive(Error, Debug)]
 pub enum BigWigAverageOverBedError {
     #[error("{}", .0)]
-    StatsError(#[from] StatsError),
+    BBIReadError(#[from] BBIReadError),
     #[error("{}", .0)]
     BedValueError(#[from] BedValueError),
+    #[error("{}", .0)]
+    InvalidNameColError(#[from] InvalidNameColError),
 }
 
 pub fn bigwig_average_over_bed<R: BBIFileRead>(
     bed: impl BufRead,
     mut bigwig: BigWigRead<R>,
     name: Name,
-) -> impl Iterator<Item = Result<BigWigAverageOverBedEntry, BigWigAverageOverBedError>> {
+) -> impl Iterator<Item = Result<(String, BigWigAverageOverBedEntry), BigWigAverageOverBedError>> {
     let mut bedstream = StreamingLineReader::new(bed);
 
     let mut error: bool = false;
     let iter = std::iter::from_fn(
-        move || -> Option<Result<BigWigAverageOverBedEntry, BigWigAverageOverBedError>> {
+        move || -> Option<Result<(String, BigWigAverageOverBedEntry), BigWigAverageOverBedError>> {
             if error {
                 return None;
             }
@@ -140,12 +144,19 @@ pub fn bigwig_average_over_bed<R: BBIFileRead>(
                 Some(Ok(v)) => v,
             };
 
-            match stats_for_bed_item(name, chrom, entry, &mut bigwig) {
+            let name = match name_for_bed_item(name, chrom, &entry) {
+                Ok(name) => name,
+                Err(e) => {
+                    return Some(Err(e.into()));
+                }
+            };
+
+            match stats_for_bed_item(chrom, entry, &mut bigwig) {
                 Err(e) => {
                     error = true;
                     Some(Err(e.into()))
                 }
-                Ok(v) => Some(Ok(v)),
+                Ok(v) => Some(Ok((name, v))),
             }
         },
     );

pybigtools/src/lib.rs

@@ -2256,7 +2256,8 @@ impl BigWigAverageOverBedStatistics {
 #[pyclass(module = "pybigtools")]
 struct BigWigAverageOverBedEntriesIterator {
     iter: Box<
-        dyn Iterator<Item = Result<BigWigAverageOverBedEntry, BigWigAverageOverBedError>> + Send,
+        dyn Iterator<Item = Result<(String, BigWigAverageOverBedEntry), BigWigAverageOverBedError>>
+            + Send,
     >,
     usename: bool,
     stats: Option<Vec<BigWigAverageOverBedStatistics>>,
@@ -2276,7 +2277,7 @@ impl BigWigAverageOverBedEntriesIterator {
             .transpose()
             .map_err(|e| PyErr::new::<exceptions::PyException, _>(format!("{}", e)))?;
 
-        let Some(v) = v else {
+        let Some((name, v)) = v else {
             return Ok(None);
         };
         let stats = match &slf.stats {
@@ -2319,7 +2320,7 @@ impl BigWigAverageOverBedEntriesIterator {
         };
 
         match slf.usename {
-            true => Ok(Some((v.name, stats).to_object(slf.py()))),
+            true => Ok(Some((name, stats).to_object(slf.py()))),
             false => Ok(Some(stats)),
         }
     }