qmk-via-api 0.7.0

VIA api implementation for QMK-based keyboards
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

use std::fmt::Debug;

use hidapi::HidError;

use crate::api_commands::ViaCommandId;

pub type Result<T> = core::result::Result<T, Error>;

#[derive(Debug)]
pub enum Error {
    Hid(String),
    BadCommandResponse(ViaCommandId),
    SendCommand(ViaCommandId, String),
    NoSuchKeyboard {
        vid: u16,
        pid: u16,
        usage_page: u16,
    },
    UnsupportedProtocol(u16),
    UnsupportedFeature(&'static str),
    SizeMismatch {
        expected: usize,
        actual: usize,
        context: &'static str,
    },
    InvalidArgument(&'static str),
}

impl Error {
    pub fn size_mismatch(context: &'static str, expected: usize, actual: usize) -> Self {
        Error::SizeMismatch {
            expected,
            actual,
            context,
        }
    }
}

impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Error::SizeMismatch {
                expected,
                actual,
                context,
            } => f.write_fmt(format_args!(
                "{}: expected size = {}, actual size = {}",
                context, expected, actual
            )),
            Error::UnsupportedProtocol(version) => {
                f.write_fmt(format_args!("unsupported protocol version: {}", version))
            }
            Error::UnsupportedFeature(feature) => {
                f.write_fmt(format_args!("unsupported feature: {}", feature))
            }
            Error::NoSuchKeyboard {
                vid,
                pid,
                usage_page,
            } => f.write_fmt(format_args!(
                "could not find keyboard: 0x{:04x}/0x{:04x}/0x{:04x} (vendor_id/product_id/usage_page)",
                vid, pid, usage_page
            )),
            Error::BadCommandResponse(cmd) => f.write_fmt(format_args!(
                "unexpected command response for command {:?}",
                cmd
            )),
            Error::InvalidArgument(arg) => f.write_fmt(format_args!("invalid argument: {}", arg)),
            _ => Debug::fmt(&self, f),
        }
    }
}

impl From<HidError> for Error {
    fn from(value: HidError) -> Self {
        Error::Hid(value.to_string())
    }
}

#[cfg(feature = "python")]
impl From<Error> for pyo3::PyErr {
    fn from(err: Error) -> Self {
        match err {
            Error::Hid(msg) => pyo3::PyErr::new::<crate::HidError, _>(msg),
            Error::NoSuchKeyboard {
                vid,
                pid,
                usage_page,
            } => pyo3::PyErr::new::<crate::DeviceNotFoundError, _>(format!(
                "could not find keyboard: 0x{:04x}/0x{:04x}/0x{:04x} (vendor_id/product_id/usage_page)",
                vid, pid, usage_page
            )),
            Error::UnsupportedProtocol(version) => {
                pyo3::PyErr::new::<crate::UnsupportedProtocolError, _>(format!(
                    "unsupported protocol version: {}",
                    version
                ))
            }
            Error::UnsupportedFeature(feature) => {
                pyo3::PyErr::new::<crate::UnsupportedProtocolError, _>(format!(
                    "unsupported feature: {}",
                    feature
                ))
            }
            Error::SizeMismatch {
                expected,
                actual,
                context,
            } => pyo3::PyErr::new::<crate::SizeMismatchError, _>(format!(
                "{}: expected size = {}, actual size = {}",
                context, expected, actual
            )),
            Error::BadCommandResponse(cmd) => {
                pyo3::PyErr::new::<crate::CommandResponseError, _>(format!(
                    "command failure for {:?}",
                    cmd
                ))
            }
            Error::SendCommand(cmd, msg) => pyo3::PyErr::new::<crate::CommandResponseError, _>(
                format!("failed sending command {:?}: {}", cmd, msg),
            ),
            Error::InvalidArgument(arg) => {
                pyo3::PyErr::new::<crate::InvalidArgumentError, _>(arg)
            }
        }
    }
}