Enum MontyObject 

pub enum MontyObject {
    Ellipsis,
    NotImplemented,
    None,
    Bool(bool),
    Int(i64),
    BigInt(BigInt),
    Float(f64),
    String(String),
    Bytes(Vec<u8>),
    List(Vec<MontyObject>),
    Tuple(Vec<MontyObject>),
    NamedTuple {
        type_name: String,
        field_names: Vec<String>,
        values: Vec<MontyObject>,
    },
    Dict(DictPairs),
    Set(Vec<MontyObject>),
    FrozenSet(Vec<MontyObject>),
    Date(MontyDate),
    DateTime(MontyDateTime),
    Time(MontyTime),
    TimeDelta(MontyTimeDelta),
    TimeZone(MontyTimeZone),
    Exception {
        exc_type: ExcType,
        arg: Option<String>,
    },
    Type(MontyType),
    BuiltinFunction(BuiltinsFunctions),
    Path(String),
    FileHandle(MontyFileHandle),
    ClassInstance(Box<MontyClassInstance>),
    Function {
        name: String,
        docstring: Option<String>,
    },
    Repr(String),
    Cycle(usize, String),
}

An owned Python value exchanged between Monty and its host.

Construct MontyObject values to provide globals, external-function results, and other inputs to sandboxed code. Execution results and values passed to host callbacks use the same representation.

Most common Python values have a direct variant, including nested collections and datetime values. Repr and Cycle can only appear in output because they cannot be reconstructed as executable Python values. Exception can be used both to raise an exception and to represent one returned by execution.

Collections are owned snapshots: modifying a returned MontyObject does not modify the corresponding value in a running session.

Hashability

Only immutable variants implement Hash, including the datetime family (Date, DateTime, TimeDelta, TimeZone). Attempting to hash mutable variants (List, Dict) will panic.

Serialization

The derived Serialize / Deserialize impls use an externally tagged format ({"Int": 42}, {"String": "hi"}, …). This is what postcard and serde_json::to_string(&obj) produce. It is lossless and designed for snapshots and binary transport, not for human-facing JSON.

Variants

Ellipsis

Python’s Ellipsis singleton (...).

NotImplemented

Python’s NotImplemented singleton.

None

Python’s None singleton.

Bool(bool)

Python boolean (True or False).

Int(i64)

Python integer (64-bit signed).

BigInt(BigInt)

Python arbitrary-precision integer (larger than i64).

Float(f64)

Python float (64-bit IEEE 754).

String(String)

Python string (UTF-8).

Bytes(Vec<u8>)

Python bytes object.

List(Vec<MontyObject>)

Python list (mutable sequence).

Tuple(Vec<MontyObject>)

Python tuple (immutable sequence).

NamedTuple

Python named tuple (immutable sequence with named fields).

Named tuples behave like tuples but also support attribute access by field name. The type_name is used in repr (e.g., “os.stat_result”), and field_names provides the attribute names for each position.

Fields

type_name: String

Type name for repr (e.g., “os.stat_result”).

field_names: Vec<String>

Field names in order.

values: Vec<MontyObject>

Values in order (same length as field_names).

Dict(DictPairs)

Python dictionary (insertion-ordered mapping).

Set(Vec<MontyObject>)

Python set (mutable, unordered collection of unique elements).

FrozenSet(Vec<MontyObject>)

Python frozenset (immutable, unordered collection of unique elements).

Date(MontyDate)

Python datetime.date.

DateTime(MontyDateTime)

Python datetime.datetime.

Time(MontyTime)

Python datetime.time.

TimeDelta(MontyTimeDelta)

Python datetime.timedelta.

TimeZone(MontyTimeZone)

Python datetime.timezone fixed-offset timezone.

Exception

Python exception with type and optional message argument.

Fields

exc_type: ExcType

The exception type (e.g., ValueError, TypeError).

arg: Option<String>

Optional string argument passed to the exception constructor.

Type(MontyType)

A Python type object (e.g., int, str, list).

Returned by the type() builtin and can be compared with other types.

BuiltinFunction(BuiltinsFunctions)

Path(String)

Python pathlib.Path object (or technically a PurePosixPath).

Represents a filesystem path. Can be used both as input (from host) and output.

FileHandle(MontyFileHandle)

An open file object (the result of open()).

ClassInstance(Box<MontyClassInstance>)

A class instance crossing the sandbox boundary (see MontyClassInstance). Boxed: the payload is larger than every other variant and would grow MontyObject (and so every container element) otherwise.

Function

An external function provided by the host.

Returned by the host in response to a NameLookup to provide a callable that the VM can invoke. When called, the VM yields FunctionCall to the host.

Fields

name: String

The function name (used for repr, error messages, and function call identification).

docstring: Option<String>

Optional docstring for the function.

Repr(String)

Fallback for values that cannot be represented as other variants.

Contains the repr() string of the original value.

This is output-only and cannot be used as an input to the interpreter.

Cycle(usize, String)

Represents a cycle detected during Value-to-MontyObject conversion.

When converting cyclic structures (e.g., a = []; a.append(a)), this variant is used to break the infinite recursion. Contains an opaque identity token (the raw heap index of the object the cycle points back to — meaningful only for equality, and only within the result that produced it) and the type-specific placeholder string (e.g., "[...]" for lists, "{...}" for dicts). Two Cycle values compare equal if they refer to the same object.

This is output-only and cannot be used as an input to the interpreter.

Implementations

impl MontyObject

pub fn dict(dict: impl Into<DictPairs>) -> MontyObject

Creates a new MontyObject from something that can be converted into a DictPairs.

pub fn builtin_function_from_name(name: &str) -> Option<MontyObject>

Resolves a builtin function by its Python name (e.g. "len").

The BuiltinsFunctions enum inside MontyObject::BuiltinFunction is crate-private, so boundaries that serialize a builtin function by name (e.g. the subprocess wire protocol) use this to reconstruct the variant. The name matches the variant’s Display output.

pub const fn host_base_size() -> usize

Returns the fixed host footprint charged for each decoded object.

pub const fn host_metadata_string_size(value: &str) -> usize

Returns the host footprint of one owned string in a metadata vector.

pub fn host_size(&self) -> usize

Shallow host footprint of a freshly decoded obj: the fixed MontyObject size plus any leaf payload it owns directly (string/bytes/bigint bytes, and the Vec<String> field names of structured values, which aren’t themselves MontyObjects and would otherwise be uncharged). Boxed payloads (ClassInstance, Type(Instance)) charge their heap allocation plus the class name; their eager attrs are charged like container elements. Container elements are excluded — each charges its own size via monty-proto’s decode_field, so a list charges size_of::<MontyObject>() here.

pub fn deep_host_size(&self) -> usize

Returns the recursively expanded host footprint used by transport budgets.

Unlike Self::host_size, this includes every value stored in a container.

pub fn py_repr(&self) -> String

Returns the Python repr() string for this value.

Panics

Could panic if out of memory.

pub fn is_truthy(&self) -> bool

Returns true if this value is “truthy” according to Python’s truth testing rules.

In Python, the following values are considered falsy:

• None and Ellipsis
• False
• Zero numeric values (0, 0.0)
• Empty sequences and collections ("", b"", [], (), {})

All other values are truthy, including Exception and Repr variants.

pub fn type_name(&self) -> &str

Returns the Python type name for this value (e.g., "int", "str", "list").

These are the same names returned by Python’s type(x).__name__; a class instance reports its class name ("Point").

Trait Implementations

impl AsRef<MontyObject> for MontyObject

fn as_ref(&self) -> &MontyObject

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for MontyObject

fn clone(&self) -> MontyObject

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MontyObject

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MontyObject

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for MontyObject

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

Formats the value using the given formatter.

impl Eq for MontyObject

impl Hash for MontyObject

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for MontyObject

fn eq(&self, other: &MontyObject) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for MontyObject

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.

impl ToMontyObject for MontyObject

fn into_monty_object(self) -> MontyObject