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

1from typing import 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 

61class RuleOptions(Serialize): 

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

63 

64 keep_all_tokens: bool 

65 expand1: bool 

66 priority: Optional[int] 

67 template_source: Optional[str] 

68 empty_indices: Tuple[bool, ...] 

69 

70 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: 

71 self.keep_all_tokens = keep_all_tokens 

72 self.expand1 = expand1 

73 self.priority = priority 

74 self.template_source = template_source 

75 self.empty_indices = empty_indices 

76 

77 def __repr__(self): 

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

79 self.keep_all_tokens, 

80 self.expand1, 

81 self.priority, 

82 self.template_source 

83 ) 

84 

85 

86class Rule(Serialize): 

87 """ 

88 origin : a symbol 

89 expansion : a list of symbols 

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

91 """ 

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

93 

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

95 __serialize_namespace__ = Terminal, NonTerminal, RuleOptions 

96 

97 origin: NonTerminal 

98 expansion: Sequence[Symbol] 

99 order: int 

100 alias: Optional[str] 

101 options: RuleOptions 

102 _hash: int 

103 

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

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

106 self.origin = origin 

107 self.expansion = expansion 

108 self.alias = alias 

109 self.order = order 

110 self.options = options or RuleOptions() 

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

112 

113 def _deserialize(self): 

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

115 

116 def __str__(self): 

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

118 

119 def __repr__(self): 

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

121 

122 def __hash__(self): 

123 return self._hash 

124 

125 def __eq__(self, other): 

126 if not isinstance(other, Rule): 

127 return False 

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

129 

130 

131###}