juglans 0.2.13

Compiler and runtime for Juglans Workflow Language
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

// src/runtime/python/protocol.rs
//
// JSON-RPC protocol types for Python worker communication

use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::collections::HashMap;

/// Request types that can be sent to the Python worker
#[derive(Debug, Clone, Serialize)]
#[serde(tag = "type", rename_all = "lowercase")]
pub enum PythonRequest {
    /// Call a function/method on a module or reference
    Call {
        id: String,
        target: String,
        method: String,
        args: Vec<Value>,
        kwargs: HashMap<String, Value>,
    },
    /// Get an attribute from a reference
    _Getattr {
        id: String,
        target: String,
        attr: String,
    },
    /// Delete references (garbage collection)
    Del { id: String, refs: Vec<String> },
    /// Health check
    Ping { id: String },
}

impl PythonRequest {
    pub fn call(
        id: impl Into<String>,
        target: impl Into<String>,
        method: impl Into<String>,
        args: Vec<Value>,
        kwargs: HashMap<String, Value>,
    ) -> Self {
        Self::Call {
            id: id.into(),
            target: target.into(),
            method: method.into(),
            args,
            kwargs,
        }
    }

    pub fn ping(id: impl Into<String>) -> Self {
        Self::Ping { id: id.into() }
    }

    pub fn _id(&self) -> &str {
        match self {
            Self::Call { id, .. } => id,
            Self::_Getattr { id, .. } => id,
            Self::Del { id, .. } => id,
            Self::Ping { id } => id,
        }
    }
}

/// Error information from Python
#[derive(Debug, Clone, Deserialize)]
pub struct PythonError {
    #[serde(rename = "type")]
    pub error_type: String,
    pub message: String,
    pub traceback: Option<String>,
}

/// Response from the Python worker
#[derive(Debug, Clone, Deserialize)]
pub struct PythonResponse {
    #[serde(rename = "id")]
    pub _id: String,
    #[serde(rename = "type")]
    pub response_type: String,
    pub value: Option<Value>,
    #[serde(rename = "ref")]
    pub reference: Option<String>,
    pub error: Option<PythonError>,
}

impl PythonResponse {
    /// Check if this response indicates an error
    pub fn is_error(&self) -> bool {
        self.response_type == "error" || self.error.is_some()
    }

    /// Get the result value, or None if this is a reference or error
    pub fn _into_value(self) -> Option<Value> {
        if self.is_error() {
            None
        } else {
            self.value
        }
    }

    /// Get the reference ID if this response contains one
    pub fn _get_ref(&self) -> Option<&str> {
        self.reference.as_deref()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_call_request_serialization() {
        let req = PythonRequest::call(
            "test-1",
            "pandas",
            "read_csv",
            vec![Value::String("data.csv".to_string())],
            HashMap::new(),
        );

        let json = serde_json::to_string(&req).unwrap();
        assert!(json.contains("\"type\":\"call\""));
        assert!(json.contains("\"target\":\"pandas\""));
        assert!(json.contains("\"method\":\"read_csv\""));
    }

    #[test]
    fn test_response_deserialization() {
        let json =
            r#"{"id": "test-1", "type": "value", "value": {"a": 1}, "ref": null, "error": null}"#;
        let resp: PythonResponse = serde_json::from_str(json).unwrap();

        assert_eq!(resp._id, "test-1");
        assert_eq!(resp.response_type, "value");
        assert!(resp.value.is_some());
        assert!(!resp.is_error());
    }

    #[test]
    fn test_error_response() {
        let json = r#"{"id": "test-1", "type": "error", "value": null, "ref": null, "error": {"type": "ValueError", "message": "test error", "traceback": null}}"#;
        let resp: PythonResponse = serde_json::from_str(json).unwrap();

        assert!(resp.is_error());
        assert!(resp.error.is_some());
        assert_eq!(resp.error.as_ref().unwrap().error_type, "ValueError");
    }
}