build: replace the usage of reserved Python words

Internally, we were using many words like 'filter', 'vars',
and 'dir' which are built-in functions in Python.
To avoid confusion and a possible wrong behavior, we renamed them.

Change-Id: Idbadda3857705ef3a5f0440112ee923d3a61ffa0
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@qt.io>
(cherry picked from commit eba195611ac30fd490e87a03238060eca05f2073)
Reviewed-by: Qt Cherry-pick Bot <cherrypick_bot@qt-project.org>

8 files changed, 198 insertions, 200 deletions

diff --git a/build_scripts/build_info_collector.py b/build_scripts/build_info_collector.py
index 61eb8197b..6ffa42918 100644
--- a/build_scripts/build_info_collector.py
+++ b/build_scripts/build_info_collector.py
@@ -102,8 +102,8 @@ 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 = f"include/python{py_version}"
-        py_include_dir = os.path.join(py_prefix, dir)
+        directory = f"include/python{py_version}"
+        py_include_dir = os.path.join(py_prefix, directory)
     lib_exts = ['.so']
     if sys.platform == 'darwin':
         lib_exts.append('.dylib')
diff --git a/build_scripts/main.py b/build_scripts/main.py
index ff3957347..cf5a6ff4c 100644
--- a/build_scripts/main.py
+++ b/build_scripts/main.py
@@ -907,7 +907,7 @@ class PysideBuild(_build, DistUtilsCommandMixin, BuildInfoCollectorMixin):
         """
         try:
             log.info("\nPreparing setup tools build directory.\n")
-            vars = {
+            _vars = {
                 "site_packages_dir": self.site_packages_dir,
                 "sources_dir": self.sources_dir,
                 "install_dir": self.install_dir,
@@ -939,7 +939,7 @@ class PysideBuild(_build, DistUtilsCommandMixin, BuildInfoCollectorMixin):
             # 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
+                _vars['cmake_package_name'] = config.shiboken_module_option_name
 
             os.chdir(self.script_dir)
 
@@ -957,10 +957,10 @@ class PysideBuild(_build, DistUtilsCommandMixin, BuildInfoCollectorMixin):
                     log.warn(f'ignored error: {e}')
 
             if sys.platform == "win32":
-                vars['dbg_postfix'] = OPTION["DEBUG"] and "_d" or ""
-                return prepare_packages_win32(self, vars)
+                _vars['dbg_postfix'] = OPTION["DEBUG"] and "_d" or ""
+                return prepare_packages_win32(self, _vars)
             else:
-                return prepare_packages_posix(self, vars)
+                return prepare_packages_posix(self, _vars)
         except IOError as e:
             print('setup.py/prepare_packages: ', e)
             raise
@@ -970,10 +970,10 @@ class PysideBuild(_build, DistUtilsCommandMixin, BuildInfoCollectorMixin):
             return True
         return False
 
-    def get_built_pyside_config(self, vars):
+    def get_built_pyside_config(self, _vars):
         # Get config that contains list of built modules, and
         # SOVERSIONs of the built libraries.
-        st_build_dir = vars['st_build_dir']
+        st_build_dir = _vars['st_build_dir']
         config_path = os.path.join(st_build_dir, config.package_name(), "_config.py")
         temp_config = get_python_dict(config_path)
         if 'built_modules' not in temp_config:
@@ -1042,10 +1042,10 @@ class PysideBuild(_build, DistUtilsCommandMixin, BuildInfoCollectorMixin):
             clang_lib_path = os.path.abspath(clang_lib_path)
 
         # 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 = "{st_build_dir}/{st_package_name}".format(**vars)
+        _vars = {}
+        _vars['st_build_dir'] = self.st_build_dir
+        _vars['st_package_name'] = config.package_name()
+        destination_dir = "{st_build_dir}/{st_package_name}".format(**_vars)
 
         if os.path.exists(clang_lib_path):
             basename = os.path.basename(clang_lib_path)
diff --git a/build_scripts/platforms/linux.py b/build_scripts/platforms/linux.py
index a8d286184..229d4397d 100644
--- a/build_scripts/platforms/linux.py
+++ b/build_scripts/platforms/linux.py
@@ -45,8 +45,8 @@ from ..utils import (copy_icu_libs, copydir, copyfile, find_files_using_glob,
 from ..versions import PYSIDE
 
 
-def prepare_standalone_package_linux(self, vars):
-    built_modules = vars['built_modules']
+def prepare_standalone_package_linux(self, _vars):
+    built_modules = _vars['built_modules']
 
     constrain_modules = None
     copy_plugins = True
@@ -72,13 +72,13 @@ def prepare_standalone_package_linux(self, vars):
     accepted_modules.append("libicu*.so.??")
 
     copydir("{qt_lib_dir}", destination_lib_dir,
-            filter=accepted_modules,
-            recursive=False, vars=vars, force_copy_symlinks=True)
+            _filter=accepted_modules,
+            recursive=False, _vars=_vars, force_copy_symlinks=True)
 
     if should_copy_icu_libs:
         # Check if ICU libraries were copied over to the destination
         # Qt libdir.
-        resolved_destination_lib_dir = destination_lib_dir.format(**vars)
+        resolved_destination_lib_dir = destination_lib_dir.format(**_vars)
         maybe_icu_libs = find_files_using_glob(resolved_destination_lib_dir, "libicu*")
 
         # If no ICU libraries are present in the Qt libdir (like when
@@ -92,39 +92,39 @@ def prepare_standalone_package_linux(self, vars):
             copy_icu_libs(self._patchelf_path, resolved_destination_lib_dir)
 
     # Set RPATH for Qt libs.
-    self.update_rpath_for_linux_qt_libraries(destination_lib_dir.format(**vars))
+    self.update_rpath_for_linux_qt_libraries(destination_lib_dir.format(**_vars))
 
     # Patching designer to use the Qt libraries provided in the wheel
     if config.is_internal_pyside_build():
-        assistant_path = "{st_build_dir}/{st_package_name}/assistant".format(**vars)
+        assistant_path = "{st_build_dir}/{st_package_name}/assistant".format(**_vars)
         linux_patch_executable(self._patchelf_path, assistant_path)
-        designer_path = "{st_build_dir}/{st_package_name}/designer".format(**vars)
+        designer_path = "{st_build_dir}/{st_package_name}/designer".format(**_vars)
         linux_patch_executable(self._patchelf_path, designer_path)
 
     if self.is_webengine_built(built_modules):
         copydir("{qt_data_dir}/resources",
                 "{st_build_dir}/{st_package_name}/Qt/resources",
-                filter=None,
+                _filter=None,
                 recursive=False,
-                vars=vars)
+                _vars=_vars)
 
     if copy_plugins:
         is_pypy = "pypy" in self.build_classifiers
         # <qt>/plugins/* -> <setup>/{st_package_name}/Qt/plugins
         plugins_target = "{st_build_dir}/{st_package_name}/Qt/plugins"
         copydir("{qt_plugins_dir}", plugins_target,
-                filter=["*.so"],
+                _filter=["*.so"],
                 recursive=True,
-                vars=vars)
+                _vars=_vars)
         if not is_pypy:
             copydir("{install_dir}/plugins/designer",
                     f"{plugins_target}/designer",
-                    filter=["*.so"],
+                    _filter=["*.so"],
                     recursive=False,
-                    vars=vars)
+                    _vars=_vars)
 
         copied_plugins = self.get_shared_libraries_in_path_recursively(
-            plugins_target.format(**vars))
+            plugins_target.format(**_vars))
         self.update_rpath_for_linux_plugins(copied_plugins)
 
     if copy_qml:
@@ -132,16 +132,16 @@ def prepare_standalone_package_linux(self, vars):
         qml_plugins_target = "{st_build_dir}/{st_package_name}/Qt/qml"
         copydir("{qt_qml_dir}",
                 qml_plugins_target,
-                filter=None,
+                _filter=None,
                 force=False,
                 recursive=True,
                 ignore=["*.debug"],
-                vars=vars)
+                _vars=_vars)
         copied_plugins = self.get_shared_libraries_in_path_recursively(
-            qml_plugins_target.format(**vars))
+            qml_plugins_target.format(**_vars))
         self.update_rpath_for_linux_plugins(
             copied_plugins,
-            qt_lib_dir=destination_lib_dir.format(**vars),
+            qt_lib_dir=destination_lib_dir.format(**_vars),
             is_qml_plugin=True)
 
     if copy_translations:
@@ -149,14 +149,14 @@ def prepare_standalone_package_linux(self, vars):
         # <setup>/{st_package_name}/Qt/translations
         copydir("{qt_translations_dir}",
                 "{st_build_dir}/{st_package_name}/Qt/translations",
-                filter=["*.qm", "*.pak"],
+                _filter=["*.qm", "*.pak"],
                 force=False,
-                vars=vars)
+                _vars=_vars)
 
     if copy_qt_conf:
         # Copy the qt.conf file to libexec.
-        qt_libexec_path = "{st_build_dir}/{st_package_name}/Qt/libexec".format(**vars)
+        qt_libexec_path = "{st_build_dir}/{st_package_name}/Qt/libexec".format(**_vars)
         if not os.path.isdir(qt_libexec_path):
             os.makedirs(qt_libexec_path)
         copyfile(f"{{build_dir}}/{PYSIDE}/{{st_package_name}}/qt.conf",
-                 qt_libexec_path, vars=vars)
+                 qt_libexec_path, _vars=_vars)
diff --git a/build_scripts/platforms/macos.py b/build_scripts/platforms/macos.py
index 2429ef13f..0f615991c 100644
--- a/build_scripts/platforms/macos.py
+++ b/build_scripts/platforms/macos.py
@@ -46,17 +46,17 @@ from ..utils import (copydir, copyfile, macos_add_rpath,
 from ..versions import PYSIDE
 
 
-def _macos_patch_executable(name, vars=None):
+def _macos_patch_executable(name, _vars=None):
     """ Patch an executable to run with the Qt libraries. """
     upper_name = name[0:1].upper() + name[1:]
-    bundle = f"{{st_build_dir}}/{{st_package_name}}/{upper_name}.app".format(**vars)
+    bundle = f"{{st_build_dir}}/{{st_package_name}}/{upper_name}.app".format(**_vars)
     binary = f"{bundle}/Contents/MacOS/{upper_name}"
     rpath = "@loader_path/../../../Qt/lib"
     macos_add_rpath(rpath, binary)
 
 
-def prepare_standalone_package_macos(self, vars):
-    built_modules = vars['built_modules']
+def prepare_standalone_package_macos(self, _vars):
+    built_modules = _vars['built_modules']
 
     constrain_modules = None
     copy_plugins = True
@@ -91,9 +91,9 @@ def prepare_standalone_package_macos(self, vars):
 
     # Patching designer to use the Qt libraries provided in the wheel
     if config.is_internal_pyside_build():
-        _macos_patch_executable('assistant', vars)
-        _macos_patch_executable('designer', vars)
-        _macos_patch_executable('linguist', vars)
+        _macos_patch_executable('assistant', _vars)
+        _macos_patch_executable('designer', _vars)
+        _macos_patch_executable('linguist', _vars)
 
     # <qt>/lib/* -> <setup>/{st_package_name}/Qt/lib
     if self.qt_is_framework_build():
@@ -129,7 +129,7 @@ def prepare_standalone_package_macos(self, vars):
             return True
 
         copydir("{qt_lib_dir}", "{st_build_dir}/{st_package_name}/Qt/lib",
-                recursive=True, vars=vars,
+                recursive=True, _vars=_vars,
                 ignore=["*.la", "*.a", "*.cmake", "*.pc", "*.prl"],
                 dir_filter_function=framework_dir_filter,
                 file_filter_function=framework_variant_filter)
@@ -139,7 +139,7 @@ def prepare_standalone_package_macos(self, vars):
         # from Versions/5/Helpers, thus adding two more levels of
         # directory hierarchy.
         if self.is_webengine_built(built_modules):
-            qt_lib_path = "{st_build_dir}/{st_package_name}/Qt/lib".format(**vars)
+            qt_lib_path = "{st_build_dir}/{st_package_name}/Qt/lib".format(**_vars)
             bundle = "QtWebEngineCore.framework/Helpers/"
             bundle += "QtWebEngineProcess.app"
             binary = "Contents/MacOS/QtWebEngineProcess"
@@ -157,20 +157,20 @@ def prepare_standalone_package_macos(self, vars):
 
         copydir("{qt_lib_dir}",
                 "{st_build_dir}/{st_package_name}/Qt/lib",
-                filter=accepted_modules,
+                _filter=accepted_modules,
                 ignore=ignored_modules,
                 file_filter_function=file_variant_filter,
-                recursive=True, vars=vars, force_copy_symlinks=True)
+                recursive=True, _vars=_vars, force_copy_symlinks=True)
 
         if self.is_webengine_built(built_modules):
             copydir("{qt_data_dir}/resources",
                     "{st_build_dir}/{st_package_name}/Qt/resources",
-                    filter=None,
+                    _filter=None,
                     recursive=False,
-                    vars=vars)
+                    _vars=_vars)
 
             # Fix rpath for WebEngine process executable.
-            qt_libexec_path = "{st_build_dir}/{st_package_name}/Qt/libexec".format(**vars)
+            qt_libexec_path = "{st_build_dir}/{st_package_name}/Qt/libexec".format(**_vars)
             binary = "QtWebEngineProcess"
             final_path = os.path.join(qt_libexec_path, binary)
             rpath = "@loader_path/../lib"
@@ -182,7 +182,7 @@ def prepare_standalone_package_macos(self, vars):
                     os.makedirs(qt_libexec_path)
                 copyfile(
                     f"{{build_dir}}/{PYSIDE}/{{st_package_name}}/qt.conf",
-                    qt_libexec_path, vars=vars)
+                    qt_libexec_path, _vars=_vars)
 
     if copy_plugins:
         is_pypy = "pypy" in self.build_classifiers
@@ -190,34 +190,34 @@ def prepare_standalone_package_macos(self, vars):
         plugins_target = "{st_build_dir}/{st_package_name}/Qt/plugins"
         filters = ["*.dylib"]
         copydir("{qt_plugins_dir}", plugins_target,
-                filter=filters,
+                _filter=filters,
                 recursive=True,
                 dir_filter_function=general_dir_filter,
                 file_filter_function=file_variant_filter,
-                vars=vars)
+                _vars=_vars)
         if not is_pypy:
             copydir("{install_dir}/plugins/designer",
                     f"{plugins_target}/designer",
-                    filter=filters,
+                    _filter=filters,
                     recursive=False,
-                    vars=vars)
+                    _vars=_vars)
 
     if copy_qml:
         # <qt>/qml/* -> <setup>/{st_package_name}/Qt/qml
         copydir("{qt_qml_dir}",
                 "{st_build_dir}/{st_package_name}/Qt/qml",
-                filter=None,
+                _filter=None,
                 recursive=True,
                 force=False,
                 dir_filter_function=general_dir_filter,
                 file_filter_function=file_variant_filter,
-                vars=vars)
+                _vars=_vars)
 
     if copy_translations:
         # <qt>/translations/* ->
         # <setup>/{st_package_name}/Qt/translations
         copydir("{qt_translations_dir}",
                 "{st_build_dir}/{st_package_name}/Qt/translations",
-                filter=["*.qm", "*.pak"],
+                _filter=["*.qm", "*.pak"],
                 force=False,
-                vars=vars)
+                _vars=_vars)
diff --git a/build_scripts/platforms/unix.py b/build_scripts/platforms/unix.py
index 0772cc625..dd7a1510d 100644
--- a/build_scripts/platforms/unix.py
+++ b/build_scripts/platforms/unix.py
@@ -49,32 +49,32 @@ from .linux import prepare_standalone_package_linux
 from .macos import prepare_standalone_package_macos
 
 
-def _macos_copy_gui_executable(name, vars=None):
+def _macos_copy_gui_executable(name, _vars=None):
     """macOS helper: Copy a GUI executable from the .app folder and return the
        files"""
     app_name = name[:1].upper() + name[1:] + '.app'
     return copydir(f"{{install_dir}}/bin/{app_name}",
                    f"{{st_build_dir}}/{{st_package_name}}/{app_name}",
-                   filter=None, recursive=True,
-                   force=False, vars=vars)
+                   _filter=None, recursive=True,
+                   force=False, _vars=_vars)
 
 
-def _unix_copy_gui_executable(name, vars=None):
+def _unix_copy_gui_executable(name, _vars=None):
     """UNIX helper: Copy a GUI executable and return the files"""
     return copydir("{install_dir}/bin/",
                    "{st_build_dir}/{st_package_name}/",
-                   filter=[name],
-                   force=False, vars=vars)
+                   _filter=[name],
+                   force=False, _vars=_vars)
 
 
-def _copy_gui_executable(name, vars=None):
+def _copy_gui_executable(name, _vars=None):
     """Copy a GUI executable and return the files"""
     if sys.platform == 'darwin':
-        return _macos_copy_gui_executable(name, vars)
-    return _unix_copy_gui_executable(name, vars)
+        return _macos_copy_gui_executable(name, _vars)
+    return _unix_copy_gui_executable(name, _vars)
 
 
-def prepare_packages_posix(self, vars):
+def prepare_packages_posix(self, _vars):
     executables = []
     libexec_executables = []
 
@@ -85,9 +85,9 @@ def prepare_packages_posix(self, vars):
     copydir(
         "{site_packages_dir}/{st_package_name}",
         "{st_build_dir}/{st_package_name}",
-        vars=vars)
+        _vars=_vars)
 
-    generated_config = self.get_built_pyside_config(vars)
+    generated_config = self.get_built_pyside_config(_vars)
 
     def adjusted_lib_name(name, version):
         postfix = ''
@@ -103,61 +103,61 @@ def prepare_packages_posix(self, vars):
         copydir(
             f"{{build_dir}}/{SHIBOKEN}/doc/html",
             f"{{st_build_dir}}/{{st_package_name}}/docs/{SHIBOKEN}",
-            force=False, vars=vars)
+            force=False, _vars=_vars)
 
         # <install>/lib/lib* -> {st_package_name}/
         copydir(
             "{install_dir}/lib/",
             "{st_build_dir}/{st_package_name}",
-            filter=[
+            _filter=[
                 adjusted_lib_name("libshiboken*",
                                   generated_config['shiboken_library_soversion']),
             ],
-            recursive=False, vars=vars, force_copy_symlinks=True)
+            recursive=False, _vars=_vars, force_copy_symlinks=True)
 
     if config.is_internal_shiboken_generator_build():
         # <install>/bin/* -> {st_package_name}/
         executables.extend(copydir(
             "{install_dir}/bin/",
             "{st_build_dir}/{st_package_name}",
-            filter=[SHIBOKEN],
-            recursive=False, vars=vars))
+            _filter=[SHIBOKEN],
+            recursive=False, _vars=_vars))
 
         # Used to create scripts directory.
         makefile(
             "{st_build_dir}/{st_package_name}/scripts/shiboken_tool.py",
-            vars=vars)
+            _vars=_vars)
 
         # For setting up setuptools entry points.
         copyfile(
             "{install_dir}/bin/shiboken_tool.py",
             "{st_build_dir}/{st_package_name}/scripts/shiboken_tool.py",
-            force=False, vars=vars)
+            force=False, _vars=_vars)
 
     if config.is_internal_shiboken_generator_build() or config.is_internal_pyside_build():
         # <install>/include/* -> <setup>/{st_package_name}/include
         copydir(
             "{install_dir}/include/{cmake_package_name}",
             "{st_build_dir}/{st_package_name}/include",
-            vars=vars)
+            _vars=_vars)
 
     if config.is_internal_pyside_build():
         makefile(
             "{st_build_dir}/{st_package_name}/scripts/__init__.py",
-            vars=vars)
+            _vars=_vars)
 
         # For setting up setuptools entry points
         for script in ("pyside_tool.py", "metaobjectdump.py", "project.py"):
             src = f"{{install_dir}}/bin/{script}"
             target = f"{{st_build_dir}}/{{st_package_name}}/scripts/{script}"
-            copyfile(src, target, force=False, vars=vars)
+            copyfile(src, target, force=False, _vars=_vars)
 
         # <install>/bin/* -> {st_package_name}/
         executables.extend(copydir(
             "{install_dir}/bin/",
             "{st_build_dir}/{st_package_name}",
-            filter=[f"{PYSIDE}-lupdate"],
-            recursive=False, vars=vars))
+            _filter=[f"{PYSIDE}-lupdate"],
+            recursive=False, _vars=_vars))
 
         lib_exec_filters = []
         if not OPTION['NO_QT_TOOLS']:
@@ -165,68 +165,68 @@ def prepare_packages_posix(self, vars):
             executables.extend(copydir(
                 "{install_dir}/bin/",
                 "{st_build_dir}/{st_package_name}",
-                filter=["lrelease", "lupdate", "qmllint"],
-                recursive=False, vars=vars))
+                _filter=["lrelease", "lupdate", "qmllint"],
+                recursive=False, _vars=_vars))
             # Copying assistant/designer
-            executables.extend(_copy_gui_executable('assistant', vars=vars))
-            executables.extend(_copy_gui_executable('designer', vars=vars))
-            executables.extend(_copy_gui_executable('linguist', vars=vars))
+            executables.extend(_copy_gui_executable('assistant', _vars=_vars))
+            executables.extend(_copy_gui_executable('designer', _vars=_vars))
+            executables.extend(_copy_gui_executable('linguist', _vars=_vars))
 
         # <qt>/lib/metatypes/* -> <setup>/{st_package_name}/Qt/lib/metatypes
         destination_lib_dir = "{st_build_dir}/{st_package_name}/Qt/lib"
         copydir("{qt_lib_dir}/metatypes", f"{destination_lib_dir}/metatypes",
-                filter=["*.json"],
-                recursive=False, vars=vars, force_copy_symlinks=True)
+                _filter=["*.json"],
+                recursive=False, _vars=_vars, force_copy_symlinks=True)
 
         # Copy libexec
-        built_modules = self.get_built_pyside_config(vars)['built_modules']
+        built_modules = self.get_built_pyside_config(_vars)['built_modules']
         if self.is_webengine_built(built_modules):
             lib_exec_filters.append('QtWebEngineProcess')
         if lib_exec_filters:
             libexec_executables.extend(copydir("{qt_lib_execs_dir}",
                                                "{st_build_dir}/{st_package_name}/Qt/libexec",
-                                               filter=lib_exec_filters,
+                                               _filter=lib_exec_filters,
                                                recursive=False,
-                                               vars=vars))
+                                               _vars=_vars))
 
         # <install>/lib/lib* -> {st_package_name}/
         copydir(
             "{install_dir}/lib/",
             "{st_build_dir}/{st_package_name}",
-            filter=[
+            _filter=[
                 adjusted_lib_name("libpyside*",
                                   generated_config['pyside_library_soversion']),
             ],
-            recursive=False, vars=vars, force_copy_symlinks=True)
+            recursive=False, _vars=_vars, force_copy_symlinks=True)
 
         # <install>/share/{st_package_name}/typesystems/* ->
         #   <setup>/{st_package_name}/typesystems
         copydir(
             "{install_dir}/share/{st_package_name}/typesystems",
             "{st_build_dir}/{st_package_name}/typesystems",
-            vars=vars)
+            _vars=_vars)
 
         # <install>/share/{st_package_name}/glue/* ->
         #   <setup>/{st_package_name}/glue
         copydir(
             "{install_dir}/share/{st_package_name}/glue",
             "{st_build_dir}/{st_package_name}/glue",
-            vars=vars)
+            _vars=_vars)
 
         # <source>/pyside6/{st_package_name}/support/* ->
         #   <setup>/{st_package_name}/support/*
         copydir(
             f"{{build_dir}}/{PYSIDE}/{{st_package_name}}/support",
             "{st_build_dir}/{st_package_name}/support",
-            vars=vars)
+            _vars=_vars)
 
         # <source>/pyside6/{st_package_name}/*.pyi ->
         #   <setup>/{st_package_name}/*.pyi
         copydir(
             f"{{build_dir}}/{PYSIDE}/{{st_package_name}}",
             "{st_build_dir}/{st_package_name}",
-            filter=["*.pyi", "py.typed"],
-            vars=vars)
+            _filter=["*.pyi", "py.typed"],
+            _vars=_vars)
 
         if not OPTION["NOEXAMPLES"]:
             def pycache_dir_filter(dir_name, parent_full_path, dir_full_path):
@@ -236,16 +236,16 @@ def prepare_packages_posix(self, vars):
             # examples/* -> <setup>/{st_package_name}/examples
             copydir(os.path.join(self.script_dir, "examples"),
                     "{st_build_dir}/{st_package_name}/examples",
-                    force=False, vars=vars, dir_filter_function=pycache_dir_filter)
+                    force=False, _vars=_vars, dir_filter_function=pycache_dir_filter)
 
     # Copy Qt libs to package
     if OPTION["STANDALONE"]:
         if config.is_internal_pyside_build() or config.is_internal_shiboken_generator_build():
-            vars['built_modules'] = generated_config['built_modules']
+            _vars['built_modules'] = generated_config['built_modules']
             if sys.platform == 'darwin':
-                prepare_standalone_package_macos(self, vars)
+                prepare_standalone_package_macos(self, _vars)
             else:
-                prepare_standalone_package_linux(self, vars)
+                prepare_standalone_package_linux(self, _vars)
 
         if config.is_internal_shiboken_generator_build():
             # Copy over clang before rpath patching.
@@ -253,7 +253,7 @@ def prepare_packages_posix(self, vars):
 
     # Update rpath to $ORIGIN
     if sys.platform.startswith('linux') or sys.platform.startswith('darwin'):
-        rpath_path = "{st_build_dir}/{st_package_name}".format(**vars)
+        rpath_path = "{st_build_dir}/{st_package_name}".format(**_vars)
         self.update_rpath(rpath_path, executables)
         self.update_rpath(rpath_path, self.package_libraries(rpath_path))
         if libexec_executables:
diff --git a/build_scripts/platforms/windows_desktop.py b/build_scripts/platforms/windows_desktop.py
index 7b96e42a9..2c801a0a7 100644
--- a/build_scripts/platforms/windows_desktop.py
+++ b/build_scripts/platforms/windows_desktop.py
@@ -48,7 +48,7 @@ from ..utils import (copydir, copyfile, download_and_extract_7z, filter_match,
 from ..versions import PYSIDE, SHIBOKEN
 
 
-def prepare_packages_win32(self, vars):
+def prepare_packages_win32(self, _vars):
     # For now, debug symbols will not be shipped into the package.
     copy_pdbs = False
     pdbs = []
@@ -62,7 +62,7 @@ def prepare_packages_win32(self, vars):
     copydir(
         "{site_packages_dir}/{st_package_name}",
         "{st_build_dir}/{st_package_name}",
-        vars=vars)
+        _vars=_vars)
 
     if config.is_internal_shiboken_module_build():
         # <build>/shiboken6/doc/html/* ->
@@ -70,21 +70,21 @@ def prepare_packages_win32(self, vars):
         copydir(
             f"{{build_dir}}/{SHIBOKEN}/doc/html",
             f"{{st_build_dir}}/{{st_package_name}}/docs/{SHIBOKEN}",
-            force=False, vars=vars)
+            force=False, _vars=_vars)
 
         # <install>/bin/*.dll -> {st_package_name}/
         copydir(
             "{install_dir}/bin/",
             "{st_build_dir}/{st_package_name}",
-            filter=["shiboken*.dll"],
-            recursive=False, vars=vars)
+            _filter=["shiboken*.dll"],
+            recursive=False, _vars=_vars)
 
         # <install>/lib/*.lib -> {st_package_name}/
         copydir(
             "{install_dir}/lib/",
             "{st_build_dir}/{st_package_name}",
-            filter=["shiboken*.lib"],
-            recursive=False, vars=vars)
+            _filter=["shiboken*.lib"],
+            recursive=False, _vars=_vars)
 
         # @TODO: Fix this .pdb file not to overwrite release
         # {shibokengenerator}.pdb file.
@@ -92,34 +92,34 @@ def prepare_packages_win32(self, vars):
         copydir(
             f"{{build_dir}}/{SHIBOKEN}/shibokenmodule",
             "{st_build_dir}/{st_package_name}",
-            filter=pdbs,
-            recursive=False, vars=vars)
+            _filter=pdbs,
+            recursive=False, _vars=_vars)
 
         # pdb files for libshiboken and libpyside
         copydir(
             f"{{build_dir}}/{SHIBOKEN}/libshiboken",
             "{st_build_dir}/{st_package_name}",
-            filter=pdbs,
-            recursive=False, vars=vars)
+            _filter=pdbs,
+            recursive=False, _vars=_vars)
 
     if config.is_internal_shiboken_generator_build():
         # <install>/bin/*.dll -> {st_package_name}/
         copydir(
             "{install_dir}/bin/",
             "{st_build_dir}/{st_package_name}",
-            filter=["shiboken*.exe"],
-            recursive=False, vars=vars)
+            _filter=["shiboken*.exe"],
+            recursive=False, _vars=_vars)
 
         # Used to create scripts directory.
         makefile(
             "{st_build_dir}/{st_package_name}/scripts/shiboken_tool.py",
-            vars=vars)
+            _vars=_vars)
 
         # For setting up setuptools entry points.
         copyfile(
             "{install_dir}/bin/shiboken_tool.py",
             "{st_build_dir}/{st_package_name}/scripts/shiboken_tool.py",
-            force=False, vars=vars)
+            force=False, _vars=_vars)
 
         # @TODO: Fix this .pdb file not to overwrite release
         # {shibokenmodule}.pdb file.
@@ -127,15 +127,15 @@ def prepare_packages_win32(self, vars):
         copydir(
             f"{{build_dir}}/{SHIBOKEN}/generator",
             "{st_build_dir}/{st_package_name}",
-            filter=pdbs,
-            recursive=False, vars=vars)
+            _filter=pdbs,
+            recursive=False, _vars=_vars)
 
     if config.is_internal_shiboken_generator_build() or config.is_internal_pyside_build():
         # <install>/include/* -> <setup>/{st_package_name}/include
         copydir(
             "{install_dir}/include/{cmake_package_name}",
             "{st_build_dir}/{st_package_name}/include",
-            vars=vars)
+            _vars=_vars)
 
     if config.is_internal_pyside_build():
         # <build>/pyside6/{st_package_name}/*.pdb ->
@@ -143,18 +143,18 @@ def prepare_packages_win32(self, vars):
         copydir(
             f"{{build_dir}}/{PYSIDE}/{{st_package_name}}",
             "{st_build_dir}/{st_package_name}",
-            filter=pdbs,
-            recursive=False, vars=vars)
+            _filter=pdbs,
+            recursive=False, _vars=_vars)
 
         makefile(
             "{st_build_dir}/{st_package_name}/scripts/__init__.py",
-            vars=vars)
+            _vars=_vars)
 
         # For setting up setuptools entry points
         for script in ("pyside_tool.py", "metaobjectdump.py", "project.py"):
             src = f"{{install_dir}}/bin/{script}"
             target = f"{{st_build_dir}}/{{st_package_name}}/scripts/{script}"
-            copyfile(src, target, force=False, vars=vars)
+            copyfile(src, target, force=False, _vars=_vars)
 
         # <install>/bin/*.exe,*.dll -> {st_package_name}/
         filters = ["pyside*.exe", "pyside*.dll"]
@@ -166,56 +166,56 @@ def prepare_packages_win32(self, vars):
         copydir(
             "{install_dir}/bin/",
             "{st_build_dir}/{st_package_name}",
-            filter=filters,
-            recursive=False, vars=vars)
+            _filter=filters,
+            recursive=False, _vars=_vars)
 
         # <qt>/lib/metatypes/* -> <setup>/{st_package_name}/lib/metatypes
         destination_lib_dir = "{st_build_dir}/{st_package_name}/lib"
         copydir("{qt_lib_dir}/metatypes", f"{destination_lib_dir}/metatypes",
-                filter=["*.json"],
-                recursive=False, vars=vars)
+                _filter=["*.json"],
+                recursive=False, _vars=_vars)
 
         # <install>/lib/*.lib -> {st_package_name}/
         copydir(
             "{install_dir}/lib/",
             "{st_build_dir}/{st_package_name}",
-            filter=["pyside*.lib"],
-            recursive=False, vars=vars)
+            _filter=["pyside*.lib"],
+            recursive=False, _vars=_vars)
 
         # <install>/share/{st_package_name}/typesystems/* ->
         #   <setup>/{st_package_name}/typesystems
         copydir(
             "{install_dir}/share/{st_package_name}/typesystems",
             "{st_build_dir}/{st_package_name}/typesystems",
-            vars=vars)
+            _vars=_vars)
 
         # <install>/share/{st_package_name}/glue/* ->
         #   <setup>/{st_package_name}/glue
         copydir(
             "{install_dir}/share/{st_package_name}/glue",
             "{st_build_dir}/{st_package_name}/glue",
-            vars=vars)
+            _vars=_vars)
 
         # <source>/pyside6/{st_package_name}/support/* ->
         #   <setup>/{st_package_name}/support/*
         copydir(
             f"{{build_dir}}/{PYSIDE}/{{st_package_name}}/support",
             "{st_build_dir}/{st_package_name}/support",
-            vars=vars)
+            _vars=_vars)
 
         # <source>/pyside6/{st_package_name}/*.pyi ->
         #   <setup>/{st_package_name}/*.pyi
         copydir(
             f"{{build_dir}}/{PYSIDE}/{{st_package_name}}",
             "{st_build_dir}/{st_package_name}",
-            filter=["*.pyi", "py.typed"],
-            vars=vars)
+            _filter=["*.pyi", "py.typed"],
+            _vars=_vars)
 
         copydir(
             f"{{build_dir}}/{PYSIDE}/libpyside",
             "{st_build_dir}/{st_package_name}",
-            filter=pdbs,
-            recursive=False, vars=vars)
+            _filter=pdbs,
+            recursive=False, _vars=_vars)
 
         if not OPTION["NOEXAMPLES"]:
             def pycache_dir_filter(dir_name, parent_full_path, dir_full_path):
@@ -225,27 +225,27 @@ def prepare_packages_win32(self, vars):
             # examples/* -> <setup>/{st_package_name}/examples
             copydir(os.path.join(self.script_dir, "examples"),
                     "{st_build_dir}/{st_package_name}/examples",
-                    force=False, vars=vars, dir_filter_function=pycache_dir_filter)
+                    force=False, _vars=_vars, dir_filter_function=pycache_dir_filter)
 
-        if vars['ssl_libs_dir']:
+        if _vars['ssl_libs_dir']:
             # <ssl_libs>/* -> <setup>/{st_package_name}/openssl
             copydir("{ssl_libs_dir}", "{st_build_dir}/{st_package_name}/openssl",
-                    filter=[
+                    _filter=[
                         "libeay32.dll",
                         "ssleay32.dll"],
-                    force=False, vars=vars)
+                    force=False, _vars=_vars)
 
     if config.is_internal_shiboken_module_build():
         # The C++ std library dlls need to be packaged with the
         # shiboken module, because libshiboken uses C++ code.
-        copy_msvc_redist_files(vars, "{build_dir}/msvc_redist".format(**vars))
+        copy_msvc_redist_files(_vars, "{build_dir}/msvc_redist".format(**_vars))
 
     if config.is_internal_pyside_build() or config.is_internal_shiboken_generator_build():
-        copy_qt_artifacts(self, copy_pdbs, vars)
-        copy_msvc_redist_files(vars, "{build_dir}/msvc_redist".format(**vars))
+        copy_qt_artifacts(self, copy_pdbs, _vars)
+        copy_msvc_redist_files(_vars, "{build_dir}/msvc_redist".format(**_vars))
 
 
-def copy_msvc_redist_files(vars, redist_target_path):
+def copy_msvc_redist_files(_vars, redist_target_path):
     # MSVC redistributable file list.
     msvc_redist = [
         "concrt140.dll",
@@ -270,7 +270,7 @@ def copy_msvc_redist_files(vars, redist_target_path):
     if in_coin is not None:
         redist_url = "https://download.qt.io/development_releases/prebuilt/vcredist/"
         zip_file = "pyside_qt_deps_64_2019.7z"
-        if "{target_arch}".format(**vars) == "32":
+        if "{target_arch}".format(**_vars) == "32":
             zip_file = "pyside_qt_deps_32_2019.7z"
         try:
             download_and_extract_7z(redist_url + zip_file, redist_target_path)
@@ -284,11 +284,11 @@ def copy_msvc_redist_files(vars, redist_target_path):
 
     copydir(redist_target_path,
             "{st_build_dir}/{st_package_name}",
-            filter=msvc_redist, recursive=False, vars=vars)
+            _filter=msvc_redist, recursive=False, _vars=_vars)
 
 
-def copy_qt_artifacts(self, copy_pdbs, vars):
-    built_modules = self.get_built_pyside_config(vars)['built_modules']
+def copy_qt_artifacts(self, copy_pdbs, _vars):
+    built_modules = self.get_built_pyside_config(_vars)['built_modules']
 
     constrain_modules = None
     copy_plugins = True
@@ -344,12 +344,12 @@ def copy_qt_artifacts(self, copy_pdbs, vars):
         # because the extracted archive also contains the opengl32sw
         # and the d3dcompiler dlls, which are copied not by this
         # function, but by the copydir below.
-        copy_msvc_redist_files(vars, "{qt_bin_dir}".format(**vars))
+        copy_msvc_redist_files(_vars, "{qt_bin_dir}".format(**_vars))
 
     if artifacts:
         copydir("{qt_bin_dir}",
                 "{st_build_dir}/{st_package_name}",
-                filter=artifacts, recursive=False, vars=vars)
+                _filter=artifacts, recursive=False, _vars=_vars)
 
     # <qt>/bin/*.dll and Qt *.pdbs -> <setup>/{st_package_name} part two
     # File filter to copy only debug or only release files.
@@ -388,27 +388,25 @@ def copy_qt_artifacts(self, copy_pdbs, vars):
         # file is a debug or release file.
 
         # e.g. ["Qt6Cored", ".dll"]
-        file_split = os.path.splitext(file_name)
-        file_base_name = file_split[0]
-        file_ext = file_split[1]
+        file_base_name, file_ext = os.path.splitext(file_name)
         # e.g. "/home/work/qt/qtbase/bin"
         file_path_dir_name = os.path.dirname(file_full_path)
         # e.g. "Qt6Coredd"
         maybe_debug_name = f"{file_base_name}d"
         if self.debug:
-            filter = debug
+            _filter = debug
 
             def predicate(path):
                 return not os.path.exists(path)
         else:
-            filter = release
+            _filter = release
 
             def predicate(path):
                 return os.path.exists(path)
         # e.g. "/home/work/qt/qtbase/bin/Qt6Coredd.dll"
         other_config_path = os.path.join(file_path_dir_name, maybe_debug_name + file_ext)
 
-        if (filter_match(file_name, filter) and predicate(other_config_path)):
+        if (filter_match(file_name, _filter) and predicate(other_config_path)):
             return True
         return False
 
@@ -417,7 +415,7 @@ def copy_qt_artifacts(self, copy_pdbs, vars):
     copydir("{qt_bin_dir}",
             "{st_build_dir}/{st_package_name}",
             file_filter_function=qt_dll_filter,
-            recursive=False, vars=vars)
+            recursive=False, _vars=_vars)
 
     if copy_plugins:
         is_pypy = "pypy" in self.build_classifiers
@@ -430,21 +428,21 @@ def copy_qt_artifacts(self, copy_pdbs, vars):
         plugin_dll_filter = functools.partial(qt_build_config_filter, plugin_dll_patterns)
         copydir("{qt_plugins_dir}", plugins_target,
                 file_filter_function=plugin_dll_filter,
-                vars=vars)
+                _vars=_vars)
         if not is_pypy:
             copydir("{install_dir}/plugins/designer",
                     f"{plugins_target}/designer",
-                    filter=["*.dll"],
+                    _filter=["*.dll"],
                     recursive=False,
-                    vars=vars)
+                    _vars=_vars)
 
     if copy_translations:
         # <qt>/translations/* -> <setup>/{st_package_name}/translations
         copydir("{qt_translations_dir}",
                 "{st_build_dir}/{st_package_name}/translations",
-                filter=["*.qm", "*.pak"],
+                _filter=["*.qm", "*.pak"],
                 force=False,
-                vars=vars)
+                _vars=_vars)
 
     if copy_qml:
         # <qt>/qml/* -> <setup>/{st_package_name}/qml
@@ -457,7 +455,7 @@ def copy_qt_artifacts(self, copy_pdbs, vars):
                 ignore=qml_ignore,
                 force=False,
                 recursive=True,
-                vars=vars)
+                _vars=_vars)
 
         if copy_pdbs:
             qml_dll_patterns += [pdb_pattern]
@@ -468,27 +466,27 @@ def copy_qt_artifacts(self, copy_pdbs, vars):
                 file_filter_function=qml_dll_filter,
                 force=False,
                 recursive=True,
-                vars=vars)
+                _vars=_vars)
 
     if self.is_webengine_built(built_modules):
         copydir("{qt_data_dir}/resources",
                 "{st_build_dir}/{st_package_name}/resources",
-                filter=None,
+                _filter=None,
                 recursive=False,
-                vars=vars)
+                _vars=_vars)
 
-        filter = 'QtWebEngineProcess{}.exe'.format(
+        _filter = 'QtWebEngineProcess{}.exe'.format(
             'd' if self.debug else '')
         copydir("{qt_bin_dir}",
                 "{st_build_dir}/{st_package_name}",
-                filter=[filter],
-                recursive=False, vars=vars)
+                _filter=[_filter],
+                recursive=False, _vars=_vars)
 
     if copy_qt_conf:
         # Copy the qt.conf file to prefix dir.
         copyfile(f"{{build_dir}}/{PYSIDE}/{{st_package_name}}/qt.conf",
                  "{st_build_dir}/{st_package_name}",
-                 vars=vars)
+                 _vars=_vars)
 
     if copy_clang:
         self.prepare_standalone_clang(is_win=True)
diff --git a/build_scripts/qp5_tool.py b/build_scripts/qp5_tool.py
index ac9dab457..4e8c09bf6 100644
--- a/build_scripts/qp5_tool.py
+++ b/build_scripts/qp5_tool.py
@@ -126,8 +126,8 @@ def which(needle):
     return None
 
 
-def command_log_string(args, dir):
-    result = f'[{os.path.basename(dir)}]'
+def command_log_string(args, directory):
+    result = f'[{os.path.basename(directory)}]'
     for arg in args:
         result += f' "{arg}"' if ' ' in arg else f' {arg}'
     return result
diff --git a/build_scripts/utils.py b/build_scripts/utils.py
index 77e78bf3e..7c254c376 100644
--- a/build_scripts/utils.py
+++ b/build_scripts/utils.py
@@ -264,11 +264,11 @@ def platform_cmake_options(as_tuple_list=False):
     return result
 
 
-def copyfile(src, dst, force=True, vars=None, force_copy_symlink=False,
+def copyfile(src, dst, force=True, _vars=None, force_copy_symlink=False,
              make_writable_by_owner=False):
-    if vars is not None:
-        src = src.format(**vars)
-        dst = dst.format(**vars)
+    if _vars is not None:
+        src = src.format(**_vars)
+        dst = dst.format(**_vars)
 
     if not os.path.exists(src) and not force:
         log.info(f"**Skipping copy file\n  {src} to\n  {dst}\n  Source does not exist")
@@ -317,11 +317,11 @@ def copyfile(src, dst, force=True, vars=None, force_copy_symlink=False,
     return dst
 
 
-def makefile(dst, content=None, vars=None):
-    if vars is not None:
+def makefile(dst, content=None, _vars=None):
+    if _vars is not None:
         if content is not None:
-            content = content.format(**vars)
-        dst = dst.format(**vars)
+            content = content.format(**_vars)
+        dst = dst.format(**_vars)
 
     log.info(f"Making file {dst}.")
 
@@ -334,25 +334,25 @@ def makefile(dst, content=None, vars=None):
             f.write(content)
 
 
-def copydir(src, dst, filter=None, ignore=None, force=True, recursive=True, vars=None,
+def copydir(src, dst, _filter=None, ignore=None, force=True, recursive=True, _vars=None,
             dir_filter_function=None, file_filter_function=None, force_copy_symlinks=False):
 
-    if vars is not None:
-        src = src.format(**vars)
-        dst = dst.format(**vars)
-        if filter is not None:
-            for i in range(len(filter)):
-                filter[i] = filter[i].format(**vars)
+    if _vars is not None:
+        src = src.format(**_vars)
+        dst = dst.format(**_vars)
+        if _filter is not None:
+            for i in range(len(_filter)):
+                _filter[i] = _filter[i].format(**_vars)
         if ignore is not None:
             for i in range(len(ignore)):
-                ignore[i] = ignore[i].format(**vars)
+                ignore[i] = ignore[i].format(**_vars)
 
     if not os.path.exists(src) and not force:
         log.info(f"**Skipping copy tree\n  {src} to\n  {dst}\n  Source does not exist. "
-                 f"filter={filter}. ignore={ignore}.")
+                 f"filter={_filter}. ignore={ignore}.")
         return []
 
-    log.info(f"Copying tree\n  {src} to\n  {dst}. filter={filter}. ignore={ignore}.")
+    log.info(f"Copying tree\n  {src} to\n  {dst}. filter={_filter}. ignore={ignore}.")
 
     names = os.listdir(src)
 
@@ -366,17 +366,17 @@ def copydir(src, dst, filter=None, ignore=None, force=True, recursive=True, vars
                 if (dir_filter_function and not dir_filter_function(name, src, srcname)):
                     continue
                 if recursive:
-                    results.extend(copydir(srcname, dstname, filter, ignore, force, recursive,
-                                           vars, dir_filter_function, file_filter_function,
+                    results.extend(copydir(srcname, dstname, _filter, ignore, force, recursive,
+                                           _vars, dir_filter_function, file_filter_function,
                                            force_copy_symlinks))
             else:
                 if ((file_filter_function is not None and not file_filter_function(name, srcname))
-                        or (filter is not None and not filter_match(name, filter))
+                        or (_filter is not None and not filter_match(name, _filter))
                         or (ignore is not None and filter_match(name, ignore))):
                     continue
                 if not os.path.exists(dst):
                     os.makedirs(dst)
-                results.append(copyfile(srcname, dstname, True, vars, force_copy_symlinks))
+                results.append(copyfile(srcname, dstname, True, _vars, force_copy_symlinks))
         # catch the Error from the recursive copytree so that we can
         # continue with other files
         except shutil.Error as err:
@@ -460,10 +460,10 @@ def get_environment_from_batch_command(env_cmd, initial=None):
             return False
         return True
 
-    def consume(iter):
+    def consume(it):
         try:
             while True:
-                next(iter)
+                next(it)
         except StopIteration:
             pass