pamly 0.3.5

Command line interface for digital pathology tools.
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

use anyhow::{bail, Result};
use pyo3::{pyclass, pymethods, PyResult};
use std::{collections::HashMap, convert::TryFrom};
use strum::{Display, EnumIter, EnumString, IntoEnumIterator};

#[derive(Debug, Clone, Copy, PartialEq, Eq, EnumIter, Display, EnumString)]
#[repr(u8)]
#[pyclass(eq, eq_int)]
#[rustfmt::skip]
#[strum(ascii_case_insensitive)]
pub enum Stain {
    Unknown = 0,
    HE = 1,
    CD3 = 3,
    CD20 = 20,
    CD30 = 30,
    CD68 = 68,
}

impl Stain {
    pub fn from(s: &str) -> Result<Stain> {
        let clean = s.replace(" ", "").replace("_", "").replace("&", "");
        match Stain::try_from(clean.as_str()) {
            Ok(l) => Ok(l),
            Err(e) => bail!(e.to_string()),
        }
    }
    pub fn to_hash_map() -> HashMap<String, u8> {
        let mut map = HashMap::new();
        for stain in Stain::list() {
            map.insert(stain.to_string(), stain as u8);
        }
        map
    }
}

#[pymethods]
impl Stain {
    #[staticmethod]
    pub fn list() -> Vec<Stain> {
        Stain::iter().collect()
    }
    pub fn to_string(&self) -> String {
        let s = format!("{}", self);
        s
    }
    #[new]
    pub fn new(s: &str) -> PyResult<Stain> {
        let s = Stain::from(s)?;
        Ok(s)
    }

    #[staticmethod]
    pub fn from_int(v: u8) -> PyResult<Stain> {
        let stain = Stain::try_from(v as u8)?;
        Ok(stain)
    }
}

impl TryFrom<u8> for Stain {
    type Error = anyhow::Error;
    fn try_from(value: u8) -> Result<Stain> {
        let stains = Stain::list();
        for stain in stains {
            if stain as u8 == value {
                return Ok(stain);
            }
        }
        bail!("No stain for number {}", value);
    }
}

#[cfg(test)]
mod tests {
    use super::{Result, Stain, TryFrom};
    #[test]
    fn stain_consistency() -> Result<()> {
        for stain in Stain::list() {
            let num = stain as u8;
            let stain2 = Stain::try_from(num)?;
            assert_eq!(stain, stain2);
        }
        Ok(())
    }
    #[test]
    fn he() -> Result<()> {
        let he1 = Stain::from("HE")?;
        let he2 = Stain::from("H&E")?;
        let he3 = Stain::from("H_E")?;
        let he4 = Stain::from("H_E")?;
        assert_eq!(he1, he2);
        assert_eq!(he2, he3);
        assert_eq!(he3, he4);
        Ok(())
    }
}