Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/lark/common.py: 81%

1from copy import deepcopy 

2import sys 

3from types import ModuleType 

4from typing import Callable, Collection, Dict, Optional, TYPE_CHECKING, List 

5 

6if TYPE_CHECKING: 

7 from .lark import PostLex 

8 from .lexer import Lexer 

9 from .grammar import Rule 

10 from typing import Union, Type 

11 if sys.version_info >= (3, 8): 

12 from typing import Literal 

13 else: 

14 from typing_extensions import Literal 

15 if sys.version_info >= (3, 10): 

16 from typing import TypeAlias 

17 else: 

18 from typing_extensions import TypeAlias 

19 

20from .utils import Serialize 

21from .lexer import TerminalDef, Token 

22 

23###{standalone 

24 

25_ParserArgType: 'TypeAlias' = 'Literal["earley", "lalr", "cyk", "auto"]' 

26_LexerArgType: 'TypeAlias' = 'Union[Literal["auto", "basic", "contextual", "dynamic", "dynamic_complete"], Type[Lexer]]' 

27_LexerCallback = Callable[[Token], Token] 

28ParserCallbacks = Dict[str, Callable] 

29 

30class LexerConf(Serialize): 

31 __serialize_fields__ = 'terminals', 'ignore', 'g_regex_flags', 'use_bytes', 'lexer_type' 

32 __serialize_namespace__ = TerminalDef, 

33 

34 terminals: Collection[TerminalDef] 

35 re_module: ModuleType 

36 ignore: Collection[str] 

37 postlex: 'Optional[PostLex]' 

38 callbacks: Dict[str, _LexerCallback] 

39 g_regex_flags: int 

40 skip_validation: bool 

41 use_bytes: bool 

42 lexer_type: Optional[_LexerArgType] 

43 strict: bool 

44 

45 def __init__(self, terminals: Collection[TerminalDef], re_module: ModuleType, ignore: Collection[str]=(), postlex: 'Optional[PostLex]'=None, 

46 callbacks: Optional[Dict[str, _LexerCallback]]=None, g_regex_flags: int=0, skip_validation: bool=False, use_bytes: bool=False, strict: bool=False): 

47 self.terminals = terminals 

48 self.terminals_by_name = {t.name: t for t in self.terminals} 

49 assert len(self.terminals) == len(self.terminals_by_name) 

50 self.ignore = ignore 

51 self.postlex = postlex 

52 self.callbacks = callbacks or {} 

53 self.g_regex_flags = g_regex_flags 

54 self.re_module = re_module 

55 self.skip_validation = skip_validation 

56 self.use_bytes = use_bytes 

57 self.strict = strict 

58 self.lexer_type = None 

59 

60 def _deserialize(self): 

61 self.terminals_by_name = {t.name: t for t in self.terminals} 

62 

63 def __deepcopy__(self, memo=None): 

64 return type(self)( 

65 deepcopy(self.terminals, memo), 

66 self.re_module, 

67 deepcopy(self.ignore, memo), 

68 deepcopy(self.postlex, memo), 

69 deepcopy(self.callbacks, memo), 

70 deepcopy(self.g_regex_flags, memo), 

71 deepcopy(self.skip_validation, memo), 

72 deepcopy(self.use_bytes, memo), 

73 ) 

74 

75class ParserConf(Serialize): 

76 __serialize_fields__ = 'rules', 'start', 'parser_type' 

77 

78 rules: List['Rule'] 

79 callbacks: ParserCallbacks 

80 start: List[str] 

81 parser_type: _ParserArgType 

82 

83 def __init__(self, rules: List['Rule'], callbacks: ParserCallbacks, start: List[str]): 

84 assert isinstance(start, list) 

85 self.rules = rules 

86 self.callbacks = callbacks 

87 self.start = start 

88 

89###}