monty-type-checking 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

# This file contains intentional type errors to test the type checker.
# Each section demonstrates a different category of type error.
# ===

import sys
from typing import TypedDict, assert_type


def takes_int(x: int) -> None:
    pass


def takes_str(x: str) -> None:
    pass


def takes_list_int(x: list[int]) -> None:
    pass


# Wrong primitive types
takes_int('hello')
takes_int(3.14)
takes_str(42)
takes_str([1, 2, 3])

# Wrong container element types
takes_list_int(['a', 'b', 'c'])
takes_list_int([1.0, 2.0, 3.0])


# === Invalid return types ===


def should_return_int() -> int:
    return 'oops'


def should_return_str() -> str:
    return 123


def should_return_list_int() -> list[int]:
    return ['a', 'b']


def should_return_none() -> None:
    return 42


# === Type mismatches in expressions ===


def get_int() -> int:
    return 42


def get_str() -> str:
    return 'hello'


# Binary operations with incompatible types
result1 = get_int() + get_str()
result2 = get_str() - get_int()


# === assert_type failures ===

x: int = 42
assert_type(x, str)

y: list[int] = [1, 2, 3]
assert_type(y, list[str])


# === Attribute errors ===


class MyClass:
    def __init__(self) -> None:
        self.value: int = 42


obj = MyClass()
z = obj.nonexistent_attr


# === Too many / too few arguments ===


def takes_two(a: int, b: str) -> None:
    pass


takes_two(1)
takes_two(1, 'hello', 'extra')


# === Wrong keyword arguments ===

takes_two(a=1, c='wrong')


# === Calling non-callable ===

not_callable: int = 42
not_callable()


# === Errors on loop variables ===
# The loop variable's element type comes through `Iterator.__next__`, which is
# `@abstractmethod`; without `abc` in the stub tree it is `Unknown` and none of
# these errors are reported (https://github.com/pydantic/monty/issues/197).


class SearchTag(TypedDict):
    id: str


def loop_over_typed_dicts(tags: list[SearchTag]) -> None:
    for tag in tags:
        takes_str(tag['uuid'])


def loop_over_ints(values: list[int]) -> None:
    for value in values:
        takes_str(value)


def loop_over_dict_items(mapping: dict[str, int]) -> None:
    for key, value in mapping.items():
        takes_int(key)
        takes_str(value)


print(sys.copyright)