gecco 0.5.3

Gene Cluster prediction with Conditional Random Fields
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

//! InterPro metadata for domain annotations.

use std::collections::HashMap;

use serde::{Deserialize, Serialize};

/// A single Gene Ontology term.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct GOTerm {
    pub accession: String,
    pub name: String,
    #[serde(default)]
    pub namespace: String,
}

/// A single entry in the InterPro database.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InterProEntry {
    pub accession: String,
    pub members: Vec<String>,
    pub name: String,
    pub databases: Vec<String>,
    #[serde(rename = "type")]
    pub entry_type: String,
    pub go_terms: Vec<GOTerm>,
    pub go_functions: Vec<GOFunctionRef>,
}

/// GO function reference (without namespace, added at load time).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GOFunctionRef {
    pub accession: String,
    pub name: String,
}

/// A subset of the InterPro database.
pub struct InterPro {
    pub entries: Vec<InterProEntry>,
    /// Maps member accessions → InterPro entry index.
    pub by_accession: HashMap<String, usize>,
}

impl InterPro {
    /// Load InterPro metadata from a JSON byte slice.
    pub fn from_json(data: &[u8]) -> anyhow::Result<Self> {
        let entries: Vec<InterProEntry> = serde_json::from_slice(data)?;
        let mut by_accession = HashMap::new();
        for (idx, entry) in entries.iter().enumerate() {
            for member in &entry.members {
                by_accession.insert(member.clone(), idx);
            }
        }
        Ok(Self {
            entries,
            by_accession,
        })
    }

    /// Look up an entry by member domain accession.
    pub fn get(&self, accession: &str) -> Option<&InterProEntry> {
        self.by_accession
            .get(accession)
            .map(|&idx| &self.entries[idx])
    }

    /// Get GO terms for a domain accession.
    pub fn go_terms_for(&self, accession: &str) -> Vec<GOTerm> {
        match self.get(accession) {
            Some(entry) => entry.go_terms.clone(),
            None => Vec::new(),
        }
    }

    /// Get GO functions for a domain accession (with namespace filled in).
    pub fn go_functions_for(&self, accession: &str) -> Vec<GOTerm> {
        match self.get(accession) {
            Some(entry) => entry
                .go_functions
                .iter()
                .map(|gf| GOTerm {
                    accession: gf.accession.clone(),
                    name: gf.name.clone(),
                    namespace: "molecular_function".to_string(),
                })
                .collect(),
            None => Vec::new(),
        }
    }
}