starred/zen
1
0
Fork 0
mirror of https://github.com/gorules/zen.git synced 2026-10-04 00:02:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix: py validate methods (#316)

Browse Source 
* fix: py validate methods

* fix
This commit is contained in:
stefan-gorules
2025-02-15 21:46:55 +01:00
committed by GitHub
parent 94e1da239a
commit d7624311f6
5 changed files with 22 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files
bindings/python/Cargo.toml
-1
View File
@@ -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
+9 -20
View File
@@ -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
+3 -3
View File
@@ -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
+1 -2
View File
@@ -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
core/expression/src/validate.rs
+9 -92
View File
@@ -1,98 +1,15 @@
use bumpalo::Bump;
use crate::{Isolate, IsolateError};
use crate::{compiler::Compiler, lexer::Lexer, parser::Parser};
pub fn validate_unary_expression(expression: &str) -> Result<(), IsolateError> {
let mut isolate = Isolate::new();
isolate.compile_unary(expression)?;
pub struct ValidationError {
pub error_type: String,
pub source: String,
Ok(())
}
pub fn validate_unary_expression(expression: &str) -> Option<ValidationError> {
let mut lexer = Lexer::new();
let tokens = match lexer.tokenize(expression) {
Err(e) => {
return Some(ValidationError {
error_type: "lexerError".to_string(),
source: e.to_string(),
})
}
Ok(tokens) => tokens,
};
pub fn validate_expression(expression: &str) -> Result<(), IsolateError> {
let mut isolate = Isolate::new();
isolate.compile_standard(expression)?;
let bump = Bump::new();
let parser = match Parser::try_new(tokens, &bump) {
Err(e) => {
return Some(ValidationError {
error_type: "parserError".to_string(),
source: e.to_string(),
})
}
Ok(p) => p.unary(),
};
let parser_result = parser.parse();
match parser_result.error() {
Err(e) => {
return Some(ValidationError {
error_type: "parserError".to_string(),
source: e.to_string(),
})
}
Ok(n) => n,
};
let mut compiler = Compiler::new();
if let Err(e) = compiler.compile(parser_result.root) {
return Some(ValidationError {
error_type: "compilerError".to_string(),
source: e.to_string(),
});
}
None
}
pub fn validate_expression(expression: &str) -> Option<ValidationError> {
let mut lexer = Lexer::new();
let tokens = match lexer.tokenize(expression) {
Err(e) => {
return Some(ValidationError {
error_type: "lexerError".to_string(),
source: e.to_string(),
})
}
Ok(tokens) => tokens,
};
let bump = Bump::new();
let parser = match Parser::try_new(tokens, &bump) {
Err(e) => {
return Some(ValidationError {
error_type: "parserError".to_string(),
source: e.to_string(),
})
}
Ok(p) => p.standard(),
};
let parser_result = parser.parse();
match parser_result.error() {
Err(e) => {
return Some(ValidationError {
error_type: "parserError".to_string(),
source: e.to_string(),
})
}
Ok(n) => n,
};
let mut compiler = Compiler::new();
if let Err(e) = compiler.compile(parser_result.root) {
return Some(ValidationError {
error_type: "compilerError".to_string(),
source: e.to_string(),
});
}
None
Ok(())
}