Struct pyembed::MainPythonInterpreter

pub struct MainPythonInterpreter<'python, 'interpreter: 'python, 'resources: 'interpreter> { /* fields omitted */ }

Manages an embedded Python interpreter.

Python interpreters have global state and there can only be a single instance of this type per process. There exists a global lock enforcing this. Calling new() will block waiting for this lock. The lock is released when the instance is dropped.

Instances must only be constructed through MainPythonInterpreter::new().

This type and its various functionality is a glorified wrapper around the Python C API. But there’s a lot of added functionality on top of what the C API provides.

Both the low-level python3-sys and higher-level cpython crates are used.

Implementations

impl<'python, 'interpreter, 'resources> MainPythonInterpreter<'python, 'interpreter, 'resources>

pub fn new(
    config: OxidizedPythonInterpreterConfig<'resources>
) -> Result<MainPythonInterpreter<'python, 'interpreter, 'resources>, NewInterpreterError>

Construct a Python interpreter from a configuration.

The Python interpreter is initialized as a side-effect. The GIL is held.

pub fn release_gil(&mut self)

Ensure the Python GIL is released.

pub fn acquire_gil(&mut self) -> Python<'_>

Ensure the Python GIL is acquired, returning a handle on the interpreter.

The returned value has a lifetime of the MainPythonInterpreter instance. This is because MainPythonInterpreter.drop() finalizes the interpreter. The borrow checker should refuse to compile code where the returned Python outlives self.

pub fn py_runmain(self) -> i32

Runs Py_RunMain() and finalizes the interpreter.

This will execute whatever is configured by the Python interpreter config and return an integer suitable for use as a process exit code.

Calling this function will finalize the interpreter and only gives you an exit code: there is no opportunity to inspect the return value or handle an uncaught exception. If you want to keep the interpreter alive or inspect the evaluation result, consider calling a function on the interpreter handle that executes code.

Trait Implementations

impl<'python, 'interpreter, 'resources> Drop for MainPythonInterpreter<'python, 'interpreter, 'resources>

fn drop(&mut self)

Executes the destructor for this type.