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"]);
}
}