Macro rumtk_python_exec 

macro_rules! rumtk_python_exec {
    ( $closure:expr ) => { ... };
}

Execute the contents of a closure passed to this macro. This macro is an alias for [crate::rumtk_core::scripting::python_utils::py_exec].

See the blurp about that function to learn more!

Closure Format

Without Return

    |py: RUMPython| {
        rumtk_python_exec_module!(py, "module/path");
    };

With Return

    |py: RUMPython| -> usize {
        let result = rumtk_python_exec_module!(py, "module/path", "my_python_function");
        let val: usize = py_extract_any(py, &result)?;
        val
    };

Example

Running the Module

    use std::fs::write;
    use pyo3::Python;
    use uuid::Uuid;
    use crate::rumtk_core::scripting::python_utils::RUMPython;
    use crate::rumtk_core::core::RUMResult;
    use crate::rumtk_core::{rumtk_python_exec_module, rumtk_python_exec};

    fn test_module_exec() {
        let module_fname = format!("{}_module.py", Uuid::new_v4());
        let module_contents = "print(\"Hello World!\")";
        write(&module_fname, module_contents).expect("Failed to write file!");

        let closure = |py: RUMPython| -> RUMResult<()> {
            rumtk_python_exec_module!(py, &module_fname);
            Ok(())
        };

        let result = rumtk_python_exec!(closure);
        std::fs::remove_file(&module_fname).unwrap();
    }

    test_module_exec()

Running A Function

    use std::fs::write;
    use pyo3::Python;
    use uuid::Uuid;
    use crate::rumtk_core::core::RUMResult;
    use crate::rumtk_core::scripting::python_utils::RUMPython;
    use crate::rumtk_core::{rumtk_python_exec_module, rumtk_python_exec};

    fn test_module_exec() {
        let module_fname = format!("{}_module.py", Uuid::new_v4());
        let module_contents = "def test():\n\tprint(\"Hello World!\")";
        write(&module_fname, module_contents).expect("Failed to write file!");

        let closure = |py: RUMPython| -> RUMResult<()> {
            rumtk_python_exec_module!(py, &module_fname, "test");
            Ok(())
        };

        let result = rumtk_python_exec!(closure);
        std::fs::remove_file(&module_fname).unwrap();

    }

    test_module_exec()

Running A Function With Result

    use std::fs::write;
    use pyo3::Python;
    use uuid::Uuid;
    use crate::rumtk_core::core::RUMResult;
    use crate::rumtk_core::scripting::python_utils::{py_extract_any, RUMPython};
    use crate::rumtk_core::{rumtk_python_exec_module, rumtk_python_exec};

    fn test_module_exec() -> usize {
        let module_fname = format!("{}_module.py", Uuid::new_v4());
        let module_contents = "def test():\n\treturn 5+5";
        write(&module_fname, module_contents).expect("Failed to write file!");

        let closure = |py: RUMPython| -> RUMResult<usize> {
            let result = rumtk_python_exec_module!(py, &module_fname, "test");
            let val: usize = py_extract_any(py, &result)?;
            Ok(val)
        };

        let result = rumtk_python_exec!(closure);
        std::fs::remove_file(&module_fname).unwrap();

        result.unwrap()
    }

    let result = test_module_exec();

    assert_eq!(10, result, "Bad value returned from Python snippet!")

Running A Function With Arguments and Result

    use std::fs::write;
    use pyo3::Python;
    use uuid::Uuid;
    use crate::rumtk_core::core::RUMResult;
    use crate::rumtk_core::scripting::python_utils::{py_extract_any, py_new_args, py_push_arg, RUMPython};
    use crate::rumtk_core::{rumtk_python_exec, rumtk_python_exec_module};

    fn test_module_exec() -> f64 {
        let module_fname = format!("{}_module.py", Uuid::new_v4());
        let module_contents = "def test(a,b):\n\treturn a+b";
        write(&module_fname, module_contents).expect("Failed to write file!");

        let closure = |py: RUMPython| -> RUMResult<f64> {
            let a = 5;
            let b = 5.0;

            let mut args = py_new_args(py);
            py_push_arg(py, &mut args, &a);
            py_push_arg(py, &mut args, &b);

            let result = rumtk_python_exec_module!(py, &module_fname, "test", &args);
            let val: f64 = py_extract_any(py, &result)?;
            Ok(val)
        };

        let result = rumtk_python_exec!(closure);
        std::fs::remove_file(&module_fname).unwrap();

        result.unwrap()
    }

    let result = test_module_exec();

    assert_eq!(10.0, result, "Bad value returned from Python snippet!")