FilesExpand file tree

 language

/

typecheck.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

86 lines (71 loc) · 2.56 KB

 language

/

typecheck.py

Copy path

Top

File metadata and controls

• Code
• Blame

86 lines (71 loc) · 2.56 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

import typing

Type = typing.Union[

typing.Any # anything more elaborate really fails with mypy at the moment.

]

def sequence_type(typeinfo: typing.Type[typing.List]) -> Type:

"""Return the type of a sequence, e.g. typing.List"""

return typeinfo.__args__[0] # type: ignore

def tuple_types(typeinfo: typing.Type[typing.Tuple]) -> typing.Sequence[Type]:

"""Return the types of a typing.Tuple"""

return typeinfo.__args__ # type: ignore

def union_types(typeinfo: typing.Type[typing.Tuple]) -> typing.Sequence[Type]:

"""return the types of a typing.Union"""

return typeinfo.__args__ # type: ignore

def mapping_types(typeinfo: typing.Type[typing.Mapping]) -> typing.Tuple[Type, Type]:

"""return the types of a mapping, e.g. typing.Dict"""

return typeinfo.__args__ # type: ignore

def check_option_type(name: str, value: typing.Any, typeinfo: Type) -> None:

"""

Check if the provided value is an instance of typeinfo and raises a

TypeError otherwise. This function supports only those types required for

options.

"""

e = TypeError("Expected {} for {}, but got {}.".format(

typeinfo,

name,

type(value)

))

typename = str(typeinfo)

if typename.startswith("typing.Union"):

for T in union_types(typeinfo):

try:

check_option_type(name, value, T)

except TypeError:

pass

else:

return

raise e

elif typename.startswith("typing.Tuple"):

types = tuple_types(typeinfo)

if not isinstance(value, (tuple, list)):

raise e

if len(types) != len(value):

raise e

for i, (x, T) in enumerate(zip(value, types)):

check_option_type("{}[{}]".format(name, i), x, T)

return

elif typename.startswith("typing.Sequence"):

T = sequence_type(typeinfo)

if not isinstance(value, (tuple, list)):

raise e

for v in value:

check_option_type(name, v, T)

elif typename.startswith("typing.IO"):

if hasattr(value, "read"):

return

else:

raise e

elif typename.startswith("typing.Any"):

return

elif not isinstance(value, typeinfo):

raise e

def typespec_to_str(typespec: typing.Any) -> str:

if typespec in (str, int, bool):

t = typespec.__name__

elif typespec == typing.Optional[str]:

t = 'optional str'

elif typespec == typing.Sequence[str]:

t = 'sequence of str'

else:

raise NotImplementedError

return t