From 6cc55fefc8ddf12ecc9dcce33e367148e6216b1f Mon Sep 17 00:00:00 2001 From: Cristian Maureira-Fredes Date: Tue, 29 Dec 2020 18:22:54 +0100 Subject: build_scripts: use f-strings instead of format() Pick-to: 6.0 Change-Id: I165e9a39f968f67f9eae3a632739908d5f8fda59 Reviewed-by: Friedemann Kleint Reviewed-by: Christian Tismer --- build_scripts/config.py | 8 +- build_scripts/main.py | 222 ++++++++++++++--------------- build_scripts/options.py | 12 +- build_scripts/platforms/macos.py | 2 +- build_scripts/platforms/windows_desktop.py | 2 +- build_scripts/qtinfo.py | 4 +- build_scripts/setup_runner.py | 21 ++- build_scripts/utils.py | 151 ++++++++++---------- build_scripts/wheel_override.py | 4 +- build_scripts/wheel_utils.py | 21 ++- 10 files changed, 215 insertions(+), 232 deletions(-) (limited to 'build_scripts') diff --git a/build_scripts/config.py b/build_scripts/config.py index eb632fe3f..bcbc0b6e4 100644 --- a/build_scripts/config.py +++ b/build_scripts/config.py @@ -200,7 +200,7 @@ class Config(object): elif self.internal_build_type == self.shiboken_generator_option_name: setup_kwargs['name'] = self.shiboken_generator_st_name setup_kwargs['description'] = "Python / C++ bindings generator" - setup_kwargs['install_requires'] = ["{}=={}".format(self.shiboken_module_st_name, package_version)] + setup_kwargs['install_requires'] = [f"{self.shiboken_module_st_name}=={package_version}"] setup_kwargs['entry_points'] = { 'console_scripts': [ f'{SHIBOKEN} = {package_name}.scripts.shiboken_tool:main' @@ -210,7 +210,7 @@ class Config(object): elif self.internal_build_type == self.pyside_option_name: setup_kwargs['name'] = self.pyside_st_name setup_kwargs['description'] = "Python bindings for the Qt cross-platform application and UI framework" - setup_kwargs['install_requires'] = ["{}=={}".format(self.shiboken_module_st_name, package_version)] + setup_kwargs['install_requires'] = [f"{self.shiboken_module_st_name}=={package_version}"] setup_kwargs['entry_points'] = { 'console_scripts': [ f'{PYSIDE}-uic = {package_name}.scripts.pyside_tool:uic', @@ -238,7 +238,7 @@ class Config(object): with open(os.path.join(self.setup_script_dir, readme_filename)) as f: readme = f.read() except Exception as e: - log.error("Couldn't read contents of {}.".format(readme_filename)) + log.error(f"Couldn't read contents of {readme_filename}. {e}") raise # Don't include CHANGES.rst for now, because we have not decided @@ -249,7 +249,7 @@ class Config(object): with open(os.path.join(self.setup_script_dir, changes_filename)) as f: changes = f.read() except Exception as e: - log.error("Couldn't read contents of {}".format(changes_filename)) + log.error(f"Couldn't read contents of {changes_filename}. {e}") raise content += readme diff --git a/build_scripts/main.py b/build_scripts/main.py index 773460de1..1d79621c8 100644 --- a/build_scripts/main.py +++ b/build_scripts/main.py @@ -94,9 +94,9 @@ def _get_make(platform_arch, build_type): if not OPTION["NO_JOM"]: jom_path = find_executable("jom") if jom_path: - log.info("jom was found in {}".format(jom_path)) + log.info(f"jom was found in {jom_path}") return (jom_path, "NMake Makefiles JOM") - log.info("nmake was found in {}".format(nmake_path)) + log.info(f"nmake was found in {nmake_path}") if OPTION["JOBS"]: msg = "Option --jobs can only be used with 'jom' on Windows." raise DistutilsSetupError(msg) @@ -105,8 +105,7 @@ def _get_make(platform_arch, build_type): return ("mingw32-make", "mingw32-make") if makespec == "ninja": return ("ninja", "Ninja") - m = 'Invalid option --make-spec "{}".'.format(makespec) - raise DistutilsSetupError(m) + raise DistutilsSetupError(f'Invalid option --make-spec "{makespec}".') def get_make(platform_arch, build_type): @@ -136,11 +135,10 @@ def _get_py_library_win(build_type, py_version, py_prefix, py_libdir, raise DistutilsSetupError("Failed to locate the 'libs' directory") dbg_postfix = "_d" if build_type == "Debug" else "" if OPTION["MAKESPEC"] == "mingw": - static_lib_name = "libpython{}{}.a".format( - py_version.replace(".", ""), dbg_postfix) + static_lib_name = f"libpython{py_version.replace('.', '')}{dbg_postfix}.a" return os.path.join(py_libdir, static_lib_name) v = py_version.replace(".", "") - python_lib_name = "python{}{}.lib".format(v, dbg_postfix) + python_lib_name = f"python{v}{dbg_postfix}.lib" return os.path.join(py_libdir, python_lib_name) @@ -150,7 +148,7 @@ def _get_py_library_unix(build_type, py_version, py_prefix, py_libdir, if py_libdir is None or not os.path.exists(py_libdir): py_libdir = os.path.join(py_prefix, "lib") if py_include_dir is None or not os.path.exists(py_include_dir): - dir = "include/python{}".format(py_version) + dir = f"include/python{py_version}" py_include_dir = os.path.join(py_prefix, dir) dbg_postfix = "_d" if build_type == "Debug" else "" lib_exts = ['.so'] @@ -165,7 +163,7 @@ def _get_py_library_unix(build_type, py_version, py_prefix, py_libdir, libs_tried = [] for lib_ext in lib_exts: - lib_name = "libpython{}{}{}".format(py_version, lib_suff, lib_ext) + lib_name = f"libpython{py_version}{lib_suff}{lib_ext}" py_library = os.path.join(py_libdir, lib_name) if os.path.exists(py_library): return py_library @@ -178,14 +176,13 @@ def _get_py_library_unix(build_type, py_version, py_prefix, py_libdir, try_py_libdir = os.path.join(py_libdir, py_multiarch) libs_tried = [] for lib_ext in lib_exts: - lib_name = "libpython{}{}{}".format(py_version, lib_suff, lib_ext) + lib_name = f"libpython{py_version}{lib_suff}{lib_ext}" py_library = os.path.join(try_py_libdir, lib_name) if os.path.exists(py_library): return py_library libs_tried.append(py_library) - m = "Failed to locate the Python library with {}".format(", ".join(libs_tried)) - raise DistutilsSetupError(m) + raise DistutilsSetupError(f"Failed to locate the Python library with {', '.join(libs_tried)}") def get_py_library(build_type, py_version, py_prefix, py_libdir, py_include_dir): @@ -198,7 +195,7 @@ def get_py_library(build_type, py_version, py_prefix, py_libdir, py_include_dir) py_libdir, py_include_dir) if py_library.endswith('.a'): # Python was compiled as a static library - log.error("Failed to locate a dynamic Python library, using {}".format(py_library)) + log.error(f"Failed to locate a dynamic Python library, using {py_library}") return py_library @@ -316,7 +313,7 @@ def prepare_build(): for n in ["build"]: d = os.path.join(setup_script_dir, n) if os.path.isdir(d): - log.info("Removing {}".format(d)) + log.info(f"Removing {d}") try: rmtree(d) except Exception as e: @@ -422,7 +419,7 @@ class PysideInstallLib(_install_lib): # Using our own copydir makes sure to preserve symlinks. outfiles = copydir(os.path.abspath(self.build_dir), os.path.abspath(self.install_dir)) else: - self.warn("'{}' does not exist -- no Python modules to install".format(self.build_dir)) + self.warn(f"'{self.build_dir}' does not exist -- no Python modules to install") return return outfiles @@ -474,7 +471,7 @@ class PysideBuild(_build, DistUtilsCommandMixin): def run(self): prepare_build() platform_arch = platform.architecture()[0] - log.info("Python architecture is {}".format(platform_arch)) + log.info(f"Python architecture is {platform_arch}") self.py_arch = platform_arch[:-3] build_type = "Debug" if OPTION["DEBUG"] else "Release" @@ -489,7 +486,7 @@ class PysideBuild(_build, DistUtilsCommandMixin): # Prepare parameters py_executable = sys.executable - py_version = "{}.{}".format(sys.version_info[0], sys.version_info[1]) + py_version = f"{sys.version_info[0]}.{sys.version_info[1]}" py_include_dir = get_config_var("INCLUDEPY") py_libdir = get_config_var("LIBDIR") py_prefix = get_config_var("prefix") @@ -517,8 +514,7 @@ class PysideBuild(_build, DistUtilsCommandMixin): if clang_dir[0]: clangBinDir = os.path.join(clang_dir[0], 'bin') if clangBinDir not in os.environ.get('PATH'): - log.info("Adding {} as detected by {} to PATH".format(clangBinDir, - clang_dir[1])) + log.info(f"Adding {clangBinDir} as detected by {clang_dir[1]} to PATH") additional_paths.append(clangBinDir) else: raise DistutilsSetupError("Failed to detect Clang when checking " @@ -527,18 +523,18 @@ class PysideBuild(_build, DistUtilsCommandMixin): update_env_path(additional_paths) # Used for test blacklists and registry test. - self.build_classifiers = "py{}-qt{}-{}-{}".format(py_version, qt_version, - platform.architecture()[0], - build_type.lower()) + self.build_classifiers = (f"py{py_version}-qt{qt_version}-{platform.architecture()[0]}-" + f"{build_type.lower()}") + if OPTION["SHORTER_PATHS"]: - build_name = "p{}".format(py_version) + build_name = f"p{py_version}" else: build_name = self.build_classifiers script_dir = setup_script_dir sources_dir = os.path.join(script_dir, "sources") - build_dir = os.path.join(script_dir, prefix() + "_build", "{}".format(build_name)) - install_dir = os.path.join(script_dir, prefix() + "_install", "{}".format(build_name)) + build_dir = os.path.join(script_dir, f"{prefix()}_build", f"{build_name}") + install_dir = os.path.join(script_dir, f"{prefix()}_install", f"{build_name}") self.make_path = make_path self.make_generator = make_generator @@ -564,13 +560,13 @@ class PysideBuild(_build, DistUtilsCommandMixin): # Prepare folders if not os.path.exists(self.sources_dir): - log.info("Creating sources folder {}...".format(self.sources_dir)) + log.info(f"Creating sources folder {self.sources_dir}...") os.makedirs(self.sources_dir) if not os.path.exists(self.build_dir): - log.info("Creating build folder {}...".format(self.build_dir)) + log.info(f"Creating build folder {self.build_dir}...") os.makedirs(self.build_dir) if not os.path.exists(self.install_dir): - log.info("Creating install folder {}...".format(self.install_dir)) + log.info(f"Creating install folder {self.install_dir}...") os.makedirs(self.install_dir) if (not OPTION["ONLYPACKAGE"] @@ -590,7 +586,7 @@ class PysideBuild(_build, DistUtilsCommandMixin): with open(fpath, 'w') as f: print(build_dir, file=f) print(self.build_classifiers, file=f) - log.info("Created {}".format(build_history)) + log.info(f"Created {build_history}") if not OPTION["SKIP_PACKAGING"]: # Build patchelf if needed @@ -613,57 +609,53 @@ class PysideBuild(_build, DistUtilsCommandMixin): if OPTION["FINAL_INSTALL_PREFIX"]: setuptools_install_prefix = OPTION["FINAL_INSTALL_PREFIX"] log.info("=" * 30) - log.info("Package version: {}".format(get_package_version())) - log.info("Build type: {}".format(self.build_type)) - log.info("Build tests: {}".format(self.build_tests)) + 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("Make path: {}".format(self.make_path)) - log.info("Make generator: {}".format(self.make_generator)) - log.info("Make jobs: {}".format(OPTION["JOBS"])) + 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("setup.py directory: {}".format(self.script_dir)) - log.info("Build scripts directory: {}".format(build_scripts_dir)) - log.info("Sources directory: {}".format(self.sources_dir)) - log.info(dedent(""" - Building {st_package_name} will create and touch directories + 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(dedent(f""" + Building {config.package_name()} will create and touch directories in the following order: make build directory (py*_build/*/*) -> make install directory (py*_install/*/*) -> setuptools build directory (build/*/*) -> setuptools install directory (usually path-installed-python/lib/python*/site-packages/*) - """).format(st_package_name=config.package_name())) - log.info("make build directory: {}".format(self.build_dir)) - log.info("make install directory: {}".format(self.install_dir)) - log.info("setuptools build directory: {}".format(self.st_build_dir)) - log.info("setuptools install directory: {}".format(setuptools_install_prefix)) - log.info(dedent(""" - make-installed site-packages directory: {} + """)) + 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(dedent(f""" + make-installed site-packages directory: {self.site_packages_dir} (only relevant for copying files from 'make install directory' to 'setuptools build directory' - """).format( - self.site_packages_dir)) + """)) log.info("-" * 3) - log.info("Python executable: {}".format(self.py_executable)) - log.info("Python includes: {}".format(self.py_include_dir)) - log.info("Python library: {}".format(self.py_library)) - log.info("Python prefix: {}".format(self.py_prefix)) - log.info("Python scripts: {}".format(self.py_scripts_dir)) + 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("-" * 3) - log.info("Qt qmake: {}".format(self.qtinfo.qmake_command)) - log.info("Qt version: {}".format(self.qtinfo.version)) - log.info("Qt bins: {}".format(self.qtinfo.bins_dir)) - log.info("Qt docs: {}".format(self.qtinfo.docs_dir)) - log.info("Qt plugins: {}".format(self.qtinfo.plugins_dir)) + log.info(f"Qt qmake: {self.qtinfo.qmake_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("OpenSSL dll directory: {}".format(OPTION["OPENSSL"])) + log.info(f"OpenSSL dll directory: {OPTION['OPENSSL']}") if sys.platform == 'darwin': - pyside_macos_deployment_target = ( - macos_pyside_min_deployment_target() - ) - log.info("MACOSX_DEPLOYMENT_TARGET set to: {}".format( - pyside_macos_deployment_target)) + 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): @@ -673,11 +665,11 @@ class PysideBuild(_build, DistUtilsCommandMixin): if self._patchelf_path: if not os.path.isabs(self._patchelf_path): self._patchelf_path = os.path.join(os.getcwd(), self._patchelf_path) - log.info("Using {} ...".format(self._patchelf_path)) + log.info(f"Using {self._patchelf_path} ...") return log.info("Building patchelf...") module_src_dir = os.path.join(self.sources_dir, "patchelf") - build_cmd = ["g++", "{}/patchelf.cc".format(module_src_dir), "-o", "patchelf"] + build_cmd = ["g++", f"{module_src_dir}/patchelf.cc", "-o", "patchelf"] if run_process(build_cmd) != 0: raise DistutilsSetupError("Error building patchelf") self._patchelf_path = os.path.join(self.script_dir, "patchelf") @@ -685,29 +677,29 @@ class PysideBuild(_build, DistUtilsCommandMixin): def build_extension(self, extension): # calculate the subrepos folder name - log.info("Building module {}...".format(extension)) + log.info(f"Building module {extension}...") # Prepare folders os.chdir(self.build_dir) module_build_dir = os.path.join(self.build_dir, extension) - skipflag_file = "{} -skip".format(module_build_dir) + skipflag_file = f"{module_build_dir} -skip" if os.path.exists(skipflag_file): - log.info("Skipping {} because {} exists".format(extension, skipflag_file)) + log.info(f"Skipping {extension} because {skipflag_file} exists") return module_build_exists = os.path.exists(module_build_dir) if module_build_exists: if not OPTION["REUSE_BUILD"]: - log.info("Deleting module build folder {}...".format(module_build_dir)) + log.info(f"Deleting module build folder {module_build_dir}...") try: rmtree(module_build_dir) except Exception as e: - print('***** problem removing "{}"'.format(module_build_dir)) - print('ignored error: {}'.format(e)) + log.error(f'***** problem removing "{module_build_dir}"') + log.error(f'ignored error: {e}') else: - log.info("Reusing module build folder {}...".format(module_build_dir)) + log.info(f"Reusing module build folder {module_build_dir}...") if not os.path.exists(module_build_dir): - log.info("Creating module build folder {}...".format(module_build_dir)) + log.info(f"Creating module build folder {module_build_dir}...") os.makedirs(module_build_dir) os.chdir(module_build_dir) @@ -726,15 +718,15 @@ class PysideBuild(_build, DistUtilsCommandMixin): cmake_cmd += [ "-G", self.make_generator, - "-DBUILD_TESTS={}".format(self.build_tests), - "-DQt5Help_DIR={}".format(self.qtinfo.docs_dir), - "-DCMAKE_BUILD_TYPE={}".format(self.build_type), - "-DCMAKE_INSTALL_PREFIX={}".format(self.install_dir), + 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}", module_src_dir ] - cmake_cmd.append("-DPYTHON_EXECUTABLE={}".format(self.py_executable)) - cmake_cmd.append("-DPYTHON_INCLUDE_DIR={}".format(self.py_include_dir)) - cmake_cmd.append("-DPYTHON_LIBRARY={}".format(self.py_library)) + 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(): @@ -754,7 +746,7 @@ class PysideBuild(_build, DistUtilsCommandMixin): if module_sub_set: module_sub_set += ';' module_sub_set += m - cmake_cmd.append("-DMODULES={}".format(module_sub_set)) + cmake_cmd.append(f"-DMODULES={module_sub_set}") if OPTION["SKIP_MODULES"]: skip_modules = '' for m in OPTION["SKIP_MODULES"].split(','): @@ -763,15 +755,14 @@ class PysideBuild(_build, DistUtilsCommandMixin): if skip_modules: skip_modules += ';' skip_modules += m - cmake_cmd.append("-DSKIP_MODULES={}".format(skip_modules)) + cmake_cmd.append(f"-DSKIP_MODULES={skip_modules}") # Add source location for generating documentation cmake_src_dir = OPTION["QT_SRC"] if OPTION["QT_SRC"] else qt_src_dir - cmake_cmd.append("-DQT_SRC_DIR={}".format(cmake_src_dir)) - log.info("Qt Source dir: {}".format(cmake_src_dir)) + cmake_cmd.append(f"-DQT_SRC_DIR={cmake_src_dir}") + log.info(f"Qt Source dir: {cmake_src_dir}") if self.build_type.lower() == 'debug': - cmake_cmd.append("-DPYTHON_DEBUG_LIBRARY={}".format( - self.py_library)) + cmake_cmd.append(f"-DPYTHON_DEBUG_LIBRARY={self.py_library}") if OPTION["LIMITED_API"] == "yes": cmake_cmd.append("-DFORCE_LIMITED_API=yes") @@ -803,13 +794,12 @@ class PysideBuild(_build, DistUtilsCommandMixin): pyside_qt_conf_prefix = '"Qt"' if sys.platform == 'win32': pyside_qt_conf_prefix = '"."' - cmake_cmd.append("-DPYSIDE_QT_CONF_PREFIX={}".format( - pyside_qt_conf_prefix)) + cmake_cmd.append(f"-DPYSIDE_QT_CONF_PREFIX={pyside_qt_conf_prefix}") # Pass package version to CMake, so this string can be # embedded into _config.py file. package_version = get_package_version() - cmake_cmd.append("-DPACKAGE_SETUP_PY_PACKAGE_VERSION={}".format(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 @@ -817,7 +807,7 @@ class PysideBuild(_build, DistUtilsCommandMixin): timestamp = '' if OPTION["SNAPSHOT_BUILD"]: timestamp = get_package_timestamp() - cmake_cmd.append("-DPACKAGE_SETUP_PY_PACKAGE_TIMESTAMP={}".format(timestamp)) + cmake_cmd.append(f"-DPACKAGE_SETUP_PY_PACKAGE_TIMESTAMP={timestamp}") if extension.lower() in [SHIBOKEN]: cmake_cmd.append("-DCMAKE_INSTALL_RPATH_USE_LINK_PATH=yes") @@ -826,7 +816,7 @@ class PysideBuild(_build, DistUtilsCommandMixin): if sys.platform == 'darwin': if OPTION["MACOS_ARCH"]: # also tell cmake which architecture to use - cmake_cmd.append("-DCMAKE_OSX_ARCHITECTURES:STRING={}".format(OPTION["MACOS_ARCH"])) + cmake_cmd.append(f"-DCMAKE_OSX_ARCHITECTURES:STRING={OPTION['MACOS_ARCH']}") if OPTION["MACOS_USE_LIBCPP"]: # Explicitly link the libc++ standard library (useful @@ -840,15 +830,13 @@ class PysideBuild(_build, DistUtilsCommandMixin): cmake_cmd.append("-DOSX_USE_LIBCPP=ON") if OPTION["MACOS_SYSROOT"]: - cmake_cmd.append("-DCMAKE_OSX_SYSROOT={}".format( - 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("-DCMAKE_OSX_SYSROOT={}".format( - latest_sdk_path)) + cmake_cmd.append(f"-DCMAKE_OSX_SYSROOT={latest_sdk_path}") # Set macOS minimum deployment target (version). # This is required so that calling @@ -859,7 +847,7 @@ class PysideBuild(_build, DistUtilsCommandMixin): # Doing so could break the detected clang include paths # for example. deployment_target = macos_pyside_min_deployment_target() - cmake_cmd.append("-DCMAKE_OSX_DEPLOYMENT_TARGET={}".format(deployment_target)) + cmake_cmd.append(f"-DCMAKE_OSX_DEPLOYMENT_TARGET={deployment_target}") os.environ['MACOSX_DEPLOYMENT_TARGET'] = deployment_target elif sys.platform == 'win32': # Prevent cmake from auto-detecting clang if it is in path. @@ -877,19 +865,18 @@ class PysideBuild(_build, DistUtilsCommandMixin): cmake_cmd.append("-DFULLDOCSBUILD=1") if not OPTION["SKIP_CMAKE"]: - log.info("Configuring module {} ({})...".format(extension, module_src_dir)) + log.info(f"Configuring module {extension} ({module_src_dir})...") if run_process(cmake_cmd) != 0: - raise DistutilsSetupError("Error configuring {}".format(extension)) + raise DistutilsSetupError(f"Error configuring {extension}") else: - log.info("Reusing old configuration for module {} ({})...".format( - extension, module_src_dir)) + log.info(f"Reusing old configuration for module {extension} ({module_src_dir})...") - log.info("-- Compiling module {}...".format(extension)) + log.info(f"-- Compiling module {extension}...") cmd_make = [self.make_path] if OPTION["JOBS"]: cmd_make.append(OPTION["JOBS"]) if run_process(cmd_make) != 0: - raise DistutilsSetupError("Error compiling {}".format(extension)) + raise DistutilsSetupError(f"Error compiling {extension}") if not OPTION["SKIP_DOCS"]: if extension.lower() == SHIBOKEN: @@ -900,14 +887,14 @@ class PysideBuild(_build, DistUtilsCommandMixin): log.info("Generating Shiboken documentation") if run_process([self.make_path, "doc"]) != 0: raise DistutilsSetupError("Error generating documentation " - "for {}".format(extension)) + f"for {extension}") except ImportError: log.info("Sphinx not found, skipping documentation build") else: log.info("Skipped documentation generation") if not OPTION["SKIP_MAKE_INSTALL"]: - log.info("Installing module {}...".format(extension)) + 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 @@ -918,10 +905,9 @@ class PysideBuild(_build, DistUtilsCommandMixin): # ninja: error: unknown target 'install/fast' target = 'install/fast' if self.make_generator != 'Ninja' else 'install' if run_process([self.make_path, target]) != 0: - raise DistutilsSetupError("Error pseudo installing {}".format( - extension)) + raise DistutilsSetupError(f"Error pseudo installing {extension}") else: - log.info("Skipped installing module {}".format(extension)) + log.info(f"Skipped installing module {extension}") os.chdir(self.script_dir) @@ -1058,8 +1044,8 @@ class PysideBuild(_build, DistUtilsCommandMixin): if os.path.exists(clang_lib_path): basename = os.path.basename(clang_lib_path) - log.info('Copying libclang shared library {} to the package folder as {}.'.format( - clang_lib_path, basename)) + log.info(f"Copying libclang shared library {clang_lib_path} to the package " + f"folder as {basename}.") destination_path = os.path.join(destination_dir, basename) # Need to modify permissions in case file is not writable @@ -1070,7 +1056,7 @@ class PysideBuild(_build, DistUtilsCommandMixin): make_writable_by_owner=True) else: raise RuntimeError("Error copying libclang library " - "from {} to {}. ".format(clang_lib_path, destination_dir)) + f"from {clang_lib_path} to {destination_dir}. ") def update_rpath(self, package_path, executables): if sys.platform.startswith('linux'): @@ -1111,7 +1097,7 @@ class PysideBuild(_build, DistUtilsCommandMixin): macos_fix_rpaths_for_library(srcpath, final_rpath) else: - raise RuntimeError('Not configured for platform {}'.format(sys.platform)) + raise RuntimeError(f"Not configured for platform {sys.platform}") pyside_libs.extend(executables) @@ -1124,7 +1110,7 @@ class PysideBuild(_build, DistUtilsCommandMixin): continue rpath_cmd(srcpath) log.info("Patched rpath to '$ORIGIN/' (Linux) or " - "updated rpath (OS/X) in {}.".format(srcpath)) + f"updated rpath (OS/X) in {srcpath}.") class PysideRstDocs(Command, DistUtilsCommandMixin): @@ -1172,8 +1158,8 @@ class PysideRstDocs(Command, DistUtilsCommandMixin): # 'pyside6' directory elif self.name == PYSIDE: self.out_dir = os.path.join(self.html_dir, PYSIDE) - except: - raise DistutilsSetupError("Error while creating directories for {}".format(self.doc_dir)) + except (PermissionError, FileExistsError): + raise DistutilsSetupError(f"Error while creating directories for {self.doc_dir}") def run(self): if not self.skip: @@ -1185,7 +1171,7 @@ class PysideRstDocs(Command, DistUtilsCommandMixin): "-DFULLDOCSBUILD=0", ] if run_process(cmake_cmd) != 0: - raise DistutilsSetupError("Error running CMake for {}".format(self.doc_dir)) + raise DistutilsSetupError(f"Error running CMake for {self.doc_dir}") if self.name == PYSIDE: self.sphinx_src = os.path.join(self.out_dir, "rst") @@ -1195,7 +1181,7 @@ class PysideRstDocs(Command, DistUtilsCommandMixin): sphinx_cmd = ["sphinx-build", "-b", "html", "-c", self.sphinx_src, self.doc_dir, self.out_dir] if run_process(sphinx_cmd) != 0: - raise DistutilsSetupError("Error running CMake for {}".format(self.doc_dir)) + raise DistutilsSetupError(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") diff --git a/build_scripts/options.py b/build_scripts/options.py index ab45c915c..d7f878519 100644 --- a/build_scripts/options.py +++ b/build_scripts/options.py @@ -60,13 +60,13 @@ Additional options: def _warn_multiple_option(option): - warnings.warn('Option "{}" occurs multiple times on the command line.'.format(option)) + warnings.warn(f'Option "{option}" occurs multiple times on the command line.') def _warn_deprecated_option(option, replacement=None): - w = 'Option "{}" is deprecated and may be removed in a future release.'.format(option) + w = f'Option "{option}" is deprecated and may be removed in a future release.' if replacement: - w = '{}\nUse "{}" instead.'.format(w, replacement) + w = f'{w}\nUse "{replacement}" instead.' warnings.warn(w) @@ -79,12 +79,12 @@ class Options(object): def has_option(self, name, remove=True): """ Returns True if argument '--name' was passed on the command line. """ - option = '--{}'.format(name) + option = f"--{name}" count = sys.argv.count(option) remove_count = count if not remove and count > 0: remove_count -= 1 - for i in range(remove_count): + for _ in range(remove_count): sys.argv.remove(option) if count > 1: _warn_multiple_option(option) @@ -115,7 +115,7 @@ class Options(object): _warn_multiple_option(option) else: if index + 1 >= len(sys.argv): - raise RuntimeError("The option {} requires a value".format(option)) + raise RuntimeError(f"The option {option} requires a value") value = sys.argv[index + 1] if remove: diff --git a/build_scripts/platforms/macos.py b/build_scripts/platforms/macos.py index a3b1df91a..8448929a0 100644 --- a/build_scripts/platforms/macos.py +++ b/build_scripts/platforms/macos.py @@ -81,7 +81,7 @@ def prepare_standalone_package_macos(self, vars): # Patching designer to use the Qt libraries provided in the wheel if config.is_internal_pyside_build(): designer_bundle = "{st_build_dir}/{st_package_name}/Designer.app".format(**vars) - designer_binary = "{}/Contents/MacOS/Designer".format(designer_bundle) + designer_binary = f"{designer_bundle}/Contents/MacOS/Designer" rpath = "@loader_path/../../../Qt/lib" macos_add_rpath(rpath, designer_binary) diff --git a/build_scripts/platforms/windows_desktop.py b/build_scripts/platforms/windows_desktop.py index a17f1da6a..a6c59b16a 100644 --- a/build_scripts/platforms/windows_desktop.py +++ b/build_scripts/platforms/windows_desktop.py @@ -384,7 +384,7 @@ def copy_qt_artifacts(self, copy_pdbs, vars): # e.g. "/home/work/qt/qtbase/bin" file_path_dir_name = os.path.dirname(file_full_path) # e.g. "Qt6Coredd" - maybe_debug_name = "{}d".format(file_base_name) + maybe_debug_name = f"{file_base_name}d" if self.debug: filter = debug diff --git a/build_scripts/qtinfo.py b/build_scripts/qtinfo.py index 4ab3b8ede..6c20f3f9d 100644 --- a/build_scripts/qtinfo.py +++ b/build_scripts/qtinfo.py @@ -55,7 +55,7 @@ def _effective_qmake_command(qmake, qt_version): sys.exit(-1) # Set -qt=X here. if "qtchooser" in os.readlink(qmake): - result.append("-qt={}".format(qt_version)) + result.append(f"-qt={qt_version}") return result @@ -74,7 +74,7 @@ class QtInfo(object): def get_qmake_command(self): qmake_command_string = self._qmake_command[0] for entry in self._qmake_command[1:]: - qmake_command_string += " {}".format(entry) + qmake_command_string = f"{qmake_command_string} {entry}" return qmake_command_string def get_version(self): diff --git a/build_scripts/setup_runner.py b/build_scripts/setup_runner.py index 21e00063b..23eaff3fe 100644 --- a/build_scripts/setup_runner.py +++ b/build_scripts/setup_runner.py @@ -76,8 +76,8 @@ class SetupRunner(object): def construct_cmd_line_argument(name, value=None): """ Constructs a command line argument given name and value. """ if not value: - return "--{}".format(name) - return "--{}={}".format(name, value) + return f"--{name}" + return f"--{name}={value}" @staticmethod def construct_internal_build_type_cmd_line_argument(internal_build_type): @@ -120,8 +120,8 @@ class SetupRunner(object): # build. if config.is_internal_invocation(): if config.internal_build_type not in config.get_allowed_internal_build_values(): - raise RuntimeError("Invalid '{}' option given to --internal-build-type. " - .format(config.internal_build_type)) + raise RuntimeError(f"Invalid '{config.internal_build_type}' option given to " + "--internal-build-type. ") self.run_setuptools_setup() return @@ -129,8 +129,7 @@ class SetupRunner(object): # modules we will build and depending on that, call setup.py # multiple times with different arguments. if config.build_type not in config.get_allowed_top_level_build_values(): - raise RuntimeError("Invalid '{}' option given to --build-type. " - .format(config.build_type)) + raise RuntimeError(f"Invalid '{config.build_type}' option given to --build-type. ") # Build everything: shiboken6, shiboken6-generator and PySide6. help_requested = '--help' in self.sub_argv or '-h' in self.sub_argv @@ -158,13 +157,13 @@ class SetupRunner(object): for cmd in self.invocations_list: cmd_as_string = " ".join(cmd) - log.info("\nRunning setup: {}\n".format(cmd_as_string)) + log.info(f"\nRunning setup: {cmd_as_string}\n") exit_code = run_process(cmd) if exit_code != 0: - msg = textwrap.dedent(""" - setup.py invocation failed with exit code: {}.\n\n - setup.py invocation was: {} - """).format(exit_code, cmd_as_string) + msg = textwrap.dedent(f""" + setup.py invocation failed with exit code: {exit_code}.\n\n + setup.py invocation was: {cmd_as_string} + """) raise RuntimeError(msg) if help_requested: diff --git a/build_scripts/utils.py b/build_scripts/utils.py index 2555c7c7e..8919cff75 100644 --- a/build_scripts/utils.py +++ b/build_scripts/utils.py @@ -78,9 +78,9 @@ def update_env_path(newpaths): paths = os.environ['PATH'].lower().split(os.pathsep) for path in newpaths: if not path.lower() in paths: - log.info("Inserting path '{}' to environment".format(path)) + log.info(f"Inserting path '{path}' to environment") paths.insert(0, path) - os.environ['PATH'] = "{}{}{}".format(path, os.pathsep, os.environ['PATH']) + os.environ['PATH'] = f"{path}{os.pathsep}{os.environ['PATH']}" def winsdk_setenv(platform_arch, build_type): @@ -97,13 +97,13 @@ def winsdk_setenv(platform_arch, build_type): "v7.1": 10.0 } - log.info("Searching Windows SDK with MSVC compiler version {}".format(MSVC_VERSION)) + log.info(f"Searching Windows SDK with MSVC compiler version {MSVC_VERSION}") setenv_paths = [] for base in HKEYS: sdk_versions = Reg.read_keys(base, WINSDK_BASE) if sdk_versions: for sdk_version in sdk_versions: - installationfolder = Reg.get_value("{}\\{}".format(WINSDK_BASE, sdk_version), + installationfolder = Reg.get_value(f"{WINSDK_BASE}\\{sdk_version}", "installationfolder") # productversion = Reg.get_value("{}\\{}".format(WINSDK_BASE, sdk_version), # "productversion") @@ -117,13 +117,13 @@ def winsdk_setenv(platform_arch, build_type): setenv_paths.append(setenv_path) if len(setenv_paths) == 0: raise DistutilsSetupError("Failed to find the Windows SDK with MSVC compiler " - "version {}".format(MSVC_VERSION)) + f"version {MSVC_VERSION}") for setenv_path in setenv_paths: - log.info("Found {}".format(setenv_path)) + log.info(f"Found {setenv_path}") # Get SDK env (use latest SDK version installed on system) setenv_path = setenv_paths[-1] - log.info("Using {} ".format(setenv_path)) + log.info(f"Using {setenv_path} ") build_arch = "/x86" if platform_arch.startswith("32") else "/x64" build_type = "/Debug" if build_type.lower() == "debug" else "/Release" setenv_cmd = [setenv_path, build_arch, build_type] @@ -136,7 +136,7 @@ def winsdk_setenv(platform_arch, build_type): update_env_path(setenv_env_paths) for k in sorted(setenv_env_without_paths): v = setenv_env_without_paths[k] - log.info("Inserting '{} = {}' to environment".format(k, v)) + log.info(f"Inserting '{k} = {v}' to environment") os.environ[k] = v log.info("Done initializing Windows SDK env") @@ -150,7 +150,7 @@ def find_vcdir(version): from distutils.msvc9compiler import Reg vsbase = VS_BASE % version try: - productdir = Reg.get_value(r"{}\Setup\VC".format(vsbase), "productdir") + productdir = Reg.get_value(rf"{vsbase}\Setup\VC", "productdir") except KeyError: productdir = None @@ -163,23 +163,23 @@ def find_vcdir(version): else: vsbase = VSEXPRESS_BASE % version try: - productdir = Reg.get_value(r"{}\Setup\VC".format(vsbase), "productdir") + productdir = Reg.get_value(rf"{vsbase}\Setup\VC", "productdir") except KeyError: productdir = None log.debug("Unable to find productdir in registry") if not productdir or not os.path.isdir(productdir): - toolskey = "VS{:0.0f}0COMNTOOLS".format(version) + toolskey = f"VS{version:0.0f}0COMNTOOLS" toolsdir = os.environ.get(toolskey, None) if toolsdir and os.path.isdir(toolsdir): productdir = os.path.join(toolsdir, os.pardir, os.pardir, "VC") productdir = os.path.abspath(productdir) if not os.path.isdir(productdir): - log.debug("{} is not a valid directory".format(productdir)) + log.debug(f"{productdir} is not a valid directory") return None else: - log.debug("Env var {} is not set or invalid".format(toolskey)) + log.debug(f"Env var {toolskey} is not set or invalid") if not productdir: log.debug("No productdir found") return None @@ -189,15 +189,15 @@ def find_vcdir(version): def init_msvc_env(platform_arch, build_type): from distutils.msvc9compiler import VERSION as MSVC_VERSION - log.info("Searching MSVC compiler version {}".format(MSVC_VERSION)) + log.info(f"Searching MSVC compiler version {MSVC_VERSION}") vcdir_path = find_vcdir(MSVC_VERSION) if not vcdir_path: - raise DistutilsSetupError("Failed to find the MSVC compiler version {} on your " - "system.".format(MSVC_VERSION)) + raise DistutilsSetupError(f"Failed to find the MSVC compiler version {MSVC_VERSION} on " + "your system.") else: - log.info("Found {}".format(vcdir_path)) + log.info(f"Found {vcdir_path}") - log.info("Searching MSVC compiler {} environment init script".format(MSVC_VERSION)) + log.info(f"Searching MSVC compiler {MSVC_VERSION} environment init script") if platform_arch.startswith("32"): vcvars_path = os.path.join(vcdir_path, "bin", "vcvars32.bat") else: @@ -214,12 +214,12 @@ def init_msvc_env(platform_arch, build_type): winsdk_setenv(platform_arch, build_type) return else: - log.info("Found {}".format(vcvars_path)) + log.info(f"Found {vcvars_path}") # Get MSVC env - log.info("Using MSVC {} in {}".format(MSVC_VERSION, vcvars_path)) + log.info(f"Using MSVC {MSVC_VERSION} in {vcvars_path}") msvc_arch = "x86" if platform_arch.startswith("32") else "amd64" - log.info("Getting MSVC env for {} architecture".format(msvc_arch)) + log.info(f"Getting MSVC env for {msvc_arch} architecture") vcvars_cmd = [vcvars_path, msvc_arch] msvc_env = get_environment_from_batch_command(vcvars_cmd) msvc_env_paths = os.pathsep.join([msvc_env[k] for k in msvc_env if k.upper() == 'PATH']).split(os.pathsep) @@ -230,7 +230,7 @@ def init_msvc_env(platform_arch, build_type): update_env_path(msvc_env_paths) for k in sorted(msvc_env_without_paths): v = msvc_env_without_paths[k] - log.info("Inserting '{} = {}' to environment".format(k, v)) + log.info(f"Inserting '{k} = {v}' to environment") os.environ[k] = v log.info("Done initializing MSVC env") @@ -242,11 +242,11 @@ def copyfile(src, dst, force=True, vars=None, force_copy_symlink=False, dst = dst.format(**vars) if not os.path.exists(src) and not force: - log.info("**Skiping copy file {} to {}. Source does not exists.".format(src, dst)) + log.info(f"**Skipping copy file {src} to {dst}. Source does not exists.") return if not os.path.islink(src) or force_copy_symlink: - log.info("Copying file {} to {}.".format(src, dst)) + log.info(f"Copying file {src} to {dst}.") shutil.copy2(src, dst) if make_writable_by_owner: make_file_writable_by_owner(dst) @@ -262,15 +262,15 @@ def copyfile(src, dst, force=True, vars=None, force_copy_symlink=False, os.chdir(target_dir) if os.path.exists(link_name): os.remove(link_name) - log.info("Symlinking {} -> {} in {}.".format(link_name, link_target, target_dir)) + log.info(f"Symlinking {link_name} -> {link_target} in {target_dir}.") os.symlink(link_target, link_name) except OSError: - log.error("{} -> {}: Error creating symlink".format(link_name, link_target)) + log.error(f"{link_name} -> {link_target}: Error creating symlink") finally: os.chdir(current_directory) else: - log.error("{} -> {}: Can only create symlinks within the same " - "directory".format(src, link_target_path)) + log.error(f"{src} -> {link_target_path}: Can only create symlinks within the same " + "directory") return dst @@ -281,7 +281,7 @@ def makefile(dst, content=None, vars=None): content = content.format(**vars) dst = dst.format(**vars) - log.info("Making file {}.".format(dst)) + log.info(f"Making file {dst}.") dstdir = os.path.dirname(dst) if not os.path.exists(dstdir): @@ -306,11 +306,11 @@ def copydir(src, dst, filter=None, ignore=None, force=True, recursive=True, vars ignore[i] = ignore[i].format(**vars) if not os.path.exists(src) and not force: - log.info("**Skiping copy tree {} to {}. Source does not exists. " - "filter={}. ignore={}.".format(src, dst, filter, ignore)) + log.info(f"**Skipping copy tree {src} to {dst}. Source does not exists. " + f"filter={filter}. ignore={ignore}.") return [] - log.info("Copying tree {} to {}. filter={}. ignore={}.".format(src, dst, filter, ignore)) + log.info(f"Copying tree {src} to {dst}. filter={filter}. ignore={ignore}.") names = os.listdir(src) @@ -389,8 +389,8 @@ def run_process(args, initial_env=None): Run process until completion and return the process exit code. No output is captured. """ - command = " ".join([(" " in x and '"{}"'.format(x) or x) for x in args]) - log.info("In directory {}:\n\tRunning command: {}".format(os.getcwd(), command)) + command = " ".join([(" " in x and f'"{x}"' or x) for x in args]) + log.info(f"In directory {os.getcwd()}:\n\tRunning command: {command}") if initial_env is None: initial_env = os.environ @@ -416,7 +416,7 @@ def get_environment_from_batch_command(env_cmd, initial=None): def validate_pair(ob): try: if not (len(ob) == 2): - print("Unexpected result: {}".format(ob)) + log.error(f"Unexpected result: {ob}") raise ValueError except: return False @@ -436,7 +436,7 @@ def get_environment_from_batch_command(env_cmd, initial=None): # create a tag so we can tell in the output when the proc is done tag = 'Done running command' # construct a cmd.exe command to do accomplish this - cmd = 'cmd.exe /E:ON /V:ON /s /c "{} && echo "{}" && set"'.format(env_cmd, tag) + cmd = f'cmd.exe /E:ON /V:ON /s /c "{env_cmd} && echo "{tag}" && set"' # launch the process proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, env=initial) # parse the output sent to stdout @@ -468,7 +468,7 @@ def regenerate_qt_resources(src, pyside_rcc_path, pyside_rcc_options): srcname_split = srcname.rsplit('.qrc', 1) dstname = '_rc.py'.join(srcname_split) if os.path.exists(dstname): - log.info('Regenerating {} from {}'.format(dstname, os.path.basename(srcname))) + log.info(f"Regenerating {dstname} from {os.path.basename(srcname)}") run_process([pyside_rcc_path] + pyside_rcc_options + [srcname, '-o', dstname]) @@ -508,10 +508,9 @@ def back_tick(cmd, ret_err=False): retcode = proc.returncode if retcode is None and not ret_err: proc.terminate() - raise RuntimeError("{} process did not terminate".format(cmd)) + raise RuntimeError(f"{cmd} process did not terminate") if retcode != 0 and not ret_err: - raise RuntimeError("{} process returned code {}\n*** {}".format( - (cmd, retcode, err))) + raise RuntimeError(f"{cmd} process returned code {retcode}\n*** {err}") out = out.strip() if not ret_err: return out @@ -535,7 +534,7 @@ def macos_get_install_names(libpath): install_names : list of str install names in library `libpath` """ - out = back_tick("otool -L {}".format(libpath)) + out = back_tick(f"otool -L {libpath}") libs = [line for line in out.split('\n')][1:] return [MACOS_OUTNAME_RE.sub('', lib).strip() for lib in libs] @@ -560,7 +559,7 @@ def macos_get_rpaths(libpath): ----- See ``man dyld`` for more information on rpaths in libraries """ - lines = back_tick('otool -l {}'.format(libpath)).split('\n') + lines = back_tick(f"otool -l {libpath}").split('\n') ctr = 0 rpaths = [] while ctr < len(lines): @@ -572,14 +571,14 @@ def macos_get_rpaths(libpath): rpath_line = lines[ctr + 2].strip() match = MACOS_RPATH_RE.match(rpath_line) if match is None: - raise RuntimeError("Unexpected path line: {}".format(rpath_line)) + raise RuntimeError(f"Unexpected path line: {rpath_line}") rpaths.append(match.groups()[0]) ctr += 3 return rpaths def macos_add_rpath(rpath, library_path): - back_tick("install_name_tool -add_rpath {} {}".format(rpath, library_path)) + back_tick(f"install_name_tool -add_rpath {rpath} {library_path}") def macos_fix_rpaths_for_library(library_path, qt_lib_dir): @@ -700,29 +699,29 @@ def download_and_extract_7z(fileurl, target): localfile = None for i in range(1, 10): try: - print("Downloading fileUrl {}, attempt #{}".format(fileurl, i)) + log.info(f"Downloading fileUrl {fileurl}, attempt #{i}") localfile, info = urllib.urlretrieve(fileurl) break - except: + except urllib.URLError: pass if not localfile: - print("Error downloading {} : {}".format(fileurl, info)) - raise RuntimeError(' Error downloading {}'.format(fileurl)) + log.error(f"Error downloading {fileurl} : {info}") + raise RuntimeError(f" Error downloading {fileurl}") try: global _7z_binary - outputDir = "-o{}".format(target) + outputDir = f"-o{target}" if not _7z_binary: - if sys.platform == 'win32': - candidate = 'c:\\Program Files\\7-Zip\\7z.exe' + if sys.platform == "win32": + candidate = "c:\\Program Files\\7-Zip\\7z.exe" if os.path.exists(candidate): _7z_binary = candidate if not _7z_binary: _7z_binary = '7z' - print("calling {} x {} {}".format(_7z_binary, localfile, outputDir)) + log.info(f"calling {_7z_binary} x {localfile} {outputDir}") subprocess.call([_7z_binary, "x", "-y", localfile, outputDir]) - except: - raise RuntimeError(' Error extracting {}'.format(localfile)) + except (subprocess.CalledProcessError, OSError): + raise RuntimeError(f"Error extracting {localfile}") def split_and_strip(sinput): @@ -819,7 +818,7 @@ def ldd(executable_path): # Code 127 is returned by ld.so when called without any # arguments (some kind of sanity check I guess). if code == 127: - (_, _, code) = back_tick("{} --verify {}".format(rtld, executable_path), True) + (_, _, code) = back_tick(f"{rtld} --verify {executable_path}", True) # Codes 0 and 2 mean given executable_path can be # understood by ld.so. if code in [0, 2]: @@ -831,13 +830,13 @@ def ldd(executable_path): # Query for shared library dependencies. rtld_env = "LD_TRACE_LOADED_OBJECTS=1" - rtld_cmd = "{} {} {}".format(rtld_env, chosen_rtld, executable_path) + rtld_cmd = f"{rtld_env} {chosen_rtld} {executable_path}" (out, _, return_code) = back_tick(rtld_cmd, True) if return_code == 0: return out else: raise RuntimeError("ld.so failed to query for dependent shared " - "libraries of {} ".format(executable_path)) + f"libraries of {executable_path}") def find_files_using_glob(path, pattern): @@ -868,8 +867,8 @@ def copy_icu_libs(patchelf, destination_lib_dir): qt_core_library_path = find_qt_core_library_glob(destination_lib_dir) if not qt_core_library_path or not os.path.exists(qt_core_library_path): - raise RuntimeError('QtCore library does not exist at path: {}. ' - 'Failed to copy ICU libraries.'.format(qt_core_library_path)) + raise RuntimeError(f"QtCore library does not exist at path: {qt_core_library_path}. " + "Failed to copy ICU libraries.") dependencies = ldd_get_dependencies(qt_core_library_path) @@ -911,11 +910,11 @@ def copy_icu_libs(patchelf, destination_lib_dir): def linux_run_read_elf(executable_path): - cmd = "readelf -d {}".format(executable_path) + cmd = f"readelf -d {executable_path}" (out, err, code) = back_tick(cmd, True) if code != 0: - raise RuntimeError("Running `readelf -d {}` failed with error " - "output:\n {}. ".format(executable_path, err)) + raise RuntimeError(f"Running `readelf -d {executable_path}` failed with error " + f"output:\n {err}. ") lines = split_and_strip(out) return lines @@ -926,7 +925,7 @@ def linux_set_rpaths(patchelf, executable_path, rpath_string): cmd = [patchelf, '--set-rpath', rpath_string, executable_path] if run_process(cmd) != 0: - raise RuntimeError("Error patching rpath in {}".format(executable_path)) + raise RuntimeError(f"Error patching rpath in {executable_path}") def linux_get_dependent_libraries(executable_path): @@ -1046,8 +1045,8 @@ def get_python_dict(python_script_path): exec(code, {}, python_dict) return python_dict except IOError as e: - print("get_python_dict: Couldn't get dict from python " - "file: {}.".format(python_script_path)) + print(f"get_python_dict: Couldn't get dict from python " + f"file: {python_script_path}. {e}") raise @@ -1056,7 +1055,7 @@ def install_pip_package_from_url_specifier(env_pip, url, upgrade=True): if upgrade: args.append("--upgrade") args.append(url) - run_instruction(args, "Failed to install {}".format(url)) + run_instruction(args, f"Failed to install {url}") def install_pip_dependencies(env_pip, packages, upgrade=True): @@ -1065,14 +1064,14 @@ def install_pip_dependencies(env_pip, packages, upgrade=True): if upgrade: args.append("--upgrade") args.append(p) - run_instruction(args, "Failed to install {}".format(p)) + run_instruction(args, f"Failed to install {p}") def get_qtci_virtualEnv(python_ver, host, hostArch, targetArch): _pExe = "python" - _env = "env{}".format(str(python_ver)) - env_python = _env + "/bin/python" - env_pip = _env + "/bin/pip" + _env = f"env{python_ver}" + env_python = f"{_env}/bin/python" + env_pip = f"{_env}/bin/pip" if host == "Windows": log.info("New virtualenv to build {targetArch} in {hostArch} host") @@ -1098,8 +1097,8 @@ def get_qtci_virtualEnv(python_ver, host, hostArch, targetArch): if not os.path.isfile(_pExe): log.warn(f"Can't find python.exe from {_pExe}, using default python3") _pExe = os.path.join(os.getenv("PYTHON3_PATH"), "python.exe") - env_python = _env + "\\Scripts\\python.exe" - env_pip = _env + "\\Scripts\\pip.exe" + env_python = f"{_env}\\Scripts\\python.exe" + env_pip = f"{_env}\\Scripts\\pip.exe" else: if python_ver == "3": _pExe = "python3" @@ -1134,10 +1133,10 @@ def acceptCITestConfiguration(hostOS, hostOSVer, targetArch, compiler): def get_ci_qmake_path(ci_install_dir, ci_host_os): - qmake_path = "--qmake={}".format(ci_install_dir) + qmake_path = f"--qmake={ci_install_dir}" if ci_host_os == "MacOS": - return qmake_path + "/bin/qmake" + return f"{qmake_path}/bin/qmake" elif ci_host_os == "Windows": - return qmake_path + "\\bin\\qmake.exe" + return f"{qmake_path}\\bin\\qmake.exe" else: - return qmake_path + "/bin/qmake" + return f"{qmake_path}/bin/qmake" diff --git a/build_scripts/wheel_override.py b/build_scripts/wheel_override.py index b5e59cfc2..534ae54e9 100644 --- a/build_scripts/wheel_override.py +++ b/build_scripts/wheel_override.py @@ -102,7 +102,7 @@ class PysideBuildWheel(_bdist_wheel, DistUtilsCommandMixin): # PySide6-5.6-5.6.4-cp27-cp27m-macosx_10_10_intel.whl # The PySide6 version is "5.6". # The Qt version built against is "5.6.4". - wheel_version = "{}-{}".format(self._package_version, get_qt_version()) + wheel_version = f"{self._package_version}-{get_qt_version()}" components = (_safer_name(self.distribution.get_name()), wheel_version) if self.build_number: components += (self.build_number,) @@ -175,7 +175,7 @@ class PysideBuildWheel(_bdist_wheel, DistUtilsCommandMixin): # XXX switch to this alternate implementation for non-pure: if (self.py_limited_api) or (plat_name in ('manylinux1_x86_64')): return tag - assert tag in supported_tags, ("would build wheel with unsupported tag {}".format(tag)) + assert tag in supported_tags, (f"would build wheel with unsupported tag {tag}") return tag # Copy of get_tag from bdist_wheel.py, to write a triplet Tag diff --git a/build_scripts/wheel_utils.py b/build_scripts/wheel_utils.py index d1d349120..a976e2bce 100644 --- a/build_scripts/wheel_utils.py +++ b/build_scripts/wheel_utils.py @@ -65,12 +65,12 @@ def get_qt_version(): qt_version = qtinfo.version if not qt_version: - m = "Failed to query the Qt version with qmake {0}".format(qtinfo.qmake_command) - raise DistutilsSetupError(m) + raise DistutilsSetupError("Failed to query the Qt version with " + f"qmake {qtinfo.qmake_command}") if LooseVersion(qtinfo.version) < LooseVersion("5.7"): - m = "Incompatible Qt version detected: {}. A Qt version >= 5.7 is required.".format(qt_version) - raise DistutilsSetupError(m) + raise DistutilsSetupError(f"Incompatible Qt version detected: {qt_version}. " + "A Qt version >= 5.7 is required.") return qt_version @@ -82,20 +82,19 @@ def get_package_version(): pyside_version_py = os.path.join( setup_script_dir, "sources", PYSIDE, "pyside_version.py") d = get_python_dict(pyside_version_py) - - final_version = "{}.{}.{}".format( - d['major_version'], d['minor_version'], d['patch_version']) + final_version = f"{d['major_version']}.{d['minor_version']}.{d['patch_version']}" release_version_type = d['release_version_type'] pre_release_version = d['pre_release_version'] if pre_release_version and release_version_type: - final_version += release_version_type + pre_release_version + final_version = f"{final_version}{release_version_type}{pre_release_version}" + if release_version_type.startswith("comm"): - final_version += "." + release_version_type + final_version = f"{final_version}.{release_version_type}" # Add the current timestamp to the version number, to suggest it # is a development snapshot build. if OPTION["SNAPSHOT_BUILD"]: - final_version += ".dev{}".format(get_package_timestamp()) + final_version = f"{final_version}.dev{get_package_timestamp()}" return final_version @@ -157,5 +156,5 @@ def macos_plat_name(): deployment_target = macos_pyside_min_deployment_target() # Example triple "macosx-10.12-x86_64". plat = get_platform().split("-") - plat_name = "{}-{}-{}".format(plat[0], deployment_target, plat[2]) + plat_name = f"{plat[0]}-{deployment_target}-{plat[2]}" return plat_name -- cgit v1.2.3