edlib_rs 0.1.0

A rust interface to the C++ edlib library
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

/// This file provides examples and tests similar to the file edaligner.cpp in  apps directory
/// of edlib. It loads simple fasta files of one sequence in directory test_data of edlib.
///

extern crate edlib_rs;
use edlib_rs::edlibrs::*;

use clap::{App, Arg};
use std::path::Path;
use std::process;
use log::*;

use ::cpu_time::ProcessTime;
use std::time::Duration;
/// example
/// edaligner --dirdata  "/Soft/edlib/test_data/Enterobacteria_phage_1.fasta"
///           --tf "Enterobacteria_phage_1.fasta"
///           --qf "mutated_60_perc.fasta"
fn main() {
    // initialize logger from env variable RUST_LOG
    env_logger::Builder::from_default_env().init();

    let dirdata : String;
    let qfile : String;
    let tfile : String;

    let matches = App::new("edaligner")
        .arg(Arg::with_name("dirdata")
            .long("dirdata")
            .required(true)
            .takes_value(true)
            .help("expection directory of data files"))
        .arg(Arg::with_name("qfile")
            .long("qf")
            .takes_value(true)
            .help("expection query file for seq"))
        .arg(Arg::with_name("tfile")
            .long("tf")
            .takes_value(true)
            .help("expection target file for seq"))
        .get_matches();

    // get data directory
    if matches.is_present("dirdata") {
        println!("dirdata");
        dirdata = matches.value_of("dirdata").ok_or("bad value").unwrap().parse::<String>().unwrap();
        println!("got dirdata , {}", dirdata);
    }
    else {
        println!("dirdata is mandatory");
        process::exit(1);
    }

    // get query file
    if matches.is_present("qfile") {
        qfile = matches.value_of("qfile").ok_or("bad value").unwrap().parse::<String>().unwrap();
        println!("got qfile , {}", qfile);
    }
    else {
        println!("query file is mandatory");
        process::exit(1);
    }

    // get target file
    if matches.is_present("tfile") {
        tfile = matches.value_of("tfile").ok_or("bad value").unwrap().parse::<String>().unwrap();
        println!("got target file , {}", tfile);
    }
    else {
        println!("target file is mandatory");
        process::exit(1);
    }

    let qfname = Path::new(&dirdata).join(qfile);
    info!(" got query file : {:?} ", qfname);
    let tfname = Path::new(&dirdata).join(tfile);
    info!(" got target file : {:?} ",tfname);
    // use logger
    let qseq : Vec<u8>;
    // get sequences
    let mut reader = needletail::parse_fastx_file(&qfname).expect("expecting valid query filename");
    if let Some(record) = reader.next() {
        let qrec = record.expect("invalid record");
        let n_bases = qrec.num_bases();
        println!(" query nb bases : {}", n_bases);
        qseq = qrec.seq().into_owned();
    } else {
        std::process::exit(1);
    } // end for query seq
    //
    let tseq: Vec<u8>;
    // get sequences
    let mut reader = needletail::parse_fastx_file(&tfname).expect("expecting valid target filename");
    if let Some(record) = reader.next() {
        let trec = record.expect("invalid record");
        let n_bases = trec.num_bases();
        println!(" target nb bases : {}", n_bases);
        tseq = trec.seq().into_owned();
    } else {
        std::process::exit(1);
    } // end for query seq
    let mut config = EdlibAlignConfigRs::default();
    let mut mod_str;
    //
    mod_str = "EDLIB_MODE_NW";
    config.mode = EdlibAlignModeRs::EDLIB_MODE_NW;
    let start = ProcessTime::try_now().unwrap();
    let align_res = edlibAlignRs(&qseq, &tseq, &config);
    assert_eq!(align_res.status, EDLIB_STATUS_OK);
    let cpu_time: Duration = start.try_elapsed().unwrap();
    println!("\n mode : {}, cpu time (ms) {} distance : {} ", mod_str , cpu_time.as_millis(), align_res.editDistance);
    //
    mod_str = "EDLIB_MODE_SHW";
    config.mode = EdlibAlignModeRs::EDLIB_MODE_SHW;
    let start = ProcessTime::try_now().unwrap();
    let align_res = edlibAlignRs(&qseq, &tseq, &config);
    assert_eq!(align_res.status, EDLIB_STATUS_OK);
    let cpu_time: Duration = start.try_elapsed().unwrap();
    println!("\n mode : {}, cpu time (ms) {} distance : {} ", mod_str , cpu_time.as_millis(), align_res.editDistance);
    //
    mod_str = "EDLIB_MODE_HW";
    config.mode = EdlibAlignModeRs::EDLIB_MODE_HW;
    let start = ProcessTime::try_now().unwrap();
    let align_res = edlibAlignRs(&qseq, &tseq, &config);
    assert_eq!(align_res.status, EDLIB_STATUS_OK);
    let cpu_time: Duration = start.try_elapsed().unwrap();
    println!("\n mode : {}, cpu time (ms) {} distance : {} ", mod_str , cpu_time.as_millis(), align_res.editDistance);




}