GetPDB 1.0.1

Download Protein files from rcsb.org
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

use std::io;

#[derive(Debug)]
pub enum UriType {
    Fasta,
    Pdb,
    PdbGz,
    Cif,
    CifGz,
    Xml,
    XmlGz,
}

#[derive(Debug)]
pub enum Server {
    PDBE,
    RCSB,
}

impl Server {
    pub fn get_server(s: &str) -> Result<Server, io::Error> {
        match s.to_uppercase().as_ref() {
            "RCSB" => Ok(Server::RCSB),
            "PDBE" => Ok(Server::PDBE),
            _ => Err(io::Error::new(
                io::ErrorKind::InvalidInput,
                format!(
                    "[Error] '{}' is not an accepted server. Use -h to see available severs",
                    s
                ),
            )),
        }
    }
}

impl UriType {
    pub fn get_type(t: &str) -> Result<UriType, io::Error> {
        let t = String::from(t);
        match t.to_uppercase().as_ref() {
            "FASTA" => Ok(UriType::Fasta),
            "PDB" => Ok(UriType::Pdb),
            "PDBGZ" => Ok(UriType::PdbGz),
            "CIF" => Ok(UriType::Cif),
            "CIFGZ" => Ok(UriType::CifGz),
            "XMLGZ" => Ok(UriType::XmlGz),
            "XML" => Ok(UriType::Xml),
            _ => Err(io::Error::new(
                io::ErrorKind::InvalidInput,
                format!(
                    "[Error] '{}' is not an accepted format. Use -h to see available types",
                    t
                ),
            )),
        }
    }

    pub fn generate_uri(&self, id: &str, server: &Server) -> Result<String, io::Error> {
        match server {
            Server::RCSB =>
                match self {
                    UriType::Fasta => Ok(format!("https://www.rcsb.org/pdb/download/downloadFastaFiles.do?structureIdList={}&compressionType=uncompressed", id)),
                    UriType::Pdb => Ok(format!("https://files.rcsb.org/download/{}.pdb", id)),
                    UriType::PdbGz => Ok(format!("https://files.rcsb.org/download/{}.pdb.gz", id)),
                    UriType::Cif => Ok(format!("https://files.rcsb.org/download/{}.cif", id)),
                    UriType::CifGz => Ok(format!("https://files.rcsb.org/download/{}.cif.gz", id)),
                    UriType::XmlGz => Ok(format!("https://files.rcsb.org/download/{}.xml.gz", id)),
                    _ => Err(
                        io::Error::new(
                            io::ErrorKind::InvalidData,
                            format!(
                                "[Error] '{:?}' format is not supported on {:?} server",
                                self,
                                server
                            )
                        )
                    ),
                },
            Server::PDBE =>
                match self {
                    UriType::Fasta => Ok(format!("http://www.ebi.ac.uk/pdbe/entry/pdb/{}/fasta", id)),
                    UriType::Pdb => Ok(format!("http://www.ebi.ac.uk/pdbe/entry-files/download/pdb{}.ent", id)),
                    UriType::PdbGz => Ok(format!("http://ftp.ebi.ac.uk/pub/databases/rcsb/pdb-remediated/data/structures/divided/pdb/ci/pdb{}.ent.gz", id)),
                    UriType::Cif => Ok(format!("http://www.ebi.ac.uk/pdbe/entry-files/download/{}_updated.cif", id)),
                    UriType::Xml => Ok(format!("https://www.ebi.ac.uk/pdbe/entry-files/download/{}_validation.xml", id)),
                    _ => Err(
                        io::Error::new(
                            io::ErrorKind::InvalidData,
                            format!(
                                "[Error] '{:?}' format is not supported on {:?} server",
                                self,
                                server
                            )
                        )
                    ),
                },
        }
    }

    pub fn get_extension(&self) -> &str {
        match self {
            UriType::Fasta => ".fasta",
            UriType::Pdb => ".pdb",
            UriType::Cif => ".cif",
            UriType::PdbGz => ".pdb.gz",
            UriType::CifGz => ".cif.gz",
            UriType::XmlGz => ".xml.gz",
            UriType::Xml => ".xml",
        }
    }
}