bsxplorer2 0.2.3

A high-performance library for bisulfite sequencing data analysis and DNA methylation research
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use itertools::Itertools;
use polars::error::PolarsResult;

use super::BsxFileReader;
use crate::data_structs::batch::{
    merge_replicates,
    AggMethod,
    BsxBatch,
};

pub struct MultiBsxFileReader {
    readers: Vec<BsxFileReader>,
}

impl MultiBsxFileReader {
    pub fn n_readers(&self) -> usize {
        self.readers.len()
    }

    pub fn validate(
        &mut self,
        deep: bool,
    ) -> anyhow::Result<()> {
        if self
            .readers
            .iter()
            .map(BsxFileReader::blocks_total)
            .unique()
            .count()
            > 1
        {
            anyhow::bail!("BSX files have different block counts")
        }
        let mut iterators = self.readers.iter_mut().map(|r| r.iter()).collect_vec();
        let mut batch_count = 0;

        while let Some(batches) = iterators
            .iter_mut()
            .map(|i| i.next())
            .collect::<Option<PolarsResult<Vec<_>>>>()
            .transpose()?
        {
            if !batches.iter().map(|b| b.as_contig()).all_equal() {
                anyhow::bail!(
                    "BSX files have different contig lengths (batch {})",
                    batch_count
                )
            }

            if deep
                && !batches
                    .iter()
                    .map(|b| b.position().to_vec_null_aware().unwrap_left())
                    .all_equal()
            {
                anyhow::bail!(
                    "BSX files have different positions (batch {})",
                    batch_count
                )
            }

            batch_count += 1;
        }

        Ok(())
    }

    pub fn get_batch(
        &mut self,
        batch_idx: usize,
    ) -> Option<Vec<PolarsResult<BsxBatch>>> {
        self.readers
            .iter_mut()
            .map(|r| r.get_batch(batch_idx))
            .collect::<Option<Vec<_>>>()
    }

    pub fn get_batch_merged(
        &mut self,
        batch_idx: usize,
        count_agg: AggMethod,
        density_agg: AggMethod,
    ) -> Option<PolarsResult<BsxBatch>> {
        let batches = match self
            .get_batch(batch_idx)?
            .into_iter()
            .collect::<PolarsResult<Vec<_>>>()
        {
            Ok(batches) => batches,
            Err(e) => return Some(Err(e)),
        };
        Some(merge_replicates(
            batches,
            count_agg.get_expr(),
            density_agg.get_expr(),
        ))
    }

    pub fn blocks_total(&self) -> usize {
        self.readers.first().unwrap().blocks_total()
    }

    pub fn iter(&mut self) -> MultiBsxIterator<'_> {
        MultiBsxIterator {
            inner: self
                .readers
                .iter_mut()
                .map(|r| {
                    Box::new(r.iter())
                        as Box<dyn Iterator<Item = PolarsResult<BsxBatch>> + '_>
                })
                .collect_vec(),
        }
    }

    pub fn iter_merged(
        &mut self,
        count_agg: AggMethod,
        density_agg: AggMethod,
    ) -> impl Iterator<Item = PolarsResult<BsxBatch>> + '_ {
        self.iter().map(move |batches| -> PolarsResult<BsxBatch> {
            merge_replicates(batches?, count_agg.get_expr(), density_agg.get_expr())
        })
    }
}

impl FromIterator<BsxFileReader> for MultiBsxFileReader {
    fn from_iter<I: IntoIterator<Item = BsxFileReader>>(iter: I) -> Self {
        let readers = iter.into_iter().collect_vec();
        assert!(!readers.is_empty(), "No readers provided");
        MultiBsxFileReader { readers }
    }
}

pub struct MultiBsxIterator<'a> {
    inner: Vec<Box<dyn Iterator<Item = PolarsResult<BsxBatch>> + 'a>>,
}

impl Iterator for MultiBsxIterator<'_> {
    type Item = PolarsResult<Vec<BsxBatch>>;

    fn next(&mut self) -> Option<Self::Item> {
        self.inner.iter_mut().map(|r| r.next()).collect()
    }
}