Skip to main content

rsomics_composition/
metadata.rs

1use std::collections::{HashMap, HashSet};
2use std::io::Read;
3
4use crate::{CompositionError, DelimitedFormat, LabeledMatrix, Result};
5
6#[derive(Clone, Debug, PartialEq, Eq)]
7pub struct Grouping {
8    assignments: HashMap<String, String>,
9}
10
11impl Grouping {
12    pub fn new(assignments: impl IntoIterator<Item = (String, String)>) -> Result<Self> {
13        let mut checked = HashMap::new();
14        for (sample, group) in assignments {
15            if sample.is_empty() {
16                return Err(CompositionError::EmptyIdentity { kind: "sample" });
17            }
18            if group.is_empty() {
19                return Err(CompositionError::EmptyGroup(sample));
20            }
21            if checked.insert(sample.clone(), group).is_some() {
22                return Err(CompositionError::DuplicateMetadataSample(sample));
23            }
24        }
25        Ok(Self {
26            assignments: checked,
27        })
28    }
29
30    pub fn read(reader: impl Read, format: DelimitedFormat, group_column: &str) -> Result<Self> {
31        let mut parser = csv::ReaderBuilder::new()
32            .delimiter(format.delimiter())
33            .has_headers(true)
34            .flexible(false)
35            .from_reader(reader);
36        let header = parser
37            .headers()
38            .map_err(|error| CompositionError::Delimited(error.to_string()))?
39            .clone();
40        let group_index = header
41            .iter()
42            .position(|field| field == group_column)
43            .ok_or_else(|| CompositionError::UnknownMetadataColumn(group_column.to_owned()))?;
44        if group_index == 0 || header.get(0).is_none_or(str::is_empty) {
45            return Err(CompositionError::InvalidHeader);
46        }
47        let mut assignments = Vec::new();
48        for record in parser.records() {
49            let record = record.map_err(|error| CompositionError::Delimited(error.to_string()))?;
50            assignments.push((
51                record.get(0).unwrap_or_default().to_owned(),
52                record.get(group_index).unwrap_or_default().to_owned(),
53            ));
54        }
55        Self::new(assignments)
56    }
57
58    pub fn align(&self, matrix: &LabeledMatrix) -> Result<Vec<String>> {
59        let samples: HashSet<&str> = matrix.samples().iter().map(String::as_str).collect();
60        for sample in self.assignments.keys() {
61            if !samples.contains(sample.as_str()) {
62                return Err(CompositionError::UnusedMetadataSample(sample.clone()));
63            }
64        }
65        matrix
66            .samples()
67            .iter()
68            .map(|sample| {
69                self.assignments
70                    .get(sample)
71                    .cloned()
72                    .ok_or_else(|| CompositionError::MissingMetadataSample(sample.clone()))
73            })
74            .collect()
75    }
76}
77
78#[cfg(test)]
79mod tests {
80    use super::*;
81
82    fn table() -> LabeledMatrix {
83        LabeledMatrix::new(
84            vec!["s1".into(), "s2".into()],
85            vec!["a".into()],
86            vec![1.0, 2.0],
87        )
88        .unwrap()
89    }
90
91    #[test]
92    fn aligns_by_identity_not_row_order() {
93        let grouping = Grouping::new(vec![
94            ("s2".into(), "case".into()),
95            ("s1".into(), "control".into()),
96        ])
97        .unwrap();
98        assert_eq!(grouping.align(&table()).unwrap(), ["control", "case"]);
99    }
100
101    #[test]
102    fn missing_and_unused_rows_fail() {
103        let missing = Grouping::new(vec![("s1".into(), "a".into())]).unwrap();
104        assert!(matches!(
105            missing.align(&table()),
106            Err(CompositionError::MissingMetadataSample(_))
107        ));
108        let unused = Grouping::new(vec![
109            ("s1".into(), "a".into()),
110            ("s2".into(), "b".into()),
111            ("s3".into(), "c".into()),
112        ])
113        .unwrap();
114        assert!(matches!(
115            unused.align(&table()),
116            Err(CompositionError::UnusedMetadataSample(_))
117        ));
118    }
119
120    #[test]
121    fn reads_named_metadata_column() {
122        let source = "sample\tbatch\tgroup\ns2\tb2\tcase\ns1\tb1\tcontrol\n";
123        let grouping = Grouping::read(source.as_bytes(), DelimitedFormat::Tsv, "group").unwrap();
124        assert_eq!(grouping.align(&table()).unwrap(), ["control", "case"]);
125    }
126}