Trying to mimic exec(...)

[dbr]

(I'm using pyo3 0.13.2, Rust 1.48, Python 3.7, on Linux)

I'm embedding Python as a scripting interface within an application. There's an input where the user can enter some code, and it'll run it with a few additional globals present.

I have things mostly working - but when actually running the users code with pyo3's Python::run I get some correct, but initially very confusing, behavior:

fn main() {
    use pyo3::{
        prelude::*,
        types::{PyBytes, PyDict},
    };
    let gil = pyo3::Python::acquire_gil();
    let py = gil.python();
    let locals = PyDict::new(py);
    locals.set_item("dummy_api", 123);
    py.run(
        r#"
print(dummy_api)
eg = 'Confusing!'
def func():
    print(eg)
func()
"#,
None,
        Some(locals),
    )
    .map_err(|e| e.print_and_set_sys_last_vars(py))
    .unwrap();
}

This executes but results in a confusing NameError - the function can't see the eg variable:

Traceback (most recent call last):
  File "<string>", line 6, in <module>
  File "<string>", line 5, in func
NameError: name 'eg' is not defined

Eventually I noticed this sentence in the Python docs about eval:

Remember that at module level, globals and locals are the same dictionary. If exec gets two separate objects as globals and locals, the code will be executed as if it were embedded in a class definition

So the above Rust code is identical to doing either of these:

exec(open("test.py").read(), None, {'a': 123})
exec(open("test.py").read(), globals(), {'a': 123})

Fair enough, all is well so far.

The problem

What I actually want to do is the equivalent to this Python:

exec(code_snippet, {'dummy_api': 123}, None)

however if I do this in pyo3, it cannot find builtins like print - exec does this:

If the globals dictionary does not contain a value for the key builtins, a reference to the dictionary of the built-in module builtins is inserted under that key. That way you can control what builtins are available to the executed code by inserting your own builtins dictionary into globals before passing it to exec().

Whereas pyo3 does not automatically insert the builtins in globals

My questions

This is all a very long way of asking two things:

1. How would I get access to the __builtins__ to insert it into my dict - only mention in the docs is the unsafe pyo3::ffi::PyEval_GetBuiltins, but I assume there must be a nicer way of doing this
2. Is it desired behaviour for Python::run to differ from eval like this? If so, while the pyo3 docs are accurate, it might be worth expanding on exactly how the two arguments work exactly, similar to the eval docs

[dbr]

1. How would I get access to the builtins to insert it into my dict [...]

Ah, can get __builtins__ by just importing __main__

let exec_globals = [
    ("__builtins__", py.import("__main__")?.getattr("__builtins__")?),
    ("dummy_api", ...),
]
.into_py_dict(py);

py.run(&code_string, Some(&exec_globals), None)?;

[kngwyu]

Yeah, you need to import __main__ to do so.
Maybe it's beneficial to note that in the FAQ section of the guide.