prodigal-rs 0.3.4

Prokaryotic gene prediction — Prodigal rewritten in Rust
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

/// Strand of a predicted gene.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Strand {
    Forward,
    Reverse,
}

impl std::fmt::Display for Strand {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Strand::Forward => write!(f, "+"),
            Strand::Reverse => write!(f, "-"),
        }
    }
}

/// Start codon type.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum StartCodon {
    ATG,
    GTG,
    TTG,
    Edge,
}

impl std::fmt::Display for StartCodon {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            StartCodon::ATG => write!(f, "ATG"),
            StartCodon::GTG => write!(f, "GTG"),
            StartCodon::TTG => write!(f, "TTG"),
            StartCodon::Edge => write!(f, "Edge"),
        }
    }
}

/// A single predicted gene.
#[derive(Debug, Clone)]
pub struct PredictedGene {
    /// 1-indexed start position in the input sequence.
    pub begin: usize,
    /// 1-indexed end position (inclusive).
    pub end: usize,
    /// Strand.
    pub strand: Strand,
    /// Start codon type.
    pub start_codon: StartCodon,
    /// Translation table used for this gene.
    pub translation_table: u8,
    /// Whether left/right ends are partial (run off sequence edges).
    pub partial: (bool, bool),
    /// RBS motif name (e.g. "AGGAG" or "None").
    pub rbs_motif: String,
    /// RBS spacer distance (e.g. "3-4bp" or "None").
    pub rbs_spacer: String,
    /// GC content of this gene.
    pub gc_content: f64,
    /// Confidence score (50.0 - 99.99).
    pub confidence: f64,
    /// Total score (coding + start).
    pub score: f64,
    /// Coding score.
    pub cscore: f64,
    /// Start score (rscore + uscore + tscore).
    pub sscore: f64,
    /// RBS score.
    pub rscore: f64,
    /// Upstream composition score.
    pub uscore: f64,
    /// Start codon type score.
    pub tscore: f64,
}

/// Configuration for gene prediction.
#[derive(Debug, Clone)]
pub struct ProdigalConfig {
    /// NCBI translation table (1-25, excluding 7,8,17-20). Default: 11.
    pub translation_table: u8,
    /// Do not allow genes to run off sequence edges.
    pub closed_ends: bool,
    /// Treat runs of N as masked regions.
    pub mask_n_runs: bool,
    /// Bypass Shine-Dalgarno trainer, force full motif scan.
    pub force_non_sd: bool,
}

impl Default for ProdigalConfig {
    fn default() -> Self {
        ProdigalConfig {
            translation_table: 11,
            closed_ends: false,
            mask_n_runs: false,
            force_non_sd: false,
        }
    }
}

/// Errors from gene prediction.
#[derive(Debug)]
pub enum ProdigalError {
    EmptySequence,
    SequenceTooShort { length: usize, min: usize },
    SequenceTooLong { length: usize, max: usize },
    InvalidTranslationTable(u8),
    Io(std::io::Error),
}

impl std::fmt::Display for ProdigalError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ProdigalError::EmptySequence => write!(f, "sequence is empty"),
            ProdigalError::SequenceTooShort { length, min } => {
                write!(f, "sequence too short ({length} bp, need >= {min} bp)")
            }
            ProdigalError::SequenceTooLong { length, max } => {
                write!(f, "sequence too long ({length} bp, max {max} bp)")
            }
            ProdigalError::InvalidTranslationTable(t) => {
                write!(f, "invalid translation table: {t}")
            }
            ProdigalError::Io(e) => write!(f, "I/O error: {e}"),
        }
    }
}

impl std::error::Error for ProdigalError {}

impl From<std::io::Error> for ProdigalError {
    fn from(e: std::io::Error) -> Self {
        ProdigalError::Io(e)
    }
}