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