Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/jmespath/exceptions.py: 71%

1from jmespath.compat import with_str_method 

2 

3 

4class JMESPathError(ValueError): 

5 pass 

6 

7 

8@with_str_method 

9class ParseError(JMESPathError): 

10 _ERROR_MESSAGE = 'Invalid jmespath expression' 

11 def __init__(self, lex_position, token_value, token_type, 

12 msg=_ERROR_MESSAGE): 

13 super(ParseError, self).__init__(lex_position, token_value, token_type) 

14 self.lex_position = lex_position 

15 self.token_value = token_value 

16 self.token_type = token_type.upper() 

17 self.msg = msg 

18 # Whatever catches the ParseError can fill in the full expression 

19 self.expression = None 

20 

21 def __str__(self): 

22 # self.lex_position +1 to account for the starting double quote char. 

23 underline = ' ' * (self.lex_position + 1) + '^' 

24 return ( 

25 '%s: Parse error at column %s, ' 

26 'token "%s" (%s), for expression:\n"%s"\n%s' % ( 

27 self.msg, self.lex_position, self.token_value, self.token_type, 

28 self.expression, underline)) 

29 

30 

31@with_str_method 

32class IncompleteExpressionError(ParseError): 

33 def set_expression(self, expression): 

34 self.expression = expression 

35 self.lex_position = len(expression) 

36 self.token_type = None 

37 self.token_value = None 

38 

39 def __str__(self): 

40 # self.lex_position +1 to account for the starting double quote char. 

41 underline = ' ' * (self.lex_position + 1) + '^' 

42 return ( 

43 'Invalid jmespath expression: Incomplete expression:\n' 

44 '"%s"\n%s' % (self.expression, underline)) 

45 

46 

47@with_str_method 

48class LexerError(ParseError): 

49 def __init__(self, lexer_position, lexer_value, message, expression=None): 

50 self.lexer_position = lexer_position 

51 self.lexer_value = lexer_value 

52 self.message = message 

53 super(LexerError, self).__init__(lexer_position, 

54 lexer_value, 

55 message) 

56 # Whatever catches LexerError can set this. 

57 self.expression = expression 

58 

59 def __str__(self): 

60 underline = ' ' * self.lexer_position + '^' 

61 return 'Bad jmespath expression: %s:\n%s\n%s' % ( 

62 self.message, self.expression, underline) 

63 

64 

65@with_str_method 

66class ArityError(ParseError): 

67 def __init__(self, expected, actual, name): 

68 self.expected_arity = expected 

69 self.actual_arity = actual 

70 self.function_name = name 

71 self.expression = None 

72 

73 def __str__(self): 

74 return ("Expected %s %s for function %s(), " 

75 "received %s" % ( 

76 self.expected_arity, 

77 self._pluralize('argument', self.expected_arity), 

78 self.function_name, 

79 self.actual_arity)) 

80 

81 def _pluralize(self, word, count): 

82 if count == 1: 

83 return word 

84 else: 

85 return word + 's' 

86 

87 

88@with_str_method 

89class VariadictArityError(ArityError): 

90 def __str__(self): 

91 return ("Expected at least %s %s for function %s(), " 

92 "received %s" % ( 

93 self.expected_arity, 

94 self._pluralize('argument', self.expected_arity), 

95 self.function_name, 

96 self.actual_arity)) 

97 

98 

99@with_str_method 

100class JMESPathTypeError(JMESPathError): 

101 def __init__(self, function_name, current_value, actual_type, 

102 expected_types): 

103 self.function_name = function_name 

104 self.current_value = current_value 

105 self.actual_type = actual_type 

106 self.expected_types = expected_types 

107 

108 def __str__(self): 

109 return ('In function %s(), invalid type for value: %s, ' 

110 'expected one of: %s, received: "%s"' % ( 

111 self.function_name, self.current_value, 

112 self.expected_types, self.actual_type)) 

113 

114 

115class EmptyExpressionError(JMESPathError): 

116 def __init__(self): 

117 super(EmptyExpressionError, self).__init__( 

118 "Invalid JMESPath expression: cannot be empty.") 

119 

120 

121class UnknownFunctionError(JMESPathError): 

122 pass