ebiotic 0.0.26

A Rust crate for interacting with common bioinformatics web services.
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
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
133
134
135
136

use super::{AccessionIds, AvailableReturnFormats, DataReturnFormats, EBI_DBFETCH_ENDPOINT};
use crate::core::{self, EbioticClient, EbioticHttpClient, Service};
use crate::errors::EbioticError;
use bio::io::fasta::Record;
use std::fmt::{Display, Formatter};

pub mod dbfetchdbs;

/// The `Dbfetch` struct is used to specify the parameters for the `Dbfetch` service.
#[derive(Debug, Clone)]
pub struct Dbfetch {
    pub(crate) client: EbioticClient,
    db: dbfetchdbs::DbfetchDbs,
    return_format: DataReturnFormats,
    style: DbfetchStyle,
}

#[derive(Debug, Clone)]
pub struct DbfetchResult {
    data: String,
}

/// The `DbfetchStyle` enum is used to specify the style of the return data from the `Dbfetch` service.
#[derive(Debug, Clone)]
pub enum DbfetchStyle {
    Raw,
    Html,
}

impl Display for DbfetchStyle {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            DbfetchStyle::Raw => write!(f, "raw"),
            DbfetchStyle::Html => write!(f, "html"),
        }
    }
}

impl Default for Dbfetch {
    fn default() -> Self {
        Dbfetch {
            client: EbioticClient::default(),
            db: dbfetchdbs::DbfetchDbs::EnaSequence,
            return_format: DataReturnFormats::Fasta,
            style: DbfetchStyle::Raw,
        }
    }
}

impl DbfetchResult {
    fn new(data: String) -> DbfetchResult {
        DbfetchResult { data }
    }

    /// Convert the results of a `Dbfetch` service into a `Vec<Record>`.
    pub fn into_records(self) -> Result<Vec<Record>, EbioticError> {
        core::parse_fa_from_bufread(&self.data)
    }

    /// Get the raw data from the `Dbfetch` service. This is useful if you want to handle the data yourself.
    pub fn data(self) -> String {
        self.data
    }
}

impl Dbfetch {
    pub fn new(
        client: EbioticClient,
        db: dbfetchdbs::DbfetchDbs,
        return_format: DataReturnFormats,
        style: DbfetchStyle,
    ) -> Dbfetch {
        Dbfetch {
            client,
            db,
            return_format,
            style,
        }
    }

    pub fn set_db(&mut self, db: dbfetchdbs::DbfetchDbs) {
        self.db = db;
    }

    pub fn set_return_format(&mut self, format: DataReturnFormats) {
        self.return_format = format;
    }

    pub fn set_style(&mut self, style: DbfetchStyle) {
        self.style = style;
    }

    pub fn db(&self) -> &dbfetchdbs::DbfetchDbs {
        &self.db
    }

    pub fn format(&self) -> &DataReturnFormats {
        &self.return_format
    }

    pub fn style(&self) -> &DbfetchStyle {
        &self.style
    }
}

impl Service for Dbfetch {
    type ResultType = DbfetchResult;
    type InputType = AccessionIds;

    /// Run the `Dbfetch` service with a list of IDs.
    async fn run(&self, input: Self::InputType) -> Result<Self::ResultType, EbioticError> {
        if !self
            .db
            .available_return_formats()
            .iter()
            .any(|x| x == &self.return_format)
        {
            return Err(EbioticError::ReturnFormatNotAvailable(
                self.return_format.to_string(),
                self.db.to_string(),
            ));
        }

        log::info!("Submitting DBfetch request");

        let res = self
            .client
            .get(&format!(
                "{}?db={}&format={}&style={}&id={}",
                EBI_DBFETCH_ENDPOINT, self.db, self.return_format, self.style, input
            ))
            .await?;

        Ok(DbfetchResult::new(res))
    }
}