deimos 0.16.2

Control-loop and data pipeline for the Deimos data acquisition system
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

/// Glue for passing Deimos trait objects between Python and Rust via json.
///
/// These are never used in-the-loop, so they do not need to be exceptionally
/// performant, only consistent and ergonomic.
use pyo3::prelude::*;

use crate::{
    calc::Calc, dispatcher::Dispatcher, peripheral::Peripheral, python::BackendErr, socket::Socket,
};

macro_rules! impl_from_pyobject_json {
    ($trait:path, $err_variant:ident, $type_name:expr) => {
        /// Glue for passing dyn Trait objects from Python to Rust via json
        /// to handle the fact that they are concrete types on the Python side,
        /// but dyn Trait objects on the Rust side.
        impl<'a, 'py> FromPyObject<'a, 'py> for Box<dyn $trait> {
            type Error = PyErr;

            fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
                // Require a to_json() method on the Python instance
                let to_json = obj
                    .getattr("to_json")
                    .map_err(|e| BackendErr::$err_variant {
                        msg: format!("{} object missing to_json(): {e}", $type_name),
                    })?;
                if !to_json.is_callable() {
                    return Err(BackendErr::$err_variant {
                        msg: format!("{}.to_json is not callable", $type_name),
                    }
                    .into());
                }

                let json_any = to_json.call0().map_err(|e| BackendErr::$err_variant {
                    msg: format!("{}.to_json() failed: {e}", $type_name),
                })?;
                let json_str: String =
                    json_any.extract().map_err(|e| BackendErr::$err_variant {
                        msg: format!("{}.to_json() did not return a string: {e}", $type_name),
                    })?;

                serde_json::from_str(&json_str).map_err(|e| {
                    BackendErr::$err_variant {
                        msg: format!("Unable to process {} object: {e}", $type_name),
                    }
                    .into()
                })
            }
        }
    };
}

impl_from_pyobject_json!(Calc, InvalidCalc, "Calc");
impl_from_pyobject_json!(Dispatcher, InvalidDispatcher, "Dispatcher");
impl_from_pyobject_json!(Peripheral, InvalidPeripheral, "Peripheral");
impl_from_pyobject_json!(Socket, InvalidSocket, "Socket");