ggetrs-info 0.1.0

ggetrs submodule for querying information about genes
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

use std::collections::HashMap;
use std::fmt;

use ggetrs_ensembl::types::LookupResponse;
use ggetrs_ncbi::types::NcbiResults;
use ggetrs_uniprot::UniprotInfoContainer;
use serde::{Deserialize, Serialize};

#[cfg(feature = "python")]
use pyo3::{
    types::{IntoPyDict, PyDict, PyDictMethods},
    {Bound, PyResult},
};

/// Container for `Info` which aggregates results from multiple databases
#[derive(Serialize, Deserialize, Debug)]
pub struct InfoContainer(pub HashMap<String, Info>);
impl fmt::Display for InfoContainer {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "{}",
            serde_json::to_string_pretty(&self).expect("cannot serialize")
        )
    }
}
#[cfg(feature = "python")]
impl<'py> IntoPyDict<'py> for InfoContainer {
    fn into_py_dict(self, py: pyo3::Python<'py>) -> PyResult<Bound<'py, PyDict>> {
        let map = PyDict::new(py);
        self.0.iter().for_each(|(k, v)| {
            map.set_item(k, v.clone().into_py_dict(py).unwrap())
                .unwrap();
        });
        Ok(map)
    }
}
impl InfoContainer {
    #[must_use]
    pub fn from_queries(
        ensembl: &LookupResponse,
        uniprot: &UniprotInfoContainer,
        ncbi: &NcbiResults,
    ) -> Self {
        let map = ncbi
            .0
            .keys()
            .filter_map(|k| {
                Info::from_queries(ensembl, uniprot, ncbi, k).map(|info| (k.to_string(), info))
            })
            .collect();
        Self(map)
    }
}

/// Container which aggregates query results from multiple databases
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct Info {
    ensembl_id: String,
    uniprot_id: String,
    ncbi_id: String,
    pdb_id: Option<String>,
    symbol: String,
    ensembl_description: String,
    uniprot_description: String,
    ncbi_description: String,
    species: String,
    assembly_name: String,
}
impl fmt::Display for Info {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "{}",
            serde_json::to_string_pretty(&self).expect("cannot serialize")
        )
    }
}
#[cfg(feature = "python")]
impl<'py> IntoPyDict<'py> for Info {
    fn into_py_dict(self, py: pyo3::Python<'py>) -> PyResult<Bound<'py, PyDict>> {
        let map = PyDict::new(py);
        map.set_item("ensembl_id", &self.ensembl_id).unwrap();
        map.set_item("uniprot_id", &self.uniprot_id).unwrap();
        map.set_item("ncbi_id", &self.ncbi_id).unwrap();
        map.set_item("symbol", &self.symbol).unwrap();
        map.set_item("pdb_id", &self.pdb_id).unwrap();
        map.set_item("ensembl_description", &self.ensembl_description)
            .unwrap();
        map.set_item("uniprot_description", &self.uniprot_description)
            .unwrap();
        map.set_item("ncbi_description", &self.ncbi_description)
            .unwrap();
        map.set_item("species", &self.species).unwrap();
        map.set_item("assembly_name", &self.assembly_name).unwrap();
        Ok(map)
    }
}
impl Info {
    #[must_use]
    pub fn from_queries(
        ensembl: &LookupResponse,
        uniprot: &UniprotInfoContainer,
        ncbi: &NcbiResults,
        key: &str,
    ) -> Option<Self> {
        let ensembl_result = ensembl.0.get(key)?.as_ref()?;
        let uniprot_result = uniprot.0.get(key)?;
        let ncbi_result = ncbi.0.get(key)?;
        let ensembl_id = ensembl_result.id.clone();
        let uniprot_id = uniprot_result.uniprot_id.clone();
        let ncbi_id = ncbi_result.gene_id.clone();
        let symbol = ncbi_result.symbol.clone();
        let ensembl_description = ensembl_result.description.clone();
        let uniprot_description = uniprot_result.uniprot_description.clone();
        let ncbi_description = ncbi_result.description.clone();
        let species = ensembl_result.species.clone();
        let assembly_name = ensembl_result.assembly_name.clone();
        let pdb_id = uniprot_result.pdb_id.clone();

        Some(Self {
            ensembl_id,
            uniprot_id,
            ncbi_id,
            pdb_id,
            symbol,
            ensembl_description,
            uniprot_description,
            ncbi_description,
            species,
            assembly_name,
        })
    }
}