Struct inline_python::Context

pub struct Context { /* fields omitted */ }

An execution context for Python code.

If you pass a manually created context to the python!{} macro, you can share it across invocations. This will keep all global variables and imports intact between macro invocations.

let c = inline_python::Context::new();
python! {
  #![context = &c]
  foo = 5
}
python! {
  #![context = &c]
  assert foo == 5
}

You may also use it to inspect global variables after the execution of the Python code. Note that you need to acquire the GIL in order to access those globals:

use inline_python::{pyo3, python};
let context = inline_python::Context::new();
python! {
  #![context = &context]
  foo = 5
}

let gil = pyo3::Python::acquire_gil();
let py  = gil.python();
let foo: Option<i32> = context.get_global(py, "foo").unwrap();
assert_eq!(foo, Some(5));

Methods

impl Context

pub fn new() -> Self

Create a new context for running python code.

This function temporarily acquires the GIL. If you already have the GIL, use Context::new_with_gil instead.

This function panics if it fails to create the context. See Context::new_checked for a version that returns a result.

pub fn new_checked() -> PyResult<Self>

Create a new context for running python code.

This function temporarily acquires the GIL. If you already have the GIL, use Context::new_with_gil instead.

pub fn new_with_gil(py: Python) -> PyResult<Self>

Create a new context for running Python code.

You must acquire the GIL to call this function.

pub fn globals<'p>(&self, py: Python<'p>) -> &'p PyDict

Get the globals as dictionary.

pub fn get_global<'p, T: FromPyObject<'p>>(
    self,
    py: Python<'p>,
    name: &str
) -> PyResult<Option<T>>

Retrieve a global variable from the context.