FilesExpand file tree

 main

/

validate.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

173 lines (131 loc) · 4.3 KB

 main

/

validate.py

Copy path

Top

File metadata and controls

• Code
• Blame

173 lines (131 loc) · 4.3 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

165

166

167

168

169

170

171

172

173

# 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)

# Collect all derived classes into a dict

validators = { }

@classmethod

def __init_subclass__(cls):

cls.validators[cls.__name__] = cls

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)

_typed_classes = [

('Integer', int),

('Float', float),

('String', str) ]

globals().update((name, type(name, (Typed,), {'expected_type':ty}))

for name, ty in _typed_classes)

class Positive(Validator):

@classmethod

def check(cls, value):

if value < 0:

raise ValueError('must be >= 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

from functools import wraps

def isvalidator(item):

return isinstance(item, type) and issubclass(item, Validator)

def validated(func):

sig = signature(func)

# Gather the function annotations

annotations = { name:val for name, val in func.__annotations__.items()

if isvalidator(val) }

# Get the return annotation (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)

if retcheck:

try:

retcheck.check(result)

except Exception as e:

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

return result

return wrapper

return decorate

# Examples

if __name__ == '__main__':

@validated

def add(x:Integer, y:Integer) -> Integer:

return x + y

@validated

def div(x:Integer, y:Integer) -> Integer:

return x / y

@enforce(x=Integer, y=Integer)

def sub(x, y):

return x - y

class Stock:

name = NonEmptyString()

shares = PositiveInteger()

price = PositiveFloat()

def __init__(self, name, shares, price):

self.name = name

self.shares = shares

self.price = price

def __repr__(self):

return f'Stock({self.name!r}, {self.shares!r}, {self.price!r})'

@property

def cost(self):

return self.shares * self.price

@validated

def sell(self, nshares:PositiveInteger):

self.shares -= nshares