layermap 0.1.0

package/analyzers/project-map-python/typeshed/stdlib/pdb.pyi

@@ -0,0 +1,275 @@
+import signal
+import sys
+from _typeshed import ReadableBuffer
+from bdb import Bdb, _Backend
+from cmd import Cmd
+from collections.abc import Callable, Iterable, Mapping, Sequence
+from linecache import _ModuleGlobals
+from rlcompleter import Completer
+from types import CodeType, FrameType, TracebackType
+from typing import IO, Any, ClassVar, Final, Literal, ParamSpec, TypeAlias, TypeVar
+from typing_extensions import Self, deprecated
+
+__all__ = ["run", "pm", "Pdb", "runeval", "runctx", "runcall", "set_trace", "post_mortem", "help"]
+if sys.version_info >= (3, 14):
+    __all__ += ["set_default_backend", "get_default_backend"]
+
+_T = TypeVar("_T")
+_P = ParamSpec("_P")
+_Mode: TypeAlias = Literal["inline", "cli"]
+
+line_prefix: Final[str]  # undocumented
+
+class Restart(Exception): ...
+
+def run(  # matches `builtins.exec`
+    statement: str | ReadableBuffer | CodeType, globals: dict[str, Any] | None = None, locals: Mapping[str, object] | None = None
+) -> None: ...
+def runctx(  # matches `builtins.exec`
+    statement: str | ReadableBuffer | CodeType, globals: dict[str, Any], locals: Mapping[str, object]
+) -> None: ...
+def runeval(  # matches `builtins.eval`
+    expression: str | ReadableBuffer | CodeType, globals: dict[str, Any] | None = None, locals: Mapping[str, object] | None = None
+) -> Any: ...
+def runcall(func: Callable[_P, _T], *args: _P.args, **kwds: _P.kwargs) -> _T | None: ...
+
+if sys.version_info >= (3, 14):
+    def set_default_backend(backend: _Backend) -> None: ...
+    def get_default_backend() -> _Backend: ...
+    def set_trace(*, header: str | None = None, commands: Iterable[str] | None = None) -> None: ...
+    async def set_trace_async(*, header: str | None = None, commands: Iterable[str] | None = None) -> None: ...
+
+else:
+    def set_trace(*, header: str | None = None) -> None: ...
+
+def post_mortem(t: TracebackType | None = None) -> None: ...
+def pm() -> None: ...
+
+class Pdb(Bdb, Cmd):
+    # Everything here is undocumented, except for __init__
+
+    commands_resuming: ClassVar[list[str]]
+
+    if sys.version_info >= (3, 13):
+        MAX_CHAINED_EXCEPTION_DEPTH: Final = 999
+
+    aliases: dict[str, str]
+    mainpyfile: str
+    _wait_for_mainpyfile: bool
+    rcLines: list[str]
+    commands: dict[int, list[str]]
+    commands_doprompt: dict[int, bool]
+    commands_silent: dict[int, bool]
+    commands_defining: bool
+    commands_bnum: int | None
+    lineno: int | None
+    stack: list[tuple[FrameType, int]]
+    curindex: int
+    curframe: FrameType | None
+    if sys.version_info >= (3, 13):
+        @property
+        @deprecated("The frame locals reference is no longer cached. Use 'curframe.f_locals' instead.")
+        def curframe_locals(self) -> Mapping[str, Any]: ...
+        @curframe_locals.setter
+        @deprecated(
+            "Setting 'curframe_locals' no longer has any effect as of 3.14. Update the contents of 'curframe.f_locals' instead."
+        )
+        def curframe_locals(self, value: Mapping[str, Any]) -> None: ...
+    else:
+        curframe_locals: Mapping[str, Any]
+    if sys.version_info >= (3, 14):
+        mode: _Mode | None
+        colorize: bool
+        def __init__(
+            self,
+            completekey: str = "tab",
+            stdin: IO[str] | None = None,
+            stdout: IO[str] | None = None,
+            skip: Iterable[str] | None = None,
+            nosigint: bool = False,
+            readrc: bool = True,
+            mode: _Mode | None = None,
+            backend: _Backend | None = None,
+            colorize: bool = False,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            completekey: str = "tab",
+            stdin: IO[str] | None = None,
+            stdout: IO[str] | None = None,
+            skip: Iterable[str] | None = None,
+            nosigint: bool = False,
+            readrc: bool = True,
+        ) -> None: ...
+    if sys.version_info >= (3, 14):
+        def set_trace(self, frame: FrameType | None = None, *, commands: Iterable[str] | None = None) -> None: ...
+        async def set_trace_async(self, frame: FrameType | None = None, *, commands: Iterable[str] | None = None) -> None: ...
+
+    def forget(self) -> None: ...
+    def setup(self, f: FrameType | None, tb: TracebackType | None) -> None: ...
+    if sys.version_info < (3, 11):
+        def execRcLines(self) -> None: ...
+
+    if sys.version_info >= (3, 13):
+        user_opcode = Bdb.user_line
+
+    def bp_commands(self, frame: FrameType) -> bool: ...
+
+    if sys.version_info >= (3, 13):
+        def interaction(self, frame: FrameType | None, tb_or_exc: TracebackType | BaseException | None) -> None: ...
+    else:
+        def interaction(self, frame: FrameType | None, traceback: TracebackType | None) -> None: ...
+
+    def displayhook(self, obj: object) -> None: ...
+    def handle_command_def(self, line: str) -> bool: ...
+    def defaultFile(self) -> str: ...
+    def lineinfo(self, identifier: str) -> tuple[None, None, None] | tuple[str, str, int]: ...
+    if sys.version_info >= (3, 14):
+        def checkline(self, filename: str, lineno: int, module_globals: _ModuleGlobals | None = None) -> int: ...
+    else:
+        def checkline(self, filename: str, lineno: int) -> int: ...
+
+    def _getval(self, arg: str) -> object: ...
+    if sys.version_info >= (3, 14):
+        def print_stack_trace(self, count: int | None = None) -> None: ...
+    else:
+        def print_stack_trace(self) -> None: ...
+
+    if sys.version_info >= (3, 15):
+        def print_stack_entry(self, frame_lineno: tuple[FrameType, int], prompt_prefix: str | None = None) -> None: ...
+    else:
+        def print_stack_entry(self, frame_lineno: tuple[FrameType, int], prompt_prefix: str = "\n-> ") -> None: ...
+
+    def lookupmodule(self, filename: str) -> str | None: ...
+    if sys.version_info < (3, 11):
+        def _runscript(self, filename: str) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def complete_multiline_names(self, text: str, line: str, begidx: int, endidx: int) -> list[str]: ...
+
+    if sys.version_info >= (3, 13):
+        def completedefault(self, text: str, line: str, begidx: int, endidx: int) -> list[str]: ...
+
+    def do_commands(self, arg: str) -> bool | None: ...
+    if sys.version_info >= (3, 14):
+        def do_break(self, arg: str, temporary: bool = False) -> bool | None: ...
+    else:
+        def do_break(self, arg: str, temporary: bool | Literal[0, 1] = 0) -> bool | None: ...
+
+    def do_tbreak(self, arg: str) -> bool | None: ...
+    def do_enable(self, arg: str) -> bool | None: ...
+    def do_disable(self, arg: str) -> bool | None: ...
+    def do_condition(self, arg: str) -> bool | None: ...
+    def do_ignore(self, arg: str) -> bool | None: ...
+    def do_clear(self, arg: str) -> bool | None: ...
+    def do_where(self, arg: str) -> bool | None: ...
+    if sys.version_info >= (3, 13):
+        def do_exceptions(self, arg: str) -> bool | None: ...
+
+    def do_up(self, arg: str) -> bool | None: ...
+    def do_down(self, arg: str) -> bool | None: ...
+    def do_until(self, arg: str) -> bool | None: ...
+    def do_step(self, arg: str) -> bool | None: ...
+    def do_next(self, arg: str) -> bool | None: ...
+    def do_run(self, arg: str) -> bool | None: ...
+    def do_return(self, arg: str) -> bool | None: ...
+    def do_continue(self, arg: str) -> bool | None: ...
+    def do_jump(self, arg: str) -> bool | None: ...
+    def do_debug(self, arg: str) -> bool | None: ...
+    def do_quit(self, arg: str) -> bool | None: ...
+    def do_EOF(self, arg: str) -> bool | None: ...
+    def do_args(self, arg: str) -> bool | None: ...
+    def do_retval(self, arg: str) -> bool | None: ...
+    def do_p(self, arg: str) -> bool | None: ...
+    def do_pp(self, arg: str) -> bool | None: ...
+    def do_list(self, arg: str) -> bool | None: ...
+    def do_whatis(self, arg: str) -> bool | None: ...
+    def do_alias(self, arg: str) -> bool | None: ...
+    def do_unalias(self, arg: str) -> bool | None: ...
+    def do_help(self, arg: str) -> bool | None: ...
+    do_b = do_break
+    do_cl = do_clear
+    do_w = do_where
+    do_bt = do_where
+    do_u = do_up
+    do_d = do_down
+    do_unt = do_until
+    do_s = do_step
+    do_n = do_next
+    do_restart = do_run
+    do_r = do_return
+    do_c = do_continue
+    do_cont = do_continue
+    do_j = do_jump
+    do_q = do_quit
+    do_exit = do_quit
+    do_a = do_args
+    do_rv = do_retval
+    do_l = do_list
+    do_h = do_help
+    def help_exec(self) -> None: ...
+    def help_pdb(self) -> None: ...
+    def sigint_handler(self, signum: signal.Signals, frame: FrameType) -> None: ...
+    if sys.version_info >= (3, 13):
+        def message(self, msg: str, end: str = "\n") -> None: ...
+    else:
+        def message(self, msg: str) -> None: ...
+
+    def error(self, msg: str) -> None: ...
+    if sys.version_info >= (3, 13):
+        def completenames(self, text: str, line: str, begidx: int, endidx: int) -> list[str]: ...  # type: ignore[override]
+    if sys.version_info >= (3, 12):
+        def set_convenience_variable(self, frame: FrameType, name: str, value: Any) -> None: ...
+    if sys.version_info >= (3, 13):
+        # Added in 3.13.8 and 3.14.1
+        @property
+        def rlcompleter(self) -> type[Completer]: ...
+
+    def _select_frame(self, number: int) -> None: ...
+    def _getval_except(self, arg: str, frame: FrameType | None = None) -> object: ...
+    def _print_lines(
+        self, lines: Sequence[str], start: int, breaks: Sequence[int] = (), frame: FrameType | None = None
+    ) -> None: ...
+    def _cmdloop(self) -> None: ...
+    def do_display(self, arg: str) -> bool | None: ...
+    def do_interact(self, arg: str) -> bool | None: ...
+    def do_longlist(self, arg: str) -> bool | None: ...
+    def do_source(self, arg: str) -> bool | None: ...
+    def do_undisplay(self, arg: str) -> bool | None: ...
+    do_ll = do_longlist
+    def _complete_location(self, text: str, line: str, begidx: int, endidx: int) -> list[str]: ...
+    def _complete_bpnumber(self, text: str, line: str, begidx: int, endidx: int) -> list[str]: ...
+    def _complete_expression(self, text: str, line: str, begidx: int, endidx: int) -> list[str]: ...
+    def complete_undisplay(self, text: str, line: str, begidx: int, endidx: int) -> list[str]: ...
+    def complete_unalias(self, text: str, line: str, begidx: int, endidx: int) -> list[str]: ...
+    complete_commands = _complete_bpnumber
+    complete_break = _complete_location
+    complete_b = _complete_location
+    complete_tbreak = _complete_location
+    complete_enable = _complete_bpnumber
+    complete_disable = _complete_bpnumber
+    complete_condition = _complete_bpnumber
+    complete_ignore = _complete_bpnumber
+    complete_clear = _complete_location
+    complete_cl = _complete_location
+    complete_debug = _complete_expression
+    complete_print = _complete_expression
+    complete_p = _complete_expression
+    complete_pp = _complete_expression
+    complete_source = _complete_expression
+    complete_whatis = _complete_expression
+    complete_display = _complete_expression
+
+    if sys.version_info < (3, 11):
+        def _runmodule(self, module_name: str) -> None: ...
+
+# undocumented
+
+def find_function(funcname: str, filename: str) -> tuple[str, str, int] | None: ...
+def main() -> None: ...
+def help() -> None: ...
+def lasti2lineno(code: CodeType, lasti: int) -> int: ...
+
+class _rstr(str):
+    def __repr__(self) -> Self: ...

package/analyzers/project-map-python/typeshed/stdlib/pickle.pyi

@@ -0,0 +1,240 @@
+import sys
+from _pickle import (
+    PickleError as PickleError,
+    Pickler as Pickler,
+    PicklingError as PicklingError,
+    Unpickler as Unpickler,
+    UnpicklingError as UnpicklingError,
+    _BufferCallback,
+    _ReadableFileobj,
+    _ReducedType,
+    dump as dump,
+    dumps as dumps,
+    load as load,
+    loads as loads,
+)
+from _typeshed import ReadableBuffer, SupportsWrite
+from collections.abc import Callable, Iterable, Mapping
+from typing import Any, ClassVar, Final, SupportsBytes, SupportsIndex, final
+from typing_extensions import Self
+
+__all__ = [
+    "PickleBuffer",
+    "PickleError",
+    "PicklingError",
+    "UnpicklingError",
+    "Pickler",
+    "Unpickler",
+    "dump",
+    "dumps",
+    "load",
+    "loads",
+    "ADDITEMS",
+    "APPEND",
+    "APPENDS",
+    "BINBYTES",
+    "BINBYTES8",
+    "BINFLOAT",
+    "BINGET",
+    "BININT",
+    "BININT1",
+    "BININT2",
+    "BINPERSID",
+    "BINPUT",
+    "BINSTRING",
+    "BINUNICODE",
+    "BINUNICODE8",
+    "BUILD",
+    "BYTEARRAY8",
+    "DEFAULT_PROTOCOL",
+    "DICT",
+    "DUP",
+    "EMPTY_DICT",
+    "EMPTY_LIST",
+    "EMPTY_SET",
+    "EMPTY_TUPLE",
+    "EXT1",
+    "EXT2",
+    "EXT4",
+    "FALSE",
+    "FLOAT",
+    "FRAME",
+    "FROZENSET",
+    "GET",
+    "GLOBAL",
+    "HIGHEST_PROTOCOL",
+    "INST",
+    "INT",
+    "LIST",
+    "LONG",
+    "LONG1",
+    "LONG4",
+    "LONG_BINGET",
+    "LONG_BINPUT",
+    "MARK",
+    "MEMOIZE",
+    "NEWFALSE",
+    "NEWOBJ",
+    "NEWOBJ_EX",
+    "NEWTRUE",
+    "NEXT_BUFFER",
+    "NONE",
+    "OBJ",
+    "PERSID",
+    "POP",
+    "POP_MARK",
+    "PROTO",
+    "PUT",
+    "READONLY_BUFFER",
+    "REDUCE",
+    "SETITEM",
+    "SETITEMS",
+    "SHORT_BINBYTES",
+    "SHORT_BINSTRING",
+    "SHORT_BINUNICODE",
+    "STACK_GLOBAL",
+    "STOP",
+    "STRING",
+    "TRUE",
+    "TUPLE",
+    "TUPLE1",
+    "TUPLE2",
+    "TUPLE3",
+    "UNICODE",
+]
+
+HIGHEST_PROTOCOL: Final = 5
+if sys.version_info >= (3, 14):
+    DEFAULT_PROTOCOL: Final = 5
+else:
+    DEFAULT_PROTOCOL: Final = 4
+
+bytes_types: tuple[type[Any], ...]  # undocumented
+
+@final
+class PickleBuffer:
+    def __new__(cls, buffer: ReadableBuffer) -> Self: ...
+    def raw(self) -> memoryview: ...
+    def release(self) -> None: ...
+    def __buffer__(self, flags: int, /) -> memoryview: ...
+    def __release_buffer__(self, buffer: memoryview, /) -> None: ...
+
+MARK: Final = b"("
+STOP: Final = b"."
+POP: Final = b"0"
+POP_MARK: Final = b"1"
+DUP: Final = b"2"
+FLOAT: Final = b"F"
+INT: Final = b"I"
+BININT: Final = b"J"
+BININT1: Final = b"K"
+LONG: Final = b"L"
+BININT2: Final = b"M"
+NONE: Final = b"N"
+PERSID: Final = b"P"
+BINPERSID: Final = b"Q"
+REDUCE: Final = b"R"
+STRING: Final = b"S"
+BINSTRING: Final = b"T"
+SHORT_BINSTRING: Final = b"U"
+UNICODE: Final = b"V"
+BINUNICODE: Final = b"X"
+APPEND: Final = b"a"
+BUILD: Final = b"b"
+GLOBAL: Final = b"c"
+DICT: Final = b"d"
+EMPTY_DICT: Final = b"}"
+APPENDS: Final = b"e"
+GET: Final = b"g"
+BINGET: Final = b"h"
+INST: Final = b"i"
+LONG_BINGET: Final = b"j"
+LIST: Final = b"l"
+EMPTY_LIST: Final = b"]"
+OBJ: Final = b"o"
+PUT: Final = b"p"
+BINPUT: Final = b"q"
+LONG_BINPUT: Final = b"r"
+SETITEM: Final = b"s"
+TUPLE: Final = b"t"
+EMPTY_TUPLE: Final = b")"
+SETITEMS: Final = b"u"
+BINFLOAT: Final = b"G"
+
+TRUE: Final = b"I01\n"
+FALSE: Final = b"I00\n"
+
+# protocol 2
+PROTO: Final = b"\x80"
+NEWOBJ: Final = b"\x81"
+EXT1: Final = b"\x82"
+EXT2: Final = b"\x83"
+EXT4: Final = b"\x84"
+TUPLE1: Final = b"\x85"
+TUPLE2: Final = b"\x86"
+TUPLE3: Final = b"\x87"
+NEWTRUE: Final = b"\x88"
+NEWFALSE: Final = b"\x89"
+LONG1: Final = b"\x8a"
+LONG4: Final = b"\x8b"
+
+# protocol 3
+BINBYTES: Final = b"B"
+SHORT_BINBYTES: Final = b"C"
+
+# protocol 4
+SHORT_BINUNICODE: Final = b"\x8c"
+BINUNICODE8: Final = b"\x8d"
+BINBYTES8: Final = b"\x8e"
+EMPTY_SET: Final = b"\x8f"
+ADDITEMS: Final = b"\x90"
+FROZENSET: Final = b"\x91"
+NEWOBJ_EX: Final = b"\x92"
+STACK_GLOBAL: Final = b"\x93"
+MEMOIZE: Final = b"\x94"
+FRAME: Final = b"\x95"
+
+# protocol 5
+BYTEARRAY8: Final = b"\x96"
+NEXT_BUFFER: Final = b"\x97"
+READONLY_BUFFER: Final = b"\x98"
+
+def encode_long(x: int) -> bytes: ...  # undocumented
+def decode_long(data: Iterable[SupportsIndex] | SupportsBytes | ReadableBuffer) -> int: ...  # undocumented
+
+# undocumented pure-Python implementations
+class _Pickler:
+    fast: bool
+    dispatch_table: Mapping[type, Callable[[Any], _ReducedType]]
+    bin: bool  # undocumented
+    dispatch: ClassVar[dict[type, Callable[[Unpickler, Any], None]]]  # undocumented, _Pickler only
+    def __init__(
+        self,
+        file: SupportsWrite[bytes],
+        protocol: int | None = None,
+        *,
+        fix_imports: bool = True,
+        buffer_callback: _BufferCallback = None,
+    ) -> None: ...
+    def dump(self, obj: Any) -> None: ...
+    def clear_memo(self) -> None: ...
+    def persistent_id(self, obj: Any) -> Any: ...
+    # The following method is not defined on _Pickler, but can be defined on
+    # sub-classes. Should return `NotImplemented` if pickling the supplied
+    # object is not supported and returns the same types as `__reduce__()`.
+    def reducer_override(self, obj: object, /) -> _ReducedType: ...
+
+class _Unpickler:
+    dispatch: ClassVar[dict[int, Callable[[Unpickler], None]]]  # undocumented, _Unpickler only
+    def __init__(
+        self,
+        file: _ReadableFileobj,
+        *,
+        fix_imports: bool = True,
+        encoding: str = "ASCII",
+        errors: str = "strict",
+        buffers: Iterable[Any] | None = None,
+    ) -> None: ...
+    def load(self) -> Any: ...
+    def find_class(self, module: str, name: str) -> Any: ...
+    def persistent_load(self, pid: Any) -> Any: ...

package/analyzers/project-map-python/typeshed/stdlib/pickletools.pyi

@@ -0,0 +1,176 @@
+import sys
+from collections.abc import Callable, Iterator, MutableMapping
+from typing import IO, Any, Final, TypeAlias
+
+__all__ = ["dis", "genops", "optimize"]
+
+_Reader: TypeAlias = Callable[[IO[bytes]], Any]
+bytes_types: tuple[type[Any], ...]
+
+UP_TO_NEWLINE: Final = -1
+TAKEN_FROM_ARGUMENT1: Final = -2
+TAKEN_FROM_ARGUMENT4: Final = -3
+TAKEN_FROM_ARGUMENT4U: Final = -4
+TAKEN_FROM_ARGUMENT8U: Final = -5
+
+class ArgumentDescriptor:
+    __slots__ = ("name", "n", "reader", "doc")
+    name: str
+    n: int
+    reader: _Reader
+    doc: str
+    def __init__(self, name: str, n: int, reader: _Reader, doc: str) -> None: ...
+
+def read_uint1(f: IO[bytes]) -> int: ...
+
+uint1: ArgumentDescriptor
+
+def read_uint2(f: IO[bytes]) -> int: ...
+
+uint2: ArgumentDescriptor
+
+def read_int4(f: IO[bytes]) -> int: ...
+
+int4: ArgumentDescriptor
+
+def read_uint4(f: IO[bytes]) -> int: ...
+
+uint4: ArgumentDescriptor
+
+def read_uint8(f: IO[bytes]) -> int: ...
+
+uint8: ArgumentDescriptor
+
+if sys.version_info >= (3, 12):
+    def read_stringnl(
+        f: IO[bytes], decode: bool = True, stripquotes: bool = True, *, encoding: str = "latin-1"
+    ) -> bytes | str: ...
+
+else:
+    def read_stringnl(f: IO[bytes], decode: bool = True, stripquotes: bool = True) -> bytes | str: ...
+
+stringnl: ArgumentDescriptor
+
+def read_stringnl_noescape(f: IO[bytes]) -> str: ...
+
+stringnl_noescape: ArgumentDescriptor
+
+def read_stringnl_noescape_pair(f: IO[bytes]) -> str: ...
+
+stringnl_noescape_pair: ArgumentDescriptor
+
+def read_string1(f: IO[bytes]) -> str: ...
+
+string1: ArgumentDescriptor
+
+def read_string4(f: IO[bytes]) -> str: ...
+
+string4: ArgumentDescriptor
+
+def read_bytes1(f: IO[bytes]) -> bytes: ...
+
+bytes1: ArgumentDescriptor
+
+def read_bytes4(f: IO[bytes]) -> bytes: ...
+
+bytes4: ArgumentDescriptor
+
+def read_bytes8(f: IO[bytes]) -> bytes: ...
+
+bytes8: ArgumentDescriptor
+
+def read_unicodestringnl(f: IO[bytes]) -> str: ...
+
+unicodestringnl: ArgumentDescriptor
+
+def read_unicodestring1(f: IO[bytes]) -> str: ...
+
+unicodestring1: ArgumentDescriptor
+
+def read_unicodestring4(f: IO[bytes]) -> str: ...
+
+unicodestring4: ArgumentDescriptor
+
+def read_unicodestring8(f: IO[bytes]) -> str: ...
+
+unicodestring8: ArgumentDescriptor
+
+def read_decimalnl_short(f: IO[bytes]) -> int: ...
+def read_decimalnl_long(f: IO[bytes]) -> int: ...
+
+decimalnl_short: ArgumentDescriptor
+decimalnl_long: ArgumentDescriptor
+
+def read_floatnl(f: IO[bytes]) -> float: ...
+
+floatnl: ArgumentDescriptor
+
+def read_float8(f: IO[bytes]) -> float: ...
+
+float8: ArgumentDescriptor
+
+def read_long1(f: IO[bytes]) -> int: ...
+
+long1: ArgumentDescriptor
+
+def read_long4(f: IO[bytes]) -> int: ...
+
+long4: ArgumentDescriptor
+
+class StackObject:
+    __slots__ = ("name", "obtype", "doc")
+    name: str
+    obtype: type[Any] | tuple[type[Any], ...]
+    doc: str
+    def __init__(self, name: str, obtype: type[Any] | tuple[type[Any], ...], doc: str) -> None: ...
+
+pyint: StackObject
+pylong: StackObject
+pyinteger_or_bool: StackObject
+pybool: StackObject
+pyfloat: StackObject
+pybytes_or_str: StackObject
+pystring: StackObject
+pybytes: StackObject
+pyunicode: StackObject
+pynone: StackObject
+pytuple: StackObject
+pylist: StackObject
+pydict: StackObject
+pyset: StackObject
+pyfrozenset: StackObject
+anyobject: StackObject
+markobject: StackObject
+stackslice: StackObject
+
+class OpcodeInfo:
+    __slots__ = ("name", "code", "arg", "stack_before", "stack_after", "proto", "doc")
+    name: str
+    code: str
+    arg: ArgumentDescriptor | None
+    stack_before: list[StackObject]
+    stack_after: list[StackObject]
+    proto: int
+    doc: str
+    def __init__(
+        self,
+        name: str,
+        code: str,
+        arg: ArgumentDescriptor | None,
+        stack_before: list[StackObject],
+        stack_after: list[StackObject],
+        proto: int,
+        doc: str,
+    ) -> None: ...
+
+opcodes: list[OpcodeInfo]
+
+def genops(pickle: bytes | bytearray | IO[bytes]) -> Iterator[tuple[OpcodeInfo, Any | None, int | None]]: ...
+def optimize(p: bytes | bytearray | IO[bytes]) -> bytes: ...
+def dis(
+    pickle: bytes | bytearray | IO[bytes],
+    out: IO[str] | None = None,
+    memo: MutableMapping[int, Any] | None = None,
+    indentlevel: int = 4,
+    annotate: int = 0,
+) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/pipes.pyi

@@ -0,0 +1,16 @@
+import os
+
+__all__ = ["Template"]
+
+class Template:
+    def reset(self) -> None: ...
+    def clone(self) -> Template: ...
+    def debug(self, flag: bool) -> None: ...
+    def append(self, cmd: str, kind: str) -> None: ...
+    def prepend(self, cmd: str, kind: str) -> None: ...
+    def open(self, file: str, rw: str) -> os._wrap_close: ...
+    def copy(self, infile: str, outfile: str) -> int: ...
+
+# Not documented, but widely used.
+# Documented as shlex.quote since 3.3.
+def quote(s: str) -> str: ...