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

use itertools::Itertools;
use polars::prelude::*;

use super::{
    BsxBatch,
    BsxColumns as BsxCol,
};
use crate::data_structs::enums::{
    Context,
    Strand,
};

#[derive(Clone)]
pub struct LazyBsxBatch {
    data: LazyFrame,
}

impl From<BsxBatch> for LazyBsxBatch {
    fn from(batch: BsxBatch) -> Self {
        Self {
            data: batch.into_inner().lazy(),
        }
    }
}

impl LazyBsxBatch {
    pub fn collect(self) -> PolarsResult<BsxBatch> {
        let data = self
            .data
            .collect()?
            .select(BsxCol::schema().iter_names_cloned().collect_vec())?;
        Ok(unsafe { BsxBatch::new_unchecked(data) })
    }

    fn filter(
        self,
        predicate: Expr,
    ) -> Self {
        Self {
            data: self.data.filter(predicate),
        }
    }

    /// Filters positions less than the specified value.
    pub fn filter_pos_lt<N: Literal>(
        self,
        value: N,
    ) -> Self {
        self.filter(BsxCol::Position.col().lt(lit(value)))
    }

    /// Filters positions greater than the specified value.
    pub fn filter_pos_gt<N: Literal>(
        self,
        value: N,
    ) -> Self {
        self.filter(BsxCol::Position.col().gt(lit(value)))
    }

    /// Filters entries with coverage greater than the specified value.
    pub fn filter_coverage_gt<N: Literal>(
        self,
        value: N,
    ) -> Self {
        self.filter(BsxCol::CountTotal.col().gt(lit(value)))
    }

    /// Filters entries by strand value.
    pub fn filter_strand(
        self,
        value: Strand,
    ) -> Self {
        self.filter(match value {
            Strand::Forward | Strand::Reverse => {
                BsxCol::Strand
                    .col()
                    .eq(lit(Option::<bool>::from(value).unwrap()))
            },
            _ => BsxCol::Context.col().is_null(),
        })
    }

    /// Filters entries by context value.
    pub fn filter_context(
        self,
        value: Context,
    ) -> Self {
        self.filter(match value {
            Context::CG | Context::CHG => {
                BsxCol::Context
                    .col()
                    .eq(lit(Option::<bool>::from(value).unwrap()))
            },
            _ => BsxCol::Context.col().is_null(),
        })
    }
}