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

# Native `@dataclass` construction: the synthesized `__init__` binds positional
# and keyword arguments to the annotated fields, applies defaults, excludes
# `ClassVar`, and raises CPython's exact arity/keyword errors.
import typing
from dataclasses import dataclass
from typing import ClassVar


@dataclass
class Point:
    x: int
    y: int


# === Construction: positional, keyword, mixed ===
p = Point(1, 2)
assert p.x == 1 and p.y == 2, 'positional construction sets fields'
assert Point(10, y=20).y == 20
assert Point(x=5, y=6).x == 5


# === Defaults ===
@dataclass
class WithDefault:
    a: int
    b: int = 5
    c: str = 'hi'


assert WithDefault(1).b == 5
assert WithDefault(1).c == 'hi'
assert WithDefault(1, 2).b == 2
assert WithDefault(1, c='x').c == 'x'
assert WithDefault(1, b=9).b == 9


# === ClassVar is excluded from the constructor ===
@dataclass
class WithClassVar:
    x: int
    count: ClassVar[int] = 0


assert WithClassVar(7).x == 7
assert WithClassVar.count == 0


# A dotted spelling is excluded too, and a dotted *type argument*
# (`ClassVar[typing.Dict[...]]`) must not confuse the qualifier match. The
# quoted spelling is covered in `tests/dataclass_rejections.rs`: CPython
# resolves it via the defining module's namespace, so it is not stable here.
@dataclass
class ClassVarSpellings:
    x: int
    bare: ClassVar[int] = 1
    dotted: typing.ClassVar[int] = 3
    dotted_arg: ClassVar[typing.Dict[str, int]] = {}


assert repr(ClassVarSpellings(7)) == 'ClassVarSpellings(x=7)'
# Both stay class attributes — and a ClassVar, being no field, may be mutable.
assert ClassVarSpellings.dotted == 3
assert ClassVarSpellings.dotted_arg == {}


# === Errors: messages match CPython exactly ===
def expect_type_error(fn, message):
    try:
        fn()
        assert False, f'expected TypeError: {message}'
    except TypeError as e:
        assert str(e) == message, f'wrong message: {e!r}'


expect_type_error(lambda: Point(), "Point.__init__() missing 2 required positional arguments: 'x' and 'y'")
expect_type_error(lambda: Point(1), "Point.__init__() missing 1 required positional argument: 'y'")
expect_type_error(lambda: Point(1, 2, 3), 'Point.__init__() takes 3 positional arguments but 4 were given')
expect_type_error(lambda: Point(1, x=2), "Point.__init__() got multiple values for argument 'x'")
expect_type_error(lambda: Point(1, 2, z=3), "Point.__init__() got an unexpected keyword argument 'z'")
expect_type_error(lambda: WithClassVar(7, 8), 'WithClassVar.__init__() takes 2 positional arguments but 3 were given')

# A non-string `**kwargs` key is raised by the call machinery before `__init__`
# is entered, so it outranks every arity error.
expect_type_error(lambda: Point(**{1: 2}), 'keywords must be strings')
expect_type_error(lambda: Point(**{1: 2, 'x': 5}), 'keywords must be strings')
# Every key is checked before any is bound, so a non-string key wins even when
# an unbindable one comes first.
expect_type_error(lambda: Point(**{'z': 1, 1: 2}), 'keywords must be strings')
expect_type_error(lambda: Point(1, **{'x': 2, 1: 3}), 'keywords must be strings')
expect_type_error(lambda: Point(1, 2, 3, **{1: 2}), 'keywords must be strings')


# === Class-body rejections that match CPython exactly ===
def expect_error(fn, exc_type, message):
    try:
        fn()
        assert False, f'expected an exception: {message}'
    except exc_type as e:
        assert str(e) == message, f'wrong message: {e!r}'


def mutable_default():
    @dataclass
    class BadList:
        xs: list[int] = []


def mutable_default_dict():
    @dataclass
    class BadDict:
        d: dict[str, int] = {}


def non_default_after_default():
    @dataclass
    class BadOrder:
        a: int = 1
        b: int


# CPython's rule is hashability; Monty matches it for built-in unhashable types.
# A class setting `__hash__ = None` is NOT rejected (see limitations/dataclasses.md).
expect_error(
    mutable_default, ValueError, "mutable default <class 'list'> for field xs is not allowed: use default_factory"
)
expect_error(
    mutable_default_dict, ValueError, "mutable default <class 'dict'> for field d is not allowed: use default_factory"
)
expect_error(non_default_after_default, TypeError, "non-default argument 'b' follows default argument 'a'")


# === Keyword binding is reported before the positional-arity error ===
# CPython's generated `__init__` binds keywords first, so an excess positional
# only surfaces once the keywords are known to be valid.
expect_type_error(lambda: Point(1, 2, 3, z=4), "Point.__init__() got an unexpected keyword argument 'z'")
expect_type_error(lambda: Point(1, 2, 3, x=4), "Point.__init__() got multiple values for argument 'x'")
expect_type_error(lambda: WithDefault(1, 2, 3, 4, b=9), "WithDefault.__init__() got multiple values for argument 'b'")
expect_type_error(
    lambda: WithDefault(1, 2, 3, 4), 'WithDefault.__init__() takes from 2 to 4 positional arguments but 5 were given'
)


# === Defaults are captured when @dataclass runs, not read at construction ===
# CPython bakes them into the generated `__init__`, so rebinding the class
# attribute afterwards changes `Rebind.b` but not what new instances receive.
@dataclass
class Rebind:
    a: int
    b: int = 5


Rebind.b = 99
assert Rebind(1).b == 5
assert Rebind.b == 99
assert repr(Rebind(1)) == 'Rebind(a=1, b=5)'