monty 0.0.21

A sandboxed, snapshotable Python interpreter written in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! Implementation of the `sys` module.
//!
//! Provides a minimal implementation of Python's `sys` module with:
//! - `version`: Python version string (e.g., "3.14.0 (Monty)")
//! - `version_info`: Named tuple (3, 14, 0, 'final', 0)
//! - `platform`: Platform identifier ("monty")
//! - `stdout`: Marker for standard output (no real functionality)
//! - `stderr`: Marker for standard error (no real functionality)
//!
//! Under the `test-hooks` feature one callable is also exposed:
//! - `setrecursionlimit(n)`: tighten the active recursion ceiling so fixtures
//!   can simulate Monty's lower default depth on CPython too. Only allows
//!   *lowering* the host-configured ceiling — see [`SysFunctions`].

#[cfg(feature = "test-hooks")]
use crate::{
    args::ArgValues,
    exception_private::{ExcType, ExcTypeExt, RunResult},
    modules::ModuleFunctions,
};
use crate::{
    bytecode::VM,
    heap::{HeapData, HeapId},
    intern::StaticStrings,
    types::{Module, NamedTuple},
    value::{Marker, Value},
};

/// Functions exposed by the `sys` module under the `test-hooks` feature.
///
/// Production builds keep `sys` attribute-only; this enum exists so fixtures
/// (and only fixtures) can call back into Monty internals that production
/// sandbox code must never reach.
#[cfg(feature = "test-hooks")]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, strum::Display, serde::Serialize, serde::Deserialize)]
#[strum(serialize_all = "lowercase")]
pub(crate) enum SysFunctions {
    /// `sys.setrecursionlimit(n)` — tightens the live recursion ceiling to
    /// `n`. Only allows lowering; attempting to raise raises `ValueError`.
    Setrecursionlimit,
}

/// Creates the `sys` module and allocates it on the heap.
///
/// # Panics
///
/// Panics if the required strings have not been pre-interned during prepare phase.
pub fn create_module(vm: &mut VM<'_>) -> HeapId {
    let mut module = Module::new(StaticStrings::Sys);

    // sys.platform
    module.set_attr(StaticStrings::Platform, StaticStrings::Monty.into(), vm);

    // sys.stdout / sys.stderr - markers for standard output/error
    module.set_attr(StaticStrings::Stdout, Value::Marker(Marker(StaticStrings::Stdout)), vm);
    module.set_attr(StaticStrings::Stderr, Value::Marker(Marker(StaticStrings::Stderr)), vm);

    // sys.version
    module.set_attr(StaticStrings::Version, StaticStrings::MontyVersionString.into(), vm);
    // sys.version_info - named tuple (major=3, minor=14, micro=0, releaselevel='final', serial=0)
    let version_info = NamedTuple::new(
        StaticStrings::SysVersionInfo,
        vec![
            StaticStrings::Major.into(),
            StaticStrings::Minor.into(),
            StaticStrings::Micro.into(),
            StaticStrings::Releaselevel.into(),
            StaticStrings::Serial.into(),
        ],
        vec![
            Value::Int(3),
            Value::Int(14),
            Value::Int(0),
            Value::InternString(StaticStrings::Final.into()),
            Value::Int(0),
        ],
    );
    let version_info_id = vm.heap.allocate(HeapData::NamedTuple(Box::new(version_info)));
    module.set_attr(StaticStrings::VersionInfo, Value::Ref(version_info_id), vm);

    // Test-only callables — see the module-level docs and the
    // [`test-hooks`] feature gate.
    #[cfg(feature = "test-hooks")]
    module.set_attr(
        StaticStrings::Setrecursionlimit,
        Value::ModuleFunction(ModuleFunctions::Sys(SysFunctions::Setrecursionlimit)),
        vm,
    );

    vm.heap.allocate(HeapData::Module(Box::new(module)))
}

/// Dispatches a `sys` module function call.
///
/// Only present under the `test-hooks` feature — production builds register
/// no callables on the `sys` module, so this dispatcher would have nothing
/// to do.
#[cfg(feature = "test-hooks")]
pub(super) fn call(vm: &mut VM<'_>, function: SysFunctions, args: ArgValues) -> RunResult<Value> {
    match function {
        SysFunctions::Setrecursionlimit => setrecursionlimit(vm, args),
    }
}

/// `sys.setrecursionlimit(n)` — tightens the live recursion ceiling.
///
/// Differs from CPython in one safety-critical way: the limit may only be
/// *lowered*, never raised. Sandboxed code raising the ceiling would let it
/// escape the host-configured depth bound that protects the Rust call stack
/// from overflow inside recursive type machinery (repr, eq, hash, json
/// dump, etc.). Attempts to raise raise `ValueError` with a message
/// pointing at the current cap.
#[cfg(feature = "test-hooks")]
fn setrecursionlimit(vm: &mut VM<'_>, args: ArgValues) -> RunResult<Value> {
    let arg = args.get_one_arg("sys.setrecursionlimit", vm.heap)?;
    let Value::Int(limit) = arg else {
        arg.drop_with(vm);
        return Err(ExcType::type_error("sys.setrecursionlimit() argument must be int"));
    };
    let Ok(new_limit) = usize::try_from(limit) else {
        return Err(ExcType::value_error("recursion limit must be greater or equal than 1"));
    };
    if new_limit == 0 {
        return Err(ExcType::value_error("recursion limit must be greater or equal than 1"));
    }
    match vm.heap.tracker().lower_recursion_limit(new_limit) {
        Ok(()) => Ok(Value::None),
        Err(current) => Err(ExcType::value_error(format!(
            "sys.setrecursionlimit: cannot raise above current limit {current} (sandbox only allows lowering)"
        ))),
    }
}