diff --git a/parso/__init__.pyi b/parso/__init__.pyi new file mode 100644 index 0000000..1846996 --- /dev/null +++ b/parso/__init__.pyi @@ -0,0 +1,19 @@ +from typing import Any, Optional, Union + +from parso.grammar import Grammar, load_grammar +from parso.parser import ParserSyntaxError +from parso.utils import python_bytes_to_unicode, split_lines + +__version__: str = ... + +def parse( + code: Optional[Union[str, bytes]], + *, + version: Optional[str] = None, + error_recovery: bool = True, + path: Optional[str] = None, + start_symbol: Optional[str] = None, + cache: bool = False, + diff_cache: bool = False, + cache_path: Optional[str] = None, +) -> Any: ... diff --git a/parso/grammar.pyi b/parso/grammar.pyi new file mode 100644 index 0000000..e5cd2ea --- /dev/null +++ b/parso/grammar.pyi @@ -0,0 +1,38 @@ +from typing import Any, Callable, Generic, Optional, Sequence, TypeVar, Union +from typing_extensions import Literal + +from parso.utils import PythonVersionInfo + +_Token = Any +_NodeT = TypeVar("_NodeT") + +class Grammar(Generic[_NodeT]): + _default_normalizer_config: Optional[Any] = ... + _error_normalizer_config: Optional[Any] = None + _start_nonterminal: str = ... + _token_namespace: Optional[str] = None + def __init__( + self, + text: str, + tokenizer: Callable[[Sequence[str], int], Sequence[_Token]], + parser: Any = ..., + diff_parser: Any = ..., + ) -> None: ... + def parse( + self, + code: Union[str, bytes] = ..., + error_recovery: bool = ..., + path: Optional[str] = ..., + start_symbol: Optional[str] = ..., + cache: bool = ..., + diff_cache: bool = ..., + cache_path: Optional[str] = ..., + ) -> _NodeT: ... + +class PythonGrammar(Grammar): + version_info: PythonVersionInfo + def __init__(self, version_info: PythonVersionInfo, bnf_text: str) -> None: ... + +def load_grammar( + language: Literal["python"] = "python", version: Optional[str] = ..., path: str = ... +) -> Grammar: ... diff --git a/parso/pgen2/__init__.pyi b/parso/pgen2/__init__.pyi new file mode 100644 index 0000000..c62c856 --- /dev/null +++ b/parso/pgen2/__init__.pyi @@ -0,0 +1 @@ +from parso.pgen2.generator import generate_grammar diff --git a/parso/pgen2/generator.pyi b/parso/pgen2/generator.pyi new file mode 100644 index 0000000..0d67a18 --- /dev/null +++ b/parso/pgen2/generator.pyi @@ -0,0 +1,38 @@ +from typing import Any, Generic, Mapping, Sequence, Set, TypeVar, Union + +from parso.pgen2.grammar_parser import NFAState + +_TokenTypeT = TypeVar("_TokenTypeT") + +class Grammar(Generic[_TokenTypeT]): + nonterminal_to_dfas: Mapping[str, Sequence[DFAState[_TokenTypeT]]] + reserved_syntax_strings: Mapping[str, ReservedString] + start_nonterminal: str + def __init__( + self, + start_nonterminal: str, + rule_to_dfas: Mapping[str, Sequence[DFAState]], + reserved_syntax_strings: Mapping[str, ReservedString], + ) -> None: ... + +class DFAPlan: + next_dfa: DFAState + dfa_pushes: Sequence[DFAState] + +class DFAState(Generic[_TokenTypeT]): + from_rule: str + nfa_set: Set[NFAState] + is_final: bool + arcs: Mapping[str, DFAState] # map from all terminals/nonterminals to DFAState + nonterminal_arcs: Mapping[str, DFAState] + transitions: Mapping[Union[_TokenTypeT, ReservedString], DFAPlan] + def __init__( + self, from_rule: str, nfa_set: Set[NFAState], final: NFAState + ) -> None: ... + +class ReservedString: + value: str + def __init__(self, value: str) -> None: ... + def __repr__(self) -> str: ... + +def generate_grammar(bnf_grammar: str, token_namespace: Any) -> Grammar[Any]: ... diff --git a/parso/pgen2/grammar_parser.pyi b/parso/pgen2/grammar_parser.pyi new file mode 100644 index 0000000..b73a5a6 --- /dev/null +++ b/parso/pgen2/grammar_parser.pyi @@ -0,0 +1,20 @@ +from typing import Generator, List, Optional, Tuple + +from parso.python.token import TokenType + +class GrammarParser: + generator: Generator[TokenType, None, None] + def __init__(self, bnf_grammar: str) -> None: ... + def parse(self) -> Generator[Tuple[NFAState, NFAState], None, None]: ... + +class NFAArc: + next: NFAState + nonterminal_or_string: Optional[str] + def __init__( + self, next_: NFAState, nonterminal_or_string: Optional[str] + ) -> None: ... + +class NFAState: + from_rule: str + arcs: List[NFAArc] + def __init__(self, from_rule: str) -> None: ... diff --git a/parso/python/token.pyi b/parso/python/token.pyi new file mode 100644 index 0000000..48e8dac --- /dev/null +++ b/parso/python/token.pyi @@ -0,0 +1,30 @@ +from typing import Container, Iterable + +class TokenType: + name: str + contains_syntax: bool + def __init__(self, name: str, contains_syntax: bool) -> None: ... + +class TokenTypes: + def __init__( + self, names: Iterable[str], contains_syntax: Container[str] + ) -> None: ... + +# not an actual class in the source code, but we need this class to type the fields of +# PythonTokenTypes +class _FakePythonTokenTypesClass(TokenTypes): + STRING: TokenType + NUMBER: TokenType + NAME: TokenType + ERRORTOKEN: TokenType + NEWLINE: TokenType + INDENT: TokenType + DEDENT: TokenType + ERROR_DEDENT: TokenType + FSTRING_STRING: TokenType + FSTRING_START: TokenType + FSTRING_END: TokenType + OP: TokenType + ENDMARKER: TokenType + +PythonTokenTypes: _FakePythonTokenTypesClass = ... diff --git a/parso/python/tokenize.pyi b/parso/python/tokenize.pyi new file mode 100644 index 0000000..1870bc2 --- /dev/null +++ b/parso/python/tokenize.pyi @@ -0,0 +1,24 @@ +from typing import Generator, Iterable, NamedTuple, Tuple + +from parso.python.token import TokenType +from parso.utils import PythonVersionInfo + +class Token(NamedTuple): + type: TokenType + string: str + start_pos: Tuple[int, int] + prefix: str + @property + def end_pos(self) -> Tuple[int, int]: ... + +class PythonToken(Token): + def __repr__(self) -> str: ... + +def tokenize( + code: str, version_info: PythonVersionInfo, start_pos: Tuple[int, int] = (1, 0) +) -> Generator[PythonToken, None, None]: ... +def tokenize_lines( + lines: Iterable[str], + version_info: PythonVersionInfo, + start_pos: Tuple[int, int] = (1, 0), +) -> Generator[PythonToken, None, None]: ... diff --git a/parso/utils.pyi b/parso/utils.pyi new file mode 100644 index 0000000..12c77da --- /dev/null +++ b/parso/utils.pyi @@ -0,0 +1,29 @@ +from typing import NamedTuple, Optional, Sequence, Union + +class Version(NamedTuple): + major: int + minor: int + micro: int + +def split_lines(string: str, keepends: bool = ...) -> Sequence[str]: ... +def python_bytes_to_unicode( + source: Union[str, bytes], encoding: str = ..., errors: str = ... +) -> str: ... +def version_info() -> Version: + """ + Returns a namedtuple of parso's version, similar to Python's + ``sys.version_info``. + """ + ... + +class PythonVersionInfo(NamedTuple): + major: int + minor: int + +def parse_version_string(version: Optional[str]) -> PythonVersionInfo: + """ + Checks for a valid version number (e.g. `3.2` or `2.7.1` or `3`) and + returns a corresponding version info that is always two characters long in + decimal. + """ + ...