sosaku-py 0.6.0

Python bindings for the sosaku JSON Query language
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

use std::{error::Error, fmt::Display};

use pyo3::{
    Bound, IntoPyObject, IntoPyObjectExt, PyAny, Python,
    exceptions::{PyException, PyNameError, PyRuntimeError, PyTypeError, PyValueError},
};

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PySosakuError {
    inner: sosaku::Error,
}

impl<'py> IntoPyObject<'py> for PySosakuError {
    type Target = PyAny;

    type Output = Bound<'py, Self::Target>;

    type Error = pyo3::PyErr;

    fn into_pyobject(self, py: pyo3::Python<'py>) -> Result<Self::Output, Self::Error> {
        match self.inner {
            sosaku::Error::Parse(e) => {
                Ok(PyValueError::new_err(e.to_string()).into_bound_py_any(py)?)
            }
            sosaku::Error::Eval(e) => match e {
                sosaku::EvalError::FnCallError(fne) => Self {
                    inner: sosaku::Error::from(fne.reason.as_ref().clone()),
                }
                .into_pyobject(py),
                sosaku::EvalError::VarAccess(va) => {
                    Ok(PyNameError::new_err(va.to_string()).into_bound_py_any(py)?)
                }
                sosaku::EvalError::FunctionNotFound { .. } => {
                    Ok(PyNameError::new_err(e.to_string()).into_bound_py_any(py)?)
                }
                sosaku::EvalError::TypeError { message } => {
                    Ok(PyTypeError::new_err(message).into_bound_py_any(py)?)
                }
                sosaku::EvalError::ValueError { message }
                | sosaku::EvalError::RegexError { message } => {
                    Ok(PyValueError::new_err(message).into_bound_py_any(py)?)
                }
                sosaku::EvalError::ArgumentCount { expected, got } => Ok(PyValueError::new_err(
                    format!("Expected {expected} arguments, got {got}"),
                )
                .into_bound_py_any(py)?),
                sosaku::EvalError::CallSyncinAsync => Ok(PyRuntimeError::new_err(
                    "Cannot call an async function in a synchronous context",
                )
                .into_bound_py_any(py)?),
                sosaku::EvalError::Custom { message } => {
                    Ok(PyException::new_err(message).into_bound_py_any(py)?)
                }
                e => Ok(PyException::new_err(e.to_string()).into_bound_py_any(py)?),
            },
            e => Ok(PyException::new_err(e.to_string()).into_bound_py_any(py)?),
        }
    }
}

impl<T: Into<sosaku::Error>> From<T> for PySosakuError {
    fn from(value: T) -> Self {
        Self {
            inner: value.into(),
        }
    }
}

impl From<PySosakuError> for pyo3::PyErr {
    fn from(error: PySosakuError) -> Self {
        Python::attach(|py| {
            Self::from_value(
                error
                    .into_pyobject(py)
                    .expect("Failed to convert PySosakuError to PyErr"),
            )
        })
    }
}

impl Display for PySosakuError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.inner)
    }
}

impl Error for PySosakuError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        Some(&self.inner)
    }
}