layermap 0.1.0

package/analyzers/project-map-python/typeshed/stdlib/asyncio/windows_utils.pyi

@@ -0,0 +1,49 @@
+import subprocess
+import sys
+from collections.abc import Callable
+from types import TracebackType
+from typing import Any, AnyStr, Final
+from typing_extensions import Self
+
+if sys.platform == "win32":
+    __all__ = ("pipe", "Popen", "PIPE", "PipeHandle")
+
+    BUFSIZE: Final = 8192
+    PIPE: Final = subprocess.PIPE
+    STDOUT: Final = subprocess.STDOUT
+    def pipe(*, duplex: bool = False, overlapped: tuple[bool, bool] = (True, True), bufsize: int = 8192) -> tuple[int, int]: ...
+
+    class PipeHandle:
+        def __init__(self, handle: int) -> None: ...
+        def __del__(self) -> None: ...
+        def __enter__(self) -> Self: ...
+        def __exit__(self, t: type[BaseException] | None, v: BaseException | None, tb: TracebackType | None) -> None: ...
+        @property
+        def handle(self) -> int: ...
+        def fileno(self) -> int: ...
+        def close(self, *, CloseHandle: Callable[[int], object] = ...) -> None: ...
+
+    class Popen(subprocess.Popen[AnyStr]):
+        stdin: PipeHandle | None  # type: ignore[assignment]
+        stdout: PipeHandle | None  # type: ignore[assignment]
+        stderr: PipeHandle | None  # type: ignore[assignment]
+        # For simplicity we omit the full overloaded __new__ signature of
+        # subprocess.Popen. The arguments are mostly the same, but
+        # subprocess.Popen takes other positional-or-keyword arguments before
+        # stdin.
+        def __new__(
+            cls,
+            args: subprocess._CMD,
+            stdin: subprocess._FILE | None = None,
+            stdout: subprocess._FILE | None = None,
+            stderr: subprocess._FILE | None = None,
+            **kwds: Any,
+        ) -> Self: ...
+        def __init__(
+            self,
+            args: subprocess._CMD,
+            stdin: subprocess._FILE | None = None,
+            stdout: subprocess._FILE | None = None,
+            stderr: subprocess._FILE | None = None,
+            **kwds: Any,
+        ) -> None: ...

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

@@ -0,0 +1,91 @@
+import sys
+from _typeshed import FileDescriptorLike, ReadableBuffer
+from socket import socket
+from typing import Any, TypeAlias, overload
+
+# cyclic dependence with asynchat
+_MapType: TypeAlias = dict[int, Any]
+_Socket: TypeAlias = socket
+
+socket_map: _MapType  # undocumented
+
+class ExitNow(Exception): ...
+
+def read(obj: Any) -> None: ...
+def write(obj: Any) -> None: ...
+def readwrite(obj: Any, flags: int) -> None: ...
+def poll(timeout: float = 0.0, map: _MapType | None = None) -> None: ...
+def poll2(timeout: float = 0.0, map: _MapType | None = None) -> None: ...
+
+poll3 = poll2
+
+def loop(timeout: float = 30.0, use_poll: bool = False, map: _MapType | None = None, count: int | None = None) -> None: ...
+
+# Not really subclass of socket.socket; it's only delegation.
+# It is not covariant to it.
+class dispatcher:
+    debug: bool
+    connected: bool
+    accepting: bool
+    connecting: bool
+    closing: bool
+    ignore_log_types: frozenset[str]
+    socket: _Socket | None
+    def __init__(self, sock: _Socket | None = None, map: _MapType | None = None) -> None: ...
+    def add_channel(self, map: _MapType | None = None) -> None: ...
+    def del_channel(self, map: _MapType | None = None) -> None: ...
+    def create_socket(self, family: int = ..., type: int = ...) -> None: ...
+    def set_socket(self, sock: _Socket, map: _MapType | None = None) -> None: ...
+    def set_reuse_addr(self) -> None: ...
+    def readable(self) -> bool: ...
+    def writable(self) -> bool: ...
+    def listen(self, num: int) -> None: ...
+    def bind(self, addr: tuple[Any, ...] | str) -> None: ...
+    def connect(self, address: tuple[Any, ...] | str) -> None: ...
+    def accept(self) -> tuple[_Socket, Any] | None: ...
+    def send(self, data: ReadableBuffer) -> int: ...
+    def recv(self, buffer_size: int) -> bytes: ...
+    def close(self) -> None: ...
+    def log(self, message: Any) -> None: ...
+    def log_info(self, message: Any, type: str = "info") -> None: ...
+    def handle_read_event(self) -> None: ...
+    def handle_connect_event(self) -> None: ...
+    def handle_write_event(self) -> None: ...
+    def handle_expt_event(self) -> None: ...
+    def handle_error(self) -> None: ...
+    def handle_expt(self) -> None: ...
+    def handle_read(self) -> None: ...
+    def handle_write(self) -> None: ...
+    def handle_connect(self) -> None: ...
+    def handle_accept(self) -> None: ...
+    def handle_close(self) -> None: ...
+
+class dispatcher_with_send(dispatcher):
+    def initiate_send(self) -> None: ...
+    # incompatible signature:
+    # def send(self, data: bytes) -> int | None: ...
+
+def compact_traceback() -> tuple[tuple[str, str, str], type, type, str]: ...
+def close_all(map: _MapType | None = None, ignore_all: bool = False) -> None: ...
+
+if sys.platform != "win32":
+    class file_wrapper:
+        fd: int
+        def __init__(self, fd: int) -> None: ...
+        def recv(self, bufsize: int, flags: int = ...) -> bytes: ...
+        def send(self, data: bytes, flags: int = ...) -> int: ...
+
+        @overload
+        def getsockopt(self, level: int, optname: int, buflen: None = None) -> int: ...
+        @overload
+        def getsockopt(self, level: int, optname: int, buflen: int) -> bytes: ...
+
+        def read(self, bufsize: int, flags: int = ...) -> bytes: ...
+        def write(self, data: bytes, flags: int = ...) -> int: ...
+        def close(self) -> None: ...
+        def fileno(self) -> int: ...
+        def __del__(self) -> None: ...
+
+    class file_dispatcher(dispatcher):
+        def __init__(self, fd: FileDescriptorLike, map: _MapType | None = None) -> None: ...
+        def set_file(self, fd: int) -> None: ...

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

@@ -0,0 +1,11 @@
+from collections.abc import Callable
+from typing import ParamSpec, TypeVar
+
+_T = TypeVar("_T")
+_P = ParamSpec("_P")
+
+def _clear() -> None: ...
+def _ncallbacks() -> int: ...
+def _run_exitfuncs() -> None: ...
+def register(func: Callable[_P, _T], /, *args: _P.args, **kwargs: _P.kwargs) -> Callable[_P, _T]: ...
+def unregister(func: Callable[..., object], /) -> None: ...

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

@@ -0,0 +1,44 @@
+from typing import TypeAlias
+from typing_extensions import Buffer
+
+_AdpcmState: TypeAlias = tuple[int, int]
+_RatecvState: TypeAlias = tuple[int, tuple[tuple[int, int], ...]]
+
+class error(Exception): ...
+
+def add(fragment1: Buffer, fragment2: Buffer, width: int, /) -> bytes: ...
+def adpcm2lin(fragment: Buffer, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]: ...
+def alaw2lin(fragment: Buffer, width: int, /) -> bytes: ...
+def avg(fragment: Buffer, width: int, /) -> int: ...
+def avgpp(fragment: Buffer, width: int, /) -> int: ...
+def bias(fragment: Buffer, width: int, bias: int, /) -> bytes: ...
+def byteswap(fragment: Buffer, width: int, /) -> bytes: ...
+def cross(fragment: Buffer, width: int, /) -> int: ...
+def findfactor(fragment: Buffer, reference: Buffer, /) -> float: ...
+def findfit(fragment: Buffer, reference: Buffer, /) -> tuple[int, float]: ...
+def findmax(fragment: Buffer, length: int, /) -> int: ...
+def getsample(fragment: Buffer, width: int, index: int, /) -> int: ...
+def lin2adpcm(fragment: Buffer, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]: ...
+def lin2alaw(fragment: Buffer, width: int, /) -> bytes: ...
+def lin2lin(fragment: Buffer, width: int, newwidth: int, /) -> bytes: ...
+def lin2ulaw(fragment: Buffer, width: int, /) -> bytes: ...
+def max(fragment: Buffer, width: int, /) -> int: ...
+def maxpp(fragment: Buffer, width: int, /) -> int: ...
+def minmax(fragment: Buffer, width: int, /) -> tuple[int, int]: ...
+def mul(fragment: Buffer, width: int, factor: float, /) -> bytes: ...
+def ratecv(
+    fragment: Buffer,
+    width: int,
+    nchannels: int,
+    inrate: int,
+    outrate: int,
+    state: _RatecvState | None,
+    weightA: int = 1,
+    weightB: int = 0,
+    /,
+) -> tuple[bytes, _RatecvState]: ...
+def reverse(fragment: Buffer, width: int, /) -> bytes: ...
+def rms(fragment: Buffer, width: int, /) -> int: ...
+def tomono(fragment: Buffer, width: int, lfactor: float, rfactor: float, /) -> bytes: ...
+def tostereo(fragment: Buffer, width: int, lfactor: float, rfactor: float, /) -> bytes: ...
+def ulaw2lin(fragment: Buffer, width: int, /) -> bytes: ...

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

@@ -0,0 +1,124 @@
+import sys
+from _typeshed import ReadableBuffer, SupportsNoArgReadline, SupportsRead, SupportsWrite
+
+__all__ = [
+    "encode",
+    "decode",
+    "encodebytes",
+    "decodebytes",
+    "b64encode",
+    "b64decode",
+    "b32encode",
+    "b32decode",
+    "b16encode",
+    "b16decode",
+    "b32hexencode",
+    "b32hexdecode",
+    "b85encode",
+    "b85decode",
+    "a85encode",
+    "a85decode",
+    "standard_b64encode",
+    "standard_b64decode",
+    "urlsafe_b64encode",
+    "urlsafe_b64decode",
+]
+
+if sys.version_info >= (3, 13):
+    __all__ += ["z85decode", "z85encode"]
+
+if sys.version_info >= (3, 15):
+    def b64encode(
+        s: ReadableBuffer, altchars: ReadableBuffer | None = None, *, padded: bool = True, wrapcol: int = 0
+    ) -> bytes: ...
+    def b64decode(
+        s: str | ReadableBuffer,
+        altchars: str | ReadableBuffer | None = None,
+        validate: bool = ...,
+        *,
+        padded: bool = True,
+        ignorechars: ReadableBuffer = ...,
+        canonical: bool = False,
+    ) -> bytes: ...
+
+else:
+    def b64encode(s: ReadableBuffer, altchars: ReadableBuffer | None = None) -> bytes: ...
+    def b64decode(s: str | ReadableBuffer, altchars: str | ReadableBuffer | None = None, validate: bool = False) -> bytes: ...
+
+def standard_b64encode(s: ReadableBuffer) -> bytes: ...
+def standard_b64decode(s: str | ReadableBuffer) -> bytes: ...
+
+if sys.version_info >= (3, 15):
+    def urlsafe_b64encode(s: ReadableBuffer, *, padded: bool = True) -> bytes: ...
+    def urlsafe_b64decode(s: str | ReadableBuffer, *, padded: bool = False) -> bytes: ...
+    def b32encode(s: ReadableBuffer, *, padded: bool = True, wrapcol: int = 0) -> bytes: ...
+    def b32decode(
+        s: str | ReadableBuffer,
+        casefold: bool = False,
+        map01: str | ReadableBuffer | None = None,
+        *,
+        padded: bool = True,
+        ignorechars: ReadableBuffer = b"",
+        canonical: bool = False,
+    ) -> bytes: ...
+    def b16encode(s: ReadableBuffer, *, wrapcol: int = 0) -> bytes: ...
+    def b16decode(s: str | ReadableBuffer, casefold: bool = False, *, ignorechars: ReadableBuffer = b"") -> bytes: ...
+
+else:
+    def urlsafe_b64encode(s: ReadableBuffer) -> bytes: ...
+    def urlsafe_b64decode(s: str | ReadableBuffer) -> bytes: ...
+    def b32encode(s: ReadableBuffer) -> bytes: ...
+    def b32decode(s: str | ReadableBuffer, casefold: bool = False, map01: str | ReadableBuffer | None = None) -> bytes: ...
+    def b16encode(s: ReadableBuffer) -> bytes: ...
+    def b16decode(s: str | ReadableBuffer, casefold: bool = False) -> bytes: ...
+
+if sys.version_info >= (3, 15):
+    def b32hexencode(s: ReadableBuffer, *, padded: bool = True, wrapcol: int = 0) -> bytes: ...
+    def b32hexdecode(
+        s: str | ReadableBuffer,
+        casefold: bool = False,
+        *,
+        padded: bool = True,
+        ignorechars: ReadableBuffer = b"",
+        canonical: bool = False,
+    ) -> bytes: ...
+
+else:
+    def b32hexencode(s: ReadableBuffer) -> bytes: ...
+    def b32hexdecode(s: str | ReadableBuffer, casefold: bool = False) -> bytes: ...
+
+def a85encode(
+    b: ReadableBuffer, *, foldspaces: bool = False, wrapcol: int = 0, pad: bool = False, adobe: bool = False
+) -> bytes: ...
+
+if sys.version_info >= (3, 15):
+    def a85decode(
+        b: str | ReadableBuffer,
+        *,
+        foldspaces: bool = False,
+        adobe: bool = False,
+        ignorechars: bytearray | bytes = b" \t\n\r\x0b",
+        canonical: bool = False,
+    ) -> bytes: ...
+    def b85encode(b: ReadableBuffer, pad: bool = False, *, wrapcol: int = 0) -> bytes: ...
+    def b85decode(b: str | ReadableBuffer, *, ignorechars: ReadableBuffer = b"", canonical: bool = False) -> bytes: ...
+
+else:
+    def a85decode(
+        b: str | ReadableBuffer, *, foldspaces: bool = False, adobe: bool = False, ignorechars: bytearray | bytes = b" \t\n\r\x0b"
+    ) -> bytes: ...
+    def b85encode(b: ReadableBuffer, pad: bool = False) -> bytes: ...
+    def b85decode(b: str | ReadableBuffer) -> bytes: ...
+
+def decode(input: SupportsNoArgReadline[bytes], output: SupportsWrite[bytes]) -> None: ...
+def encode(input: SupportsRead[bytes], output: SupportsWrite[bytes]) -> None: ...
+def encodebytes(s: ReadableBuffer) -> bytes: ...
+def decodebytes(s: ReadableBuffer) -> bytes: ...
+
+if sys.version_info >= (3, 13):
+    if sys.version_info >= (3, 15):
+        def z85encode(s: ReadableBuffer, pad: bool = False, *, wrapcol: int = 0) -> bytes: ...
+        def z85decode(s: str | ReadableBuffer, *, ignorechars: ReadableBuffer = b"", canonical: bool = False) -> bytes: ...
+    else:
+        def z85encode(s: ReadableBuffer) -> bytes: ...
+        def z85decode(s: str | ReadableBuffer) -> bytes: ...

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

@@ -0,0 +1,139 @@
+import sys
+from _typeshed import ExcInfo, ReadableBuffer, TraceFunction, Unused
+from collections.abc import Callable, Iterable, Iterator, Mapping
+from contextlib import contextmanager
+from types import CodeType, FrameType, TracebackType
+from typing import IO, Any, Final, Literal, ParamSpec, SupportsInt, TypeAlias, TypeVar
+
+__all__ = ["BdbQuit", "Bdb", "Breakpoint"]
+
+_T = TypeVar("_T")
+_P = ParamSpec("_P")
+_Backend: TypeAlias = Literal["settrace", "monitoring"]
+
+# A union of code-object flags at runtime.
+# The exact values of code-object flags are implementation details,
+# so we don't include the value of this constant in the stubs.
+GENERATOR_AND_COROUTINE_FLAGS: Final[int]
+
+class BdbQuit(Exception): ...
+
+class Bdb:
+    skip: set[str] | None
+    breaks: dict[str, list[int]]
+    fncache: dict[str, str]
+    frame_returning: FrameType | None
+    botframe: FrameType | None
+    quitting: bool
+    stopframe: FrameType | None
+    returnframe: FrameType | None
+    stoplineno: int
+    if sys.version_info >= (3, 14):
+        backend: _Backend
+        def __init__(self, skip: Iterable[str] | None = None, backend: _Backend = "settrace") -> None: ...
+    else:
+        def __init__(self, skip: Iterable[str] | None = None) -> None: ...
+
+    def canonic(self, filename: str) -> str: ...
+    def reset(self) -> None: ...
+    if sys.version_info >= (3, 12):
+        @contextmanager
+        def set_enterframe(self, frame: FrameType) -> Iterator[None]: ...
+
+    def trace_dispatch(self, frame: FrameType, event: str, arg: Any) -> TraceFunction: ...
+    def dispatch_line(self, frame: FrameType) -> TraceFunction: ...
+    def dispatch_call(self, frame: FrameType, arg: None) -> TraceFunction: ...
+    def dispatch_return(self, frame: FrameType, arg: Any) -> TraceFunction: ...
+    def dispatch_exception(self, frame: FrameType, arg: ExcInfo) -> TraceFunction: ...
+    if sys.version_info >= (3, 13):
+        def dispatch_opcode(self, frame: FrameType, arg: Unused) -> Callable[[FrameType, str, Any], TraceFunction]: ...
+
+    def is_skipped_module(self, module_name: str) -> bool: ...
+    def stop_here(self, frame: FrameType) -> bool: ...
+    def break_here(self, frame: FrameType) -> bool: ...
+    def do_clear(self, arg: Any) -> bool | None: ...
+    def break_anywhere(self, frame: FrameType) -> bool: ...
+    def user_call(self, frame: FrameType, argument_list: None) -> None: ...
+    def user_line(self, frame: FrameType) -> None: ...
+    def user_return(self, frame: FrameType, return_value: Any) -> None: ...
+    def user_exception(self, frame: FrameType, exc_info: ExcInfo) -> None: ...
+    def set_until(self, frame: FrameType, lineno: int | None = None) -> None: ...
+    if sys.version_info >= (3, 13):
+        def user_opcode(self, frame: FrameType) -> None: ...  # undocumented
+
+    def set_step(self) -> None: ...
+    if sys.version_info >= (3, 13):
+        def set_stepinstr(self) -> None: ...  # undocumented
+
+    def set_next(self, frame: FrameType) -> None: ...
+    def set_return(self, frame: FrameType) -> None: ...
+    def set_trace(self, frame: FrameType | None = None) -> None: ...
+    def set_continue(self) -> None: ...
+    def set_quit(self) -> None: ...
+    def set_break(
+        self, filename: str, lineno: int, temporary: bool = False, cond: str | None = None, funcname: str | None = None
+    ) -> str | None: ...
+    def clear_break(self, filename: str, lineno: int) -> str | None: ...
+    def clear_bpbynumber(self, arg: SupportsInt) -> str | None: ...
+    def clear_all_file_breaks(self, filename: str) -> str | None: ...
+    def clear_all_breaks(self) -> str | None: ...
+    def get_bpbynumber(self, arg: SupportsInt) -> Breakpoint: ...
+    def get_break(self, filename: str, lineno: int) -> bool: ...
+    def get_breaks(self, filename: str, lineno: int) -> list[Breakpoint]: ...
+    def get_file_breaks(self, filename: str) -> list[int]: ...
+    def get_all_breaks(self) -> dict[str, list[int]]: ...
+    def get_stack(self, f: FrameType | None, t: TracebackType | None) -> tuple[list[tuple[FrameType, int]], int]: ...
+    def format_stack_entry(self, frame_lineno: tuple[FrameType, int], lprefix: str = ": ") -> str: ...
+    def run(  # matches `builtins.exec`
+        self,
+        cmd: str | ReadableBuffer | CodeType,
+        globals: dict[str, Any] | None = None,
+        locals: Mapping[str, object] | None = None,
+    ) -> None: ...
+    def runctx(  # matches `builtins.exec`
+        self, cmd: str | ReadableBuffer | CodeType, globals: dict[str, Any] | None, locals: Mapping[str, object] | None
+    ) -> None: ...
+    def runeval(  # matches `builtins.eval`
+        self,
+        expr: str | ReadableBuffer | CodeType,
+        globals: dict[str, Any] | None = None,
+        locals: Mapping[str, object] | None = None,
+    ) -> Any: ...
+    def runcall(self, func: Callable[_P, _T], /, *args: _P.args, **kwds: _P.kwargs) -> _T | None: ...
+    if sys.version_info >= (3, 14):
+        def start_trace(self) -> None: ...
+        def stop_trace(self) -> None: ...
+        def disable_current_event(self) -> None: ...
+        def restart_events(self) -> None: ...
+
+class Breakpoint:
+    next: int
+    bplist: dict[tuple[str, int], list[Breakpoint]]
+    bpbynumber: list[Breakpoint | None]
+
+    funcname: str | None
+    func_first_executable_line: int | None
+    file: str
+    line: int
+    temporary: bool
+    cond: str | None
+    enabled: bool
+    ignore: int
+    hits: int
+    number: int
+    def __init__(
+        self, file: str, line: int, temporary: bool = False, cond: str | None = None, funcname: str | None = None
+    ) -> None: ...
+    if sys.version_info >= (3, 11):
+        @staticmethod
+        def clearBreakpoints() -> None: ...
+
+    def deleteMe(self) -> None: ...
+    def enable(self) -> None: ...
+    def disable(self) -> None: ...
+    def bpprint(self, out: IO[str] | None = None) -> None: ...
+    def bpformat(self) -> str: ...
+
+def checkfuncname(b: Breakpoint, frame: FrameType) -> bool: ...
+def effective(file: str, line: int, frame: FrameType) -> tuple[Breakpoint, bool] | tuple[None, None]: ...
+def set_trace() -> None: ...

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

@@ -0,0 +1,102 @@
+import sys
+from _typeshed import ReadableBuffer
+from typing import TypeAlias
+from typing_extensions import deprecated
+
+# Many functions in binascii accept buffer objects
+# or ASCII-only strings.
+_AsciiBuffer: TypeAlias = str | ReadableBuffer
+
+def a2b_uu(data: _AsciiBuffer, /) -> bytes: ...
+def b2a_uu(data: ReadableBuffer, /, *, backtick: bool = False) -> bytes: ...
+
+if sys.version_info >= (3, 15):
+    ASCII85_ALPHABET: bytes
+    BINHEX_ALPHABET: bytes
+    CRYPT_ALPHABET: bytes
+    UU_ALPHABET: bytes
+    BASE64_ALPHABET: bytes
+    URLSAFE_BASE64_ALPHABET: bytes
+    BASE32_ALPHABET: bytes
+    BASE32HEX_ALPHABET: bytes
+    BASE85_ALPHABET: bytes
+    Z85_ALPHABET: bytes
+    def a2b_base64(
+        data: _AsciiBuffer,
+        /,
+        *,
+        strict_mode: bool = False,
+        alphabet: bytes = ...,
+        padded: bool = True,
+        ignorechars: ReadableBuffer = ...,
+        canonical: bool = False,
+    ) -> bytes: ...
+    def b2a_base64(
+        data: ReadableBuffer, /, *, newline: bool = True, alphabet: ReadableBuffer = ..., padded: bool = True, wrapcol: int = 0
+    ) -> bytes: ...
+    def b2a_base32(
+        data: ReadableBuffer, /, *, alphabet: ReadableBuffer = ..., padded: bool = True, wrapcol: int = 0
+    ) -> bytes: ...
+    def a2b_base32(
+        data: _AsciiBuffer,
+        /,
+        *,
+        alphabet: bytes = ...,
+        padded: bool = True,
+        ignorechars: ReadableBuffer = b"",
+        canonical: bool = False,
+    ) -> bytes: ...
+    def b2a_ascii85(
+        data: ReadableBuffer, /, *, foldspaces: bool = False, wrapcol: int = 0, pad: bool = False, adobe: bool = False
+    ) -> bytes: ...
+    def a2b_ascii85(
+        data: _AsciiBuffer,
+        /,
+        *,
+        foldspaces: bool = False,
+        adobe: bool = False,
+        ignorechars: ReadableBuffer = b"",
+        canonical: bool = False,
+    ) -> bytes: ...
+    def b2a_base85(data: ReadableBuffer, /, *, alphabet: ReadableBuffer = ..., pad: bool = False, wrapcol: int = 0) -> bytes: ...
+    def a2b_base85(
+        data: _AsciiBuffer, /, *, alphabet: bytes = ..., ignorechars: ReadableBuffer = b"", canonical: bool = False
+    ) -> bytes: ...
+
+elif sys.version_info >= (3, 11):
+    def a2b_base64(data: _AsciiBuffer, /, *, strict_mode: bool = False) -> bytes: ...
+
+else:
+    def a2b_base64(data: _AsciiBuffer, /) -> bytes: ...
+
+if sys.version_info < (3, 15):
+    def b2a_base64(data: ReadableBuffer, /, *, newline: bool = True) -> bytes: ...
+
+def a2b_qp(data: _AsciiBuffer, header: bool = False) -> bytes: ...
+def b2a_qp(data: ReadableBuffer, quotetabs: bool = False, istext: bool = True, header: bool = False) -> bytes: ...
+
+if sys.version_info < (3, 11):
+    @deprecated("Deprecated since Python 3.9; removed in Python 3.11.")
+    def a2b_hqx(data: _AsciiBuffer, /) -> bytes: ...
+    @deprecated("Deprecated since Python 3.9; removed in Python 3.11.")
+    def rledecode_hqx(data: ReadableBuffer, /) -> bytes: ...
+    @deprecated("Deprecated since Python 3.9; removed in Python 3.11.")
+    def rlecode_hqx(data: ReadableBuffer, /) -> bytes: ...
+    @deprecated("Deprecated since Python 3.9; removed in Python 3.11.")
+    def b2a_hqx(data: ReadableBuffer, /) -> bytes: ...
+
+def crc_hqx(data: ReadableBuffer, crc: int, /) -> int: ...
+def crc32(data: ReadableBuffer, crc: int = 0, /) -> int: ...
+def b2a_hex(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = 1) -> bytes: ...
+def hexlify(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = 1) -> bytes: ...
+
+if sys.version_info >= (3, 15):
+    def a2b_hex(hexstr: _AsciiBuffer, /, *, ignorechars: ReadableBuffer = b"") -> bytes: ...
+    def unhexlify(hexstr: _AsciiBuffer, /, *, ignorechars: ReadableBuffer = b"") -> bytes: ...
+
+else:
+    def a2b_hex(hexstr: _AsciiBuffer, /) -> bytes: ...
+    def unhexlify(hexstr: _AsciiBuffer, /) -> bytes: ...
+
+class Error(ValueError): ...
+class Incomplete(Exception): ...

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

@@ -0,0 +1,44 @@
+from _typeshed import SizedBuffer
+from typing import IO, Any, Final, TypeAlias
+
+__all__ = ["binhex", "hexbin", "Error"]
+
+class Error(Exception): ...
+
+REASONABLY_LARGE: Final = 32768
+LINELEN: Final = 64
+RUNCHAR: Final = b"\x90"
+
+class FInfo:
+    Type: str
+    Creator: str
+    Flags: int
+
+_FileInfoTuple: TypeAlias = tuple[str, FInfo, int, int]
+_FileHandleUnion: TypeAlias = str | IO[bytes]
+
+def getfileinfo(name: str) -> _FileInfoTuple: ...
+
+class openrsrc:
+    def __init__(self, *args: Any) -> None: ...
+    def read(self, *args: Any) -> bytes: ...
+    def write(self, *args: Any) -> None: ...
+    def close(self) -> None: ...
+
+class BinHex:
+    def __init__(self, name_finfo_dlen_rlen: _FileInfoTuple, ofp: _FileHandleUnion) -> None: ...
+    def write(self, data: SizedBuffer) -> None: ...
+    def close_data(self) -> None: ...
+    def write_rsrc(self, data: SizedBuffer) -> None: ...
+    def close(self) -> None: ...
+
+def binhex(inp: str, out: str) -> None: ...
+
+class HexBin:
+    def __init__(self, ifp: _FileHandleUnion) -> None: ...
+    def read(self, *n: int) -> bytes: ...
+    def close_data(self) -> None: ...
+    def read_rsrc(self, *n: int) -> bytes: ...
+    def close(self) -> None: ...
+
+def hexbin(inp: str, out: str) -> None: ...

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

@@ -0,0 +1,4 @@
+from _bisect import *
+
+bisect = bisect_right
+insort = insort_right