clincalc 0.2.2

Open, auditable clinical calculators: a pure scoring engine plus the `clincalc` CLI in one crate. The engine is a serde-only leaf (build with default-features = false); the default `cli` feature adds the `clincalc` binary.
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

// SPDX-FileCopyrightText: 2026 Marcus Baw and Baw Medical Ltd
// SPDX-License-Identifier: AGPL-3.0-or-later

//! ASA Physical Status classification.

use serde::{Deserialize, Serialize};
use serde_json::{Map, Value, json};

use crate::calculator::{CalcError, Calculator};
use crate::license::CalculatorLicense;
use crate::response::CalculationResponse;

pub const NAME: &str = "asa_physical_status";
pub const REFERENCE: &str = "American Society of Anesthesiologists. ASA Physical Status Classification System. Last amended Dec 13, 2020.";
pub const LICENSE: CalculatorLicense = CalculatorLicense {
    license: "Public professional classification - implemented from ASA published definitions",
    source_url: "https://www.asahq.org/standards-and-practice-parameters/statement-on-asa-physical-status-classification-system",
};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum AsaClass {
    Asa1,
    Asa2,
    Asa3,
    Asa4,
    Asa5,
    Asa6,
}
impl AsaClass {
    fn number(self) -> u8 {
        match self {
            AsaClass::Asa1 => 1,
            AsaClass::Asa2 => 2,
            AsaClass::Asa3 => 3,
            AsaClass::Asa4 => 4,
            AsaClass::Asa5 => 5,
            AsaClass::Asa6 => 6,
        }
    }
    fn definition(self) -> &'static str {
        match self {
            AsaClass::Asa1 => "A normal healthy patient",
            AsaClass::Asa2 => "A patient with mild systemic disease",
            AsaClass::Asa3 => "A patient with severe systemic disease",
            AsaClass::Asa4 => {
                "A patient with severe systemic disease that is a constant threat to life"
            }
            AsaClass::Asa5 => {
                "A moribund patient who is not expected to survive without the operation"
            }
            AsaClass::Asa6 => {
                "A declared brain-dead patient whose organs are being removed for donor purposes"
            }
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AsaPhysicalStatusInput {
    pub asa_class: AsaClass,
    #[serde(default)]
    pub emergency: bool,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AsaPhysicalStatusOutcome {
    pub label: String,
    pub interpretation: String,
}

pub fn compute(input: &AsaPhysicalStatusInput) -> Result<AsaPhysicalStatusOutcome, CalcError> {
    let suffix = if input.emergency { "E" } else { "" };
    let label = format!("ASA {}{suffix}", input.asa_class.number());
    let emergency_note = if input.emergency {
        " The E suffix denotes an emergency operation."
    } else {
        ""
    };
    let interpretation = format!(
        "{label}: {}.{emergency_note} ASA Physical Status describes preoperative physical status; it is not by itself an operative risk score.",
        input.asa_class.definition()
    );
    Ok(AsaPhysicalStatusOutcome {
        label,
        interpretation,
    })
}

pub fn build_response(input: &AsaPhysicalStatusInput) -> Result<CalculationResponse, CalcError> {
    let o = compute(input)?;
    let mut working = Map::new();
    working.insert("asa_class".into(), json!(input.asa_class.number()));
    working.insert("emergency_suffix".into(), json!(input.emergency));
    Ok(CalculationResponse {
        calculator: NAME.to_string(),
        result: json!(o.label),
        interpretation: o.interpretation,
        working,
        reference: REFERENCE.to_string(),
    })
}

pub struct AsaPhysicalStatus;
impl Calculator for AsaPhysicalStatus {
    fn name(&self) -> &'static str {
        NAME
    }
    fn title(&self) -> &'static str {
        "ASA Physical Status"
    }
    fn description(&self) -> &'static str {
        "ASA preoperative physical-status classification, with optional emergency suffix."
    }
    fn reference(&self) -> &'static str {
        REFERENCE
    }
    fn license(&self) -> CalculatorLicense {
        LICENSE
    }
    fn input_schema(&self) -> Value {
        json!({ "$schema": "https://json-schema.org/draft/2020-12/schema", "title": "AsaPhysicalStatusInput", "type": "object", "additionalProperties": false, "required": ["asa_class"], "properties": { "asa_class": { "type": "string", "enum": ["asa1", "asa2", "asa3", "asa4", "asa5", "asa6"], "description": "ASA class 1-6 using ASA definitions" }, "emergency": { "type": "boolean", "description": "Append E suffix for emergency operation" } } })
    }
    fn calculate(&self, input: &Value) -> Result<CalculationResponse, CalcError> {
        let parsed: AsaPhysicalStatusInput = serde_json::from_value(input.clone())
            .map_err(|e| CalcError::InvalidInput(e.to_string()))?;
        build_response(&parsed)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn emergency_suffix_is_added() {
        let out = compute(&AsaPhysicalStatusInput {
            asa_class: AsaClass::Asa3,
            emergency: true,
        })
        .unwrap();
        assert_eq!(out.label, "ASA 3E");
    }
}