sdust 0.1.0

Implementation of symmetric DUST algorithm, with optional CLI
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

use clap::Parser;
use needletail::Sequence;
use std::io::Write;

use sdust::symmetric_dust;

const DUSTMASKER_LINE_LEN: usize = 60;

#[derive(Copy, Clone, Debug, Eq, PartialEq, clap::ArgEnum)]
enum OutputFormat {
    /// Masked bases are lowercased
    Soft,
    /// Masked bases are replaced with Ns
    Hard,
}

impl Default for OutputFormat {
    fn default() -> Self {
        Self::Soft
    }
}

/// SDustMasker takes its input as a FASTA formatted file containing one
/// or more nucleotide sequences. It then identifies and masks out the
/// low complexity parts of the input sequences.
#[derive(Parser, Debug)]
#[clap(author, version, about, long_about = None)]
struct Args {
    /// Input file. Use `-` for stdin
    #[clap(short, long)]
    input: String,
    /// Output file. Use `-` for stdout
    #[clap(short, long)]
    output: String,
    #[clap(short, long, arg_enum)]
    out_format: OutputFormat,
}

fn main() {
    let args = Args::parse();
    let mut fastx_reader = if args.input == "-" {
        needletail::parse_fastx_stdin().expect("Impossible to read from stdin")
    } else {
        needletail::parse_fastx_file(&args.input).expect("Impossible to open file")
    };

    let mut out_file = std::io::BufWriter::new(
        std::fs::File::create(args.output).expect("Impossible to create file"),
    );
    let mut past_first_record = false;
    while let Some(record) = fastx_reader.next() {
        let seqrec = record.unwrap();
        if past_first_record {
            out_file.write_all(b"\n").expect("write to disk");
        } else {
            past_first_record = true;
        }
        out_file.write_all(b">").expect("write to disk");
        out_file.write_all(seqrec.id()).expect("write to disk");
        out_file.write_all(b"\n").expect("write to disk");
        let norm_seq = seqrec.normalize(false);

        let mut intervals = symmetric_dust(&norm_seq);
        intervals.reverse();

        if intervals.is_empty() {
            out_file
                .write_all(seqrec.sequence())
                .expect("write to disk");
        } else {
            let mut current = intervals.pop();
            for (i, b) in norm_seq.iter().enumerate() {
                if i != 0 && i % DUSTMASKER_LINE_LEN == 0 {
                    out_file.write_all(&[b'\n']).expect("write to disk");
                }
                let mut mask = false;
                if let Some(curr) = &current {
                    if i > curr.end {
                        current = intervals.pop();
                    } else if curr.contains(&i) {
                        mask = true;
                    }
                }

                match (args.out_format, mask, b) {
                    (OutputFormat::Soft, true, b'A') => out_file.write_all(&[b'a']),
                    (OutputFormat::Soft, true, b'T') => out_file.write_all(&[b't']),
                    (OutputFormat::Soft, true, b'C') => out_file.write_all(&[b'c']),
                    (OutputFormat::Soft, true, b'G') => out_file.write_all(&[b'g']),
                    (OutputFormat::Hard, true, _) => out_file.write_all(&[b'N']),
                    (_, _, _) => out_file.write_all(&[*b]),
                }
                .expect("write to disk");
            }
        }
    }
    out_file.write_all(&[b'\n']).expect("write to disk");
}