mypy-dev 1.9.0.dev0__py3-none-any.whl

mypy/typeshed/stdlib/token.pyi

@@ -0,0 +1,159 @@
+import sys
+
+__all__ = [
+    "AMPER",
+    "AMPEREQUAL",
+    "ASYNC",
+    "AT",
+    "ATEQUAL",
+    "AWAIT",
+    "CIRCUMFLEX",
+    "CIRCUMFLEXEQUAL",
+    "COLON",
+    "COLONEQUAL",
+    "COMMA",
+    "DEDENT",
+    "DOT",
+    "DOUBLESLASH",
+    "DOUBLESLASHEQUAL",
+    "DOUBLESTAR",
+    "DOUBLESTAREQUAL",
+    "ELLIPSIS",
+    "ENDMARKER",
+    "EQEQUAL",
+    "EQUAL",
+    "ERRORTOKEN",
+    "GREATER",
+    "GREATEREQUAL",
+    "INDENT",
+    "ISEOF",
+    "ISNONTERMINAL",
+    "ISTERMINAL",
+    "LBRACE",
+    "LEFTSHIFT",
+    "LEFTSHIFTEQUAL",
+    "LESS",
+    "LESSEQUAL",
+    "LPAR",
+    "LSQB",
+    "MINEQUAL",
+    "MINUS",
+    "NAME",
+    "NEWLINE",
+    "NOTEQUAL",
+    "NT_OFFSET",
+    "NUMBER",
+    "N_TOKENS",
+    "OP",
+    "PERCENT",
+    "PERCENTEQUAL",
+    "PLUS",
+    "PLUSEQUAL",
+    "RARROW",
+    "RBRACE",
+    "RIGHTSHIFT",
+    "RIGHTSHIFTEQUAL",
+    "RPAR",
+    "RSQB",
+    "SEMI",
+    "SLASH",
+    "SLASHEQUAL",
+    "STAR",
+    "STAREQUAL",
+    "STRING",
+    "TILDE",
+    "TYPE_COMMENT",
+    "TYPE_IGNORE",
+    "VBAR",
+    "VBAREQUAL",
+    "tok_name",
+    "ENCODING",
+    "NL",
+    "COMMENT",
+]
+
+if sys.version_info >= (3, 10):
+    __all__ += ["SOFT_KEYWORD"]
+
+if sys.version_info >= (3, 12):
+    __all__ += ["EXCLAMATION", "FSTRING_END", "FSTRING_MIDDLE", "FSTRING_START"]
+
+ENDMARKER: int
+NAME: int
+NUMBER: int
+STRING: int
+NEWLINE: int
+INDENT: int
+DEDENT: int
+LPAR: int
+RPAR: int
+LSQB: int
+RSQB: int
+COLON: int
+COMMA: int
+SEMI: int
+PLUS: int
+MINUS: int
+STAR: int
+SLASH: int
+VBAR: int
+AMPER: int
+LESS: int
+GREATER: int
+EQUAL: int
+DOT: int
+PERCENT: int
+LBRACE: int
+RBRACE: int
+EQEQUAL: int
+NOTEQUAL: int
+LESSEQUAL: int
+GREATEREQUAL: int
+TILDE: int
+CIRCUMFLEX: int
+LEFTSHIFT: int
+RIGHTSHIFT: int
+DOUBLESTAR: int
+PLUSEQUAL: int
+MINEQUAL: int
+STAREQUAL: int
+SLASHEQUAL: int
+PERCENTEQUAL: int
+AMPEREQUAL: int
+VBAREQUAL: int
+CIRCUMFLEXEQUAL: int
+LEFTSHIFTEQUAL: int
+RIGHTSHIFTEQUAL: int
+DOUBLESTAREQUAL: int
+DOUBLESLASH: int
+DOUBLESLASHEQUAL: int
+AT: int
+RARROW: int
+ELLIPSIS: int
+ATEQUAL: int
+AWAIT: int
+ASYNC: int
+OP: int
+ERRORTOKEN: int
+N_TOKENS: int
+NT_OFFSET: int
+tok_name: dict[int, str]
+COMMENT: int
+NL: int
+ENCODING: int
+TYPE_COMMENT: int
+TYPE_IGNORE: int
+COLONEQUAL: int
+EXACT_TOKEN_TYPES: dict[str, int]
+if sys.version_info >= (3, 10):
+    SOFT_KEYWORD: int
+
+if sys.version_info >= (3, 12):
+    EXCLAMATION: int
+    FSTRING_END: int
+    FSTRING_MIDDLE: int
+    FSTRING_START: int
+
+def ISTERMINAL(x: int) -> bool: ...
+def ISNONTERMINAL(x: int) -> bool: ...
+def ISEOF(x: int) -> bool: ...

mypy/typeshed/stdlib/tokenize.pyi

@@ -0,0 +1,177 @@
+import sys
+from _typeshed import FileDescriptorOrPath
+from collections.abc import Callable, Generator, Iterable, Sequence
+from re import Pattern
+from token import *
+from token import EXACT_TOKEN_TYPES as EXACT_TOKEN_TYPES
+from typing import Any, NamedTuple, TextIO
+from typing_extensions import TypeAlias
+
+__all__ = [
+    "AMPER",
+    "AMPEREQUAL",
+    "ASYNC",
+    "AT",
+    "ATEQUAL",
+    "AWAIT",
+    "CIRCUMFLEX",
+    "CIRCUMFLEXEQUAL",
+    "COLON",
+    "COLONEQUAL",
+    "COMMA",
+    "COMMENT",
+    "DEDENT",
+    "DOT",
+    "DOUBLESLASH",
+    "DOUBLESLASHEQUAL",
+    "DOUBLESTAR",
+    "DOUBLESTAREQUAL",
+    "ELLIPSIS",
+    "ENCODING",
+    "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",
+    "TYPE_COMMENT",
+    "TYPE_IGNORE",
+    "TokenInfo",
+    "VBAR",
+    "VBAREQUAL",
+    "detect_encoding",
+    "generate_tokens",
+    "tok_name",
+    "tokenize",
+    "untokenize",
+]
+
+if sys.version_info >= (3, 10):
+    __all__ += ["SOFT_KEYWORD"]
+
+if sys.version_info >= (3, 12):
+    __all__ += ["EXCLAMATION", "FSTRING_END", "FSTRING_MIDDLE", "FSTRING_START"]
+
+cookie_re: Pattern[str]
+blank_re: Pattern[bytes]
+
+_Position: TypeAlias = tuple[int, int]
+
+class _TokenInfo(NamedTuple):
+    type: int
+    string: str
+    start: _Position
+    end: _Position
+    line: str
+
+class TokenInfo(_TokenInfo):
+    @property
+    def exact_type(self) -> int: ...
+
+# Backwards compatible tokens can be sequences of a shorter length too
+_Token: TypeAlias = TokenInfo | Sequence[int | str | _Position]
+
+class TokenError(Exception): ...
+class StopTokenizing(Exception): ...  # undocumented
+
+class Untokenizer:
+    tokens: list[str]
+    prev_row: int
+    prev_col: int
+    encoding: str | None
+    def add_whitespace(self, start: _Position) -> None: ...
+    def untokenize(self, iterable: Iterable[_Token]) -> str: ...
+    def compat(self, token: Sequence[int | str], iterable: Iterable[_Token]) -> None: ...
+
+# the docstring says "returns bytes" but is incorrect --
+# if the ENCODING token is missing, it skips the encode
+def untokenize(iterable: Iterable[_Token]) -> Any: ...
+def detect_encoding(readline: Callable[[], bytes | bytearray]) -> tuple[str, Sequence[bytes]]: ...
+def tokenize(readline: Callable[[], bytes | bytearray]) -> Generator[TokenInfo, None, None]: ...
+def generate_tokens(readline: Callable[[], str]) -> Generator[TokenInfo, None, None]: ...  # undocumented
+def open(filename: FileDescriptorOrPath) -> TextIO: ...
+def group(*choices: str) -> str: ...  # undocumented
+def any(*choices: str) -> str: ...  # undocumented
+def maybe(*choices: str) -> str: ...  # undocumented
+
+Whitespace: str  # undocumented
+Comment: str  # undocumented
+Ignore: str  # undocumented
+Name: str  # undocumented
+
+Hexnumber: str  # undocumented
+Binnumber: str  # undocumented
+Octnumber: str  # undocumented
+Decnumber: str  # undocumented
+Intnumber: str  # undocumented
+Exponent: str  # undocumented
+Pointfloat: str  # undocumented
+Expfloat: str  # undocumented
+Floatnumber: str  # undocumented
+Imagnumber: str  # undocumented
+Number: str  # undocumented
+
+def _all_string_prefixes() -> set[str]: ...  # undocumented
+
+StringPrefix: str  # undocumented
+
+Single: str  # undocumented
+Double: str  # undocumented
+Single3: str  # undocumented
+Double3: str  # undocumented
+Triple: str  # undocumented
+String: str  # undocumented
+
+Special: str  # undocumented
+Funny: str  # undocumented
+
+PlainToken: str  # undocumented
+Token: str  # undocumented
+
+ContStr: str  # undocumented
+PseudoExtras: str  # undocumented
+PseudoToken: str  # undocumented
+
+endpats: dict[str, str]  # undocumented
+single_quoted: set[str]  # undocumented
+triple_quoted: set[str]  # undocumented
+
+tabsize: int  # undocumented

mypy/typeshed/stdlib/tomllib.pyi

@@ -0,0 +1,10 @@
+from _typeshed import SupportsRead
+from collections.abc import Callable
+from typing import Any
+
+__all__ = ("loads", "load", "TOMLDecodeError")
+
+class TOMLDecodeError(ValueError): ...
+
+def load(__fp: SupportsRead[bytes], *, parse_float: Callable[[str], Any] = ...) -> dict[str, Any]: ...
+def loads(__s: str, *, parse_float: Callable[[str], Any] = ...) -> dict[str, Any]: ...

mypy/typeshed/stdlib/trace.pyi

@@ -0,0 +1,79 @@
+import sys
+import types
+from _typeshed import Incomplete, StrPath, TraceFunction
+from collections.abc import Callable, Iterable, Mapping, Sequence
+from typing import Any, TypeVar
+from typing_extensions import ParamSpec, TypeAlias
+
+__all__ = ["Trace", "CoverageResults"]
+
+_T = TypeVar("_T")
+_P = ParamSpec("_P")
+_FileModuleFunction: TypeAlias = tuple[str, str | None, str]
+
+class CoverageResults:
+    counts: dict[tuple[str, int], int]
+    counter: dict[tuple[str, int], int]
+    calledfuncs: dict[_FileModuleFunction, int]
+    callers: dict[tuple[_FileModuleFunction, _FileModuleFunction], int]
+    inifile: StrPath | None
+    outfile: StrPath | None
+    def __init__(
+        self,
+        counts: dict[tuple[str, int], int] | None = None,
+        calledfuncs: dict[_FileModuleFunction, int] | None = None,
+        infile: StrPath | None = None,
+        callers: dict[tuple[_FileModuleFunction, _FileModuleFunction], int] | None = None,
+        outfile: StrPath | None = None,
+    ) -> None: ...  # undocumented
+    def update(self, other: CoverageResults) -> None: ...
+    def write_results(self, show_missing: bool = True, summary: bool = False, coverdir: StrPath | None = None) -> None: ...
+    def write_results_file(
+        self, path: StrPath, lines: Sequence[str], lnotab: Any, lines_hit: Mapping[int, int], encoding: str | None = None
+    ) -> tuple[int, int]: ...
+    def is_ignored_filename(self, filename: str) -> bool: ...  # undocumented
+
+class _Ignore:
+    def __init__(self, modules: Iterable[str] | None = None, dirs: Iterable[StrPath] | None = None) -> None: ...
+    def names(self, filename: str, modulename: str) -> int: ...
+
+class Trace:
+    inifile: StrPath | None
+    outfile: StrPath | None
+    ignore: _Ignore
+    counts: dict[str, int]
+    pathtobasename: dict[Incomplete, Incomplete]
+    donothing: int
+    trace: int
+    start_time: int | None
+    globaltrace: TraceFunction
+    localtrace: TraceFunction
+    def __init__(
+        self,
+        count: int = 1,
+        trace: int = 1,
+        countfuncs: int = 0,
+        countcallers: int = 0,
+        ignoremods: Sequence[str] = (),
+        ignoredirs: Sequence[str] = (),
+        infile: StrPath | None = None,
+        outfile: StrPath | None = None,
+        timing: bool = False,
+    ) -> None: ...
+    def run(self, cmd: str | types.CodeType) -> None: ...
+    def runctx(
+        self, cmd: str | types.CodeType, globals: Mapping[str, Any] | None = None, locals: Mapping[str, Any] | None = None
+    ) -> None: ...
+    if sys.version_info >= (3, 9):
+        def runfunc(self, __func: Callable[_P, _T], *args: _P.args, **kw: _P.kwargs) -> _T: ...
+    else:
+        def runfunc(self, func: Callable[_P, _T], *args: _P.args, **kw: _P.kwargs) -> _T: ...
+
+    def file_module_function_of(self, frame: types.FrameType) -> _FileModuleFunction: ...
+    def globaltrace_trackcallers(self, frame: types.FrameType, why: str, arg: Any) -> None: ...
+    def globaltrace_countfuncs(self, frame: types.FrameType, why: str, arg: Any) -> None: ...
+    def globaltrace_lt(self, frame: types.FrameType, why: str, arg: Any) -> None: ...
+    def localtrace_trace_and_count(self, frame: types.FrameType, why: str, arg: Any) -> TraceFunction: ...
+    def localtrace_trace(self, frame: types.FrameType, why: str, arg: Any) -> TraceFunction: ...
+    def localtrace_count(self, frame: types.FrameType, why: str, arg: Any) -> TraceFunction: ...
+    def results(self) -> CoverageResults: ...

mypy/typeshed/stdlib/traceback.pyi

@@ -0,0 +1,260 @@
+import sys
+from _typeshed import SupportsWrite, Unused
+from collections.abc import Generator, Iterable, Iterator, Mapping
+from types import FrameType, TracebackType
+from typing import Any, Literal, overload
+from typing_extensions import Self, TypeAlias
+
+__all__ = [
+    "extract_stack",
+    "extract_tb",
+    "format_exception",
+    "format_exception_only",
+    "format_list",
+    "format_stack",
+    "format_tb",
+    "print_exc",
+    "format_exc",
+    "print_exception",
+    "print_last",
+    "print_stack",
+    "print_tb",
+    "clear_frames",
+    "FrameSummary",
+    "StackSummary",
+    "TracebackException",
+    "walk_stack",
+    "walk_tb",
+]
+
+_PT: TypeAlias = tuple[str, int, str, str | None]
+
+def print_tb(tb: TracebackType | None, limit: int | None = None, file: SupportsWrite[str] | None = None) -> None: ...
+
+if sys.version_info >= (3, 10):
+    @overload
+    def print_exception(
+        __exc: type[BaseException] | None,
+        value: BaseException | None = ...,
+        tb: TracebackType | None = ...,
+        limit: int | None = None,
+        file: SupportsWrite[str] | None = None,
+        chain: bool = True,
+    ) -> None: ...
+    @overload
+    def print_exception(
+        __exc: BaseException, *, limit: int | None = None, file: SupportsWrite[str] | None = None, chain: bool = True
+    ) -> None: ...
+    @overload
+    def format_exception(
+        __exc: type[BaseException] | None,
+        value: BaseException | None = ...,
+        tb: TracebackType | None = ...,
+        limit: int | None = None,
+        chain: bool = True,
+    ) -> list[str]: ...
+    @overload
+    def format_exception(__exc: BaseException, *, limit: int | None = None, chain: bool = True) -> list[str]: ...
+
+else:
+    def print_exception(
+        etype: type[BaseException] | None,
+        value: BaseException | None,
+        tb: TracebackType | None,
+        limit: int | None = None,
+        file: SupportsWrite[str] | None = None,
+        chain: bool = True,
+    ) -> None: ...
+    def format_exception(
+        etype: type[BaseException] | None,
+        value: BaseException | None,
+        tb: TracebackType | None,
+        limit: int | None = None,
+        chain: bool = True,
+    ) -> list[str]: ...
+
+def print_exc(limit: int | None = None, file: SupportsWrite[str] | None = None, chain: bool = True) -> None: ...
+def print_last(limit: int | None = None, file: SupportsWrite[str] | None = None, chain: bool = True) -> None: ...
+def print_stack(f: FrameType | None = None, limit: int | None = None, file: SupportsWrite[str] | None = None) -> None: ...
+def extract_tb(tb: TracebackType | None, limit: int | None = None) -> StackSummary: ...
+def extract_stack(f: FrameType | None = None, limit: int | None = None) -> StackSummary: ...
+def format_list(extracted_list: list[FrameSummary]) -> list[str]: ...
+
+# undocumented
+def print_list(extracted_list: list[FrameSummary], file: SupportsWrite[str] | None = None) -> None: ...
+
+if sys.version_info >= (3, 10):
+    @overload
+    def format_exception_only(__exc: BaseException | None) -> list[str]: ...
+    @overload
+    def format_exception_only(__exc: Unused, value: BaseException | None) -> list[str]: ...
+
+else:
+    def format_exception_only(etype: type[BaseException] | None, value: BaseException | None) -> list[str]: ...
+
+def format_exc(limit: int | None = None, chain: bool = True) -> str: ...
+def format_tb(tb: TracebackType | None, limit: int | None = None) -> list[str]: ...
+def format_stack(f: FrameType | None = None, limit: int | None = None) -> list[str]: ...
+def clear_frames(tb: TracebackType | None) -> None: ...
+def walk_stack(f: FrameType | None) -> Iterator[tuple[FrameType, int]]: ...
+def walk_tb(tb: TracebackType | None) -> Iterator[tuple[FrameType, int]]: ...
+
+if sys.version_info >= (3, 11):
+    class _ExceptionPrintContext:
+        def indent(self) -> str: ...
+        def emit(self, text_gen: str | Iterable[str], margin_char: str | None = None) -> Generator[str, None, None]: ...
+
+class TracebackException:
+    __cause__: TracebackException
+    __context__: TracebackException
+    __suppress_context__: bool
+    stack: StackSummary
+    exc_type: type[BaseException]
+    filename: str
+    lineno: int
+    text: str
+    offset: int
+    msg: str
+    if sys.version_info >= (3, 11):
+        def __init__(
+            self,
+            exc_type: type[BaseException],
+            exc_value: BaseException,
+            exc_traceback: TracebackType | None,
+            *,
+            limit: int | None = None,
+            lookup_lines: bool = True,
+            capture_locals: bool = False,
+            compact: bool = False,
+            max_group_width: int = 15,
+            max_group_depth: int = 10,
+            _seen: set[int] | None = None,
+        ) -> None: ...
+        @classmethod
+        def from_exception(
+            cls,
+            exc: BaseException,
+            *,
+            limit: int | None = None,
+            lookup_lines: bool = True,
+            capture_locals: bool = False,
+            compact: bool = False,
+            max_group_width: int = 15,
+            max_group_depth: int = 10,
+        ) -> Self: ...
+    elif sys.version_info >= (3, 10):
+        def __init__(
+            self,
+            exc_type: type[BaseException],
+            exc_value: BaseException,
+            exc_traceback: TracebackType | None,
+            *,
+            limit: int | None = None,
+            lookup_lines: bool = True,
+            capture_locals: bool = False,
+            compact: bool = False,
+            _seen: set[int] | None = None,
+        ) -> None: ...
+        @classmethod
+        def from_exception(
+            cls,
+            exc: BaseException,
+            *,
+            limit: int | None = None,
+            lookup_lines: bool = True,
+            capture_locals: bool = False,
+            compact: bool = False,
+        ) -> Self: ...
+    else:
+        def __init__(
+            self,
+            exc_type: type[BaseException],
+            exc_value: BaseException,
+            exc_traceback: TracebackType | None,
+            *,
+            limit: int | None = None,
+            lookup_lines: bool = True,
+            capture_locals: bool = False,
+            _seen: set[int] | None = None,
+        ) -> None: ...
+        @classmethod
+        def from_exception(
+            cls, exc: BaseException, *, limit: int | None = None, lookup_lines: bool = True, capture_locals: bool = False
+        ) -> Self: ...
+
+    def __eq__(self, other: object) -> bool: ...
+    if sys.version_info >= (3, 11):
+        def format(self, *, chain: bool = True, _ctx: _ExceptionPrintContext | None = None) -> Generator[str, None, None]: ...
+    else:
+        def format(self, *, chain: bool = True) -> Generator[str, None, None]: ...
+
+    def format_exception_only(self) -> Generator[str, None, None]: ...
+
+    if sys.version_info >= (3, 11):
+        def print(self, *, file: SupportsWrite[str] | None = None, chain: bool = True) -> None: ...
+
+class FrameSummary(Iterable[Any]):
+    if sys.version_info >= (3, 11):
+        def __init__(
+            self,
+            filename: str,
+            lineno: int | None,
+            name: str,
+            *,
+            lookup_line: bool = True,
+            locals: Mapping[str, str] | None = None,
+            line: str | None = None,
+            end_lineno: int | None = None,
+            colno: int | None = None,
+            end_colno: int | None = None,
+        ) -> None: ...
+        end_lineno: int | None
+        colno: int | None
+        end_colno: int | None
+    else:
+        def __init__(
+            self,
+            filename: str,
+            lineno: int | None,
+            name: str,
+            *,
+            lookup_line: bool = True,
+            locals: Mapping[str, str] | None = None,
+            line: str | None = None,
+        ) -> None: ...
+    filename: str
+    lineno: int | None
+    name: str
+    locals: dict[str, str] | None
+    @property
+    def line(self) -> str | None: ...
+    @overload
+    def __getitem__(self, pos: Literal[0]) -> str: ...
+    @overload
+    def __getitem__(self, pos: Literal[1]) -> int: ...
+    @overload
+    def __getitem__(self, pos: Literal[2]) -> str: ...
+    @overload
+    def __getitem__(self, pos: Literal[3]) -> str | None: ...
+    @overload
+    def __getitem__(self, pos: int) -> Any: ...
+    def __iter__(self) -> Iterator[Any]: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __len__(self) -> Literal[4]: ...
+
+class StackSummary(list[FrameSummary]):
+    @classmethod
+    def extract(
+        cls,
+        frame_gen: Iterable[tuple[FrameType, int]],
+        *,
+        limit: int | None = None,
+        lookup_lines: bool = True,
+        capture_locals: bool = False,
+    ) -> StackSummary: ...
+    @classmethod
+    def from_list(cls, a_list: Iterable[FrameSummary | _PT]) -> StackSummary: ...
+    if sys.version_info >= (3, 11):
+        def format_frame_summary(self, frame_summary: FrameSummary) -> str: ...
+
+    def format(self) -> list[str]: ...