Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/lark/grammar.py: 89%

1from typing import Any, Dict, Optional, Tuple, ClassVar, Sequence 

2 

3from .utils import Serialize 

4 

5###{standalone 

6TOKEN_DEFAULT_PRIORITY = 0 

7 

8 

9class Symbol(Serialize): 

10 __slots__ = ('name',) 

11 

12 name: str 

13 is_term: ClassVar[bool] = NotImplemented 

14 

15 def __init__(self, name: str) -> None: 

16 self.name = name 

17 

18 def __eq__(self, other): 

19 if not isinstance(other, Symbol): 

20 return NotImplemented 

21 return self.is_term == other.is_term and self.name == other.name 

22 

23 def __ne__(self, other): 

24 return not (self == other) 

25 

26 def __hash__(self): 

27 return hash(self.name) 

28 

29 def __repr__(self): 

30 return '%s(%r)' % (type(self).__name__, self.name) 

31 

32 fullrepr = property(__repr__) 

33 

34 def renamed(self, f): 

35 return type(self)(f(self.name)) 

36 

37 

38class Terminal(Symbol): 

39 __serialize_fields__ = 'name', 'filter_out' 

40 

41 is_term: ClassVar[bool] = True 

42 

43 def __init__(self, name: str, filter_out: bool = False) -> None: 

44 self.name = name 

45 self.filter_out = filter_out 

46 

47 @property 

48 def fullrepr(self): 

49 return '%s(%r, %r)' % (type(self).__name__, self.name, self.filter_out) 

50 

51 def renamed(self, f): 

52 return type(self)(f(self.name), self.filter_out) 

53 

54 

55class NonTerminal(Symbol): 

56 __serialize_fields__ = 'name', 

57 

58 is_term: ClassVar[bool] = False 

59 

60 def serialize(self, memo=None) -> Dict[str, Any]: 

61 # TODO this is here because self.name can be a Token instance. 

62 # remove this function when the issue is fixed. (backwards-incompatible) 

63 return {'name': str(self.name), '__type__': 'NonTerminal'} 

64 

65 

66class RuleOptions(Serialize): 

67 __serialize_fields__ = 'keep_all_tokens', 'expand1', 'priority', 'template_source', 'empty_indices' 

68 

69 keep_all_tokens: bool 

70 expand1: bool 

71 priority: Optional[int] 

72 template_source: Optional[str] 

73 empty_indices: Tuple[bool, ...] 

74 

75 def __init__(self, keep_all_tokens: bool=False, expand1: bool=False, priority: Optional[int]=None, template_source: Optional[str]=None, empty_indices: Tuple[bool, ...]=()) -> None: 

76 self.keep_all_tokens = keep_all_tokens 

77 self.expand1 = expand1 

78 self.priority = priority 

79 self.template_source = template_source 

80 self.empty_indices = empty_indices 

81 

82 def __repr__(self): 

83 return 'RuleOptions(%r, %r, %r, %r)' % ( 

84 self.keep_all_tokens, 

85 self.expand1, 

86 self.priority, 

87 self.template_source 

88 ) 

89 

90 

91class Rule(Serialize): 

92 """ 

93 origin : a symbol 

94 expansion : a list of symbols 

95 order : index of this expansion amongst all rules of the same name 

96 """ 

97 __slots__ = ('origin', 'expansion', 'alias', 'options', 'order', '_hash') 

98 

99 __serialize_fields__ = 'origin', 'expansion', 'order', 'alias', 'options' 

100 __serialize_namespace__ = Terminal, NonTerminal, RuleOptions 

101 

102 origin: NonTerminal 

103 expansion: Sequence[Symbol] 

104 order: int 

105 alias: Optional[str] 

106 options: RuleOptions 

107 _hash: int 

108 

109 def __init__(self, origin: NonTerminal, expansion: Sequence[Symbol], 

110 order: int=0, alias: Optional[str]=None, options: Optional[RuleOptions]=None): 

111 self.origin = origin 

112 self.expansion = expansion 

113 self.alias = alias 

114 self.order = order 

115 self.options = options or RuleOptions() 

116 self._hash = hash((self.origin, tuple(self.expansion))) 

117 

118 def _deserialize(self): 

119 self._hash = hash((self.origin, tuple(self.expansion))) 

120 

121 def __str__(self): 

122 return '<%s : %s>' % (self.origin.name, ' '.join(x.name for x in self.expansion)) 

123 

124 def __repr__(self): 

125 return 'Rule(%r, %r, %r, %r)' % (self.origin, self.expansion, self.alias, self.options) 

126 

127 def __hash__(self): 

128 return self._hash 

129 

130 def __eq__(self, other): 

131 if not isinstance(other, Rule): 

132 return False 

133 return self.origin == other.origin and self.expansion == other.expansion 

134 

135 

136###}