Add more context to paired read errors in xleave

Author: willchet

CHANGELOG.md

@@ -13,7 +13,7 @@ is roughly based on [Keep a Changelog], and this project tries to adheres to
 
 ### Changed
 
-- Adds more context to paired read errors in `sampler`
+- Adds more context to paired read errors in `sampler` and `xleave`
 
 ## [0.9.0] - 2026-03-06
 

src/processes/standalone/xleave.rs

@@ -1,15 +1,11 @@
 //! Interleaves or de-interleaves paired FastQ or FASTA files.
 
 use crate::{
-    io::{
-        DispatchFastX, InputOptions, OutputOptions, RecordWriters, WriteFileZipStdout, WriteRecord, WriteRecords,
-        check_distinct_files,
-    },
+    io::{DispatchFastX, InputOptions, OutputOptions, RecordWriters, WriteRecords, check_distinct_files},
     utils::paired_reads::{DeinterleavedPairedReadsExt, ZipPairedReadsExt},
 };
 use clap::Args;
 use std::path::PathBuf;
-use zoe::data::records::HeaderReadable;
 
 #[derive(Args, Debug)]
 pub struct XleaveArgs {
@@ -46,61 +42,54 @@ pub fn xleave_process(args: XleaveArgs) -> Result<(), std::io::Error> {
         .use_file_zip_or_stdout()
         .open()?;
 
-    match (readers.reader1.dispatch(), readers.reader2.map(|x| x.dispatch())) {
-        (DispatchFastX::Fastq(reader), None) => match writer {
-            RecordWriters::SingleEnd(_) => {
-                return Err(std::io::Error::other(
-                    "One input and one output were provided. No interleaving or de-interleaving can occur.",
-                ));
-            }
-            RecordWriters::PairedEnd(_) => handle_single_input(reader, writer)?,
-        },
-        (DispatchFastX::Fastq(reader1), Some(DispatchFastX::Fastq(reader2))) => match writer {
-            RecordWriters::SingleEnd(_) => reader1.zip_paired_reads(reader2).write_records(writer)?,
-            RecordWriters::PairedEnd(_) => {
-                return Err(std::io::Error::other(
-                    "Two inputs and two outputs were provided. No interleaving or de-interleaving can occur.",
-                ));
-            }
-        },
-        (DispatchFastX::Fasta(reader), None) => match writer {
-            RecordWriters::SingleEnd(_) => {
+    let reader1 = readers.reader1;
+    let input_path1 = args.input_file1;
+
+    if let Some((reader2, input_path2)) = readers.reader2.zip(args.input_file2) {
+        let RecordWriters::SingleEnd(writer) = writer else {
+            return Err(std::io::Error::other(
+                "Two inputs and two outputs were provided. No interleaving or de-interleaving can occur.",
+            ));
+        };
+
+        match (reader1.dispatch(), reader2.dispatch()) {
+            (DispatchFastX::Fastq(reader1), DispatchFastX::Fastq(reader2)) => reader1
+                .zip_paired_reads(reader2)
+                .map(|res| res.map_err(|e| e.add_path_context(&input_path1, &input_path2)))
+                .write_records(writer)?,
+            (DispatchFastX::Fasta(reader1), DispatchFastX::Fasta(reader2)) => reader1
+                .zip_paired_reads(reader2)
+                .map(|res| res.map_err(|e| e.add_path_context(&input_path1, &input_path2)))
+                .write_records(writer)?,
+            (DispatchFastX::Fastq(_), DispatchFastX::Fasta(_)) => {
                 return Err(std::io::Error::other(
-                    "One input and one output were provided. No interleaving or de-interleaving can occur.",
+                    "Paired read inputs must be both FASTQ or both FASTA. Found FASTQ for first input and FASTA for second input.",
                 ));
             }
-            RecordWriters::PairedEnd(_) => handle_single_input(reader, writer)?,
-        },
-        (DispatchFastX::Fasta(reader1), Some(DispatchFastX::Fasta(reader2))) => match writer {
-            RecordWriters::SingleEnd(_) => reader1.zip_paired_reads(reader2).write_records(writer)?,
-            RecordWriters::PairedEnd(_) => {
+            (DispatchFastX::Fasta(_), DispatchFastX::Fastq(_)) => {
                 return Err(std::io::Error::other(
-                    "Two inputs and two outputs were provided. No interleaving or de-interleaving can occur.",
+                    "Paired read inputs must be both FASTQ or both FASTA. Found FASTA for first input and FASTQ for second input.",
                 ));
             }
-        },
-        (DispatchFastX::Fastq(_), Some(DispatchFastX::Fasta(_))) => {
-            return Err(std::io::Error::other(
-                "Paired read inputs must be both FASTQ or both FASTA. Found FASTQ for first input and FASTA for second input.",
-            ));
         }
-        (DispatchFastX::Fasta(_), Some(DispatchFastX::Fastq(_))) => {
+    } else {
+        let RecordWriters::PairedEnd(writer) = writer else {
             return Err(std::io::Error::other(
-                "Paired read inputs must be both FASTQ or both FASTA. Found FASTA for first input and FASTQ for second input.",
+                "One input and one output were provided. No interleaving or de-interleaving can occur.",
             ));
+        };
+
+        match reader1.dispatch() {
+            DispatchFastX::Fastq(reader) => reader
+                .deinterleave()
+                .map(|res| res.map_err(|e| e.add_path_context(&input_path1)))
+                .write_records(writer)?,
+            DispatchFastX::Fasta(reader) => reader
+                .deinterleave()
+                .map(|res| res.map_err(|e| e.add_path_context(&input_path1)))
+                .write_records(writer)?,
         }
     }
 
     Ok(())
 }
-
-fn handle_single_input<R1, A>(reader: R1, writer: RecordWriters<WriteFileZipStdout>) -> std::io::Result<()>
-where
-    R1: Iterator<Item = std::io::Result<A>>,
-    A: HeaderReadable + WriteRecord<WriteFileZipStdout>,
-    std::io::Result<A>: WriteRecord<WriteFileZipStdout>, {
-    match writer {
-        RecordWriters::SingleEnd(writer) => reader.write_records(writer),
-        RecordWriters::PairedEnd(writer) => reader.deinterleave().write_records(writer),
-    }
-}

src/utils/paired_reads.rs

@@ -177,6 +177,8 @@ where
     A: HeaderReadable,
 {
     /// Maps the error to include messages and context with the provided paths.
+    ///
+    /// It is assumed that IO errors already have path context included.
     pub fn add_path_context(self, path1: &Path, path2: &Path) -> std::io::Error {
         match self {
             ZipReadsError::IoError(e) => e,
@@ -199,6 +201,8 @@ where
     A: HeaderReadable,
 {
     /// Maps the error to include messages and context with the provided paths.
+    ///
+    /// It is assumed that IO errors already have path context included.
     pub fn add_path_context(self, path1: &Path, path2: &Path) -> std::io::Error {
         match self {
             ZipPairedReadsError::IoError(e) => e,
@@ -539,6 +543,96 @@ where
 {
 }
 
+/// The error type for [`DeinterleavedPairedReads`].
+#[derive(Debug)]
+pub enum DeinterleaveError<A> {
+    /// An IO error from the reader
+    IoError(std::io::Error),
+    /// A mismatch in the header IDs of the paired subsequent reads
+    MismatchedHeaders([A; 2]),
+    /// An odd number of reads in the iterator
+    OddNumberOfReads(A),
+}
+
+impl<A> From<std::io::Error> for DeinterleaveError<A> {
+    #[inline]
+    fn from(value: std::io::Error) -> Self {
+        Self::IoError(value)
+    }
+}
+
+impl<A: HeaderReadable> From<DeinterleaveError<A>> for std::io::Error {
+    #[inline]
+    fn from(value: DeinterleaveError<A>) -> Self {
+        match value {
+            DeinterleaveError::IoError(e) => e,
+            other => std::io::Error::other(other.to_string()),
+        }
+    }
+}
+
+impl<A: HeaderReadable> Display for DeinterleaveError<A> {
+    #[inline]
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            DeinterleaveError::IoError(e) => write!(f, "{e}"),
+            DeinterleaveError::MismatchedHeaders([r1, r2]) => write!(
+                f,
+                "Paired read IDs out of sync:\n\t{h1}\n\t{h2}\n",
+                h1 = r1.header(),
+                h2 = r2.header()
+            ),
+            DeinterleaveError::OddNumberOfReads(r1) => write!(
+                f,
+                "An odd number of reads was found while de-interleaving. See header: {header1}",
+                header1 = r1.header()
+            ),
+        }
+    }
+}
+
+impl<A: HeaderReadable + Debug> Error for DeinterleaveError<A> {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self {
+            DeinterleaveError::IoError(e) => e.source(),
+            _ => None,
+        }
+    }
+}
+
+impl<A: HeaderReadable> GetCode for DeinterleaveError<A> {
+    fn get_code(&self) -> i32 {
+        match self {
+            DeinterleaveError::IoError(e) => e.get_code(),
+            _ => 1,
+        }
+    }
+}
+
+impl<A> DeinterleaveError<A>
+where
+    A: HeaderReadable,
+{
+    /// Maps the error to include messages and context with the provided path.
+    ///
+    /// It is assumed that IO errors already have path context included.
+    pub fn add_path_context(self, path: &Path) -> std::io::Error {
+        match self {
+            DeinterleaveError::IoError(e) => e,
+            DeinterleaveError::MismatchedHeaders([r1, r2]) => std::io::Error::other(format!(
+                "Paired read IDs out of sync:\n| Header 1: {header1}\n| Header 2: {header2}",
+                header1 = r1.header(),
+                header2 = r2.header(),
+            ))
+            .with_file_context("Failed to deinterleave the reads in file", path)
+            .into(),
+            e @ DeinterleaveError::OddNumberOfReads(_) => std::io::Error::from(e)
+                .with_file_context("Failed to deinterleave the reads in file", path)
+                .into(),
+        }
+    }
+}
+
 pub struct DeinterleavedPairedReads<I, A>(I)
 where
     I: Iterator<Item = std::io::Result<A>>,
@@ -549,29 +643,21 @@ where
     I: Iterator<Item = std::io::Result<A>>,
     A: HeaderReadable,
 {
-    type Item = std::io::Result<[A; 2]>;
+    type Item = Result<[A; 2], DeinterleaveError<A>>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let read1 = unwrap_or_return_some_err!(self.0.next()?);
+        let read1 = unwrap_or_return_some_err!(self.0.next()?.map_err(DeinterleaveError::IoError));
+
         if let Some(read2) = self.0.next() {
-            let read2 = unwrap_or_return_some_err!(read2);
+            let read2 = unwrap_or_return_some_err!(read2.map_err(DeinterleaveError::IoError));
+
             if check_paired_headers(&read1, &read2).is_ok() {
                 Some(Ok([read1, read2]))
             } else {
-                Some(Err(IOError::new(
-                    ErrorKind::InvalidInput,
-                    format!(
-                        "Paired read IDs out of sync:\n\t{h1}\n\t{h2}\n",
-                        h1 = read1.header(),
-                        h2 = read2.header()
-                    ),
-                )))
+                Some(Err(DeinterleaveError::MismatchedHeaders([read1, read2])))
             }
         } else {
-            Some(Err(std::io::Error::other(format!(
-                "An odd number of reads was found while de-interleaving: {header1}",
-                header1 = read1.header()
-            ))))
+            Some(Err(DeinterleaveError::OddNumberOfReads(read1)))
         }
     }
 }