GeezerVison is showing docs.rs — Interpreter in rustpython - Rust pub struct Interpreter {
pub global_state: Arc<PyGlobalState>,
/* private fields */
}
Expand descriptionOne isolated Python interpreter in the process (≈ CPython PyInterpreterState + main tstate).
Historically RustPython exposed a single process-level Interpreter. For PEP 734
(multiple interpreters / subinterpreters) this type is now the owned handle for
one interpreter. Use Interpreter::create_subinterpreter to create additional
isolated interpreters that share the process-wide type context but not modules or
PyGlobalState.
§Examples
Runs a simple embedded hello world program.
use rustpython_vm::Interpreter;
use rustpython_vm::compiler::Mode;
Interpreter::without_stdlib(Default::default()).enter(|vm| {
let scope = vm.new_scope_with_builtins();
let source = r#"print("Hello World!")"#;
let code_obj = vm.compile(
source,
Mode::Exec,
"<embedded>",
).map_err(|err| err.into_pyexception(vm, Some(source))).unwrap();
vm.run_code_obj(code_obj, scope).unwrap();
});
Fields§§global_state: Arc<PyGlobalState>Implementations§
Create a new interpreter configuration builder.
§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();
This is a bare unit to build up an interpreter without the standard library.
To create an interpreter with the standard library with the rustpython crate, use rustpython::InterpreterBuilder.
To create an interpreter without the rustpython crate, but only with rustpython-vm,
try to build one from the source code of InterpreterBuilder. It will not be a one-liner but it also will not be too hard.
Create with initialize function taking mutable vm reference.
Note: This is a legacy API. To add stdlib, use Interpreter::builder() instead.
Where this interpreter was created.
Whether this is a top-level interpreter rather than a subinterpreter.
Every top-level interpreter answers true; for the process main, use
Interpreter::is_process_main.
Whether this is the PEP 734 process main interpreter (get_main()).
Unlike Interpreter::is_main, which is set for every top-level
interpreter, this is true for only the single first-registered main.
Create a subinterpreter and hand ownership to the runtime, returning its
id. The runtime keeps it alive until runtime::take_owned_interpreter.
This is the shape _interpreters.create() uses: Python receives an
id, not an owned handle.
Create a runtime-owned subinterpreter with the given PEP 734 config.
Create an isolated subinterpreter sharing this interpreter’s type context
(Context) and module definitions, but with its own sys.modules,
builtins module instance, thread registry, and stop-the-world state.
May be called while the parent is entered (matching CPython, where
_interpreters.create() runs under the main interpreter). When the
calling thread is currently attached to a VM, that attachment is
temporarily saved so the subinterpreter can bootstrap as an outermost
enter (correct thread-slot / stop-the-world state).
Create a subinterpreter from a parent VM (the currently entered one).
Create a subinterpreter with an explicit PEP 734 / PyInterpreterConfig.
Spawn a new OS-thread VM that shares this interpreter’s sys / builtins.
Run a function with the main virtual machine and return a PyResult of the result.
To enter vm context multiple times or to avoid buffer/exception management, this function is preferred.
enter is lightweight and it returns a python object in PyResult.
You can stop or continue the execution multiple times by calling enter.
To finalize the vm once all desired enters are called, calling finalize will be helpful.
See also Interpreter::run for managed way to run the interpreter.
Run a function with the main virtual machine and return exit code.
To enter vm context only once and safely terminate the vm, this function is preferred.
Unlike Interpreter::enter, run calls finalize and returns exit code.
You will not be able to obtain Python exception in this way.
See Interpreter::finalize for the finalization steps.
See also Interpreter::enter for pure function call to obtain Python exception.
Finalize vm and turns an exception to exit code.
Finalization steps (matching Py_FinalizeEx):
- Flush stdout and stderr.
- Handle exit exception and turn it to exit code.
- Call threading._shutdown() to join non-daemon threads.
- Run atexit exit functions.
- Set finalizing flag and hang remaining daemon threads.
- Forced GC collection pass (collect cycles while builtins are available).
- Module finalization (finalize_modules).
- Clear interpreter-owned cross-interpreter data.
- Final stdout/stderr flush.
Note that calling finalize is not necessary by purpose though.
Auto Trait Implementations§Blanket Implementations§
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more
Returns the argument unchanged.
Calls U::from(self).
That is, this conversion is whatever the implementation of
From<T> for U chooses to do.
The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.
|