nom-pdb 0.0.9

PDB parser implemented with nom
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

import os
import json

STANDARD_AA = ["ALA",
               "ARG",
               "ASN",
               "ASP",
               "CYS",
               "GLN",
               "GLU",
               "GLY",
               "HIS",
               "ILE",
               "LEU",
               "LYS",
               "MET",
               "PHE",
               "PRO",
               "SER",
               "THR",
               "TRP",
               "TYR",
               "VAL",
               "PYL",
               "SEC"]

MODRES = os.path.join(
    os.path.dirname(__file__), "modres.json")

MODRES_OUT = os.path.join(
    os.path.dirname(__file__), "modres.rs")

with open(MODRES) as f:
    modres = json.load(f)


enum_s = ""
std_s = ""
desc_s = ""
from_str_s = ""
for k, v in modres.items():
    if v[0] and v[0][0] == " ":
        # nucleotide
        continue
    if v[2] < 5:
        # threshold
        continue
    if not k[0].isalpha():
        continue

    uc = k
    tc = uc.title()
    [std, desc, n] = v

    if not std in STANDARD_AA:
        continue

    enum_s += "    " + tc + ",\n"
    std_s += "            Self::" + tc + " => "
    if std:
        std_s += f"Some(AminoAcid::{std.title()}),\n"
    else:
        std_s += "None,\n"
    desc_s += f'            Self::{tc} => "{desc}",\n'
    from_str_s += f'            "{uc}" => Ok(Self::{tc}),\n'


s = """use protein_core::types::AminoAcid;
use std::str::FromStr;
use serde::{Deserialize, Serialize};
"""

s += """#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize)]
pub enum NonstandardAminoAcid {""" + enum_s + "\n}"

s += """impl NonstandardAminoAcid {
    pub fn standard_res(&self) -> Option<AminoAcid> {
        match &self {""" + std_s + """\
        }
    }
    pub fn description(&self) -> &'static str {
        match &self {""" + desc_s + """\
        }
    }
}
"""

s += """impl FromStr for NonstandardAminoAcid {
    type Err = String;
    fn from_str(inp: & str) -> Result<Self,<Self as FromStr >::Err> {
        match inp {""" + from_str_s + """\
            _ => Err("not a known non-standard amino acid".to_owned()),
        }
    }
}
"""


with open(MODRES_OUT, "w") as f:
    f.write(s)