jaclang 0.6.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

jaclang/vendor/mypy/typeshed/stdlib/dbm/__init__.pyi

@@ -0,0 +1,95 @@
+from collections.abc import Iterator, MutableMapping
+from types import TracebackType
+from typing import Literal
+from typing_extensions import Self, TypeAlias
+
+__all__ = ["open", "whichdb", "error"]
+
+_KeyType: TypeAlias = str | bytes
+_ValueType: TypeAlias = str | bytes | bytearray
+_TFlags: TypeAlias = Literal[
+    "r",
+    "w",
+    "c",
+    "n",
+    "rf",
+    "wf",
+    "cf",
+    "nf",
+    "rs",
+    "ws",
+    "cs",
+    "ns",
+    "ru",
+    "wu",
+    "cu",
+    "nu",
+    "rfs",
+    "wfs",
+    "cfs",
+    "nfs",
+    "rfu",
+    "wfu",
+    "cfu",
+    "nfu",
+    "rsf",
+    "wsf",
+    "csf",
+    "nsf",
+    "rsu",
+    "wsu",
+    "csu",
+    "nsu",
+    "ruf",
+    "wuf",
+    "cuf",
+    "nuf",
+    "rus",
+    "wus",
+    "cus",
+    "nus",
+    "rfsu",
+    "wfsu",
+    "cfsu",
+    "nfsu",
+    "rfus",
+    "wfus",
+    "cfus",
+    "nfus",
+    "rsfu",
+    "wsfu",
+    "csfu",
+    "nsfu",
+    "rsuf",
+    "wsuf",
+    "csuf",
+    "nsuf",
+    "rufs",
+    "wufs",
+    "cufs",
+    "nufs",
+    "rusf",
+    "wusf",
+    "cusf",
+    "nusf",
+]
+
+class _Database(MutableMapping[_KeyType, bytes]):
+    def close(self) -> None: ...
+    def __getitem__(self, key: _KeyType) -> bytes: ...
+    def __setitem__(self, key: _KeyType, value: _ValueType) -> None: ...
+    def __delitem__(self, key: _KeyType) -> None: ...
+    def __iter__(self) -> Iterator[bytes]: ...
+    def __len__(self) -> int: ...
+    def __del__(self) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+    ) -> None: ...
+
+class _error(Exception): ...
+
+error: tuple[type[_error], type[OSError]]
+
+def whichdb(filename: str) -> str | None: ...
+def open(file: str, flag: _TFlags = "r", mode: int = 0o666) -> _Database: ...

jaclang/vendor/mypy/typeshed/stdlib/dbm/dumb.pyi

@@ -0,0 +1,31 @@
+from collections.abc import Iterator, MutableMapping
+from types import TracebackType
+from typing_extensions import Self, TypeAlias
+
+__all__ = ["error", "open"]
+
+_KeyType: TypeAlias = str | bytes
+_ValueType: TypeAlias = str | bytes
+
+error = OSError
+
+# This class doesn't exist at runtime. open() can return an instance of
+# any of the three implementations of dbm (dumb, gnu, ndbm), and this
+# class is intended to represent the common interface supported by all three.
+class _Database(MutableMapping[_KeyType, bytes]):
+    def __init__(self, filebasename: str, mode: str, flag: str = "c") -> None: ...
+    def sync(self) -> None: ...
+    def iterkeys(self) -> Iterator[bytes]: ...  # undocumented
+    def close(self) -> None: ...
+    def __getitem__(self, key: _KeyType) -> bytes: ...
+    def __setitem__(self, key: _KeyType, val: _ValueType) -> None: ...
+    def __delitem__(self, key: _KeyType) -> None: ...
+    def __iter__(self) -> Iterator[bytes]: ...
+    def __len__(self) -> int: ...
+    def __del__(self) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+    ) -> None: ...
+
+def open(file: str, flag: str = "c", mode: int = 0o666) -> _Database: ...

jaclang/vendor/mypy/typeshed/stdlib/dbm/gnu.pyi

@@ -0,0 +1,41 @@
+import sys
+from _typeshed import ReadOnlyBuffer
+from types import TracebackType
+from typing import TypeVar, overload
+from typing_extensions import Self, TypeAlias
+
+if sys.platform != "win32":
+    _T = TypeVar("_T")
+    _KeyType: TypeAlias = str | ReadOnlyBuffer
+    _ValueType: TypeAlias = str | ReadOnlyBuffer
+
+    open_flags: str
+
+    class error(OSError): ...
+    # Actual typename gdbm, not exposed by the implementation
+    class _gdbm:
+        def firstkey(self) -> bytes | None: ...
+        def nextkey(self, key: _KeyType) -> bytes | None: ...
+        def reorganize(self) -> None: ...
+        def sync(self) -> None: ...
+        def close(self) -> None: ...
+        def __getitem__(self, item: _KeyType) -> bytes: ...
+        def __setitem__(self, key: _KeyType, value: _ValueType) -> None: ...
+        def __delitem__(self, key: _KeyType) -> None: ...
+        def __contains__(self, key: _KeyType) -> bool: ...
+        def __len__(self) -> int: ...
+        def __enter__(self) -> Self: ...
+        def __exit__(
+            self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+        ) -> None: ...
+        @overload
+        def get(self, k: _KeyType) -> bytes | None: ...
+        @overload
+        def get(self, k: _KeyType, default: _T) -> bytes | _T: ...
+        def keys(self) -> list[bytes]: ...
+        def setdefault(self, k: _KeyType, default: _ValueType = ...) -> bytes: ...
+        # Don't exist at runtime
+        __new__: None  # type: ignore[assignment]
+        __init__: None  # type: ignore[assignment]
+
+    def open(filename: str, flags: str = "r", mode: int = 0o666, /) -> _gdbm: ...

jaclang/vendor/mypy/typeshed/stdlib/dbm/ndbm.pyi

@@ -0,0 +1,37 @@
+import sys
+from _typeshed import ReadOnlyBuffer
+from types import TracebackType
+from typing import TypeVar, overload
+from typing_extensions import Self, TypeAlias
+
+if sys.platform != "win32":
+    _T = TypeVar("_T")
+    _KeyType: TypeAlias = str | ReadOnlyBuffer
+    _ValueType: TypeAlias = str | ReadOnlyBuffer
+
+    class error(OSError): ...
+    library: str
+
+    # Actual typename dbm, not exposed by the implementation
+    class _dbm:
+        def close(self) -> None: ...
+        def __getitem__(self, item: _KeyType) -> bytes: ...
+        def __setitem__(self, key: _KeyType, value: _ValueType) -> None: ...
+        def __delitem__(self, key: _KeyType) -> None: ...
+        def __len__(self) -> int: ...
+        def __del__(self) -> None: ...
+        def __enter__(self) -> Self: ...
+        def __exit__(
+            self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+        ) -> None: ...
+        @overload
+        def get(self, k: _KeyType) -> bytes | None: ...
+        @overload
+        def get(self, k: _KeyType, default: _T) -> bytes | _T: ...
+        def keys(self) -> list[bytes]: ...
+        def setdefault(self, k: _KeyType, default: _ValueType = ...) -> bytes: ...
+        # Don't exist at runtime
+        __new__: None  # type: ignore[assignment]
+        __init__: None  # type: ignore[assignment]
+
+    def open(filename: str, flags: str = "r", mode: int = 0o666, /) -> _dbm: ...

jaclang/vendor/mypy/typeshed/stdlib/decimal.pyi

@@ -0,0 +1,2 @@
+from _decimal import *
+from _decimal import __libmpdec_version__ as __libmpdec_version__, __version__ as __version__

jaclang/vendor/mypy/typeshed/stdlib/difflib.pyi

@@ -0,0 +1,140 @@
+import sys
+from collections.abc import Callable, Iterable, Iterator, Sequence
+from typing import Any, AnyStr, Generic, Literal, NamedTuple, TypeVar, overload
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+__all__ = [
+    "get_close_matches",
+    "ndiff",
+    "restore",
+    "SequenceMatcher",
+    "Differ",
+    "IS_CHARACTER_JUNK",
+    "IS_LINE_JUNK",
+    "context_diff",
+    "unified_diff",
+    "diff_bytes",
+    "HtmlDiff",
+    "Match",
+]
+
+_T = TypeVar("_T")
+
+class Match(NamedTuple):
+    a: int
+    b: int
+    size: int
+
+class SequenceMatcher(Generic[_T]):
+    @overload
+    def __init__(self, isjunk: Callable[[_T], bool] | None, a: Sequence[_T], b: Sequence[_T], autojunk: bool = True) -> None: ...
+    @overload
+    def __init__(self, *, a: Sequence[_T], b: Sequence[_T], autojunk: bool = True) -> None: ...
+    @overload
+    def __init__(
+        self: SequenceMatcher[str],
+        isjunk: Callable[[str], bool] | None = None,
+        a: Sequence[str] = "",
+        b: Sequence[str] = "",
+        autojunk: bool = True,
+    ) -> None: ...
+    def set_seqs(self, a: Sequence[_T], b: Sequence[_T]) -> None: ...
+    def set_seq1(self, a: Sequence[_T]) -> None: ...
+    def set_seq2(self, b: Sequence[_T]) -> None: ...
+    if sys.version_info >= (3, 9):
+        def find_longest_match(self, alo: int = 0, ahi: int | None = None, blo: int = 0, bhi: int | None = None) -> Match: ...
+    else:
+        def find_longest_match(self, alo: int, ahi: int, blo: int, bhi: int) -> Match: ...
+
+    def get_matching_blocks(self) -> list[Match]: ...
+    def get_opcodes(self) -> list[tuple[Literal["replace", "delete", "insert", "equal"], int, int, int, int]]: ...
+    def get_grouped_opcodes(self, n: int = 3) -> Iterable[list[tuple[str, int, int, int, int]]]: ...
+    def ratio(self) -> float: ...
+    def quick_ratio(self) -> float: ...
+    def real_quick_ratio(self) -> float: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+@overload
+def get_close_matches(word: AnyStr, possibilities: Iterable[AnyStr], n: int = 3, cutoff: float = 0.6) -> list[AnyStr]: ...
+@overload
+def get_close_matches(
+    word: Sequence[_T], possibilities: Iterable[Sequence[_T]], n: int = 3, cutoff: float = 0.6
+) -> list[Sequence[_T]]: ...
+
+class Differ:
+    def __init__(self, linejunk: Callable[[str], bool] | None = None, charjunk: Callable[[str], bool] | None = None) -> None: ...
+    def compare(self, a: Sequence[str], b: Sequence[str]) -> Iterator[str]: ...
+
+def IS_LINE_JUNK(line: str, pat: Any = ...) -> bool: ...  # pat is undocumented
+def IS_CHARACTER_JUNK(ch: str, ws: str = " \t") -> bool: ...  # ws is undocumented
+def unified_diff(
+    a: Sequence[str],
+    b: Sequence[str],
+    fromfile: str = "",
+    tofile: str = "",
+    fromfiledate: str = "",
+    tofiledate: str = "",
+    n: int = 3,
+    lineterm: str = "\n",
+) -> Iterator[str]: ...
+def context_diff(
+    a: Sequence[str],
+    b: Sequence[str],
+    fromfile: str = "",
+    tofile: str = "",
+    fromfiledate: str = "",
+    tofiledate: str = "",
+    n: int = 3,
+    lineterm: str = "\n",
+) -> Iterator[str]: ...
+def ndiff(
+    a: Sequence[str],
+    b: Sequence[str],
+    linejunk: Callable[[str], bool] | None = None,
+    charjunk: Callable[[str], bool] | None = ...,
+) -> Iterator[str]: ...
+
+class HtmlDiff:
+    def __init__(
+        self,
+        tabsize: int = 8,
+        wrapcolumn: int | None = None,
+        linejunk: Callable[[str], bool] | None = None,
+        charjunk: Callable[[str], bool] | None = ...,
+    ) -> None: ...
+    def make_file(
+        self,
+        fromlines: Sequence[str],
+        tolines: Sequence[str],
+        fromdesc: str = "",
+        todesc: str = "",
+        context: bool = False,
+        numlines: int = 5,
+        *,
+        charset: str = "utf-8",
+    ) -> str: ...
+    def make_table(
+        self,
+        fromlines: Sequence[str],
+        tolines: Sequence[str],
+        fromdesc: str = "",
+        todesc: str = "",
+        context: bool = False,
+        numlines: int = 5,
+    ) -> str: ...
+
+def restore(delta: Iterable[str], which: int) -> Iterator[str]: ...
+def diff_bytes(
+    dfunc: Callable[[Sequence[str], Sequence[str], str, str, str, str, int, str], Iterator[str]],
+    a: Iterable[bytes | bytearray],
+    b: Iterable[bytes | bytearray],
+    fromfile: bytes | bytearray = b"",
+    tofile: bytes | bytearray = b"",
+    fromfiledate: bytes | bytearray = b"",
+    tofiledate: bytes | bytearray = b"",
+    n: int = 3,
+    lineterm: bytes | bytearray = b"\n",
+) -> Iterator[bytes]: ...

jaclang/vendor/mypy/typeshed/stdlib/dis.pyi

@@ -0,0 +1,144 @@
+import sys
+import types
+from collections.abc import Callable, Iterator
+from opcode import *  # `dis` re-exports it as a part of public API
+from typing import IO, Any, NamedTuple
+from typing_extensions import Self, TypeAlias
+
+__all__ = [
+    "code_info",
+    "dis",
+    "disassemble",
+    "distb",
+    "disco",
+    "findlinestarts",
+    "findlabels",
+    "show_code",
+    "get_instructions",
+    "Instruction",
+    "Bytecode",
+    "cmp_op",
+    "hasconst",
+    "hasname",
+    "hasjrel",
+    "hasjabs",
+    "haslocal",
+    "hascompare",
+    "hasfree",
+    "opname",
+    "opmap",
+    "HAVE_ARGUMENT",
+    "EXTENDED_ARG",
+    "stack_effect",
+]
+if sys.version_info >= (3, 12):
+    __all__ += ["hasarg", "hasexc"]
+else:
+    __all__ += ["hasnargs"]
+
+# Strictly this should not have to include Callable, but mypy doesn't use FunctionType
+# for functions (python/mypy#3171)
+_HaveCodeType: TypeAlias = types.MethodType | types.FunctionType | types.CodeType | type | Callable[..., Any]
+
+if sys.version_info >= (3, 11):
+    class Positions(NamedTuple):
+        lineno: int | None = None
+        end_lineno: int | None = None
+        col_offset: int | None = None
+        end_col_offset: int | None = None
+
+if sys.version_info >= (3, 11):
+    class _Instruction(NamedTuple):
+        opname: str
+        opcode: int
+        arg: int | None
+        argval: Any
+        argrepr: str
+        offset: int
+        starts_line: int | None
+        is_jump_target: bool
+        positions: Positions | None = None
+
+else:
+    class _Instruction(NamedTuple):
+        opname: str
+        opcode: int
+        arg: int | None
+        argval: Any
+        argrepr: str
+        offset: int
+        starts_line: int | None
+        is_jump_target: bool
+
+class Instruction(_Instruction):
+    def _disassemble(self, lineno_width: int = 3, mark_as_current: bool = False, offset_width: int = 4) -> str: ...
+
+class Bytecode:
+    codeobj: types.CodeType
+    first_line: int
+    if sys.version_info >= (3, 11):
+        def __init__(
+            self,
+            x: _HaveCodeType | str,
+            *,
+            first_line: int | None = None,
+            current_offset: int | None = None,
+            show_caches: bool = False,
+            adaptive: bool = False,
+        ) -> None: ...
+        @classmethod
+        def from_traceback(cls, tb: types.TracebackType, *, show_caches: bool = False, adaptive: bool = False) -> Self: ...
+    else:
+        def __init__(
+            self, x: _HaveCodeType | str, *, first_line: int | None = None, current_offset: int | None = None
+        ) -> None: ...
+        @classmethod
+        def from_traceback(cls, tb: types.TracebackType) -> Self: ...
+
+    def __iter__(self) -> Iterator[Instruction]: ...
+    def info(self) -> str: ...
+    def dis(self) -> str: ...
+
+COMPILER_FLAG_NAMES: dict[int, str]
+
+def findlabels(code: _HaveCodeType) -> list[int]: ...
+def findlinestarts(code: _HaveCodeType) -> Iterator[tuple[int, int]]: ...
+def pretty_flags(flags: int) -> str: ...
+def code_info(x: _HaveCodeType | str) -> str: ...
+
+if sys.version_info >= (3, 11):
+    def dis(
+        x: _HaveCodeType | str | bytes | bytearray | None = None,
+        *,
+        file: IO[str] | None = None,
+        depth: int | None = None,
+        show_caches: bool = False,
+        adaptive: bool = False,
+    ) -> None: ...
+
+else:
+    def dis(
+        x: _HaveCodeType | str | bytes | bytearray | None = None, *, file: IO[str] | None = None, depth: int | None = None
+    ) -> None: ...
+
+if sys.version_info >= (3, 11):
+    def disassemble(
+        co: _HaveCodeType, lasti: int = -1, *, file: IO[str] | None = None, show_caches: bool = False, adaptive: bool = False
+    ) -> None: ...
+    def disco(
+        co: _HaveCodeType, lasti: int = -1, *, file: IO[str] | None = None, show_caches: bool = False, adaptive: bool = False
+    ) -> None: ...
+    def distb(
+        tb: types.TracebackType | None = None, *, file: IO[str] | None = None, show_caches: bool = False, adaptive: bool = False
+    ) -> None: ...
+    def get_instructions(
+        x: _HaveCodeType, *, first_line: int | None = None, show_caches: bool = False, adaptive: bool = False
+    ) -> Iterator[Instruction]: ...
+
+else:
+    def disassemble(co: _HaveCodeType, lasti: int = -1, *, file: IO[str] | None = None) -> None: ...
+    def disco(co: _HaveCodeType, lasti: int = -1, *, file: IO[str] | None = None) -> None: ...
+    def distb(tb: types.TracebackType | None = None, *, file: IO[str] | None = None) -> None: ...
+    def get_instructions(x: _HaveCodeType, *, first_line: int | None = None) -> Iterator[Instruction]: ...
+
+def show_code(co: _HaveCodeType, *, file: IO[str] | None = None) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/distutils/__init__.pyi

@@ -0,0 +1,5 @@
+# Attempts to improve these stubs are probably not the best use of time:
+# - distutils is deleted in Python 3.12 and newer
+# - Most users already do not use stdlib distutils, due to setuptools monkeypatching
+# - We have very little quality assurance on these stubs, since due to the two above issues
+#   we allowlist all distutils errors in stubtest.

jaclang/vendor/mypy/typeshed/stdlib/distutils/archive_util.pyi

@@ -0,0 +1,20 @@
+def make_archive(
+    base_name: str,
+    format: str,
+    root_dir: str | None = None,
+    base_dir: str | None = None,
+    verbose: int = 0,
+    dry_run: int = 0,
+    owner: str | None = None,
+    group: str | None = None,
+) -> str: ...
+def make_tarball(
+    base_name: str,
+    base_dir: str,
+    compress: str | None = "gzip",
+    verbose: int = 0,
+    dry_run: int = 0,
+    owner: str | None = None,
+    group: str | None = None,
+) -> str: ...
+def make_zipfile(base_name: str, base_dir: str, verbose: int = 0, dry_run: int = 0) -> str: ...

jaclang/vendor/mypy/typeshed/stdlib/distutils/bcppcompiler.pyi

@@ -0,0 +1,3 @@
+from distutils.ccompiler import CCompiler
+
+class BCPPCompiler(CCompiler): ...

jaclang/vendor/mypy/typeshed/stdlib/distutils/ccompiler.pyi

@@ -0,0 +1,152 @@
+from collections.abc import Callable
+from typing import Any
+from typing_extensions import TypeAlias
+
+_Macro: TypeAlias = tuple[str] | tuple[str, str | None]
+
+def gen_lib_options(
+    compiler: CCompiler, library_dirs: list[str], runtime_library_dirs: list[str], libraries: list[str]
+) -> list[str]: ...
+def gen_preprocess_options(macros: list[_Macro], include_dirs: list[str]) -> list[str]: ...
+def get_default_compiler(osname: str | None = None, platform: str | None = None) -> str: ...
+def new_compiler(
+    plat: str | None = None, compiler: str | None = None, verbose: int = 0, dry_run: int = 0, force: int = 0
+) -> CCompiler: ...
+def show_compilers() -> None: ...
+
+class CCompiler:
+    dry_run: bool
+    force: bool
+    verbose: bool
+    output_dir: str | None
+    macros: list[_Macro]
+    include_dirs: list[str]
+    libraries: list[str]
+    library_dirs: list[str]
+    runtime_library_dirs: list[str]
+    objects: list[str]
+    def __init__(self, verbose: int = 0, dry_run: int = 0, force: int = 0) -> None: ...
+    def add_include_dir(self, dir: str) -> None: ...
+    def set_include_dirs(self, dirs: list[str]) -> None: ...
+    def add_library(self, libname: str) -> None: ...
+    def set_libraries(self, libnames: list[str]) -> None: ...
+    def add_library_dir(self, dir: str) -> None: ...
+    def set_library_dirs(self, dirs: list[str]) -> None: ...
+    def add_runtime_library_dir(self, dir: str) -> None: ...
+    def set_runtime_library_dirs(self, dirs: list[str]) -> None: ...
+    def define_macro(self, name: str, value: str | None = None) -> None: ...
+    def undefine_macro(self, name: str) -> None: ...
+    def add_link_object(self, object: str) -> None: ...
+    def set_link_objects(self, objects: list[str]) -> None: ...
+    def detect_language(self, sources: str | list[str]) -> str | None: ...
+    def find_library_file(self, dirs: list[str], lib: str, debug: bool = ...) -> str | None: ...
+    def has_function(
+        self,
+        funcname: str,
+        includes: list[str] | None = None,
+        include_dirs: list[str] | None = None,
+        libraries: list[str] | None = None,
+        library_dirs: list[str] | None = None,
+    ) -> bool: ...
+    def library_dir_option(self, dir: str) -> str: ...
+    def library_option(self, lib: str) -> str: ...
+    def runtime_library_dir_option(self, dir: str) -> str: ...
+    def set_executables(self, **args: str) -> None: ...
+    def compile(
+        self,
+        sources: list[str],
+        output_dir: str | None = None,
+        macros: list[_Macro] | None = None,
+        include_dirs: list[str] | None = None,
+        debug: bool = ...,
+        extra_preargs: list[str] | None = None,
+        extra_postargs: list[str] | None = None,
+        depends: list[str] | None = None,
+    ) -> list[str]: ...
+    def create_static_lib(
+        self,
+        objects: list[str],
+        output_libname: str,
+        output_dir: str | None = None,
+        debug: bool = ...,
+        target_lang: str | None = None,
+    ) -> None: ...
+    def link(
+        self,
+        target_desc: str,
+        objects: list[str],
+        output_filename: str,
+        output_dir: str | None = None,
+        libraries: list[str] | None = None,
+        library_dirs: list[str] | None = None,
+        runtime_library_dirs: list[str] | None = None,
+        export_symbols: list[str] | None = None,
+        debug: bool = ...,
+        extra_preargs: list[str] | None = None,
+        extra_postargs: list[str] | None = None,
+        build_temp: str | None = None,
+        target_lang: str | None = None,
+    ) -> None: ...
+    def link_executable(
+        self,
+        objects: list[str],
+        output_progname: str,
+        output_dir: str | None = None,
+        libraries: list[str] | None = None,
+        library_dirs: list[str] | None = None,
+        runtime_library_dirs: list[str] | None = None,
+        debug: bool = ...,
+        extra_preargs: list[str] | None = None,
+        extra_postargs: list[str] | None = None,
+        target_lang: str | None = None,
+    ) -> None: ...
+    def link_shared_lib(
+        self,
+        objects: list[str],
+        output_libname: str,
+        output_dir: str | None = None,
+        libraries: list[str] | None = None,
+        library_dirs: list[str] | None = None,
+        runtime_library_dirs: list[str] | None = None,
+        export_symbols: list[str] | None = None,
+        debug: bool = ...,
+        extra_preargs: list[str] | None = None,
+        extra_postargs: list[str] | None = None,
+        build_temp: str | None = None,
+        target_lang: str | None = None,
+    ) -> None: ...
+    def link_shared_object(
+        self,
+        objects: list[str],
+        output_filename: str,
+        output_dir: str | None = None,
+        libraries: list[str] | None = None,
+        library_dirs: list[str] | None = None,
+        runtime_library_dirs: list[str] | None = None,
+        export_symbols: list[str] | None = None,
+        debug: bool = ...,
+        extra_preargs: list[str] | None = None,
+        extra_postargs: list[str] | None = None,
+        build_temp: str | None = None,
+        target_lang: str | None = None,
+    ) -> None: ...
+    def preprocess(
+        self,
+        source: str,
+        output_file: str | None = None,
+        macros: list[_Macro] | None = None,
+        include_dirs: list[str] | None = None,
+        extra_preargs: list[str] | None = None,
+        extra_postargs: list[str] | None = None,
+    ) -> None: ...
+    def executable_filename(self, basename: str, strip_dir: int = 0, output_dir: str = "") -> str: ...
+    def library_filename(self, libname: str, lib_type: str = "static", strip_dir: int = 0, output_dir: str = "") -> str: ...
+    def object_filenames(self, source_filenames: list[str], strip_dir: int = 0, output_dir: str = "") -> list[str]: ...
+    def shared_object_filename(self, basename: str, strip_dir: int = 0, output_dir: str = "") -> str: ...
+    def execute(self, func: Callable[..., object], args: tuple[Any, ...], msg: str | None = None, level: int = 1) -> None: ...
+    def spawn(self, cmd: list[str]) -> None: ...
+    def mkpath(self, name: str, mode: int = 0o777) -> None: ...
+    def move_file(self, src: str, dst: str) -> str: ...
+    def announce(self, msg: str, level: int = 1) -> None: ...
+    def warn(self, msg: str) -> None: ...
+    def debug_print(self, msg: str) -> None: ...