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 

5 

6if TYPE_CHECKING: 

7 from .lark import PostLex 

8 from .lexer import Lexer 

9 from typing import Union, Type 

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

11 from typing import Literal 

12 else: 

13 from typing_extensions import Literal 

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

15 from typing import TypeAlias 

16 else: 

17 from typing_extensions import TypeAlias 

18 

19from .utils import Serialize 

20from .lexer import TerminalDef, Token 

21 

22###{standalone 

23 

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

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

26_Callback = Callable[[Token], Token] 

27 

28class LexerConf(Serialize): 

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

30 __serialize_namespace__ = TerminalDef, 

31 

32 terminals: Collection[TerminalDef] 

33 re_module: ModuleType 

34 ignore: Collection[str] 

35 postlex: 'Optional[PostLex]' 

36 callbacks: Dict[str, _Callback] 

37 g_regex_flags: int 

38 skip_validation: bool 

39 use_bytes: bool 

40 lexer_type: Optional[_LexerArgType] 

41 strict: bool 

42 

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

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

45 self.terminals = terminals 

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

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

48 self.ignore = ignore 

49 self.postlex = postlex 

50 self.callbacks = callbacks or {} 

51 self.g_regex_flags = g_regex_flags 

52 self.re_module = re_module 

53 self.skip_validation = skip_validation 

54 self.use_bytes = use_bytes 

55 self.strict = strict 

56 self.lexer_type = None 

57 

58 def _deserialize(self): 

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

60 

61 def __deepcopy__(self, memo=None): 

62 return type(self)( 

63 deepcopy(self.terminals, memo), 

64 self.re_module, 

65 deepcopy(self.ignore, memo), 

66 deepcopy(self.postlex, memo), 

67 deepcopy(self.callbacks, memo), 

68 deepcopy(self.g_regex_flags, memo), 

69 deepcopy(self.skip_validation, memo), 

70 deepcopy(self.use_bytes, memo), 

71 ) 

72 

73 

74class ParserConf(Serialize): 

75 __serialize_fields__ = 'rules', 'start', 'parser_type' 

76 

77 def __init__(self, rules, callbacks, start): 

78 assert isinstance(start, list) 

79 self.rules = rules 

80 self.callbacks = callbacks 

81 self.start = start 

82 

83 self.parser_type = None 

84 

85###}