bascet 0.4.0

Bascet is a tool to preprocess single-cell data, handling barcode detection, trimming, QC, and managing the execution of custom tools for each cell
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


use std::path::PathBuf;
use std::env;

use crate::mapcell::CompressionMode;
use crate::mapcell::MissingFileMode;
use crate::mapcell::MapCellFunction;

use crate::kmer::kmc_counter::KmerCounter;


#[derive(Clone, Debug)] 
pub struct MapCellCountSketchFQ {
}
impl MapCellFunction for MapCellCountSketchFQ {

    fn invoke(
        &self,
        input_dir: &PathBuf,
        output_dir: &PathBuf,
        _num_threads: usize
    ) -> anyhow::Result<(bool, String)> {

        //Define files
        let input_file_r1 = input_dir.join("r1.fq"); 
        let input_file_r2 = input_dir.join("r2.fq"); 
        let output_file = output_dir.join("countsketch.txt");

        //Parse parameters
        let kmer_size: usize = get_param_num("KMER_SIZE").unwrap_or(31);
        let sketch_size = get_param_num("SKETCH_SIZE").unwrap_or(100);
        let max_reads = get_param_num("MAX_READS").unwrap_or(100000000);

        log::debug!("Chosen KMER size: {}", kmer_size);
        log::debug!("Chosen sketch size: {}", sketch_size);
        log::debug!("Chosen max reads: {}", max_reads);

/*         println!("Chosen KMER size: {}", kmer_size);
        println!("Chosen sketch size: {}", sketch_size);
        println!("Chosen max reads: {}", max_reads); */

        //Example: novaseq cell of 8M reads - this took quite some time with this function
        let mut sketch = KmerCounter::get_countsketch_fq(
            input_file_r1,
            input_file_r2,
            kmer_size,
            sketch_size,
            max_reads
        ).expect("Could not get countsketch");

        KmerCounter::store_countsketch_seq(
            kmer_size,
            &mut sketch,
            &output_file
        );
            
        Ok((true, String::from("")))
    }  

    fn get_missing_file_mode(&self) -> MissingFileMode {
        MissingFileMode::Skip
    }

    fn get_compression_mode(&self, _fname: &str) -> CompressionMode {
        CompressionMode::Default
    }

    fn get_expect_files(&self) -> Vec<String> {
        let mut expect = Vec::new();
        expect.push("r1.fq".to_string()); 
        expect.push("r2.fq".to_string()); 
        expect
    }


    fn get_recommend_threads(&self) -> usize {
        1
    }

    fn preflight_check(&self) -> bool {
        // KMER_SIZE must be set
        //get_param_kmer_size().is_some()
        true
    }
}



fn get_param_num(key: &str) -> Option<usize> {
    let val = env::var(key);
    if let Ok(val) = val {
        let num = val.parse::<usize>();
        if let Ok(num) = num {
            Some(num)
        } else {
            panic!("Expected a number for parameter {}, but got {}", key, val);
        }
    } else {
        None
    }
}