Merge 0.3.0 work (1BADragon#15)

* Add more numeric builtins

* Adding more builtins

* Detour separating some lifetime things

* Finished adding the math builtins

* Fixed double ref clone

* Added reduce (1BADragon#13)

* Python bindings and better wasm type inference (1BADragon#14)

* Working on adding python custom functions for the bindings

* Have python function bindings working

* Working on CelFloat for wasm bindings

* Working on downcast issue

* Added the new CelFloat type to force the use of a float

* Removed wasm feature

* Removed wasm downcast crate

---------

Co-authored-by: matt <[email protected]>

* Bump to 0.3.0

---------

Co-authored-by: matt <[email protected]>

Author: 1BADragon

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rscel"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
 
 [lib]
@@ -12,7 +12,10 @@ ast_ser = []
 program_cache = []
 python = ["dep:pyo3"]
 console_error_panic_hook = ["dep:console_error_panic_hook"]
-wasm = ["dep:wasm-bindgen", "dep:serde-wasm-bindgen", "console_error_panic_hook", "chrono/wasmbind"]
+wasm = [
+  "dep:wasm-bindgen", "dep:serde-wasm-bindgen", "dep:js-sys", 
+  "console_error_panic_hook", "chrono/wasmbind"
+]
 
 
 [dependencies]
@@ -33,3 +36,4 @@ pyo3 = { version = "0.19.1", optional = true, features = ["extension-module", "c
 wasm-bindgen = { version = "0.2.87", optional = true}
 console_error_panic_hook = { version = "0.1.7", optional = true }
 serde-wasm-bindgen = { version = "0.5.0", optional = true }
+js-sys = { version = "0.3.64", optional = true }

Makefile

@@ -26,4 +26,7 @@ python-binding-release: .env
 	source .env/bin/activate && maturin build --features python --release $(CARGO_ARGS)
 
 wasm-example: wasm-binding
-	cd examples/wasm && npm start
+	cd examples/wasm && npm start
+
+.PHONY: all
+all: wasm-binding python-binding

examples/eval.py

@@ -2,7 +2,7 @@
 import rscel
 
 if len(sys.argv) == 2:
-    print(rscel.eval(sys.argv[1], "{}"))
+    print(rscel.eval(sys.argv[1], {}))
 elif len(sys.argv) == 3:
     print(rscel.eval(*sys.argv[1:]))
 else:

examples/wasm/src/pages/CelComponent.tsx

@@ -1,7 +1,7 @@
 import * as React from "react";
 import "./CelComponent.css";
 
-import init, { cel_eval, cel_details } from "rscel";
+import init, { cel_eval, cel_details, CelFloat } from "rscel";
 import { useState } from "react";
 
 export default function CelComponent() {
@@ -30,7 +30,7 @@ export default function CelComponent() {
               setParamVals((old: any) => {
                 try {
                   let newObj = { ...old };
-                  newObj[val] = JSON.parse(event.target.value);
+                  newObj[val] = Number(event.target.value);
                   setErrorMessage("");
                   return newObj;
                 } catch (e) {
@@ -59,7 +59,6 @@ export default function CelComponent() {
         <button
           onClick={() => {
             const details = cel_details(prog);
-            console.log(details);
 
             if (details.success) {
               setParams(details.result.get("params"));
@@ -73,9 +72,7 @@ export default function CelComponent() {
         </button>
         <button
           onClick={() => {
-            console.log(paramVals);
             const result = cel_eval(prog, paramVals);
-            console.log(result);
 
             if (result.success) {
               setErrorMessage(`Result: ${result.result.toString()}`);

src/bindings/python/celpycallable.rs

@@ -0,0 +1,84 @@
+use pyo3::{types::PyTuple, Py, PyAny, PyObject, Python, ToPyObject};
+
+use crate::{CelError, CelResult, CelValue};
+
+pub struct CelPyCallable {
+    func: Py<PyAny>,
+}
+
+impl CelPyCallable {
+    pub fn new(func: Py<PyAny>) -> CelPyCallable {
+        CelPyCallable { func }
+    }
+}
+
+impl FnOnce<(CelValue, &[CelValue])> for CelPyCallable {
+    type Output = CelResult<CelValue>;
+
+    extern "rust-call" fn call_once(self, args: (CelValue, &[CelValue])) -> Self::Output {
+        Python::with_gil(|py| {
+            match self.func.call(
+                py,
+                PyTuple::new(
+                    py,
+                    &[args.0]
+                        .iter()
+                        .filter(|x| !x.is_null())
+                        .map(|x| x.to_object(py))
+                        .chain(args.1.into_iter().map(|x| x.to_object(py)))
+                        .collect::<Vec<PyObject>>(),
+                ),
+                None,
+            ) {
+                Ok(val) => Ok(val.extract(py).unwrap()),
+                Err(val) => Err(CelError::runtime(&val.to_string())),
+            }
+        })
+    }
+}
+
+impl FnMut<(CelValue, &[CelValue])> for CelPyCallable {
+    extern "rust-call" fn call_mut(&mut self, args: (CelValue, &[CelValue])) -> Self::Output {
+        Python::with_gil(|py| {
+            match self.func.call(
+                py,
+                PyTuple::new(
+                    py,
+                    &[args.0]
+                        .iter()
+                        .filter(|x| !x.is_null())
+                        .map(|x| x.to_object(py))
+                        .chain(args.1.into_iter().map(|x| x.to_object(py)))
+                        .collect::<Vec<PyObject>>(),
+                ),
+                None,
+            ) {
+                Ok(val) => Ok(val.extract(py).unwrap()),
+                Err(val) => Err(CelError::runtime(&val.to_string())),
+            }
+        })
+    }
+}
+
+impl Fn<(CelValue, &[CelValue])> for CelPyCallable {
+    extern "rust-call" fn call(&self, args: (CelValue, &[CelValue])) -> Self::Output {
+        Python::with_gil(|py| {
+            match self.func.call(
+                py,
+                PyTuple::new(
+                    py,
+                    &[args.0]
+                        .iter()
+                        .filter(|x| !x.is_null())
+                        .map(|x| x.to_object(py))
+                        .chain(args.1.into_iter().map(|x| x.to_object(py)))
+                        .collect::<Vec<PyObject>>(),
+                ),
+                None,
+            ) {
+                Ok(val) => Ok(val.extract(py).unwrap()),
+                Err(val) => Err(CelError::runtime(&val.to_string())),
+            }
+        })
+    }
+}

src/bindings/python/mod.rs

@@ -8,17 +8,42 @@ use pyo3::{
 };
 use std::collections::HashMap;
 
+mod celpycallable;
+
+use celpycallable::CelPyCallable;
+
 /* Eval entry point */
 #[pyfunction]
 fn eval(py: Python<'_>, prog_str: String, bindings: &PyDict) -> PyResult<PyObject> {
+    let callables = {
+        let mut callables = Vec::new();
+        for keyobj in bindings.keys().iter() {
+            let key = keyobj.downcast::<PyString>()?;
+            let val = bindings.get_item(keyobj).unwrap();
+
+            if val.is_callable() {
+                callables.push((key.to_str()?, CelPyCallable::new(val.into())));
+            }
+        }
+        callables
+    };
     let mut ctx = CelContext::new();
     let mut exec_ctx = BindContext::new();
 
     ctx.add_program_str("entry", &prog_str).unwrap();
 
     for keyobj in bindings.keys().iter() {
         let key = keyobj.downcast::<PyString>()?;
-        exec_ctx.bind_param(key.to_str()?, bindings.get_item(keyobj).unwrap().extract()?)
+
+        let val = bindings.get_item(keyobj).unwrap();
+
+        if !val.is_callable() {
+            exec_ctx.bind_param(key.to_str()?, val.extract()?)
+        }
+    }
+
+    for callable in callables.iter() {
+        exec_ctx.bind_func(callable.0, &callable.1);
     }
 
     let res = ctx.exec("entry", &exec_ctx);
@@ -56,7 +81,17 @@ impl PyCelContext {
         name: &str,
         bindings: &PyBindContext,
     ) -> PyResult<PyObject> {
-        match slf.ctx.exec(name, &bindings.ctx) {
+        let mut bindctx = BindContext::new();
+
+        for (key, val) in bindings.bindings.iter() {
+            bindctx.bind_param(&key, val.clone());
+        }
+
+        for (key, val) in bindings.funcs.iter() {
+            bindctx.bind_func(&key, val);
+        }
+
+        match slf.ctx.exec(name, &bindctx) {
             Ok(val) => Ok(val.to_object(slf.py())),
             Err(err) => Err(PyValueError::new_err(err.to_string())),
         }
@@ -65,20 +100,37 @@ impl PyCelContext {
 
 #[pyclass(name = "BindContext")]
 struct PyBindContext {
-    ctx: BindContext,
+    bindings: HashMap<String, CelValue>,
+    funcs: HashMap<String, CelPyCallable>,
 }
 
 #[pymethods]
 impl PyBindContext {
     #[new]
     pub fn new() -> PyBindContext {
         PyBindContext {
-            ctx: BindContext::new(),
+            bindings: HashMap::new(),
+            funcs: HashMap::new(),
         }
     }
 
-    pub fn bind(mut slf: PyRefMut<'_, Self>, name: &str, val: CelValue) {
-        slf.ctx.bind_param(name, val);
+    pub fn bind_param(&mut self, name: &str, val: CelValue) {
+        self.bindings.insert(name.to_owned(), val);
+    }
+
+    pub fn bind_func(&mut self, name: &str, val: &PyAny) {
+        self.funcs
+            .insert(name.to_owned(), CelPyCallable::new(val.into()));
+    }
+
+    pub fn bind(&mut self, name: &str, val: &PyAny) -> PyResult<()> {
+        if val.is_callable() {
+            self.bind_func(name, val);
+        } else {
+            self.bind_param(name, val.extract()?);
+        }
+
+        Ok(())
     }
 }