fix: py validate methods (#316)

* fix: py validate methods

* fix

bindings/python/Cargo.toml

@@ -11,7 +11,6 @@ crate-type = ["cdylib"]
 
 [dependencies]
 anyhow = { workspace = true }
-bumpalo = "3"
 either = "1.13"
 pyo3 = { version = "0.23", features = ["anyhow", "serde", "either"] }
 pyo3-async-runtimes = { version = "0.23", features = ["tokio-runtime", "attributes"] }

bindings/python/src/expression.rs

@@ -1,11 +1,10 @@
 use crate::variable::PyVariable;
 use anyhow::{anyhow, Context};
 use either::Either;
-use pyo3::types::{PyAnyMethods, PyDict};
+use pyo3::types::PyDict;
 use pyo3::{pyclass, pyfunction, pymethods, Bound, IntoPyObjectExt, Py, PyAny, PyResult, Python};
-use pythonize::depythonize;
+use pythonize::{depythonize, pythonize};
 use zen_expression::expression::{Standard, Unary};
-use zen_expression::validate::{validate_expression, validate_unary_expression, ValidationError};
 use zen_expression::{Expression, Variable};
 
 #[pyfunction]
@@ -100,29 +99,19 @@ impl PyExpression {
 }
 
 #[pyfunction]
-#[pyo3(name = "validate_expression")]
-pub fn py_validate_expression(py: Python, expression: String) -> PyResult<Option<Py<PyDict>>> {
-    let Some(err) = validate_expression(expression.as_str()) else {
+pub fn validate_expression(py: Python, expression: String) -> PyResult<Option<Py<PyAny>>> {
+    let Err(error) = zen_expression::validate::validate_expression(expression.as_str()) else {
         return Ok(None);
     };
-    return Ok(Some(convert_error_to_dict(py, &err)));
+
+    Ok(Some(pythonize(py, &error)?.unbind()))
 }
 
 #[pyfunction]
-#[pyo3(name = "validate_unary_expression")]
-pub fn py_validate_unary_expression(
-    py: Python,
-    expression: String,
-) -> PyResult<Option<Py<PyDict>>> {
-    let Some(err) = validate_unary_expression(expression.as_str()) else {
+pub fn validate_unary_expression(py: Python, expression: String) -> PyResult<Option<Py<PyAny>>> {
+    let Err(error) = zen_expression::validate::validate_expression(expression.as_str()) else {
         return Ok(None);
     };
-    return Ok(Some(convert_error_to_dict(py, &err)));
-}
 
-fn convert_error_to_dict(py: Python, err: &ValidationError) -> Py<PyDict> {
-    let dict = PyDict::new(py);
-    dict.set_item("type", &err.error_type).unwrap();
-    dict.set_item("source", &err.source).unwrap();
-    return dict.unbind();
+    Ok(Some(pythonize(py, &error)?.unbind()))
 }

bindings/python/src/lib.rs

@@ -2,7 +2,7 @@ use crate::decision::PyZenDecision;
 use crate::engine::PyZenEngine;
 use crate::expression::{
     compile_expression, compile_unary_expression, evaluate_expression, evaluate_unary_expression,
-    py_validate_expression, py_validate_unary_expression, render_template, PyExpression,
+    render_template, validate_expression, validate_unary_expression, PyExpression,
 };
 use pyo3::prelude::PyModuleMethods;
 use pyo3::types::PyModule;
@@ -28,8 +28,8 @@ fn zen(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(render_template, m)?)?;
     m.add_function(wrap_pyfunction!(compile_expression, m)?)?;
     m.add_function(wrap_pyfunction!(compile_unary_expression, m)?)?;
-    m.add_function(wrap_pyfunction!(py_validate_expression, m)?)?;
-    m.add_function(wrap_pyfunction!(py_validate_unary_expression, m)?)?;
+    m.add_function(wrap_pyfunction!(validate_expression, m)?)?;
+    m.add_function(wrap_pyfunction!(validate_unary_expression, m)?)?;
 
     Ok(())
 }

bindings/python/zen.pyi

@@ -54,6 +54,5 @@ def validate_unary_expression(expression: str) -> Optional[ValidationResponse]:
 
 
 class ValidationResponse(TypedDict):
-    type: Literal["lexerError","parserError", "compilerError"]
+    type: Literal["lexerError", "parserError", "compilerError"]
     source: str
-