support exec, eval

include/nanobind/nanobind.h

@@ -51,6 +51,7 @@
 #include "nb_func.h"
 #include "nb_class.h"
 #include "nb_misc.h"
+#include "nb_eval.h"
 
 #if defined(_MSC_VER)
 #  pragma warning(pop)

include/nanobind/nb_eval.h

@@ -0,0 +1,63 @@
+/*
+    nanobind/nb_eval.h: Support for evaluating Python expressions and
+                        statements from strings
+
+    Adapted by Nico Schlömer from pybind11's eval.h.
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include <nanobind/nanobind.h>
+
+#include <utility>
+
+NAMESPACE_BEGIN(NB_NAMESPACE)
+
+enum eval_mode {
+    // Evaluate a string containing an isolated expression
+    eval_expr = Py_eval_input,
+
+    // Evaluate a string containing a single statement. Returns \c none
+    eval_single_statement = Py_single_input,
+
+    // Evaluate a string containing a sequence of statement. Returns \c none
+    eval_statements = Py_file_input
+};
+
+template <eval_mode start = eval_expr>
+object eval(const str &expr, handle global = handle(), handle local = handle()) {
+    if (!local)
+        local = global;
+
+    // This used to be PyRun_String, but that function isn't in the stable ABI.
+    object codeobj = steal(Py_CompileString(expr.c_str(), "<string>", start));
+    if (!codeobj)
+        detail::raise_python_error();
+
+    PyObject *result = PyEval_EvalCode(codeobj.ptr(), global.ptr(), local.ptr());
+    if (!result)
+        detail::raise_python_error();
+
+    return steal(result);
+}
+
+template <eval_mode start = eval_expr, size_t N>
+object eval(const char (&s)[N], handle global = handle(), handle local = handle()) {
+    // Support raw string literals by removing common leading whitespace
+    auto expr = (s[0] == '\n') ? str(module_::import_("textwrap").attr("dedent")(s)) : str(s);
+    return eval<start>(expr, global, local);
+}
+
+inline void exec(const str &expr, handle global = handle(), handle local = handle()) {
+    eval<eval_statements>(expr, global, local);
+}
+
+template <size_t N>
+void exec(const char (&s)[N], handle global = handle(), handle local = handle()) {
+    eval<eval_statements>(s, global, local);
+}
+
+NAMESPACE_END(NB_NAMESPACE)

tests/CMakeLists.txt

@@ -29,6 +29,7 @@ nanobind_add_module(test_bind_map_ext test_stl_bind_map.cpp ${NB_EXTRA_ARGS})
 nanobind_add_module(test_bind_vector_ext test_stl_bind_vector.cpp ${NB_EXTRA_ARGS})
 nanobind_add_module(test_chrono_ext test_chrono.cpp ${NB_EXTRA_ARGS})
 nanobind_add_module(test_enum_ext test_enum.cpp ${NB_EXTRA_ARGS})
+nanobind_add_module(test_eval_ext test_eval.cpp ${NB_EXTRA_ARGS})
 nanobind_add_module(test_ndarray_ext test_ndarray.cpp ${NB_EXTRA_ARGS})
 nanobind_add_module(test_intrusive_ext test_intrusive.cpp object.cpp object.h ${NB_EXTRA_ARGS})
 nanobind_add_module(test_exception_ext test_exception.cpp ${NB_EXTRA_ARGS})
@@ -62,6 +63,7 @@ set(TEST_FILES
   test_classes.py
   test_eigen.py
   test_enum.py
+  test_eval.py
   test_exception.py
   test_functions.py
   test_holders.py

tests/test_eval.cpp

@@ -0,0 +1,80 @@
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/pair.h>
+
+// #include "pybind11_tests.h"
+
+// #include <utility>
+
+namespace nb = nanobind;
+
+NB_MODULE(test_eval_ext, m) {
+    auto global = nb::dict(nb::module_::import_("__main__").attr("__dict__"));
+
+    m.def("test_eval_statements", [global]() {
+        auto local = nb::dict();
+        local["call_test"] = nb::cpp_function([&]() -> int { return 42; });
+
+        // Regular string literal
+        nb::exec("message = 'Hello World!'\n"
+                 "x = call_test()",
+                 global,
+                 local);
+
+        // Multi-line raw string literal
+        nb::exec(R"(
+            if x == 42:
+                print(message)
+            else:
+                raise RuntimeError
+            )",
+                 global,
+                 local);
+        auto x = nb::cast<int>(local["x"]);
+        return x == 42;
+    });
+
+    m.def("test_eval", [global]() {
+        auto local = nb::dict();
+        local["x"] = nb::int_(42);
+        auto x = nb::eval("x", global, local);
+        return nb::cast<int>(x) == 42;
+    });
+
+    m.def("test_eval_single_statement", []() {
+        auto local = nb::dict();
+        local["call_test"] = nb::cpp_function([&]() -> int { return 42; });
+
+        auto result = nb::eval<nb::eval_single_statement>("x = call_test()", nb::dict(), local);
+        auto x = nb::cast<int>(local["x"]);
+        return result.is_none() && x == 42;
+    });
+
+    m.def("test_eval_failure", []() {
+        try {
+            nb::eval("nonsense code ...");
+        } catch (nb::python_error &) {
+            return true;
+        }
+        return false;
+    });
+
+    // test_eval_closure
+    m.def("test_eval_closure", []() {
+        nb::dict global;
+        global["closure_value"] = 42;
+        nb::dict local;
+        local["closure_value"] = 0;
+        nb::exec(R"(
+            local_value = closure_value
+
+            def func_global():
+                return closure_value
+
+            def func_local():
+                return local_value
+            )",
+                 global,
+                 local);
+        return std::make_pair(global, local);
+    });
+}

tests/test_eval.py

@@ -0,0 +1,33 @@
+import os
+
+import pytest
+
+import test_eval_ext as m
+
+
+def test_evals(capsys):
+    assert m.test_eval_statements()
+    captured = capsys.readouterr()
+    assert captured.out == "Hello World!\n"
+
+    assert m.test_eval()
+    assert m.test_eval_single_statement()
+
+    assert m.test_eval_failure()
+
+
+def test_eval_closure():
+    global_, local = m.test_eval_closure()
+
+    assert global_["closure_value"] == 42
+    assert local["closure_value"] == 0
+
+    assert "local_value" not in global_
+    assert local["local_value"] == 0
+
+    assert "func_global" not in global_
+    assert local["func_global"]() == 42
+
+    assert "func_local" not in global_
+    with pytest.raises(NameError):
+        local["func_local"]()