Struct InterpreterBuilder 

pub struct InterpreterBuilder {
    pub ctx: Arc<Context>,
    /* private fields */
}

Configuration builder for constructing an Interpreter.

This is the preferred way to configure and create an interpreter with custom modules. Modules must be registered before the interpreter is built, similar to CPython’s PyImport_AppendInittab which must be called before Py_Initialize.

Example

use rustpython_vm::Interpreter;

let builder = Interpreter::builder(Default::default());
// In practice, add stdlib: builder.add_native_modules(&stdlib_module_defs(&builder.ctx))
let interp = builder.build();

Fields

ctx: Arc<Context>

Implementations

impl InterpreterBuilder

pub fn new() -> InterpreterBuilder

Create a new interpreter configuration with default settings.

pub fn settings(self, settings: Settings) -> InterpreterBuilder

Set custom settings for the interpreter.

If called multiple times, only the last settings will be used.

pub fn add_native_module(self, def: &'static PyModuleDef) -> InterpreterBuilder

Add a single native module definition.

Example

use rustpython_vm::{Interpreter, builtins::PyModuleDef};

let builder = Interpreter::builder(Default::default());
// Note: In practice, use module_def from your #[pymodule]
// let def = mymodule::module_def(&builder.ctx);
// let interp = builder.add_native_module(def).build();
let interp = builder.build();

pub fn add_native_modules( self, defs: &[&'static PyModuleDef], ) -> InterpreterBuilder

Add multiple native module definitions.

Example

use rustpython_vm::Interpreter;

let builder = Interpreter::builder(Default::default());
// In practice, use module_defs from rustpython_stdlib:
// let defs = rustpython_stdlib::stdlib_module_defs(&builder.ctx);
// let interp = builder.add_native_modules(&defs).build();
let interp = builder.build();

pub fn init_hook<F>(self, init: F) -> InterpreterBuilder

where F: FnOnce(&mut VirtualMachine) + 'static,

Add a custom initialization hook.

Hooks are executed in the order they are added during interpreter creation. This function will be called after modules are registered but before the VM is initialized, allowing for additional customization.

Example

use rustpython_vm::Interpreter;

let interp = Interpreter::builder(Default::default())
    .init_hook(|vm| {
        // Custom initialization
    })
    .build();

pub fn add_frozen_modules<I>(self, frozen: I) -> InterpreterBuilder

where I: IntoIterator<Item = (&'static str, FrozenModule)>,

Add frozen modules to the interpreter.

Frozen modules are Python modules compiled into the binary. This method accepts any iterator of (name, FrozenModule) pairs.

Example

use rustpython_vm::Interpreter;

let interp = Interpreter::builder(Default::default())
    // In practice: .add_frozen_modules(rustpython_pylib::FROZEN_STDLIB)
    .build();

pub fn build(self) -> Interpreter

Build the interpreter.

This consumes the configuration and returns a fully initialized Interpreter.

pub fn interpreter(self) -> Interpreter

Alias for build() for compatibility with the interpreter() pattern.

Trait Implementations

impl Default for InterpreterBuilder

fn default() -> InterpreterBuilder

Returns the “default value” for a type.

impl InterpreterBuilderExt for InterpreterBuilder

fn init_stdlib(self) -> Self

Initialize the Python standard library.