Struct MontyRun 

pub struct MontyRun { /* private fields */ }

Available on crate features code and embedded-python only.

Primary interface for running Monty code.

MontyRun supports two execution modes:

• Simple execution: Use run() or run_no_limits() to run code to completion
• Iterative execution: Use start() to start execution which will pause at external function calls and can be resumed later

Example

use monty::MontyRun;
use monty_types::{CompileOptions, MontyObject};

let runner = MontyRun::new(
    "x + 1".to_owned(),
    "test.py",
    vec!["x".to_owned()],
    CompileOptions::default(),
)
.unwrap();
let result = runner.run_no_limits(vec![MontyObject::Int(41)]).unwrap();
assert_eq!(result, MontyObject::Int(42));

Implementations

impl MontyRun

pub fn new( code: String, script_name: &str, input_names: Vec<String>, options: CompileOptions, ) -> Result<MontyRun, MontyException>

Creates a new run snapshot by parsing the given code.

This only parses and prepares the code - no heap or namespaces are created yet. Call run_snapshot() with inputs to start execution.

Arguments

• code - The Python code to execute
• script_name - The script name for error messages
• input_names - Names of input variables
• options - CompileOptions controlling CPython divergences; usually CompileOptions::default()

Errors

Returns MontyException if the code cannot be parsed.

pub fn code(&self) -> &str

Returns the code that was parsed to create this snapshot.

pub fn run( &self, inputs: Vec<MontyObject>, resource_tracker: impl ResourceTracker, print: PrintWriter<'_>, ) -> Result<MontyObject, MontyException>

Executes the code to completion assuming not external functions or snapshotting.

This is marginally faster than running with snapshotting enabled since we don’t need to track the position in code, but does not allow calling of external functions.

Arguments

• inputs - Values to fill the first N slots of the namespace
• resource_tracker - Custom resource tracker implementation
• print - print output writer

pub fn run_no_limits( &self, inputs: Vec<MontyObject>, ) -> Result<MontyObject, MontyException>

Executes the code to completion with no resource limits, printing to stdout/stderr.

pub fn dump(&self) -> Result<Vec<u8>, Error>

Serializes the runner to a binary format.

The serialized data can be stored and later restored with load(). This allows caching parsed code to avoid re-parsing on subsequent runs.

Errors

Returns an error if serialization fails.

pub fn load(bytes: &[u8]) -> Result<MontyRun, Error>

Deserializes a runner from binary format.

Arguments

• bytes - The serialized runner data from dump()

Errors

Returns an error if deserialization fails.

pub fn start<T>( self, inputs: Vec<MontyObject>, resource_tracker: T, print: PrintWriter<'_>, ) -> Result<RunProgress<T>, MontyException>

where T: ResourceTracker,

Starts execution with the given inputs and resource tracker, consuming self.

Creates the heap and namespaces, then begins execution.

For iterative execution, start() consumes self and returns a RunProgress:

• RunProgress::FunctionCall(call) - external function call, call call.resume(return_value) to resume
• RunProgress::Complete(value) - execution finished

This enables snapshotting execution state and returning control to the host application during long-running computations.

Arguments

• inputs - Initial input values (must match length of input_names from new())
• resource_tracker - Resource tracker for the execution
• print - Writer for print output

Errors

Returns MontyException if:

• The number of inputs doesn’t match the expected count
• An input value is invalid (e.g., MontyObject::Repr)
• A runtime error occurs during execution

Panics

This method should not panic under normal operation. Internal assertions may panic if the VM reaches an inconsistent state (indicating a bug).

Trait Implementations

impl Clone for MontyRun

fn clone(&self) -> MontyRun

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MontyRun

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MontyRun

fn deserialize<__D>( __deserializer: __D, ) -> Result<MontyRun, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for MontyRun

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.