1# -*- coding: utf-8 -*- 2 3from typing import ( 4 TypeVar, Type, List, Dict, IO, Iterator, Callable, Union, Optional, 5 Literal, Protocol, Tuple, Iterable, 6) 7 8from .parsers.lalr_interactive_parser import InteractiveParser 9from .visitors import Transformer 10from .lexer import Token, Lexer, TerminalDef 11from .tree import Tree 12from .exceptions import UnexpectedInput 13from .load_grammar import Grammar 14 15_T = TypeVar('_T') 16 17 18class PostLex(Protocol): 19 20 def process(self, stream: Iterator[Token]) -> Iterator[Token]: 21 ... 22 23 always_accept: Iterable[str] 24 25 26class LarkOptions: 27 start: List[str] 28 parser: str 29 lexer: str 30 transformer: Optional[Transformer] 31 postlex: Optional[PostLex] 32 ambiguity: str 33 regex: bool 34 debug: bool 35 keep_all_tokens: bool 36 propagate_positions: Union[bool, Callable] 37 maybe_placeholders: bool 38 lexer_callbacks: Dict[str, Callable[[Token], Token]] 39 cache: Union[bool, str] 40 g_regex_flags: int 41 use_bytes: bool 42 import_paths: List[Union[str, Callable[[Union[None, str, PackageResource], str], Tuple[str, str]]]] 43 source_path: Optional[str] 44 45 46class PackageResource(object): 47 pkg_name: str 48 path: str 49 50 def __init__(self, pkg_name: str, path: str): ... 51 52 53class FromPackageLoader: 54 def __init__(self, pkg_name: str, search_paths: Tuple[str, ...] = ...): ... 55 56 def __call__(self, base_path: Union[None, str, PackageResource], grammar_path: str) -> Tuple[PackageResource, str]: ... 57 58 59class Lark: 60 source_path: str 61 source_grammar: str 62 grammar: Grammar 63 options: LarkOptions 64 lexer: Lexer 65 terminals: List[TerminalDef] 66 67 def __init__( 68 self, 69 grammar: Union[Grammar, str, IO[str]], 70 *, 71 start: Union[None, str, List[str]] = "start", 72 parser: Literal["earley", "lalr", "cyk", "auto"] = "auto", 73 lexer: Union[Literal["auto", "standard", "contextual", "dynamic", "dynamic_complete"], Type[Lexer]] = "auto", 74 transformer: Optional[Transformer] = None, 75 postlex: Optional[PostLex] = None, 76 ambiguity: Literal["explicit", "resolve"] = "resolve", 77 regex: bool = False, 78 debug: bool = False, 79 keep_all_tokens: bool = False, 80 propagate_positions: Union[bool, Callable] = False, 81 maybe_placeholders: bool = False, 82 lexer_callbacks: Optional[Dict[str, Callable[[Token], Token]]] = None, 83 cache: Union[bool, str] = False, 84 g_regex_flags: int = ..., 85 use_bytes: bool = False, 86 import_paths: List[Union[str, Callable[[Union[None, str, PackageResource], str], Tuple[str, str]]]] = ..., 87 source_path: Optional[str]=None, 88 ): 89 ... 90 91 def parse(self, text: str, start: Optional[str] = None, on_error: Callable[[UnexpectedInput], bool] = None) -> Tree: 92 ... 93 94 def parse_interactive(self, text: str = None, start: Optional[str] = None) -> InteractiveParser: 95 ... 96 97 @classmethod 98 def open(cls: Type[_T], grammar_filename: str, rel_to: Optional[str] = None, **options) -> _T: 99 ... 100 101 @classmethod 102 def open_from_package(cls: Type[_T], package: str, grammar_path: str, search_paths: Tuple[str, ...] = ..., **options) -> _T: 103 ... 104 105 def lex(self, text: str, dont_ignore: bool = False) -> Iterator[Token]: 106 ... 107 108 def get_terminal(self, name: str) -> TerminalDef: 109 ... 110