sail 0.1.1

Sequence Analysis IO Library
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use std::{
    fmt::Display,
    io::{BufRead, BufReader, BufWriter, Read, Write},
    path::Path,
};

use anyhow::{anyhow, bail, Context};
use indexmap::IndexMap;

pub const HEADER: &str = "# STOCKHOLM 1.0";

#[derive(Default)]
pub struct StockholmRecord {
    pub id: String,
    pub gf_meta: IndexMap<String, String>,
    pub gs_meta: IndexMap<String, String>,
    pub sequences: IndexMap<String, String>,
}

impl StockholmRecord {
    pub fn parse(lines: Vec<String>) -> anyhow::Result<Self> {
        let mut rec = Self::default();
        let mut lines = lines.iter().filter(|line| !line.is_empty());

        match lines.next() {
            Some(line) => {
                if !line.starts_with("# STOCKHOLM") {
                    bail!("buffer doesn't begin with Stockholm header")
                }
            }
            None => bail!("empty buffer"),
        }

        for line in lines {
            if line.starts_with("#=GF") {
                let mut tokens = line.split_whitespace();
                let key = tokens.nth(1).ok_or(anyhow!("no GF key"))?.to_string();

                if key == "ID" {
                    rec.id = tokens.next().ok_or(anyhow!("no ID value"))?.to_string();
                }

                rec.gf_meta.insert(key, line.clone());
            } else if line.starts_with("#=GS") {
                let mut tokens = line.split_whitespace();
                let name = tokens.nth(1).ok_or(anyhow!("no GS name"))?.to_string();

                rec.gs_meta.insert(name.clone(), line.clone());
                rec.sequences.insert(name, "".to_string());
            } else if line.starts_with("#=GC") || line.starts_with("#=GR") {
                // ignore for now
            } else if !line.starts_with("#") {
                let tokens = line.split_whitespace().collect::<Vec<_>>();
                let name = tokens[0];
                let seq = tokens[1];

                rec.sequences
                    .entry(name.to_string())
                    .and_modify(|s| s.push_str(seq));
            } else {
                bail!("unexpected line format:\n{line}");
            }
        }

        if rec.id.is_empty() {
            bail!("failed to find Stockholm record ID");
        }

        Ok(rec)
    }

    pub fn get(&self, name: &str) -> Option<&String> {
        self.sequences.get(name)
    }
}

impl Display for StockholmRecord {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        writeln!(f, "{HEADER}")?;
        self.gf_meta.values().try_for_each(|s| writeln!(f, "{s}"))?;
        writeln!(f)?;
        self.gs_meta.values().try_for_each(|s| writeln!(f, "{s}"))?;
        writeln!(f)?;
        self.sequences
            .iter()
            .try_for_each(|(n, s)| writeln!(f, "{n} {s}"))?;
        writeln!(f, "//")
    }
}

#[derive(Default)]
pub struct Stockholm {
    pub records: IndexMap<String, StockholmRecord>,
}

impl Stockholm {
    pub fn from_path<P: AsRef<Path>>(path: P) -> anyhow::Result<Self> {
        let f = std::fs::File::open(path.as_ref())
            .with_context(|| format!("failed to open: {}", path.as_ref().to_string_lossy()))?;
        Self::parse(f)
    }

    pub fn parse<R: Read>(buf: R) -> anyhow::Result<Self> {
        let reader = BufReader::new(buf);

        let mut bufs: Vec<Vec<String>> = vec![];
        let mut buf: Vec<String> = vec![];

        for line in reader.lines() {
            // skip malformed lines for now
            let line = line.unwrap_or_default();

            if line.starts_with("//") {
                bufs.push(buf);
                buf = vec![];
            } else {
                buf.push(line);
            }
        }

        let mut sto = Self::default();

        for buf in bufs {
            let rec = StockholmRecord::parse(buf)?;
            sto.records.insert(rec.id.clone(), rec);
        }

        Ok(sto)
    }

    pub fn get(&self, name: &str) -> Option<&StockholmRecord> {
        self.records.get(name)
    }

    pub fn get_mut(&mut self, name: &str) -> Option<&mut StockholmRecord> {
        self.records.get_mut(name)
    }

    pub fn write<W: Write>(&self, buf: W) -> anyhow::Result<()> {
        let mut out = BufWriter::new(buf);
        self.records
            .values()
            .try_for_each(|r| writeln!(out, "{r}"))
            .context("Stockholm::write() failed")
    }

    pub fn seq_cnt(&self) -> usize {
        self.records.values().map(|r| r.sequences.len()).sum()
    }
}