FilesExpand file tree

 main

/

validate.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

165 lines (115 loc) · 4.15 KB

 main

/

validate.py

Copy path

Top

File metadata and controls

• Code
• Blame

165 lines (115 loc) · 4.15 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

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

157

158

159

160

161

162

163

164

# validate.py

class Validator:

def __init__(self, name=None):

self.name = name

def __set_name__(self, cls, name):

self.name = name

@classmethod

def check(cls, value):

return value

def __set__(self, instance, value):

instance.__dict__[self.name] = self.check(value)

class Typed(Validator):

expected_type = object

@classmethod

def check(cls, value):

if not isinstance(value, cls.expected_type):

raise TypeError(f'Expected {cls.expected_type}')

return super().check(value)

class Integer(Typed):

expected_type = int

class Float(Typed):

expected_type = float

class String(Typed):

expected_type = str

class Positive(Validator):

@classmethod

def check(cls, value):

if value < 0:

raise ValueError('Expected >= 0')

return super().check(value)

class NonEmpty(Validator):

@classmethod

def check(cls, value):

if len(value) == 0:

raise ValueError('Must be non-empty')

return super().check(value)

class PositiveInteger(Integer, Positive):

pass

class PositiveFloat(Float, Positive):

pass

class NonEmptyString(String, NonEmpty):

pass

from inspect import signature

class ValidatedFunction:

def __init__(self, func):

self._func = func

self._signature = signature(func)

self._annotations = dict(func.__annotations__)

self._retcheck = self._annotations.pop('return', None) # Return check

def __call__(self, *args, **kwargs):

bound = self._signature.bind(*args, **kwargs)

for name, val in self._annotations.items():

val.check(bound.arguments[name])

result = self._func(*args, **kwargs)

if self._retcheck:

self._retcheck.check(result)

return result

# 'signature' from 'inspect' module are used to get details about functions in a more useful form

# Signatures of functions(its name, parameters and return its type) can be bound to *args and **kwargs(passed when calling the function)

# Use 'bind()' method of 'signature' objects to bind function arguments to argument names.

# Help performing all error checking

from functools import wraps

def validated(func):

sig = signature(func)

# Gather the function annotations

annotations = dict(func.__annotations__)

# Get the return annonations (if any)

retcheck = annotations.pop('return', None)

@wraps(func)

def wrapper(*args, **kwargs):

bound = sig.bind(*args, **kwargs)

errors = []

# Enforce argument checks

for name, validator in annotations.items():

try:

validator.check(bound.arguments[name])

except Exception as e:

errors.append(f' {name}: {e}')

if errors:

raise TypeError('Bad Arguments\n' + '\n'.join(errors))

result = func(*args, **kwargs)

# Enforce return check (if any)

if retcheck:

try:

retcheck.check(result)

except Exception as e:

raise TypeError(f'Bad return: {e}') from None

return result

return wrapper

def enforce(**annotations):

retcheck = annotations.pop('return_', None)

def decorate(func):

sig = signature(func)

@wraps(func)

def wrapper(*args, **kwargs):

bound = sig.bind(*args, **kwargs)

errors = []

# Enforce argument checks

for name, validator in annotations.items():

try:

validator.check(bound.arguments[name])

except Exception as e:

errors.append(f' {name}: {e}')

if errors:

raise TypeError('Bad Arguments\n' + '\n'.join(errors))

result = func(*args, **kwargs)

# Enforce return check (if any)

if retcheck:

try:

retcheck.check(result)

except Exception as e:

raise TypeError(f'Bad return: {e}') from None

return result

return wrapper

return decorate