diff --git a/stubs/pyinstaller/@tests/stubtest_allowlist.txt b/stubs/pyinstaller/@tests/stubtest_allowlist.txt new file mode 100644 index 000000000000..c9c278ea1a3c --- /dev/null +++ b/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 diff --git a/stubs/pyinstaller/METADATA.toml b/stubs/pyinstaller/METADATA.toml new file mode 100644 index 000000000000..bbed84a0b636 --- /dev/null +++ b/stubs/pyinstaller/METADATA.toml @@ -0,0 +1,5 @@ +version = "5.4.*" +requires = ["types-setuptools"] + +[tool.stubtest] +ignore_missing_stub = false diff --git a/stubs/pyinstaller/PyInstaller/__init__.pyi b/stubs/pyinstaller/PyInstaller/__init__.pyi new file mode 100644 index 000000000000..2aa6f67789f2 --- /dev/null +++ b/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 diff --git a/stubs/pyinstaller/PyInstaller/__main__.pyi b/stubs/pyinstaller/PyInstaller/__main__.pyi new file mode 100644 index 000000000000..3e4b32ea45f9 --- /dev/null +++ b/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: ... diff --git a/stubs/pyinstaller/PyInstaller/building/__init__.pyi b/stubs/pyinstaller/PyInstaller/building/__init__.pyi new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/stubs/pyinstaller/PyInstaller/building/build_main.pyi b/stubs/pyinstaller/PyInstaller/building/build_main.pyi new file mode 100644 index 000000000000..3e87e9c76cbe --- /dev/null +++ b/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: ... diff --git a/stubs/pyinstaller/PyInstaller/building/datastruct.pyi b/stubs/pyinstaller/PyInstaller/building/datastruct.pyi new file mode 100644 index 000000000000..4edcd586044e --- /dev/null +++ b/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: ... diff --git a/stubs/pyinstaller/PyInstaller/compat.pyi b/stubs/pyinstaller/PyInstaller/compat.pyi new file mode 100644 index 000000000000..8fdb4d7fe5d0 --- /dev/null +++ b/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: ... diff --git a/stubs/pyinstaller/PyInstaller/depend/__init__.pyi b/stubs/pyinstaller/PyInstaller/depend/__init__.pyi new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/stubs/pyinstaller/PyInstaller/depend/analysis.pyi b/stubs/pyinstaller/PyInstaller/depend/analysis.pyi new file mode 100644 index 000000000000..2ae95b655fa0 --- /dev/null +++ b/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: ... diff --git a/stubs/pyinstaller/PyInstaller/depend/imphookapi.pyi b/stubs/pyinstaller/PyInstaller/depend/imphookapi.pyi new file mode 100644 index 000000000000..268ee3618eeb --- /dev/null +++ b/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: ... diff --git a/stubs/pyinstaller/PyInstaller/isolated/__init__.pyi b/stubs/pyinstaller/PyInstaller/isolated/__init__.pyi new file mode 100644 index 000000000000..6f084bfc40ea --- /dev/null +++ b/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 diff --git a/stubs/pyinstaller/PyInstaller/isolated/_parent.pyi b/stubs/pyinstaller/PyInstaller/isolated/_parent.pyi new file mode 100644 index 000000000000..ea9ee603e9f5 --- /dev/null +++ b/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: ... diff --git a/stubs/pyinstaller/PyInstaller/lib/__init__.pyi b/stubs/pyinstaller/PyInstaller/lib/__init__.pyi new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/stubs/pyinstaller/PyInstaller/lib/modulegraph/__init__.pyi b/stubs/pyinstaller/PyInstaller/lib/modulegraph/__init__.pyi new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/stubs/pyinstaller/PyInstaller/lib/modulegraph/modulegraph.pyi b/stubs/pyinstaller/PyInstaller/lib/modulegraph/modulegraph.pyi new file mode 100644 index 000000000000..0bbb6ee131b3 --- /dev/null +++ b/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): ... diff --git a/stubs/pyinstaller/PyInstaller/utils/__init__.pyi b/stubs/pyinstaller/PyInstaller/utils/__init__.pyi new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/stubs/pyinstaller/PyInstaller/utils/hooks/__init__.pyi b/stubs/pyinstaller/PyInstaller/utils/hooks/__init__.pyi new file mode 100644 index 000000000000..d9324f92975d --- /dev/null +++ b/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: ... diff --git a/stubs/pyinstaller/PyInstaller/utils/hooks/conda.pyi b/stubs/pyinstaller/PyInstaller/utils/hooks/conda.pyi new file mode 100644 index 000000000000..6801203e888a --- /dev/null +++ b/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] diff --git a/stubs/pyinstaller/PyInstaller/utils/hooks/win32.pyi b/stubs/pyinstaller/PyInstaller/utils/hooks/win32.pyi new file mode 100644 index 000000000000..105eb1f5b964 --- /dev/null +++ b/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: ... diff --git a/stubs/pyinstaller/pyi_splash/__init__.pyi b/stubs/pyinstaller/pyi_splash/__init__.pyi new file mode 100644 index 000000000000..66381afe4c39 --- /dev/null +++ b/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"]