rsomics-composition 0.1.0

Compositional-data geometry, transforms, and differential abundance
Documentation
use std::collections::{HashMap, HashSet};
use std::io::Read;

use crate::{CompositionError, DelimitedFormat, LabeledMatrix, Result};

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Grouping {
    assignments: HashMap<String, String>,
}

impl Grouping {
    pub fn new(assignments: impl IntoIterator<Item = (String, String)>) -> Result<Self> {
        let mut checked = HashMap::new();
        for (sample, group) in assignments {
            if sample.is_empty() {
                return Err(CompositionError::EmptyIdentity { kind: "sample" });
            }
            if group.is_empty() {
                return Err(CompositionError::EmptyGroup(sample));
            }
            if checked.insert(sample.clone(), group).is_some() {
                return Err(CompositionError::DuplicateMetadataSample(sample));
            }
        }
        Ok(Self {
            assignments: checked,
        })
    }

    pub fn read(reader: impl Read, format: DelimitedFormat, group_column: &str) -> Result<Self> {
        let mut parser = csv::ReaderBuilder::new()
            .delimiter(format.delimiter())
            .has_headers(true)
            .flexible(false)
            .from_reader(reader);
        let header = parser
            .headers()
            .map_err(|error| CompositionError::Delimited(error.to_string()))?
            .clone();
        let group_index = header
            .iter()
            .position(|field| field == group_column)
            .ok_or_else(|| CompositionError::UnknownMetadataColumn(group_column.to_owned()))?;
        if group_index == 0 || header.get(0).is_none_or(str::is_empty) {
            return Err(CompositionError::InvalidHeader);
        }
        let mut assignments = Vec::new();
        for record in parser.records() {
            let record = record.map_err(|error| CompositionError::Delimited(error.to_string()))?;
            assignments.push((
                record.get(0).unwrap_or_default().to_owned(),
                record.get(group_index).unwrap_or_default().to_owned(),
            ));
        }
        Self::new(assignments)
    }

    pub fn align(&self, matrix: &LabeledMatrix) -> Result<Vec<String>> {
        let samples: HashSet<&str> = matrix.samples().iter().map(String::as_str).collect();
        for sample in self.assignments.keys() {
            if !samples.contains(sample.as_str()) {
                return Err(CompositionError::UnusedMetadataSample(sample.clone()));
            }
        }
        matrix
            .samples()
            .iter()
            .map(|sample| {
                self.assignments
                    .get(sample)
                    .cloned()
                    .ok_or_else(|| CompositionError::MissingMetadataSample(sample.clone()))
            })
            .collect()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn table() -> LabeledMatrix {
        LabeledMatrix::new(
            vec!["s1".into(), "s2".into()],
            vec!["a".into()],
            vec![1.0, 2.0],
        )
        .unwrap()
    }

    #[test]
    fn aligns_by_identity_not_row_order() {
        let grouping = Grouping::new(vec![
            ("s2".into(), "case".into()),
            ("s1".into(), "control".into()),
        ])
        .unwrap();
        assert_eq!(grouping.align(&table()).unwrap(), ["control", "case"]);
    }

    #[test]
    fn missing_and_unused_rows_fail() {
        let missing = Grouping::new(vec![("s1".into(), "a".into())]).unwrap();
        assert!(matches!(
            missing.align(&table()),
            Err(CompositionError::MissingMetadataSample(_))
        ));
        let unused = Grouping::new(vec![
            ("s1".into(), "a".into()),
            ("s2".into(), "b".into()),
            ("s3".into(), "c".into()),
        ])
        .unwrap();
        assert!(matches!(
            unused.align(&table()),
            Err(CompositionError::UnusedMetadataSample(_))
        ));
    }

    #[test]
    fn reads_named_metadata_column() {
        let source = "sample\tbatch\tgroup\ns2\tb2\tcase\ns1\tb1\tcontrol\n";
        let grouping = Grouping::read(source.as_bytes(), DelimitedFormat::Tsv, "group").unwrap();
        assert_eq!(grouping.align(&table()).unwrap(), ["control", "case"]);
    }
}