# Copyright (C) 2018 The Qt Company Ltd. # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only from __future__ import annotations import importlib import os import platform import re import sys import subprocess import sysconfig import time from packaging.version import parse as parse_version from pathlib import Path from shutil import copytree, rmtree # PYSIDE-1760: Pre-load setuptools modules early to avoid racing conditions. # may be touched (should be avoided anyway, btw.) # Note: This bug is only visible when tools like pyenv are not used. They have some # pre-loading effect so that setuptools is already in the cache, hiding the problem. from setuptools import Command, Extension from setuptools.command.bdist_egg import bdist_egg as _bdist_egg from setuptools.command.build_ext import build_ext as _build_ext from setuptools.command.build_py import build_py as _build_py from setuptools.command.build import build as _build from setuptools.command.develop import develop as _develop from setuptools.command.install import install as _install from setuptools.command.install_lib import install_lib as _install_lib from setuptools.command.install_scripts import install_scripts # noqa: preload only from .log import log, LogLevel from setuptools.errors import SetupError from .build_info_collector import BuildInfoCollectorMixin from .config import config from .options import OPTION, CommandMixin from .platforms.unix import prepare_packages_posix from .platforms.windows_desktop import prepare_packages_win32 from .qtinfo import QtInfo from .utils import (copydir, copyfile, detect_clang, get_numpy_location, get_python_dict, linux_fix_rpaths_for_library, macos_fix_rpaths_for_library, parse_modules, platform_cmake_options, remove_tree, run_process, run_process_output, update_env_path, which) from . import PYSIDE, PYSIDE_MODULE, SHIBOKEN from .wheel_override import get_bdist_wheel_override, wheel_module_exists from .wheel_utils import (get_package_timestamp, get_package_version, macos_plat_name, macos_pyside_min_deployment_target) setup_script_dir = Path.cwd() build_scripts_dir = setup_script_dir / 'build_scripts' setup_py_path = setup_script_dir / "setup.py" start_time = time.time() def elapsed(): return int(time.time() - start_time) def get_setuptools_extension_modules(): # Setting py_limited_api on the extension is the "correct" thing # to do, but it doesn't actually do anything, because we # override build_ext. So this is just foolproofing for the # future. extension_args = ('QtCore', []) extension_kwargs = {} if OPTION["LIMITED_API"] == 'yes': extension_kwargs['py_limited_api'] = True extension_modules = [Extension(*extension_args, **extension_kwargs)] return extension_modules def _get_make(platform_arch, build_type): """Helper for retrieving the make command and CMake generator name""" makespec = OPTION["MAKESPEC"] if makespec == "make": return ("make", "Unix Makefiles") if makespec == "msvc": if not OPTION["NO_JOM"]: jom_path = Path(which("jom")) if jom_path: log.info(f"jom was found in {jom_path}") return (jom_path, "NMake Makefiles JOM") nmake_path = Path(which("nmake")) if nmake_path is None or not nmake_path.exists(): raise SetupError("nmake not found") log.info(f"nmake was found in {nmake_path}") if OPTION["JOBS"]: msg = "Option --jobs can only be used with 'jom' on Windows." raise SetupError(msg) return (nmake_path, "NMake Makefiles") if makespec == "mingw": return (Path("mingw32-make"), "mingw32-make") if makespec == "ninja": return (Path("ninja"), "Ninja") raise SetupError(f'Invalid option --make-spec "{makespec}".') def get_make(platform_arch, build_type): """Retrieve the make command and CMake generator name""" (make_path, make_generator) = _get_make(platform_arch, build_type) if not make_path.is_absolute(): found_path = Path(which(make_path)) if not found_path or not found_path.exists(): m = (f"You need the program '{make_path}' on your system path to " f"compile {PYSIDE_MODULE}.") raise SetupError(m) make_path = found_path return (make_path, make_generator) _allowed_versions_cache = None def get_allowed_python_versions(): global _allowed_versions_cache if _allowed_versions_cache is not None: return _allowed_versions_cache pattern = r'Programming Language :: Python :: (\d+)\.(\d+)' supported = [] for line in config.classifiers: found = re.search(pattern, line) if found: major = int(found.group(1)) minor = int(found.group(2)) supported.append((major, minor)) _allowed_versions_cache = sorted(supported) return _allowed_versions_cache def check_allowed_python_version(): """ Make sure that setup.py is run with an allowed python version. """ supported = get_allowed_python_versions() this_py = sys.version_info[:2] if this_py not in supported: log.warning("*" * 80) log.warning(f"Unsupported Python version detected: {this_py}.") log.warning("The build will probably fail.") log.warning(f"Supported versions: {supported}") log.warning("*" * 80) qt_src_dir = '' def prepare_build(): # locate Qt sources for the documentation if OPTION["QT_SRC"] is None: install_prefix = QtInfo().prefix_dir if install_prefix: global qt_src_dir # In-source, developer build if install_prefix.endswith("qtbase"): qt_src_dir = install_prefix else: # SDK: Use 'Src' directory maybe_qt_src_dir = Path(install_prefix).parent / 'Src' / 'qtbase' if maybe_qt_src_dir.exists(): qt_src_dir = maybe_qt_src_dir def get_soname(clang_lib_path: Path) -> str: """Getting SONAME from a shared library using readelf. Works only on Linux. """ clang_lib_path = Path(clang_lib_path) try: result = subprocess.run(['readelf', '-d', str(clang_lib_path)], capture_output=True, text=True, check=True) for line in result.stdout.split('\n'): if 'SONAME' in line: soname = line.split('[')[1].split(']')[0] return soname except subprocess.CalledProcessError as e: print(f"Failed to get SONAME: {e}") return None class PysideInstall(_install, CommandMixin): user_options = _install.user_options + CommandMixin.mixin_user_options def __init__(self, *args, **kwargs): self.command_name = "install" _install.__init__(self, *args, **kwargs) CommandMixin.__init__(self) def initialize_options(self): _install.initialize_options(self) def finalize_options(self): CommandMixin.mixin_finalize_options(self) _install.finalize_options(self) if sys.platform == 'darwin' or self.is_cross_compile: # Because we change the plat_name to include a correct # deployment target on macOS setuptools thinks we are # cross-compiling, and throws an exception when trying to # execute setup.py install. The check looks like this # if self.warn_dir and build_plat != get_platform(): # raise PlatformError("Can't install when " # "cross-compiling") # Obviously get_platform will return the old deployment # target. The fix is to disable the warn_dir flag, which # was created for bdist_* derived classes to override, for # similar cases. # We also do it when cross-compiling. While calling install # command directly is dubious, bdist_wheel calls install # internally before creating a wheel. self.warn_dir = False def run(self): _install.run(self) log.info(f"--- Install completed ({elapsed()}s)") class PysideDevelop(_develop): def __init__(self, *args, **kwargs): _develop.__init__(self, *args, **kwargs) def run(self): self.run_command("build") _develop.run(self) class PysideBdistEgg(_bdist_egg): def __init__(self, *args, **kwargs): _bdist_egg.__init__(self, *args, **kwargs) def run(self): self.run_command("build") _bdist_egg.run(self) class PysideBuildExt(_build_ext): def __init__(self, *args, **kwargs): _build_ext.__init__(self, *args, **kwargs) def run(self): pass class PysideBuildPy(_build_py): def __init__(self, *args, **kwargs): self.command_name = "build_py" _build_py.__init__(self, *args, **kwargs) # _install_lib is reimplemented to preserve # symlinks when setuptools copy files to various # directories from the setup tools build dir to the install dir. class PysideInstallLib(_install_lib): def __init__(self, *args, **kwargs): _install_lib.__init__(self, *args, **kwargs) def install(self): """ Installs files from self.build_dir directory into final site-packages/PySide6 directory when the command is 'install' or into build/wheel when command is 'bdist_wheel'. """ if self.build_dir.is_dir(): # Using our own copydir makes sure to preserve symlinks. outfiles = copydir(Path(self.build_dir).resolve(), Path(self.install_dir).resolve()) else: self.warn(f"'{self.build_dir}' does not exist -- no Python modules to install") return return outfiles class PysideBuild(_build, CommandMixin, BuildInfoCollectorMixin): user_options = _build.user_options + CommandMixin.mixin_user_options def __init__(self, *args, **kwargs): self.command_name = "build" _build.__init__(self, *args, **kwargs) CommandMixin.__init__(self) BuildInfoCollectorMixin.__init__(self) def finalize_options(self): os_name_backup = os.name CommandMixin.mixin_finalize_options(self) BuildInfoCollectorMixin.collect_and_assign(self) use_os_name_hack = False if self.is_cross_compile: use_os_name_hack = True elif sys.platform == 'darwin': self.plat_name = macos_plat_name() use_os_name_hack = True if use_os_name_hack: # This is a hack to circumvent the dubious check in # setuptool.commands.build -> finalize_options, which only # allows setting the plat_name for windows NT. # That is not the case for the wheel module though (which # does allow setting plat_name), so we circumvent by faking # the os name when finalizing the options, and then # restoring the original os name. os.name = "nt" _build.finalize_options(self) # Must come after _build.finalize_options BuildInfoCollectorMixin.post_collect_and_assign(self) if use_os_name_hack: os.name = os_name_backup def initialize_options(self): _build.initialize_options(self) self.make_path = None self.make_generator = None self.script_dir = None self.sources_dir = None self.build_dir = None self.install_dir = None self.py_executable = None self.py_include_dir = None self.py_library = None self.py_version = None self.py_arch = None self.build_type = "Release" self.qtinfo = None self.build_tests = False self.python_target_info = {} def run(self): prepare_build() # Check env make_path = None make_generator = None if not OPTION["ONLYPACKAGE"]: platform_arch = platform.architecture()[0] (make_path, make_generator) = get_make(platform_arch, self.build_type) self.qtinfo = QtInfo() # Update the PATH environment variable # Don't add Qt to PATH env var, we don't want it to interfere # with CMake's find_package calls which will use # CMAKE_PREFIX_PATH. # Don't add the Python scripts dir to PATH env when # cross-compiling, it could be in the device sysroot (/usr) # which can cause CMake device QtFooToolsConfig packages to be # picked up instead of host QtFooToolsConfig packages. additional_paths = [] if self.py_scripts_dir and not self.is_cross_compile: additional_paths.append(self.py_scripts_dir) # Add Clang to path for Windows. # Revisit once Clang is bundled with Qt. if (sys.platform == "win32" and parse_version(self.qtinfo.version) >= parse_version("5.7.0")): clang_dir, clang_source = detect_clang() if clang_dir: clangBinDir = clang_dir / 'bin' if str(clangBinDir) not in os.environ.get('PATH'): log.info(f"Adding {clangBinDir} as detected by {clang_source} to PATH") additional_paths.append(clangBinDir) else: raise SetupError("Failed to detect Clang when checking " "LLVM_INSTALL_DIR, CLANG_INSTALL_DIR, llvm-config") update_env_path(additional_paths) self.make_path = make_path self.make_generator = make_generator self.build_tests = OPTION["BUILDTESTS"] # Save the shiboken build dir path for clang deployment # purposes. self.shiboken_build_dir = self.build_dir / SHIBOKEN self.log_pre_build_info() # Prepare folders if not self.sources_dir.exists(): log.info(f"Creating sources folder {self.sources_dir}...") os.makedirs(self.sources_dir) if not self.build_dir.exists(): log.info(f"Creating build folder {self.build_dir}...") os.makedirs(self.build_dir) if not self.install_dir.exists(): log.info(f"Creating install folder {self.install_dir}...") os.makedirs(self.install_dir) # Write the CMake install path into a file. Is used by # SetupRunner to provide a nicer UX when cross-compiling (no # need to specify a host shiboken path explicitly) if self.internal_cmake_install_dir_query_file_path: with open(self.internal_cmake_install_dir_query_file_path, 'w') as f: f.write(os.fspath(self.install_dir)) if (not OPTION["ONLYPACKAGE"] and not config.is_internal_shiboken_generator_build_and_part_of_top_level_all()): # Build extensions for ext in config.get_buildable_extensions(): self.build_extension(ext) # We always record the history, whether tests are built or not. # Record the latest successful build and note the # build directory for supporting the tests or other tools. timestamp = time.strftime('%Y-%m-%d_%H%M%S') build_history = setup_script_dir / 'build_history' unique_dir = build_history / timestamp unique_dir.mkdir(parents=True) fpath = unique_dir / 'build_dir.txt' with open(fpath, 'w') as f: print(self.build_dir, file=f) print(self.build_classifiers, file=f) log.info(f"Created {build_history}") if not OPTION["SKIP_PACKAGING"]: # Build patchelf if needed self.build_patchelf() # Prepare packages self.prepare_packages() # Build packages _build.run(self) # Keep packaged directories for wheel construction # This is to take advantage of the packaging step # to keep the data in the proper structure to create # a wheel. _path = Path(self.st_build_dir) _wheel_path = _path.parent / "package_for_wheels" _project = None if config.is_internal_shiboken_module_build(): _project = "shiboken6" elif config.is_internal_shiboken_generator_build(): _project = "shiboken6_generator" elif config.is_internal_pyside_build(): _project = "PySide6" if _project is not None: if not _wheel_path.exists(): _wheel_path.mkdir(parents=True) _src = Path(_path / _project) _dst = Path(_wheel_path / _project) # Remove the directory in case it exists. # This applies to 'shiboken6', 'shiboken6_generator', # and 'pyside6' inside the 'package_for_wheels' directory. if _dst.exists(): log.warning(f'Found directory "{_dst}", removing it first.') remove_tree(_dst) try: # This should be copied because the package directory # is used when using the 'install' setup.py instruction. copytree(_src, _dst) except Exception as e: log.warning(f'problem renaming "{self.st_build_dir}"') log.warning(f'ignored error: {type(e).__name__}: {e}') else: log.info("Skipped preparing and building packages.") log.info(f"--- Build completed ({elapsed()}s)") def log_pre_build_info(self): if config.is_internal_shiboken_generator_build_and_part_of_top_level_all(): return setuptools_install_prefix = sysconfig.get_paths()["purelib"] if OPTION["FINAL_INSTALL_PREFIX"]: setuptools_install_prefix = OPTION["FINAL_INSTALL_PREFIX"] log.info("=" * 30) log.info(f"Package version: {get_package_version()}") log.info(f"Build type: {self.build_type}") log.info(f"Build tests: {self.build_tests}") log.info("-" * 3) log.info(f"Make path: {self.make_path}") log.info(f"Make generator: {self.make_generator}") log.info(f"Make jobs: {OPTION['JOBS']}") log.info("-" * 3) log.info(f"setup.py directory: {self.script_dir}") log.info(f"Build scripts directory: {build_scripts_dir}") log.info(f"Sources directory: {self.sources_dir}") log.info(f"make build directory: {self.build_dir}") log.info(f"make install directory: {self.install_dir}") log.info(f"setuptools build directory: {self.st_build_dir}") log.info(f"setuptools install directory: {setuptools_install_prefix}") log.info("-" * 3) log.info(f"Python executable: {self.py_executable}") log.info(f"Python includes: {self.py_include_dir}") log.info(f"Python library: {self.py_library}") log.info(f"Python prefix: {self.py_prefix}") log.info(f"Python scripts: {self.py_scripts_dir}") log.info(f"Python arch: {self.py_arch}") log.info("-" * 3) log.info(f"Qt prefix: {self.qtinfo.prefix_dir}") log.info(f"Qt qmake: {self.qtinfo.qmake_command}") log.info(f"Qt qtpaths: {self.qtinfo.qtpaths_command}") log.info(f"Qt version: {self.qtinfo.version}") log.info(f"Qt bins: {self.qtinfo.bins_dir}") log.info(f"Qt docs: {self.qtinfo.docs_dir}") log.info(f"Qt plugins: {self.qtinfo.plugins_dir}") log.info("-" * 3) if sys.platform == 'win32': log.info(f"OpenSSL dll directory: {OPTION['OPENSSL']}") # for cross-compilation it is possible to use a macOS host, but # pyside_macos_deployment_target is not relevant for the target. # The only exception here is when we are trying to cross-compile from intel mac to m1 mac. # This case is not supported yet. if sys.platform == 'darwin' and not self.is_cross_compile: pyside_macos_deployment_target = (macos_pyside_min_deployment_target()) log.info(f"MACOSX_DEPLOYMENT_TARGET set to: {pyside_macos_deployment_target}") log.info("=" * 30) def build_patchelf(self): if not sys.platform.startswith('linux'): return self._patchelf_path = which('patchelf') if self._patchelf_path: self._patchelf_path = Path(self._patchelf_path) if not self._patchelf_path.is_absolute(): self._patchelf_path = Path.cwd() / self._patchelf_path log.info(f"Using {self._patchelf_path} ...") return else: raise SetupError("patchelf not found") def _enable_numpy(self): if OPTION["ENABLE_NUMPY_SUPPORT"] or OPTION["PYSIDE_NUMPY_SUPPORT"]: return True if OPTION["DISABLE_NUMPY_SUPPORT"]: return False if self.is_cross_compile: # Do not search header in host Python return False # Debug builds require numpy to be built in debug mode on Windows # https://numpy.org/devdocs/user/troubleshooting-importerror.html return sys.platform != 'win32' or self.build_type.lower() != 'debug' def build_extension(self, extension): # calculate the subrepos folder name log.info(f"Building module {extension}...") # Prepare folders os.chdir(self.build_dir) module_build_dir = self.build_dir / extension skipflag_file = Path(f"{module_build_dir}-skip") if skipflag_file.exists(): log.info(f"Skipping {extension} because {skipflag_file} exists") return module_build_exists = module_build_dir.exists() if module_build_exists: if not OPTION["REUSE_BUILD"]: log.info(f"Deleting module build folder {module_build_dir}...") try: remove_tree(module_build_dir) except Exception as e: log.error(f'***** problem removing "{module_build_dir}"') log.error(f'ignored error: {e}') else: log.info(f"Reusing module build folder {module_build_dir}...") if not module_build_dir.exists(): log.info(f"Creating module build folder {module_build_dir}...") os.makedirs(module_build_dir) os.chdir(module_build_dir) module_src_dir = self.sources_dir / extension # Build module cmake_cmd = [str(OPTION["CMAKE"])] cmake_quiet_build = 1 cmake_rule_messages = 0 if OPTION["LOG_LEVEL"] == LogLevel.VERBOSE: # Pass a special custom option, to allow printing a lot less information when doing # a quiet build. cmake_quiet_build = 0 if self.make_generator == "Unix Makefiles": # Hide progress messages for each built source file. # Doesn't seem to work if set within the cmake files themselves. cmake_rule_messages = 1 if OPTION["UNITY"]: cmake_cmd.append("-DCMAKE_UNITY_BUILD=ON") batch_size = OPTION["UNITY_BUILD_BATCH_SIZE"] cmake_cmd.append(f"-DCMAKE_UNITY_BUILD_BATCH_SIZE={batch_size}") log.info("Using UNITY build") if OPTION['SHIBOKEN_FORCE_PROCESS_SYSTEM_HEADERS']: cmake_cmd.append("-DPYSIDE_TREAT_QT_INCLUDE_DIRS_AS_NON_SYSTEM=ON") log.info("Shiboken will now process system Qt headers") if OPTION['SHIBOKEN_EXTRA_INCLUDE_PATHS']: extra_include_paths = ';'.join(OPTION['SHIBOKEN_EXTRA_INCLUDE_PATHS'].split(',')) cmake_cmd.append(f"-DSHIBOKEN_FORCE_PROCESS_SYSTEM_INCLUDE_PATHS={extra_include_paths}") log.info(f"Shiboken will now process system headers from: {extra_include_paths}") cmake_cmd += [ "-G", self.make_generator, f"-DBUILD_TESTS={self.build_tests}", f"-DQt5Help_DIR={self.qtinfo.docs_dir}", f"-DCMAKE_BUILD_TYPE={self.build_type}", f"-DCMAKE_INSTALL_PREFIX={self.install_dir}", # Record the minimum/maximum Python version for later use in Shiboken.__init__ f"-DMINIMUM_PYTHON_VERSION={get_allowed_python_versions()[0]}", f"-DMAXIMUM_PYTHON_VERSION={get_allowed_python_versions()[-1]}", f"-DQUIET_BUILD={cmake_quiet_build}", f"-DCMAKE_RULE_MESSAGES={cmake_rule_messages}", str(module_src_dir) ] # When cross-compiling we set Python_ROOT_DIR to tell # FindPython.cmake where to pick up the device python libs. if self.is_cross_compile: if self.python_target_path: cmake_cmd.append(f"-DPython_ROOT_DIR={self.python_target_path}") # Host python is needed when cross compiling to run # embedding_generator.py. Pass it as a separate option. cmake_cmd.append(f"-DQFP_PYTHON_HOST_PATH={sys.executable}") else: cmake_cmd.append(f"-DPython_EXECUTABLE={self.py_executable}") cmake_cmd.append(f"-DPython_INCLUDE_DIR={self.py_include_dir}") cmake_cmd.append(f"-DPython_LIBRARY={self.py_library}") # If a custom shiboken cmake config directory path was provided, pass it to CMake. if OPTION["SHIBOKEN_CONFIG_DIR"] and config.is_internal_pyside_build(): config_dir = OPTION["SHIBOKEN_CONFIG_DIR"] if config_dir.exists(): log.info(f"Using custom provided {SHIBOKEN} installation: {config_dir}") cmake_cmd.append(f"-DShiboken6_DIR={config_dir}") else: log.info(f"Custom provided {SHIBOKEN} installation not found. " f"Path given: {config_dir}") if OPTION["MODULE_SUBSET"]: cmake_cmd.append(f"-DMODULES={parse_modules(OPTION['MODULE_SUBSET'])}") if OPTION["SKIP_MODULES"]: cmake_cmd.append(f"-DSKIP_MODULES={parse_modules(OPTION['SKIP_MODULES'])}") # Add source location for generating documentation cmake_src_dir = OPTION["QT_SRC"] if OPTION["QT_SRC"] else qt_src_dir if cmake_src_dir: cmake_cmd.append(f"-DQT_SRC_DIR={cmake_src_dir}") if OPTION['NO_QT_TOOLS']: cmake_cmd.append("-DNO_QT_TOOLS=yes") if OPTION['SKIP_DOCS']: log.info("Warning: '--skip-docs' is deprecated and will be removed. " "The documentation is not built by default") if OPTION['BUILD_DOCS']: cmake_cmd.append("-DBUILD_DOCS=yes") log.info(f"Qt Source dir: {cmake_src_dir}") # Use Legacy OpenGL to avoid issues on systems like Ubuntu 20.04 # which require to manually install the libraries which # were previously linked to the QtGui module in 6.1 # https://bugreports.qt.io/browse/QTBUG-89754 cmake_cmd.append("-DOpenGL_GL_PREFERENCE=LEGACY") if OPTION['AVOID_PROTECTED_HACK']: cmake_cmd.append("-DAVOID_PROTECTED_HACK=1") if self._enable_numpy(): numpy = get_numpy_location() if numpy: cmake_cmd.append(f"-DNUMPY_INCLUDE_DIR={numpy}") else: log.warning('numpy include directory was not found.') if self.build_type.lower() != 'debug': if OPTION['NO_STRIP']: cmake_cmd.append("-DQFP_NO_STRIP=1") if OPTION['NO_OVERRIDE_OPTIMIZATION_FLAGS']: cmake_cmd.append("-DQFP_NO_OVERRIDE_OPTIMIZATION_FLAGS=1") if not OPTION["LIMITED_API"]: if sys.platform == 'win32' and self.debug: cmake_cmd.append("-DFORCE_LIMITED_API=no") else: if OPTION["LIMITED_API"].lower() in ("yes", "y", "1", "true"): cmake_cmd.append("-DFORCE_LIMITED_API=yes") elif OPTION["LIMITED_API"].lower() in ("no", "n", "0", "false"): cmake_cmd.append("-DFORCE_LIMITED_API=no") else: raise SetupError( "Option '--limited-api' must be 'yes' or 'no'." f"Default is yes if Python version >= {get_allowed_python_versions()[0]} " "and Release build on Windows" ) if OPTION["DISABLE_PYI"]: cmake_cmd.append("-DDISABLE_PYI=yes") if OPTION["UNOPTIMIZE"]: value = OPTION["UNOPTIMIZE"] cmake_cmd.append(f"-DSHIBOKEN_UNOPTIMIZE={value}") if OPTION["LOG_LEVEL"] == LogLevel.VERBOSE: cmake_cmd.append("-DCMAKE_VERBOSE_MAKEFILE:BOOL=ON") else: cmake_cmd.append("-DCMAKE_VERBOSE_MAKEFILE:BOOL=OFF") if OPTION['COMPILER_LAUNCHER']: compiler_launcher = OPTION['COMPILER_LAUNCHER'] cmake_cmd.append(f"-DCMAKE_C_COMPILER_LAUNCHER={compiler_launcher}") cmake_cmd.append(f"-DCMAKE_CXX_COMPILER_LAUNCHER={compiler_launcher}") if OPTION["SANITIZE_ADDRESS"]: cmake_cmd.append("-DSANITIZE_ADDRESS=ON") if OPTION["SANITIZE_THREAD"]: # Some simple sanity checking. Only use at your own risk. if sys.platform == "win32" and not self.is_cross_compile: self.warn("Thread sanitizer may not be supported yet.") cmake_cmd.append("-DSANITIZE_THREAD=ON") if extension.lower() == PYSIDE: pyside_qt_conf_prefix = '' if OPTION["QT_CONF_PREFIX"]: pyside_qt_conf_prefix = OPTION["QT_CONF_PREFIX"] else: if OPTION["STANDALONE"]: pyside_qt_conf_prefix = '"Qt"' if sys.platform == 'win32': pyside_qt_conf_prefix = '"."' cmake_cmd.append(f"-DPYSIDE_QT_CONF_PREFIX={pyside_qt_conf_prefix}") if OPTION["STANDALONE"]: cmake_cmd.append("-DSTANDALONE:BOOL=ON") # Pass package version to CMake, so this string can be # embedded into _config.py file. package_version = get_package_version() cmake_cmd.append(f"-DPACKAGE_SETUP_PY_PACKAGE_VERSION={package_version}") # In case if this is a snapshot build, also pass the # timestamp as a separate value, because it is the only # version component that is actually generated by setup.py. timestamp = '' if OPTION["SNAPSHOT_BUILD"]: timestamp = get_package_timestamp() cmake_cmd.append(f"-DPACKAGE_SETUP_PY_PACKAGE_TIMESTAMP={timestamp}") if extension.lower() in [SHIBOKEN]: cmake_cmd.append("-DUSE_PYTHON_VERSION=3.9") cmake_cmd += platform_cmake_options() # for a macOS host, cross-compilation is possible, but for the host system as such # we only build shiboken. Hence the following code can be skipped. if sys.platform == 'darwin' and not self.is_cross_compile: if OPTION["MACOS_ARCH"]: # also tell cmake which architecture to use cmake_cmd.append(f"-DCMAKE_OSX_ARCHITECTURES:STRING={OPTION['MACOS_ARCH']}") if OPTION["MACOS_USE_LIBCPP"]: # Explicitly link the libc++ standard library (useful # for macOS deployment targets lower than 10.9). # This is not on by default, because most libraries and # executables on macOS <= 10.8 are linked to libstdc++, # and mixing standard libraries can lead to crashes. # On macOS >= 10.9 with a similar minimum deployment # target, libc++ is linked in implicitly, thus the # option is a no-op in those cases. cmake_cmd.append("-DOSX_USE_LIBCPP=ON") if OPTION["MACOS_SYSROOT"]: cmake_cmd.append(f"-DCMAKE_OSX_SYSROOT={OPTION['MACOS_SYSROOT']}") else: latest_sdk_path = run_process_output(['xcrun', '--sdk', 'macosx', '--show-sdk-path']) if latest_sdk_path: latest_sdk_path = latest_sdk_path[0] cmake_cmd.append(f"-DCMAKE_OSX_SYSROOT={latest_sdk_path}") # Set macOS minimum deployment target (version). # This is required so that calling # run_process -> subprocess.call() # does not set its own minimum deployment target # environment variable which is based on the python # interpreter sysconfig value. # Doing so could break the detected clang include paths # for example. deployment_target = macos_pyside_min_deployment_target() cmake_cmd.append(f"-DCMAKE_OSX_DEPLOYMENT_TARGET={deployment_target}") os.environ['MACOSX_DEPLOYMENT_TARGET'] = deployment_target if OPTION["BUILD_DOCS"]: # Build the whole documentation (Base + API) by default cmake_cmd.append("-DFULLDOCSBUILD=1") if OPTION["DOC_BUILD_ONLINE"]: log.info("Output format will be HTML") cmake_cmd.append("-DDOC_OUTPUT_FORMAT=html") else: log.info("Output format will be qthelp") cmake_cmd.append("-DDOC_OUTPUT_FORMAT=qthelp") else: cmake_cmd.append("-DBUILD_DOCS=no") if OPTION["DOC_BUILD_ONLINE"]: log.info("Warning: Documentation build is disabled, " "however --doc-build-online was passed. " "Use '--build-docs' to enable the documentation build") if OPTION["PYSIDE_NUMPY_SUPPORT"]: log.info("Warning: '--pyside-numpy-support' is deprecated and will be removed. " "Use --enable-numpy-support/--disable-numpy-support.") target_qt_prefix_path = self.qtinfo.prefix_dir cmake_cmd.append(f"-DQFP_QT_TARGET_PATH={target_qt_prefix_path}") if self.qt_host_path: cmake_cmd.append(f"-DQFP_QT_HOST_PATH={self.qt_host_path}") if self.is_cross_compile and (not OPTION["SHIBOKEN_HOST_PATH"] or not Path(OPTION["SHIBOKEN_HOST_PATH"]).exists()): raise SetupError("Please specify the location of host shiboken tools via " "--shiboken-host-path=") if self.shiboken_host_path: cmake_cmd.append(f"-DQFP_SHIBOKEN_HOST_PATH={self.shiboken_host_path}") if self.shiboken_target_path: cmake_cmd.append(f"-DQFP_SHIBOKEN_TARGET_PATH={self.shiboken_target_path}") elif self.cmake_toolchain_file and not extension.lower() == SHIBOKEN: # Need to tell where to find target shiboken when # cross-compiling pyside. cmake_cmd.append(f"-DQFP_SHIBOKEN_TARGET_PATH={self.install_dir}") if OPTION["SKIP_MYPY_TEST"]: cmake_cmd.append("-DSKIP_MYPY_TEST=1") if self.cmake_toolchain_file: cmake_cmd.append(f"-DCMAKE_TOOLCHAIN_FILE={self.cmake_toolchain_file}") if not OPTION["SKIP_CMAKE"]: log.info(f"Configuring module {extension} ({module_src_dir})...") if run_process(cmake_cmd) != 0: raise SetupError(f"Error configuring {extension}") else: log.info(f"Reusing old configuration for module {extension} ({module_src_dir})...") log.info(f"-- Compiling module {extension}...") cmd_make = [str(self.make_path)] if OPTION["JOBS"]: cmd_make.append(OPTION["JOBS"]) if OPTION["LOG_LEVEL"] == LogLevel.VERBOSE and self.make_generator == "Ninja": cmd_make.append("-v") if run_process(cmd_make) != 0: raise SetupError(f"Error compiling {extension}") if OPTION["BUILD_DOCS"]: if extension.lower() == SHIBOKEN: found = importlib.util.find_spec("sphinx") if found: log.info("Generating Shiboken documentation") make_doc_cmd = [str(self.make_path), "doc"] if OPTION["LOG_LEVEL"] == LogLevel.VERBOSE and self.make_generator == "Ninja": make_doc_cmd.append("-v") if run_process(make_doc_cmd) != 0: raise SetupError(f"Error generating documentation for {extension}") else: log.info("Sphinx not found, skipping documentation build") else: log.info("-- Skipped documentation generation. Enable with '--build-docs'") cmake_cmd.append("-DBUILD_DOCS=no") if not OPTION["SKIP_MAKE_INSTALL"]: log.info(f"Installing module {extension}...") # Need to wait a second, so installed file timestamps are # older than build file timestamps. # See https://gitlab.kitware.com/cmake/cmake/issues/16155 # for issue details. if sys.platform == 'darwin': log.info("Waiting 1 second, to ensure installation is successful...") time.sleep(1) # ninja: error: unknown target 'install/fast' target = 'install/fast' if self.make_generator != 'Ninja' else 'install' if run_process([str(self.make_path), target]) != 0: raise SetupError(f"Error pseudo installing {extension}") else: log.info(f"Skipped installing module {extension}") os.chdir(self.script_dir) def prepare_packages(self): """ This will copy all relevant files from the various locations in the "cmake install dir", to the setup tools build dir (which is read from self.build_lib provided by setuptools). After that setuptools.command.build_py is smart enough to copy everything from the build dir to the install dir (the virtualenv site-packages for example). """ try: log.info("Preparing setup tools build directory.") _vars = { "site_packages_dir": self.site_packages_dir, "sources_dir": self.sources_dir, "install_dir": self.install_dir, "build_dir": self.build_dir, "script_dir": self.script_dir, "st_build_dir": self.st_build_dir, "cmake_package_name": config.package_name(), "st_package_name": config.package_name(), "ssl_libs_dir": OPTION["OPENSSL"], "py_version": self.py_version, "qt_version": self.qtinfo.version, "qt_bin_dir": self.qtinfo.bins_dir, "qt_data_dir": self.qtinfo.data_dir, "qt_doc_dir": self.qtinfo.docs_dir, "qt_lib_dir": self.qtinfo.libs_dir, "qt_module_json_files_dir": self.qtinfo.module_json_files_dir, "qt_metatypes_dir": self.qtinfo.metatypes_dir, "qt_lib_execs_dir": self.qtinfo.lib_execs_dir, "qt_plugins_dir": self.qtinfo.plugins_dir, "qt_prefix_dir": self.qtinfo.prefix_dir, "qt_translations_dir": self.qtinfo.translations_dir, "qt_qml_dir": self.qtinfo.qml_dir, # TODO: This is currently None when cross-compiling # There doesn't seem to be any place where we can query # it. Fortunately it's currently only used when # packaging Windows vcredist. "target_arch": self.py_arch, } # Needed for correct file installation in generator build # case. if config.is_internal_shiboken_generator_build(): _vars['cmake_package_name'] = config.shiboken_module_option_name os.chdir(self.script_dir) # Clean up the previous st_build_dir before files are copied # into it again. That's the because the same dir is used # when copying the files for each of the sub-projects and # we don't want to accidentally install shiboken files # as part of pyside-tools package. if self.st_build_dir.is_dir(): log.info(f"Removing {self.st_build_dir}") try: remove_tree(self.st_build_dir) except Exception as e: log.warning(f'problem removing "{self.st_build_dir}"') log.warning(f'ignored error: {e}') if sys.platform == "win32": _vars['dbg_postfix'] = OPTION["DEBUG"] and "_d" or "" return prepare_packages_win32(self, _vars) else: return prepare_packages_posix(self, _vars, self.is_cross_compile) except IOError as e: print('setup.py/prepare_packages: ', e) raise def qt_is_framework_build(self): return Path(f"{self.qtinfo.headers_dir}/../lib/QtCore.framework").is_dir() def get_built_pyside_config(self, _vars): # Get config that contains list of built modules, and # SOVERSIONs of the built libraries. st_build_dir = Path(_vars['st_build_dir']) config_path = st_build_dir / config.package_name() / "_config.py" temp_config = get_python_dict(config_path) if 'built_modules' not in temp_config: temp_config['built_modules'] = [] return temp_config def is_webengine_built(self, built_modules): return ('WebEngineWidgets' in built_modules or 'WebEngineCore' in built_modules or 'WebEngine' in built_modules) def prepare_standalone_clang(self, is_win=False): """ Copies the libclang library to the shiboken6-generator package so that the shiboken executable works. """ log.info('Finding path to the libclang shared library.') cmake_cmd = [ str(OPTION["CMAKE"]), "-L", # Lists variables "-N", # Just inspects the cache (faster) "-B", # Specifies the build dir str(self.shiboken_build_dir) ] out = run_process_output(cmake_cmd) lines = [s.strip() for s in out] pattern = re.compile(r"CLANG_LIBRARY:FILEPATH=(.+)$") clang_lib_path = None for line in lines: match = pattern.search(line) if match: clang_lib_path = match.group(1) break if not clang_lib_path: raise RuntimeError("Could not find the location of the libclang " "library inside the CMake cache file.") if is_win: # clang_lib_path points to the static import library # (lib/libclang.lib), whereas we want to copy the shared # library (bin/libclang.dll). clang_lib_path = Path(re.sub(r'lib/libclang.lib$', 'bin/libclang.dll', clang_lib_path)) else: clang_lib_path = Path(clang_lib_path) # shiboken6 links against libclang.so.6 or a similarly # named library. # If the linked against library is a symlink, resolve # the symlink once (but not all the way to the real # file) on Linux and macOS, # so that we get the path to the "SO version" symlink # (the one used as the install name in the shared library # dependency section). # E.g. On Linux libclang.so -> libclang.so.6 -> # libclang.so.6.0. # "libclang.so.6" is the name we want for the copied file. if clang_lib_path.is_symlink(): link_target = Path(os.readlink(clang_lib_path)) if link_target.is_absolute(): clang_lib_path = link_target else: # link_target is relative, transform to absolute. clang_lib_path = clang_lib_path.parent / link_target clang_lib_path = clang_lib_path.resolve() # The destination will be the shiboken package folder. _vars = {} _vars['st_build_dir'] = self.st_build_dir _vars['st_package_name'] = config.package_name() destination_dir = Path("{st_build_dir}/{st_package_name}".format(**_vars)) if clang_lib_path.exists(): basename = clang_lib_path.name # In case of static libclang we don't need the lib file inside the wheel if '.a' == clang_lib_path.suffix: log.info("Skip copying libclang archive to the package.") return log.info(f"Copying libclang shared library {clang_lib_path} to the package " f"folder as {basename}.") destination_path = destination_dir / basename # It is possible that the resolved libclang has a different SONAME # For example the actual libclang might be named libclang.so.14.0.0 and its # SONAME might be libclang.so.13 # In this case, the ideal approach is to find the SONAME and create a symlink to the # actual libclang in the destination directory. But, Python packaging (setuptools) # does not support symlinks. # So, we rename the actual libclang to the SONAME and copy it to the destination if sys.platform == 'linux': soname = get_soname(clang_lib_path) if soname and soname != clang_lib_path.name: destination_path = destination_path.parent / soname # Need to modify permissions in case file is not writable # (a reinstall would cause a permission denied error). copyfile(clang_lib_path, destination_path, force_copy_symlink=True, make_writable_by_owner=True) else: raise RuntimeError("Error copying libclang library " f"from {clang_lib_path} to {destination_dir}. ") def get_shared_library_filters(self): unix_filters = ["*.so", "*.so.*"] darwin_filters = ["*.so", "*.dylib"] filters = [] if self.is_cross_compile: if 'darwin' in self.plat_name or 'macos' in self.plat_name: filters = darwin_filters elif 'linux' in self.plat_name or 'android' in self.plat_name: filters = unix_filters else: log.warning(f"No shared library filters found for platform {self.plat_name}. " f"The package might miss Qt libraries and plugins.") else: if sys.platform == 'darwin': filters = darwin_filters else: filters = unix_filters return filters def _find_shared_libraries(self, path, recursive=False): """Helper to find shared libraries in a path.""" result = set() for filter in self.get_shared_library_filters(): glob_pattern = f"**/{filter}" if recursive else filter for library in path.glob(glob_pattern): result.add(library) return list(result) def package_libraries(self, package_path): """Returns the libraries of the Python module""" return self._find_shared_libraries(package_path) def get_shared_libraries_in_path_recursively(self, initial_path): """Returns shared library plugins in given path (collected recursively)""" return self._find_shared_libraries(initial_path, recursive=True) def update_rpath(self, executables, libexec=False, message=None): ROOT = '@loader_path' if sys.platform == 'darwin' else '$ORIGIN' QT_PATH = '/../lib' if libexec else '/Qt/lib' message = "Patched rpath to '$ORIGIN/' in" if sys.platform.startswith('linux'): def rpath_cmd(srcpath): final_rpath = '' # Command line rpath option takes precedence over # automatically added one. if OPTION["RPATH_VALUES"]: final_rpath = OPTION["RPATH_VALUES"] else: # Add rpath values pointing to $ORIGIN and the # installed qt lib directory. final_rpath = self.qtinfo.libs_dir if OPTION["STANDALONE"]: final_rpath = f'{ROOT}{QT_PATH}' override = OPTION["STANDALONE"] linux_fix_rpaths_for_library(self._patchelf_path, srcpath, final_rpath, override=override) elif sys.platform == 'darwin': message = "Updated rpath in" def rpath_cmd(srcpath): final_rpath = '' # Command line rpath option takes precedence over # automatically added one. if OPTION["RPATH_VALUES"]: final_rpath = OPTION["RPATH_VALUES"] else: if OPTION["STANDALONE"]: final_rpath = f'{ROOT}{QT_PATH}' else: final_rpath = self.qtinfo.libs_dir macos_fix_rpaths_for_library(srcpath, final_rpath) else: raise RuntimeError(f"Not configured for platform {sys.platform}") # Update rpath for executable in executables: if executable.is_dir() or executable.is_symlink(): continue if not executable.exists(): continue rpath_cmd(executable) log.debug(f"{message} {executable}.") def update_rpath_for_linux_plugins( self, plugin_paths, qt_lib_dir=None, is_qml_plugin=False): # If the linux sysroot (where the plugins are copied from) # is from a mainline distribution, it might have a different # directory layout than then one we expect to have in the # wheel. # We have to ensure that any plugins copied have rpath # values that can find Qt libs in the newly assembled wheel # dir layout. if not (self.is_cross_compile and sys.platform.startswith('linux') and self.standalone): return log.info("Patching rpath for Qt and QML plugins.") for plugin in plugin_paths: if plugin.is_dir() or plugin.is_symlink(): continue if not plugin.exists(): continue if is_qml_plugin: plugin_dir = plugin.parent # FIXME: there is no os.path.relpath equivalent on pathlib. # The Path.relative_to is not equivalent and raises ValueError when the paths # are not subpaths, so it doesn't generate "../../something". rel_path_from_qml_plugin_qt_lib_dir = os.path.relpath(qt_lib_dir, plugin_dir) rpath_value = Path("$ORIGIN") / rel_path_from_qml_plugin_qt_lib_dir else: rpath_value = "$ORIGIN/../../lib" linux_fix_rpaths_for_library(self._patchelf_path, plugin, rpath_value, override=True) log.debug(f"Patched rpath to '{rpath_value}' in {plugin}.") def update_rpath_for_linux_qt_libraries(self, qt_lib_dir): # Ensure that Qt libs and ICU libs have $ORIGIN in their rpath. # Especially important for ICU lib, so that they don't # accidentally load dependencies from the system. if not (self.is_cross_compile and sys.platform.startswith('linux') and self.standalone): return qt_lib_dir = Path(qt_lib_dir) rpath_value = "$ORIGIN" log.info(f"Patching rpath for Qt and ICU libraries in {qt_lib_dir}.") for library in self.package_libraries(qt_lib_dir): if library.is_dir() or library.is_symlink(): continue if not library.exists(): continue linux_fix_rpaths_for_library(self._patchelf_path, library, rpath_value, override=True) log.debug(f"Patched rpath to '{rpath_value}' in {library}.") class PysideBaseDocs(Command, CommandMixin): description = "Build the base documentation only" user_options = CommandMixin.mixin_user_options def __init__(self, *args, **kwargs): self.command_name = "build_base_docs" Command.__init__(self, *args, **kwargs) CommandMixin.__init__(self) def initialize_options(self): log.info("-- This build process will not include the API documentation. " "API documentation requires a full build of pyside/shiboken.") self.skip = False if config.is_internal_shiboken_generator_build(): self.skip = True if not self.skip: self.name = config.package_name().lower() self.doc_dir = config.setup_script_dir / "sources" / self.name / "doc" # Check if sphinx is installed to proceed. found = importlib.util.find_spec("sphinx") self.html_dir = Path("html") if found: if self.name == SHIBOKEN: # Delete the 'html' directory since new docs will be generated anyway if self.html_dir.is_dir(): rmtree(self.html_dir) log.info("-- Deleted old html directory") log.info("-- Generating Shiboken documentation") log.info(f"-- Documentation directory: 'html/{PYSIDE}/{SHIBOKEN}/'") elif self.name == PYSIDE: log.info("-- Generating PySide documentation") log.info(f"-- Documentation directory: 'html/{PYSIDE}/'") else: raise SetupError("Sphinx not found - aborting") # creating directories html/pyside6/shiboken6 try: if not self.html_dir.is_dir(): self.html_dir.mkdir(parents=True) if self.name == SHIBOKEN: out_pyside = self.html_dir / PYSIDE if not out_pyside.is_dir(): out_pyside.mkdir(parents=True) out_shiboken = out_pyside / SHIBOKEN if not out_shiboken.is_dir(): out_shiboken.mkdir(parents=True) self.out_dir = out_shiboken # We know that on the shiboken step, we already created the # 'pyside6' directory elif self.name == PYSIDE: self.out_dir = self.html_dir / PYSIDE except (PermissionError, FileExistsError): raise SetupError(f"Error while creating directories for {self.doc_dir}") def run(self): if not self.skip: cmake_cmd = [ str(OPTION["CMAKE"]), "-S", str(self.doc_dir), "-B", str(self.out_dir), "-DDOC_OUTPUT_FORMAT=html", "-DFULLDOCSBUILD=0", ] cmake_quiet_build = 1 cmake_message_log_level = "STATUS" # Define log level if OPTION["LOG_LEVEL"] == LogLevel.VERBOSE: cmake_quiet_build = 0 cmake_message_log_level = "VERBOSE" elif OPTION["LOG_LEVEL"] == LogLevel.QUIET: cmake_message_log_level = "ERROR" cmake_cmd.append(f"-DQUIET_BUILD={cmake_quiet_build}") cmake_cmd.append(f"-DCMAKE_MESSAGE_LOG_LEVEL={cmake_message_log_level}") if run_process(cmake_cmd) != 0: raise SetupError(f"Error running CMake for {self.doc_dir}") if self.name == PYSIDE: def run_script(script_path, args=None): cmd = [sys.executable, os.fspath(script_path)] if args: cmd.extend(args) if run_process(cmd) != 0: raise SetupError(f"Error running {script_path}") self.sphinx_src = self.out_dir / "base" # Generates the .rst files from the examples example_gallery = config.setup_script_dir / "tools" / "example_gallery" / "main.py" if example_gallery.is_file(): example_gallery_args = [] if OPTION["LOG_LEVEL"] == LogLevel.QUIET: example_gallery_args.append("--quiet") qt_src_dir = OPTION['QT_SRC'] if qt_src_dir: example_gallery_args.extend(["--qt-src-dir", qt_src_dir]) run_script(example_gallery, example_gallery_args) else: log.warning("Example gallery script for generating .rst for examples" f"not found: {example_gallery}") # Generates the .rst files from the release notes release_notes = config.setup_script_dir / "tools" / "release_notes" / "main.py" if release_notes.is_file(): release_notes_args = [] if OPTION["LOG_LEVEL"] != LogLevel.QUIET: release_notes_args.append("--verbose") run_script(release_notes, release_notes_args) else: log.warning("Release notes script for generating .rst for release notes" f"not found: {release_notes}") elif self.name == SHIBOKEN: self.sphinx_src = self.out_dir sphinx_cmd = ["sphinx-build", "-b", "html", "-j", "auto", "-n", "-c", str(self.sphinx_src), str(self.doc_dir), str(self.out_dir)] if run_process(sphinx_cmd) != 0: raise SetupError(f"Error running CMake for {self.doc_dir}") # Last message if not self.skip and self.name == PYSIDE: log.info(f"-- The documentation was built. Check html/{PYSIDE}/index.html") def finalize_options(self): CommandMixin.mixin_finalize_options(self) cmd_class_dict = { 'build': PysideBuild, 'build_py': PysideBuildPy, 'build_ext': PysideBuildExt, 'bdist_egg': PysideBdistEgg, 'develop': PysideDevelop, 'install': PysideInstall, 'install_lib': PysideInstallLib, 'build_base_docs': PysideBaseDocs, } if wheel_module_exists: pyside_bdist_wheel = get_bdist_wheel_override() if pyside_bdist_wheel: cmd_class_dict['bdist_wheel'] = pyside_bdist_wheel