runmat-kernel 0.4.1

Jupyter kernel implementation for RunMat using ZeroMQ and the Jupyter protocol
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

//! RunMat Jupyter Kernel
//!
//! A high-performance Jupyter kernel for RunMat.
//! Implements the Jupyter messaging protocol over ZMQ with async execution.

use serde::{Deserialize, Serialize};
use uuid::Uuid;

pub mod connection;
pub mod execution;
#[cfg(feature = "jupyter")]
pub mod jupyter_plotting;
pub mod protocol;
pub mod server;
pub mod transport;

pub use connection::ConnectionInfo;
pub use execution::ExecutionEngine;
pub use jupyter_plotting::{
    DisplayData, JupyterPlottingConfig, JupyterPlottingExtension, JupyterPlottingManager,
};
pub use protocol::{ExecuteReply, ExecuteRequest, JupyterMessage, MessageType};
pub use server::KernelServer;

/// Kernel configuration and runtime state
#[derive(Debug, Clone)]
pub struct KernelConfig {
    /// Connection information for ZMQ sockets
    pub connection: ConnectionInfo,
    /// Kernel session identifier
    pub session_id: String,
    /// Whether to enable debug logging
    pub debug: bool,
    /// Maximum execution timeout in seconds
    pub execution_timeout: Option<u64>,
}

impl Default for KernelConfig {
    fn default() -> Self {
        Self {
            connection: ConnectionInfo::default(),
            session_id: Uuid::new_v4().to_string(),
            debug: false,
            execution_timeout: Some(300), // 5 minutes
        }
    }
}

/// Kernel capability information reported to Jupyter
#[derive(Debug, Serialize, Deserialize)]
pub struct KernelInfo {
    pub protocol_version: String,
    pub implementation: String,
    pub implementation_version: String,
    pub language_info: LanguageInfo,
    pub banner: String,
    pub help_links: Vec<HelpLink>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct LanguageInfo {
    pub name: String,
    pub version: String,
    pub mimetype: String,
    pub file_extension: String,
    pub pygments_lexer: String,
    pub codemirror_mode: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct HelpLink {
    pub text: String,
    pub url: String,
}

impl Default for KernelInfo {
    fn default() -> Self {
        Self {
            protocol_version: "5.3".to_string(),
            implementation: "runmat".to_string(),
            implementation_version: "0.0.1".to_string(),
            language_info: LanguageInfo {
                name: "matlab".to_string(),
                version: "R2025a-compatible".to_string(),
                mimetype: "text/x-matlab".to_string(),
                file_extension: ".m".to_string(),
                pygments_lexer: "matlab".to_string(),
                codemirror_mode: "octave".to_string(),
            },
            banner: "RunMat - Fast, Free, Modern MATLAB code runtime".to_string(),
            help_links: vec![HelpLink {
                text: "RunMat Documentation".to_string(),
                url: "https://github.com/runmat-org/runmat".to_string(),
            }],
        }
    }
}

/// Error types for kernel operations
#[derive(Debug, thiserror::Error)]
pub enum KernelError {
    #[error("ZMQ error: {0}")]
    Zmq(#[from] zmq::Error),
    #[error("JSON serialization error: {0}")]
    Json(#[from] serde_json::Error),
    #[error("Execution error: {0}")]
    Execution(String),
    #[error("Protocol error: {0}")]
    Protocol(String),
    #[error("Connection error: {0}")]
    Connection(String),
    #[error("Internal error: {0}")]
    Internal(String),
}

pub type Result<T> = std::result::Result<T, KernelError>;