huget 0.1.0

gProfiler for human genomics
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

use crate::readstruct::ReadAnnotate;
use crate::readstruct::ReadSNP;
use reqwest::blocking::get;
use scraper::{Html, Selector};
use std::error::Error;
use std::fs::File;
use std::io::{BufRead, BufReader};
use std::thread;

/*
Gaurav Sablok
codeprog@icloud.com
*/

#[tokio::main]
pub async fn annotateall(optionannot: &str, pathstring: &str) -> Result<String, Box<dyn Error>> {
    if optionannot == "yes" && pathstring != "" {
        let filesnpopen = File::open(pathstring).expect("file not present");
        let filesnpread = BufReader::new(filesnpopen);

        let mut opensnpstruct: Vec<ReadSNP> = Vec::new();

        for i in filesnpread.lines() {
            let line = i.expect("line not present");
            if !line.starts_with("#") {
                let linestore = line
                    .split("\t")
                    .map(|x| x.to_string())
                    .collect::<Vec<String>>();
                opensnpstruct.push(ReadSNP {
                    rsid: linestore[0].clone(),
                    chromosome: linestore[1].clone(),
                    position: linestore[2].clone(),
                    genotype: linestore[3].clone(),
                })
            }
        }

        let mut snpvec: Vec<(String, String)> = Vec::new();
        for i in opensnpstruct.iter() {
            let linestruct = format!("{}/{}", "https://www.ncbi.nlm.nih.gov/snp/", i.rsid);
            snpvec.push((i.rsid.clone(), linestruct));
        }

        let mut asyncvec: Vec<ReadAnnotate> = Vec::new();
        thread::spawn(move || {
            for i in snpvec.iter() {
                for j in opensnpstruct.iter() {
                    if i.0 == j.rsid {
                        let response = get(i.1.clone()).expect("string not found");
                        let document =
                            Html::parse_document(&response.text().expect("message not present"));
                        let snpselect = Selector::parse(".sect_heading").expect("method failed");
                        for element in document.select(&snpselect) {
                            let vector_1 = element
                                .text()
                                .collect::<Vec<_>>()
                                .join("-")
                                .replace(" ", "")
                                .replace("\n", "")
                                .replace("Genomecontext", "")
                                .replace("Selectflanklength", "")
                                .replace(":", "")
                                .replace("GenomicPlacements", "")
                                .replace("\"\"", "");
                            asyncvec.push(ReadAnnotate {
                                rsid: j.rsid.clone(),
                                chromosome: j.chromosome.clone(),
                                position: j.position.clone(),
                                genotype: j.genotype.clone(),
                                annotate: vector_1,
                            });
                        }
                    }
                }
            }
        });
    }
    Ok("path to the mapping string has been written".to_string())
}