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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

# === Empty tuple identity (singleton optimization) ===
# In Python, () is () is always True because empty tuples are interned
assert () is ()
assert tuple() is ()
assert tuple() is tuple()
a = ()
b = ()
assert a is b
# Empty tuple from operations
assert (1,)[1:] is ()
assert (1, 2) * 0 is ()

# === Tuple length ===
assert len(()) == 0
assert len((1,)) == 1
assert len((1, 2, 3)) == 3

# === Tuple indexing ===
a = (1, 2, 3)
assert a[1] == 2

a = ('a', 'b', 'c')
assert a[0 - 2] == 'b'
assert a[-1] == 'c'

# === Nested tuples ===
assert ((1, 2), (3, 4)) == ((1, 2), (3, 4))

# === Tuple repr/str ===
assert repr((1, 2)) == '(1, 2)'
assert str((1, 2)) == '(1, 2)'

# === Tuple concatenation (+) ===
assert (1, 2) + (3, 4) == (1, 2, 3, 4)
assert () + (1, 2) == (1, 2)
assert (1, 2) + () == (1, 2)
assert () + () == ()
assert ('a', 'b') + ('c',) == ('a', 'b', 'c')
assert ((1, 2),) + ((3, 4),) == ((1, 2), (3, 4))

# === Tuple repetition (*) ===
assert (1, 2) * 3 == (1, 2, 1, 2, 1, 2)
assert 3 * (1, 2) == (1, 2, 1, 2, 1, 2)
assert (1,) * 0 == ()
assert (1,) * -1 == ()
assert () * 5 == ()
assert () * (2**30) == ()
assert (2**30) * () == ()
assert (1, 2) * 1 == (1, 2)

# === Tuple augmented assignment edge cases ===
t = ([1],)
try:
    t[0] += [2]
    assert False, 'tuple item augmented assignment should fail'
except TypeError as e:
    assert e.args == ("'tuple' object does not support item assignment",)
    assert t == ([1, 2],)

# === tuple() constructor ===
assert tuple() == ()
assert tuple([1, 2, 3]) == (1, 2, 3)
assert tuple((1, 2, 3)) == (1, 2, 3)
assert tuple(range(3)) == (0, 1, 2)
assert tuple('abc') == ('a', 'b', 'c')
assert tuple(b'abc') == (97, 98, 99)
assert tuple({'a': 1, 'b': 2}) == ('a', 'b')

# non-ASCII strings (multi-byte UTF-8)
assert tuple('héllo') == ('h', 'é', 'l', 'l', 'o')
assert tuple('日本') == ('日', '本')
assert tuple('a🎉b') == ('a', '🎉', 'b')

# === Tuple unpacking (PEP 448) ===
a = (1, 2)
b = (3, 4)
assert (*a,) == (1, 2)
assert (*a, *b) == (1, 2, 3, 4)
assert (0, *a, 5) == (0, 1, 2, 5)
assert (*(),) == ()
assert (*[1, 2],) == (1, 2)

# === Tuple comparison (<, >, <=, >=) ===
assert (1, 2) < (1, 3)
assert (1,) < (2,)
assert () < (1,)
assert (1, 2) < (1, 2, 3)
assert not (1, 2) < (1, 2), 'not lt when equal'
assert not (1, 3) < (1, 2), 'not lt when greater'

assert (1, 3) > (1, 2)
assert (2,) > (1,)
assert (1,) > ()
assert (1, 2, 3) > (1, 2)
assert not (1, 2) > (1, 2), 'not gt when equal'

assert (1, 2) <= (1, 2)
assert (1, 2) <= (1, 3)
assert not (1, 3) <= (1, 2), 'not le when greater'

assert (1, 2) >= (1, 2)
assert (1, 3) >= (1, 2)
assert not (1, 2) >= (1, 3), 'not ge when less'

# === Tuple comparison with sorted() ===
assert sorted([(2, 'b'), (1, 'a')]) == [(1, 'a'), (2, 'b')]
assert sorted([(1, 'b'), (1, 'a')]) == [(1, 'a'), (1, 'b')]
assert sorted([(3,), (1,), (2,)]) == [(1,), (2,), (3,)]

# === Nested tuple comparison ===
assert ((1, 2), 3) < ((1, 3), 2)
assert (1, (2, 3)) < (1, (2, 4))

# === Equal-but-unorderable elements (None, lists, dicts) ===
# CPython checks __eq__ first; equal elements skip ordering comparison
assert not (1, None) < (1, None), 'equal None elements not lt'
assert (1, None) <= (1, None)
assert (1, None) >= (1, None)
assert not (1, None) > (1, None), 'equal None elements not gt'
assert (1, None) < (2, None)
assert (1, [1, 2]) <= (1, [1, 2])

# === Mixed types in tuple comparison ===
assert (1,) < (2.0,)
assert (1.0,) < (2,)
assert (True,) < (2,)
assert (False,) < (True,)
assert (1, 'a') < (1, 'b')
assert ('a', 1) < ('b', 1)

# === Empty and equal tuples ===
assert not () < (), 'empty tuples not lt'
assert () <= ()
assert () >= ()
assert not () > (), 'empty tuples not gt'

# === Tuple reprs ===
assert repr(()) == '()'
assert repr((1,)) == '(1,)'
assert repr((1, 2)) == '(1, 2)'
assert repr((1, (2, 3))) == '(1, (2, 3))'

# === `in` / `not in` ===
tu = (1, 'two', 3)
assert 1 in tu
assert 'two' in tu
assert 9 not in tu
assert () == ()
assert 2 in (1, (2, 3))[1]
# Members compare by value, across types where Python considers them equal.
assert True in (1, 2)
assert 1.0 in (1, 2)
assert (2, 3) in (1, (2, 3))
assert [2, 3] in (1, [2, 3])
assert None in (None,)
assert 1 not in ()