layermap 0.1.0

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_numliterals.pyi

@@ -0,0 +1,8 @@
+from typing import ClassVar, Literal
+
+from .. import fixer_base
+
+class FixNumliterals(fixer_base.BaseFix):
+    BM_compatible: ClassVar[Literal[False]]
+    def match(self, node): ...
+    def transform(self, node, results): ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_operator.pyi

@@ -0,0 +1,12 @@
+from lib2to3 import fixer_base
+from typing import ClassVar, Literal
+
+def invocation(s): ...
+
+class FixOperator(fixer_base.BaseFix):
+    BM_compatible: ClassVar[Literal[True]]
+    order: ClassVar[Literal["pre"]]
+    methods: str
+    obj: str
+    PATTERN: ClassVar[str]
+    def transform(self, node, results): ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_paren.pyi

@@ -0,0 +1,8 @@
+from typing import ClassVar, Literal
+
+from .. import fixer_base
+
+class FixParen(fixer_base.BaseFix):
+    BM_compatible: ClassVar[Literal[True]]
+    PATTERN: ClassVar[str]
+    def transform(self, node, results) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_print.pyi

@@ -0,0 +1,12 @@
+from _typeshed import Incomplete
+from typing import ClassVar, Literal
+
+from .. import fixer_base
+
+parend_expr: Incomplete
+
+class FixPrint(fixer_base.BaseFix):
+    BM_compatible: ClassVar[Literal[True]]
+    PATTERN: ClassVar[str]
+    def transform(self, node, results): ...
+    def add_kwarg(self, l_nodes, s_kwd, n_expr) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_raise.pyi

@@ -0,0 +1,8 @@
+from typing import ClassVar, Literal
+
+from .. import fixer_base
+
+class FixRaise(fixer_base.BaseFix):
+    BM_compatible: ClassVar[Literal[True]]
+    PATTERN: ClassVar[str]
+    def transform(self, node, results): ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_raw_input.pyi

@@ -0,0 +1,8 @@
+from typing import ClassVar, Literal
+
+from .. import fixer_base
+
+class FixRawInput(fixer_base.BaseFix):
+    BM_compatible: ClassVar[Literal[True]]
+    PATTERN: ClassVar[str]
+    def transform(self, node, results) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_reduce.pyi

@@ -0,0 +1,8 @@
+from lib2to3 import fixer_base
+from typing import ClassVar, Literal
+
+class FixReduce(fixer_base.BaseFix):
+    BM_compatible: ClassVar[Literal[True]]
+    order: ClassVar[Literal["pre"]]
+    PATTERN: ClassVar[str]
+    def transform(self, node, results) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_reload.pyi

@@ -0,0 +1,9 @@
+from typing import ClassVar, Literal
+
+from .. import fixer_base
+
+class FixReload(fixer_base.BaseFix):
+    BM_compatible: ClassVar[Literal[True]]
+    order: ClassVar[Literal["pre"]]
+    PATTERN: ClassVar[str]
+    def transform(self, node, results): ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_renames.pyi

@@ -0,0 +1,17 @@
+from collections.abc import Generator
+from typing import ClassVar, Final, Literal
+
+from .. import fixer_base
+
+MAPPING: Final[dict[str, dict[str, str]]]
+LOOKUP: Final[dict[tuple[str, str], str]]
+
+def alternates(members): ...
+def build_pattern() -> Generator[str]: ...
+
+class FixRenames(fixer_base.BaseFix):
+    BM_compatible: ClassVar[Literal[True]]
+    order: ClassVar[Literal["pre"]]
+    PATTERN: ClassVar[str]
+    def match(self, node): ...
+    def transform(self, node, results) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_repr.pyi

@@ -0,0 +1,8 @@
+from typing import ClassVar, Literal
+
+from .. import fixer_base
+
+class FixRepr(fixer_base.BaseFix):
+    BM_compatible: ClassVar[Literal[True]]
+    PATTERN: ClassVar[str]
+    def transform(self, node, results): ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_set_literal.pyi

@@ -0,0 +1,7 @@
+from lib2to3 import fixer_base
+from typing import ClassVar, Literal
+
+class FixSetLiteral(fixer_base.BaseFix):
+    BM_compatible: ClassVar[Literal[True]]
+    PATTERN: ClassVar[str]
+    def transform(self, node, results): ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_standarderror.pyi

@@ -0,0 +1,8 @@
+from typing import ClassVar, Literal
+
+from .. import fixer_base
+
+class FixStandarderror(fixer_base.BaseFix):
+    BM_compatible: ClassVar[Literal[True]]
+    PATTERN: ClassVar[str]
+    def transform(self, node, results): ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_sys_exc.pyi

@@ -0,0 +1,9 @@
+from typing import ClassVar, Literal
+
+from .. import fixer_base
+
+class FixSysExc(fixer_base.BaseFix):
+    exc_info: ClassVar[list[str]]
+    BM_compatible: ClassVar[Literal[True]]
+    PATTERN: ClassVar[str]
+    def transform(self, node, results): ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_throw.pyi

@@ -0,0 +1,8 @@
+from typing import ClassVar, Literal
+
+from .. import fixer_base
+
+class FixThrow(fixer_base.BaseFix):
+    BM_compatible: ClassVar[Literal[True]]
+    PATTERN: ClassVar[str]
+    def transform(self, node, results) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_tuple_params.pyi

@@ -0,0 +1,16 @@
+from typing import ClassVar, Literal
+
+from .. import fixer_base
+
+def is_docstring(stmt): ...
+
+class FixTupleParams(fixer_base.BaseFix):
+    BM_compatible: ClassVar[Literal[True]]
+    PATTERN: ClassVar[str]
+    def transform(self, node, results): ...
+    def transform_lambda(self, node, results) -> None: ...
+
+def simplify_args(node): ...
+def find_params(node): ...
+def map_to_index(param_list, prefix=[], d=None): ...
+def tuple_name(param_list): ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_types.pyi

@@ -0,0 +1,8 @@
+from typing import ClassVar, Literal
+
+from .. import fixer_base
+
+class FixTypes(fixer_base.BaseFix):
+    BM_compatible: ClassVar[Literal[True]]
+    PATTERN: ClassVar[str]
+    def transform(self, node, results): ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_unicode.pyi

@@ -0,0 +1,12 @@
+from _typeshed import StrPath
+from typing import ClassVar, Literal
+
+from .. import fixer_base
+from ..pytree import Node
+
+class FixUnicode(fixer_base.BaseFix):
+    BM_compatible: ClassVar[Literal[True]]
+    PATTERN: ClassVar[str]
+    unicode_literals: bool
+    def start_tree(self, tree: Node, filename: StrPath) -> None: ...
+    def transform(self, node, results): ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_urllib.pyi

@@ -0,0 +1,15 @@
+from collections.abc import Generator
+from typing import Final, Literal
+
+from .fix_imports import FixImports
+
+MAPPING: Final[dict[str, list[tuple[Literal["urllib.request", "urllib.parse", "urllib.error"], list[str]]]]]
+
+def build_pattern() -> Generator[str]: ...
+
+class FixUrllib(FixImports):
+    def build_pattern(self): ...
+    def transform_import(self, node, results) -> None: ...
+    def transform_member(self, node, results): ...
+    def transform_dot(self, node, results) -> None: ...
+    def transform(self, node, results) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_ws_comma.pyi

@@ -0,0 +1,12 @@
+from typing import ClassVar, Literal
+
+from .. import fixer_base
+from ..pytree import Leaf
+
+class FixWsComma(fixer_base.BaseFix):
+    BM_compatible: ClassVar[Literal[False]]
+    PATTERN: ClassVar[str]
+    COMMA: Leaf
+    COLON: Leaf
+    SEPS: tuple[Leaf, Leaf]
+    def transform(self, node, results): ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_xrange.pyi

@@ -0,0 +1,20 @@
+from _typeshed import Incomplete, StrPath
+from typing import ClassVar, Literal
+
+from .. import fixer_base
+from ..pytree import Node
+
+class FixXrange(fixer_base.BaseFix):
+    BM_compatible: ClassVar[Literal[True]]
+    PATTERN: ClassVar[str]
+    transformed_xranges: set[Incomplete] | None
+    def start_tree(self, tree: Node, filename: StrPath) -> None: ...
+    def finish_tree(self, tree: Node, filename: StrPath) -> None: ...
+    def transform(self, node, results): ...
+    def transform_xrange(self, node, results) -> None: ...
+    def transform_range(self, node, results): ...
+    P1: ClassVar[str]
+    p1: ClassVar[Incomplete]
+    P2: ClassVar[str]
+    p2: ClassVar[Incomplete]
+    def in_special_context(self, node): ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_xreadlines.pyi

@@ -0,0 +1,8 @@
+from typing import ClassVar, Literal
+
+from .. import fixer_base
+
+class FixXreadlines(fixer_base.BaseFix):
+    BM_compatible: ClassVar[Literal[True]]
+    PATTERN: ClassVar[str]
+    def transform(self, node, results) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/fixes/fix_zip.pyi

@@ -0,0 +1,9 @@
+from typing import ClassVar, Literal
+
+from .. import fixer_base
+
+class FixZip(fixer_base.ConditionalFix):
+    BM_compatible: ClassVar[Literal[True]]
+    PATTERN: ClassVar[str]
+    skip_on: ClassVar[Literal["future_builtins.zip"]]
+    def transform(self, node, results): ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/main.pyi

@@ -0,0 +1,42 @@
+from _typeshed import FileDescriptorOrPath
+from collections.abc import Container, Iterable, Iterator, Mapping, Sequence
+from logging import _ExcInfoType
+from typing import AnyStr, Literal
+
+from . import refactor as refactor
+
+def diff_texts(a: str, b: str, filename: str) -> Iterator[str]: ...
+
+class StdoutRefactoringTool(refactor.MultiprocessRefactoringTool):
+    nobackups: bool
+    show_diffs: bool
+    def __init__(
+        self,
+        fixers: Iterable[str],
+        options: Mapping[str, object] | None,
+        explicit: Container[str] | None,
+        nobackups: bool,
+        show_diffs: bool,
+        input_base_dir: str = "",
+        output_dir: str = "",
+        append_suffix: str = "",
+    ) -> None: ...
+    # Same as super.log_error and Logger.error
+    def log_error(  # type: ignore[override]
+        self,
+        msg: str,
+        *args: Iterable[str],
+        exc_info: _ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    # Same as super.write_file but without default values
+    def write_file(  # type: ignore[override]
+        self, new_text: str, filename: FileDescriptorOrPath, old_text: str, encoding: str | None
+    ) -> None: ...
+    # filename has to be str
+    def print_output(self, old: str, new: str, filename: str, equal: bool) -> None: ...  # type: ignore[override]
+
+def warn(msg: object) -> None: ...
+def main(fixer_pkg: str, args: Sequence[AnyStr] | None = None) -> Literal[0, 1, 2]: ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/pgen2/__init__.pyi

@@ -0,0 +1,8 @@
+from collections.abc import Callable
+from typing import Any, TypeAlias
+
+from ..pytree import _RawNode
+from .grammar import Grammar
+
+# This is imported in several lib2to3/pgen2 submodules
+_Convert: TypeAlias = Callable[[Grammar, _RawNode], Any]  # noqa: Y047

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/pgen2/driver.pyi

@@ -0,0 +1,27 @@
+from _typeshed import StrPath
+from collections.abc import Iterable
+from logging import Logger
+from typing import IO
+
+from ..pytree import _NL
+from . import _Convert
+from .grammar import Grammar
+
+__all__ = ["Driver", "load_grammar"]
+
+class Driver:
+    grammar: Grammar
+    logger: Logger
+    convert: _Convert
+    def __init__(self, grammar: Grammar, convert: _Convert | None = None, logger: Logger | None = None) -> None: ...
+    def parse_tokens(
+        self, tokens: Iterable[tuple[int, str, tuple[int, int], tuple[int, int], str]], debug: bool = False
+    ) -> _NL: ...
+    def parse_stream_raw(self, stream: IO[str], debug: bool = False) -> _NL: ...
+    def parse_stream(self, stream: IO[str], debug: bool = False) -> _NL: ...
+    def parse_file(self, filename: StrPath, encoding: str | None = None, debug: bool = False) -> _NL: ...
+    def parse_string(self, text: str, debug: bool = False) -> _NL: ...
+
+def load_grammar(
+    gt: str = "Grammar.txt", gp: str | None = None, save: bool = True, force: bool = False, logger: Logger | None = None
+) -> Grammar: ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/pgen2/grammar.pyi

@@ -0,0 +1,25 @@
+from _typeshed import StrPath
+from typing import TypeAlias
+from typing_extensions import Self
+
+_Label: TypeAlias = tuple[int, str | None]
+_DFA: TypeAlias = list[list[tuple[int, int]]]
+_DFAS: TypeAlias = tuple[_DFA, dict[int, int]]
+
+class Grammar:
+    symbol2number: dict[str, int]
+    number2symbol: dict[int, str]
+    states: list[_DFA]
+    dfas: dict[int, _DFAS]
+    labels: list[_Label]
+    keywords: dict[str, int]
+    tokens: dict[int, int]
+    symbol2label: dict[str, int]
+    start: int
+    def dump(self, filename: StrPath) -> None: ...
+    def load(self, filename: StrPath) -> None: ...
+    def copy(self) -> Self: ...
+    def report(self) -> None: ...
+
+opmap_raw: str
+opmap: dict[str, str]

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/pgen2/literals.pyi

@@ -0,0 +1,7 @@
+from re import Match
+
+simple_escapes: dict[str, str]
+
+def escape(m: Match[str]) -> str: ...
+def evalString(s: str) -> str: ...
+def test() -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/pgen2/parse.pyi

@@ -0,0 +1,30 @@
+from _typeshed import Incomplete
+from collections.abc import Sequence
+from typing import TypeAlias
+
+from ..pytree import _NL, _RawNode
+from . import _Convert
+from .grammar import _DFAS, Grammar
+
+_Context: TypeAlias = Sequence[Incomplete]
+
+class ParseError(Exception):
+    msg: str
+    type: int
+    value: str | None
+    context: _Context
+    def __init__(self, msg: str, type: int, value: str | None, context: _Context) -> None: ...
+
+class Parser:
+    grammar: Grammar
+    convert: _Convert
+    stack: list[tuple[_DFAS, int, _RawNode]]
+    rootnode: _NL | None
+    used_names: set[str]
+    def __init__(self, grammar: Grammar, convert: _Convert | None = None) -> None: ...
+    def setup(self, start: int | None = None) -> None: ...
+    def addtoken(self, type: int, value: str | None, context: _Context) -> bool: ...
+    def classify(self, type: int, value: str | None, context: _Context) -> int: ...
+    def shift(self, type: int, value: str | None, newstate: int, context: _Context) -> None: ...
+    def push(self, type: int, newdfa: _DFAS, newstate: int, context: _Context) -> None: ...
+    def pop(self) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/pgen2/pgen.pyi

@@ -0,0 +1,52 @@
+from _typeshed import Incomplete, StrPath
+from collections.abc import Iterable, Iterator
+from typing import IO, ClassVar, NoReturn, overload
+
+from . import grammar
+from .tokenize import _TokenInfo
+
+class PgenGrammar(grammar.Grammar): ...
+
+class ParserGenerator:
+    filename: StrPath
+    stream: IO[str]
+    generator: Iterator[_TokenInfo]
+    first: dict[str, dict[str, int]]
+    def __init__(self, filename: StrPath, stream: IO[str] | None = None) -> None: ...
+    def make_grammar(self) -> PgenGrammar: ...
+    def make_first(self, c: PgenGrammar, name: str) -> dict[int, int]: ...
+    def make_label(self, c: PgenGrammar, label: str) -> int: ...
+    def addfirstsets(self) -> None: ...
+    def calcfirst(self, name: str) -> None: ...
+    def parse(self) -> tuple[dict[str, list[DFAState]], str]: ...
+    def make_dfa(self, start: NFAState, finish: NFAState) -> list[DFAState]: ...
+    def dump_nfa(self, name: str, start: NFAState, finish: NFAState) -> list[DFAState]: ...
+    def dump_dfa(self, name: str, dfa: Iterable[DFAState]) -> None: ...
+    def simplify_dfa(self, dfa: list[DFAState]) -> None: ...
+    def parse_rhs(self) -> tuple[NFAState, NFAState]: ...
+    def parse_alt(self) -> tuple[NFAState, NFAState]: ...
+    def parse_item(self) -> tuple[NFAState, NFAState]: ...
+    def parse_atom(self) -> tuple[NFAState, NFAState]: ...
+    def expect(self, type: int, value: str | None = None) -> str: ...
+    def gettoken(self) -> None: ...
+
+    @overload
+    def raise_error(self, msg: object) -> NoReturn: ...
+    @overload
+    def raise_error(self, msg: str, *args: object) -> NoReturn: ...
+
+class NFAState:
+    arcs: list[tuple[str | None, NFAState]]
+    def addarc(self, next: NFAState, label: str | None = None) -> None: ...
+
+class DFAState:
+    nfaset: dict[NFAState, Incomplete]
+    isfinal: bool
+    arcs: dict[str, DFAState]
+    def __init__(self, nfaset: dict[NFAState, Incomplete], final: NFAState) -> None: ...
+    def addarc(self, next: DFAState, label: str) -> None: ...
+    def unifystate(self, old: DFAState, new: DFAState) -> None: ...
+    def __eq__(self, other: DFAState) -> bool: ...  # type: ignore[override]
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+
+def generate_grammar(filename: StrPath = "Grammar.txt") -> PgenGrammar: ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/pgen2/token.pyi

@@ -0,0 +1,69 @@
+from typing import Final
+
+ENDMARKER: Final[int]
+NAME: Final[int]
+NUMBER: Final[int]
+STRING: Final[int]
+NEWLINE: Final[int]
+INDENT: Final[int]
+DEDENT: Final[int]
+LPAR: Final[int]
+RPAR: Final[int]
+LSQB: Final[int]
+RSQB: Final[int]
+COLON: Final[int]
+COMMA: Final[int]
+SEMI: Final[int]
+PLUS: Final[int]
+MINUS: Final[int]
+STAR: Final[int]
+SLASH: Final[int]
+VBAR: Final[int]
+AMPER: Final[int]
+LESS: Final[int]
+GREATER: Final[int]
+EQUAL: Final[int]
+DOT: Final[int]
+PERCENT: Final[int]
+BACKQUOTE: Final[int]
+LBRACE: Final[int]
+RBRACE: Final[int]
+EQEQUAL: Final[int]
+NOTEQUAL: Final[int]
+LESSEQUAL: Final[int]
+GREATEREQUAL: Final[int]
+TILDE: Final[int]
+CIRCUMFLEX: Final[int]
+LEFTSHIFT: Final[int]
+RIGHTSHIFT: Final[int]
+DOUBLESTAR: Final[int]
+PLUSEQUAL: Final[int]
+MINEQUAL: Final[int]
+STAREQUAL: Final[int]
+SLASHEQUAL: Final[int]
+PERCENTEQUAL: Final[int]
+AMPEREQUAL: Final[int]
+VBAREQUAL: Final[int]
+CIRCUMFLEXEQUAL: Final[int]
+LEFTSHIFTEQUAL: Final[int]
+RIGHTSHIFTEQUAL: Final[int]
+DOUBLESTAREQUAL: Final[int]
+DOUBLESLASH: Final[int]
+DOUBLESLASHEQUAL: Final[int]
+OP: Final[int]
+COMMENT: Final[int]
+NL: Final[int]
+RARROW: Final[int]
+AT: Final[int]
+ATEQUAL: Final[int]
+AWAIT: Final[int]
+ASYNC: Final[int]
+ERRORTOKEN: Final[int]
+COLONEQUAL: Final[int]
+N_TOKENS: Final[int]
+NT_OFFSET: Final[int]
+tok_name: dict[int, str]
+
+def ISTERMINAL(x: int) -> bool: ...
+def ISNONTERMINAL(x: int) -> bool: ...
+def ISEOF(x: int) -> bool: ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/pgen2/tokenize.pyi

@@ -0,0 +1,96 @@
+from collections.abc import Callable, Iterable, Iterator
+from typing import TypeAlias
+
+from .token import *
+
+__all__ = [
+    "AMPER",
+    "AMPEREQUAL",
+    "ASYNC",
+    "AT",
+    "ATEQUAL",
+    "AWAIT",
+    "BACKQUOTE",
+    "CIRCUMFLEX",
+    "CIRCUMFLEXEQUAL",
+    "COLON",
+    "COMMA",
+    "COMMENT",
+    "DEDENT",
+    "DOT",
+    "DOUBLESLASH",
+    "DOUBLESLASHEQUAL",
+    "DOUBLESTAR",
+    "DOUBLESTAREQUAL",
+    "ENDMARKER",
+    "EQEQUAL",
+    "EQUAL",
+    "ERRORTOKEN",
+    "GREATER",
+    "GREATEREQUAL",
+    "INDENT",
+    "ISEOF",
+    "ISNONTERMINAL",
+    "ISTERMINAL",
+    "LBRACE",
+    "LEFTSHIFT",
+    "LEFTSHIFTEQUAL",
+    "LESS",
+    "LESSEQUAL",
+    "LPAR",
+    "LSQB",
+    "MINEQUAL",
+    "MINUS",
+    "NAME",
+    "NEWLINE",
+    "NL",
+    "NOTEQUAL",
+    "NT_OFFSET",
+    "NUMBER",
+    "N_TOKENS",
+    "OP",
+    "PERCENT",
+    "PERCENTEQUAL",
+    "PLUS",
+    "PLUSEQUAL",
+    "RARROW",
+    "RBRACE",
+    "RIGHTSHIFT",
+    "RIGHTSHIFTEQUAL",
+    "RPAR",
+    "RSQB",
+    "SEMI",
+    "SLASH",
+    "SLASHEQUAL",
+    "STAR",
+    "STAREQUAL",
+    "STRING",
+    "TILDE",
+    "VBAR",
+    "VBAREQUAL",
+    "tok_name",
+    "tokenize",
+    "generate_tokens",
+    "untokenize",
+    "COLONEQUAL",
+]
+
+_Coord: TypeAlias = tuple[int, int]
+_TokenEater: TypeAlias = Callable[[int, str, _Coord, _Coord, str], object]
+_TokenInfo: TypeAlias = tuple[int, str, _Coord, _Coord, str]
+
+class TokenError(Exception): ...
+class StopTokenizing(Exception): ...
+
+def tokenize(readline: Callable[[], str], tokeneater: _TokenEater = ...) -> None: ...
+
+class Untokenizer:
+    tokens: list[str]
+    prev_row: int
+    prev_col: int
+    def add_whitespace(self, start: _Coord) -> None: ...
+    def untokenize(self, iterable: Iterable[_TokenInfo]) -> str: ...
+    def compat(self, token: tuple[int, str], iterable: Iterable[_TokenInfo]) -> None: ...
+
+def untokenize(iterable: Iterable[_TokenInfo]) -> str: ...
+def generate_tokens(readline: Callable[[], str]) -> Iterator[_TokenInfo]: ...