Add stubs for PyInstaller (public API only) (#8702)

stubs/pyinstaller/@tests/stubtest_allowlist.txt

@@ -0,0 +1,42 @@
+# fake module, only exists once the app is frozen
+pyi_splash
+# Undocumented and clearly not meant to be exposed
+PyInstaller.__main__.generate_parser
+PyInstaller.__main__.run_build
+PyInstaller.__main__.run_makespec
+PyInstaller.utils.hooks.conda.lib_dir
+# A mix of modules meant to be private, and shallow incomplete type references for other modules
+PyInstaller.building.*
+PyInstaller.depend.analysis.*
+PyInstaller.isolated._parent.*
+# Most modules are not meant to be used, yet are not marked as private
+PyInstaller.archive.*
+PyInstaller.config
+PyInstaller.configure
+PyInstaller.depend.bindepend
+PyInstaller.depend.bytecode
+PyInstaller.depend.dylib
+PyInstaller.depend.imphook
+PyInstaller.depend.utils
+PyInstaller.exceptions
+PyInstaller.hooks.*
+PyInstaller.lib.*
+PyInstaller.loader.*
+PyInstaller.log
+PyInstaller.utils.cliutils.*
+PyInstaller.utils.conftest
+PyInstaller.utils.git
+PyInstaller.utils.hooks.django
+PyInstaller.utils.hooks.gi
+PyInstaller.utils.hooks.qt
+PyInstaller.utils.hooks.subproc.*
+PyInstaller.utils.hooks.tcl_tk
+PyInstaller.utils.misc
+PyInstaller.utils.osx
+PyInstaller.utils.run_tests
+PyInstaller.utils.tests
+PyInstaller.utils.win32.*
+# Explicitly private implementation details
+PyInstaller\._.*
+PyInstaller.isolated._child
+PyInstaller.utils._gitrevision

stubs/pyinstaller/METADATA.toml

@@ -0,0 +1,5 @@
+version = "5.4.*"
+requires = ["types-setuptools"]
+
+[tool.stubtest]
+ignore_missing_stub = false

stubs/pyinstaller/PyInstaller/__init__.pyi

@@ -0,0 +1,11 @@
+from typing_extensions import LiteralString
+
+from PyInstaller import compat as compat
+
+__all__ = ("HOMEPATH", "PLATFORM", "__version__", "DEFAULT_DISTPATH", "DEFAULT_SPECPATH", "DEFAULT_WORKPATH")
+__version__: str
+HOMEPATH: str
+DEFAULT_SPECPATH: str
+DEFAULT_DISTPATH: str
+DEFAULT_WORKPATH: str
+PLATFORM: LiteralString

stubs/pyinstaller/PyInstaller/__main__.pyi

@@ -0,0 +1,11 @@
+# https://pyinstaller.org/en/stable/usage.html#running-pyinstaller-from-python-code
+from _typeshed import SupportsKeysAndGetItem
+from collections.abc import Iterable
+from typing_extensions import TypeAlias
+
+# Used to update PyInstaller.config.CONF
+_PyIConfig: TypeAlias = (
+    SupportsKeysAndGetItem[str, bool | str | list[str] | None] | Iterable[tuple[str, bool | str | list[str] | None]]
+)
+
+def run(pyi_args: Iterable[str] | None = ..., pyi_config: _PyIConfig | None = ...) -> None: ...

stubs/pyinstaller/PyInstaller/building/build_main.pyi

@@ -0,0 +1,29 @@
+# Referenced in: https://pyinstaller.org/en/stable/hooks.html?highlight=get_hook_config#PyInstaller.utils.hooks.get_hook_config
+# Not to be imported during runtime, but is the type reference for hooks and analysis configuration
+
+from _typeshed import StrOrBytesPath
+from collections.abc import Iterable
+from typing import Any
+
+from PyInstaller.building.datastruct import Target
+
+class Analysis(Target):
+    # https://pyinstaller.org/en/stable/hooks-config.html#hook-configuration-options
+    hooksconfig: dict[str, dict[str, object]]
+    def __init__(
+        self,
+        scripts: Iterable[StrOrBytesPath],
+        pathex=...,
+        binaries=...,
+        datas=...,
+        hiddenimports=...,
+        hookspath=...,
+        hooksconfig: dict[str, dict[str, Any]] | None = ...,
+        excludes=...,
+        runtime_hooks=...,
+        cipher=...,
+        win_no_prefer_redirects: bool = ...,
+        win_private_assemblies: bool = ...,
+        noarchive: bool = ...,
+        module_collection_mode=...,
+    ) -> None: ...

stubs/pyinstaller/PyInstaller/building/datastruct.pyi

@@ -0,0 +1,30 @@
+# https://pyinstaller.org/en/stable/advanced-topics.html#the-toc-and-tree-classes
+from collections.abc import Iterable, Sequence
+from typing import ClassVar
+from typing_extensions import Literal, LiteralString, SupportsIndex, TypeAlias
+
+_TypeCode: TypeAlias = Literal["DATA", "BINARY", "EXTENSION", "OPTION"]
+_TOCTuple: TypeAlias = tuple[str, str | None, _TypeCode | None]
+
+class TOC(list[_TOCTuple]):
+    filenames: set[str]
+    def __init__(self, initlist: Iterable[_TOCTuple] | None = ...) -> None: ...
+    def append(self, entry: _TOCTuple) -> None: ...
+    def insert(self, pos: SupportsIndex, entry: _TOCTuple) -> None: ...
+    def extend(self, other: Iterable[_TOCTuple]) -> None: ...
+
+class Target:
+    invcnum: ClassVar[int]
+    tocfilename: LiteralString
+    tocbasename: LiteralString
+    dependencies: TOC
+
+class Tree(Target, TOC):
+    root: str | None
+    prefix: str | None
+    excludes: Sequence[str]
+    typecode: _TypeCode
+    def __init__(
+        self, root: str | None = ..., prefix: str | None = ..., excludes: Sequence[str] | None = ..., typecode: _TypeCode = ...
+    ) -> None: ...
+    def assemble(self) -> None: ...

stubs/pyinstaller/PyInstaller/compat.pyi

@@ -0,0 +1,82 @@
+# https://pyinstaller.org/en/stable/hooks.html#module-PyInstaller.compat
+from _typeshed import FileDescriptor, GenericPath, StrOrBytesPath
+from collections.abc import Iterable
+from importlib.abc import _Path
+from types import ModuleType
+from typing import AnyStr, overload
+from typing_extensions import Literal, TypeAlias
+
+_OpenFile: TypeAlias = StrOrBytesPath | FileDescriptor
+
+is_64bits: bool
+is_py35: bool
+is_py36: bool
+is_py37: bool
+is_py38: bool
+is_py39: bool
+is_py310: bool
+is_win: bool
+is_win_10: bool
+is_win_wine: bool
+is_cygwin: bool
+is_darwin: bool
+is_linux: bool
+is_solar: bool
+is_aix: bool
+is_freebsd: bool
+is_openbsd: bool
+is_hpux: bool
+is_unix: bool
+is_musl: bool
+is_macos_11_compat: bool
+is_macos_11_native: bool
+is_macos_11: bool
+PYDYLIB_NAMES: set[str]
+base_prefix: str
+is_venv: bool
+is_virtualenv: bool
+is_conda: bool
+is_pure_conda: bool
+python_executable: str
+is_ms_app_store: bool
+BYTECODE_MAGIC: bytes
+EXTENSION_SUFFIXES: list[str]
+ALL_SUFFIXES: list[str]
+
+architecture: Literal["64bit", "n32bit", "32bit"]
+system: Literal["Cygwin", "Linux", "Darwin", "Java", "Windows"]
+machine: Literal["sw_64", "loongarch64", "arm", "intel", "ppc", "mips", "riscv", "s390x", "unknown", None]
+
+def is_wine_dll(filename: _OpenFile) -> bool: ...
+@overload
+def getenv(name: str, default: str) -> str: ...
+@overload
+def getenv(name: str, default: None = ...) -> str | None: ...
+def setenv(name: str, value: str) -> None: ...
+def unsetenv(name: str) -> None: ...
+def exec_command(
+    *cmdargs: str, encoding: str | None = ..., raise_enoent: bool | None = ..., **kwargs: int | bool | Iterable[int] | None
+) -> str: ...
+def exec_command_rc(*cmdargs: str, **kwargs: float | bool | Iterable[int] | None) -> int: ...
+def exec_command_stdout(
+    *command_args: str, encoding: str | None = ..., **kwargs: float | str | bytes | bool | Iterable[int] | None
+) -> str: ...
+def exec_command_all(
+    *cmdargs: str, encoding: str | None = ..., **kwargs: int | bool | Iterable[int] | None
+) -> tuple[int, str, str]: ...
+def exec_python(*args: str, **kwargs: str | None) -> str: ...
+def exec_python_rc(*args: str, **kwargs: str | None) -> int: ...
+def expand_path(path: GenericPath[AnyStr]) -> AnyStr: ...
+def getsitepackages(prefixes: Iterable[str] | None = ...) -> list[str]: ...
+def importlib_load_source(name: str, pathname: _Path) -> ModuleType: ...
+
+PY3_BASE_MODULES: set[str]
+PURE_PYTHON_MODULE_TYPES: set[str]
+SPECIAL_MODULE_TYPES: set[str]
+BINARY_MODULE_TYPES: set[str]
+VALID_MODULE_TYPES: set[str]
+BAD_MODULE_TYPES: set[str]
+ALL_MODULE_TYPES: set[str]
+MODULE_TYPES_TO_TOC_DICT: dict[str, str]
+
+def check_requirements() -> None: ...

stubs/pyinstaller/PyInstaller/depend/analysis.pyi

@@ -0,0 +1,18 @@
+# https://pyinstaller.org/en/stable/hooks.html#the-pre-safe-import-module-psim-api-method
+
+# The documentation explicitely mentions that "Normally you do not need to know about the module-graph."
+# However, some PyiModuleGraph typed class attributes are still documented as existing in imphookapi.
+from _typeshed import Incomplete
+
+class PyiModuleGraph:  # incomplete
+    def __init__(
+        self,
+        pyi_homepath: str,
+        user_hook_dirs=...,
+        excludes=...,
+        path: Incomplete | None = ...,
+        replace_paths=...,
+        implies=...,
+        graph: Incomplete | None = ...,
+        debug: int = ...,
+    ) -> None: ...

stubs/pyinstaller/PyInstaller/depend/imphookapi.pyi

@@ -0,0 +1,70 @@
+# https://pyinstaller.org/en/stable/hooks-config.html#adding-an-option-to-the-hook `hook_api` is a PostGraphAPI
+# Nothing in this module is meant to be initialized externally.
+# Instances are exposed through hooks during build.
+
+from _typeshed import StrOrBytesPath
+from collections.abc import Generator, Iterable
+from typing import Any
+from typing_extensions import Literal
+
+from PyInstaller.building.build_main import Analysis
+from PyInstaller.building.datastruct import TOC
+from PyInstaller.depend.analysis import PyiModuleGraph
+from PyInstaller.lib.modulegraph.modulegraph import Package
+
+# https://pyinstaller.org/en/stable/hooks.html#the-pre-safe-import-module-psim-api-method
+class PreSafeImportModuleAPI:
+    module_basename: str
+    module_name: str
+    def __init__(
+        self, module_graph: PyiModuleGraph, module_basename: str, module_name: str, parent_package: Package | None
+    ) -> None: ...
+    @property
+    def module_graph(self) -> PyiModuleGraph: ...
+    @property
+    def parent_package(self) -> Package | None: ...
+    def add_runtime_module(self, module_name: str) -> None: ...
+    def add_runtime_package(self, package_name: str) -> None: ...
+    def add_alias_module(self, real_module_name: str, alias_module_name: str) -> None: ...
+    def append_package_path(self, directory: str) -> None: ...
+
+# https://pyinstaller.org/en/stable/hooks.html#the-pre-find-module-path-pfmp-api-method
+class PreFindModulePathAPI:
+    search_dirs: Iterable[StrOrBytesPath]
+    def __init__(self, module_graph: PyiModuleGraph, module_name: str, search_dirs: Iterable[StrOrBytesPath]) -> None: ...
+    @property
+    def module_graph(self) -> PyiModuleGraph: ...
+    @property
+    def module_name(self) -> str: ...
+
+# https://pyinstaller.org/en/stable/hooks.html#the-hook-hook-api-function
+class PostGraphAPI:
+    module_graph: PyiModuleGraph
+    module: Package
+    def __init__(self, module_name: str, module_graph: PyiModuleGraph, analysis: Analysis) -> None: ...
+    @property
+    def __file__(self) -> str: ...
+    @property
+    def __path__(self) -> tuple[str, ...] | None: ...
+    @property
+    def __name__(self) -> str: ...
+    # Compiled code. See stdlib.builtins.compile
+    @property
+    def co(self) -> Any: ...
+    @property
+    def analysis(self) -> Analysis: ...
+    @property
+    def name(self) -> str: ...
+    @property
+    def graph(self) -> PyiModuleGraph: ...
+    @property
+    def node(self) -> Package: ...
+    @property
+    def imports(self) -> Generator[Package, None, None]: ...
+    def add_imports(self, *module_names: str) -> None: ...
+    def del_imports(self, *module_names: str) -> None: ...
+    def add_binaries(self, list_of_tuples: TOC | Iterable[tuple[StrOrBytesPath, StrOrBytesPath]]) -> None: ...
+    def add_datas(self, list_of_tuples: TOC | Iterable[tuple[StrOrBytesPath, StrOrBytesPath]]) -> None: ...
+    def set_module_collection_mode(
+        self, name: str | None, mode: Literal["pyz", "pyc", "py", "pyz+py", "py+pyz", None]
+    ) -> None: ...

stubs/pyinstaller/PyInstaller/isolated/__init__.pyi

@@ -0,0 +1,2 @@
+# https://pyinstaller.org/en/stable/hooks.html#module-PyInstaller.isolated
+from PyInstaller.isolated._parent import Python as Python, call as call, decorate as decorate

stubs/pyinstaller/PyInstaller/isolated/_parent.pyi

@@ -0,0 +1,19 @@
+from _typeshed import Self
+from collections.abc import Callable
+from types import TracebackType
+from typing import TypeVar
+from typing_extensions import ParamSpec
+
+_AC = TypeVar("_AC", bound=Callable[..., object])
+_R = TypeVar("_R")
+_P = ParamSpec("_P")
+
+class Python:
+    def __enter__(self: Self) -> Self: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+    ) -> None: ...
+    def call(self, function: Callable[_P, _R], *args: _P.args, **kwargs: _P.kwargs) -> _R: ...
+
+def call(function: Callable[_P, _R], *args: _P.args, **kwargs: _P.kwargs) -> _R: ...
+def decorate(function: _AC) -> _AC: ...

stubs/pyinstaller/PyInstaller/lib/modulegraph/modulegraph.pyi

@@ -0,0 +1,40 @@
+from typing import Any, Protocol
+
+class _SupportsGraphident(Protocol):
+    graphident: str
+
+# TODO: For typing purposes, once #5768 is complete, it'll be easier to use the modulegraph package directly.
+
+# code, filename and packagepath are always initialized to None. But they can be given a value later.
+class Node:
+    # Compiled code. See stdlib.builtins.compile
+    code: Any | None
+    filename: str | None
+    graphident: str
+    identifier: str
+    packagepath: str | None
+    def __init__(self, identifier: str) -> None: ...
+    def is_global_attr(self, attr_name: str) -> bool: ...
+    def is_submodule(self, submodule_basename: str) -> bool: ...
+    def add_global_attr(self, attr_name: str) -> None: ...
+    def add_global_attrs_from_module(self, target_module: Node) -> None: ...
+    def add_submodule(self, submodule_basename: str, submodule_node: Node) -> None: ...
+    def get_submodule(self, submodule_basename: str) -> Node: ...
+    def get_submodule_or_none(self, submodule_basename: str) -> Node | None: ...
+    def remove_global_attr_if_found(self, attr_name: str) -> None: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __lt__(self, other: _SupportsGraphident) -> bool: ...
+    def __le__(self, other: _SupportsGraphident) -> bool: ...
+    def __gt__(self, other: _SupportsGraphident) -> bool: ...
+    def __ge__(self, other: _SupportsGraphident) -> bool: ...
+    def infoTuple(self) -> tuple[str]: ...
+
+class BaseModule(Node):
+    filename: str
+    packagepath: str
+    def __init__(self, name: str, filename: str | None = ..., path: str | None = ...) -> None: ...
+    # Returns a tuple of length 0, 1, 2, or 3
+    def infoTuple(self) -> tuple[str, ...]: ...  # type: ignore[override]
+
+class Package(BaseModule): ...

stubs/pyinstaller/PyInstaller/utils/hooks/__init__.pyi

@@ -0,0 +1,77 @@
+# https://pyinstaller.org/en/stable/hooks.html
+
+from _typeshed import StrOrBytesPath, SupportsKeysAndGetItem
+from collections.abc import Callable, Iterable, Mapping
+from typing import Any
+from typing_extensions import Literal, TypeAlias
+
+import pkg_resources
+from PyInstaller import HOMEPATH as HOMEPATH
+from PyInstaller.depend.imphookapi import PostGraphAPI
+from PyInstaller.utils.hooks import conda as conda_support
+from PyInstaller.utils.hooks.win32 import get_pywin32_module_file_attribute as get_pywin32_module_file_attribute
+
+_Environ: TypeAlias = SupportsKeysAndGetItem[str, str] | Iterable[tuple[str, str]] | Mapping[str, str]
+
+PY_IGNORE_EXTENSIONS: set[str]
+hook_variables: dict[str, str]
+
+def exec_statement(statement: str) -> str | int: ...
+def exec_statement_rc(statement: str) -> str | int: ...
+def exec_script(script_filename: StrOrBytesPath, *args: str, env: _Environ | None = ...) -> str | int: ...
+def exec_script_rc(script_filename: StrOrBytesPath, *args: str, env: _Environ | None = ...) -> str | int: ...
+def eval_statement(statement: str) -> Any | Literal[""]: ...
+def eval_script(script_filename: StrOrBytesPath, *args: str, env: _Environ | None = ...) -> Any | Literal[""]: ...
+def get_pyextension_imports(module_name: str) -> list[str]: ...
+def get_homebrew_path(formula: str = ...) -> str | None: ...
+def remove_prefix(string: str, prefix: str) -> str: ...
+def remove_suffix(string: str, suffix: str) -> str: ...
+def remove_file_extension(filename: str) -> str: ...
+def can_import_module(module_name: str) -> bool: ...
+def get_module_attribute(module_name: str, attr_name: str) -> Any: ...
+def get_module_file_attribute(package: str) -> str | None: ...
+def is_module_satisfies(
+    requirements: Iterable[str] | pkg_resources.Requirement,
+    version: str | pkg_resources.Distribution | None = ...,
+    version_attr: str = ...,
+) -> bool: ...
+def is_package(module_name: str) -> bool: ...
+def get_all_package_paths(package: str) -> list[str]: ...
+def package_base_path(package_path: str, package: str) -> str: ...
+def get_package_paths(package: str) -> tuple[str, str]: ...
+def collect_submodules(
+    package: str, filter: Callable[[str], bool] = ..., on_error: Literal["ignore", "warn once", "warn", "raise"] = ...
+) -> list[str]: ...
+def is_module_or_submodule(name: str, mod_or_submod: str) -> bool: ...
+
+PY_DYLIB_PATTERNS: list[str]
+
+def collect_dynamic_libs(package: str, destdir: object = ...) -> list[tuple[str, str]]: ...
+def collect_data_files(
+    package: str,
+    include_py_files: bool = ...,
+    subdir: StrOrBytesPath | None = ...,
+    excludes: Iterable[str] | None = ...,
+    includes: Iterable[str] | None = ...,
+) -> list[tuple[str, str]]: ...
+def collect_system_data_files(
+    path: str, destdir: StrOrBytesPath | None = ..., include_py_files: bool = ...
+) -> list[tuple[str, str]]: ...
+def copy_metadata(package_name: str, recursive: bool = ...) -> list[tuple[str, str]]: ...
+def get_installer(module: str) -> str | None: ...
+def requirements_for_package(package_name: str) -> list[str]: ...
+def collect_all(
+    package_name: str,
+    include_py_files: bool = ...,
+    filter_submodules: Callable[[str], bool] | None = ...,
+    exclude_datas: Iterable[str] | None = ...,
+    include_datas: Iterable[str] | None = ...,
+    on_error: Literal["ignore", "warn once", "warn", "raise"] = ...,
+) -> tuple[list[tuple[str, str]], list[tuple[str, str]], list[str]]: ...
+def collect_entry_point(name: str) -> tuple[tuple[str, str], list[str]]: ...
+def get_hook_config(hook_api: PostGraphAPI, module_name: str, key: str) -> None: ...
+def include_or_exclude_file(
+    filename: StrOrBytesPath,
+    include_list: Iterable[StrOrBytesPath] | None = ...,
+    exclude_list: Iterable[StrOrBytesPath] | None = ...,
+) -> bool: ...

stubs/pyinstaller/PyInstaller/utils/hooks/conda.pyi

@@ -0,0 +1,53 @@
+# https://pyinstaller.org/en/stable/hooks.html?highlight=conda_support#module-PyInstaller.utils.hooks.conda
+
+import sys
+from _typeshed import StrOrBytesPath
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Any
+from typing_extensions import TypeAlias, TypedDict
+
+if sys.version_info >= (3, 8):
+    from importlib.metadata import PackagePath as _PackagePath
+else:
+    _PackagePath: TypeAlias = Any
+
+CONDA_ROOT: Path
+CONDA_META_DIR: Path
+PYTHONPATH_PREFIXES: list[Path]
+
+class _RawDict(TypedDict):
+    name: str
+    version: str
+    files: list[StrOrBytesPath]
+    depends: list[str]
+
+class Distribution:
+    raw: _RawDict
+    name: str
+    version: str
+    files: list[PackagePath]
+    dependencies: list[str]
+    packages: list[str]
+    def __init__(self, json_path: str) -> None: ...
+    @classmethod
+    def from_name(cls, name: str) -> Distribution: ...
+    @classmethod
+    def from_package_name(cls, name: str) -> Distribution: ...
+
+# distribution and package_distribution are meant to be used and are not internal helpers
+distribution = Distribution.from_name
+package_distribution = Distribution.from_package_name
+
+class PackagePath(_PackagePath):
+    def locate(self) -> Path: ...
+
+def walk_dependency_tree(initial: str, excludes: Iterable[str] | None = ...) -> dict[str, Distribution]: ...
+def requires(name: str, strip_versions: bool = ...) -> list[str]: ...
+def files(name: str, dependencies: bool = ..., excludes: Iterable[str] | None = ...) -> list[PackagePath]: ...
+def collect_dynamic_libs(
+    name: str, dest: str = ..., dependencies: bool = ..., excludes: Iterable[str] | None = ...
+) -> list[tuple[str, str]]: ...
+
+distributions: dict[str, Distribution]
+distributions_by_package: dict[str | None, Distribution]

stubs/pyinstaller/PyInstaller/utils/hooks/win32.pyi

@@ -0,0 +1,3 @@
+__all__ = ("get_pywin32_module_file_attribute",)
+
+def get_pywin32_module_file_attribute(module_name: str) -> str | int: ...

stubs/pyinstaller/pyi_splash/__init__.pyi

@@ -0,0 +1,12 @@
+# Referenced in: https://pyinstaller.org/en/stable/advanced-topics.html#module-pyi_splash
+# Source: https://github.com/pyinstaller/pyinstaller/blob/develop/PyInstaller/fake-modules/pyi_splash.py
+from typing_extensions import Literal
+
+__all__ = ["CLOSE_CONNECTION", "FLUSH_CHARACTER", "is_alive", "close", "update_text"]
+
+def is_alive() -> bool: ...
+def update_text(msg: str) -> None: ...
+def close() -> None: ...
+
+CLOSE_CONNECTION: Literal[b"\u0004"]
+FLUSH_CHARACTER: Literal[b"\r"]