Revision control
++ # Copyright (C) 2024 The Qt Company Ltd.
++ # SPDX-License-Identifier: BSD-3-Clause
++
++ __qt_internal_cmake_include_guard(GLOBAL GUARD_KEY "QtPublicSbomPythonHelpers")
++
++ # Helper macro to find python and a given dependency. Expects the caller to set all of the vars.
++ # Meant to reduce the line noise due to the repeated calls.
++ macro(_qt_internal_sbom_find_python_and_dependency_helper_lambda)
++ _qt_internal_sbom_find_python_and_dependency_helper(
++ PYTHON_ARGS
++ ${extra_python_args}
++ ${python_common_args}
++ DEPENDENCY_ARGS
++ DEPENDENCY_IMPORT_STATEMENT "${import_statement}"
++ OUT_VAR_PYTHON_PATH python_path
++ OUT_VAR_PYTHON_FOUND python_found
++ OUT_VAR_PYTHON_VERSION python_version
++ OUT_VAR_DEP_FOUND dep_found
++ OUT_VAR_PYTHON_AND_DEP_FOUND everything_found
++ OUT_VAR_PYTHON_FIND_OUTPUT python_find_output
++ OUT_VAR_DEP_FIND_OUTPUT dep_find_output
++ )
++ endmacro()
++
++ # Tries to find python and a given dependency based on the args passed to PYTHON_ARGS and
++ # DEPENDENCY_ARGS which are forwarded to the respective finding functions.
++ # Returns the path to the python interpreter, whether it was found, whether the dependency was
++ # found, whether both were found, and the reason why the dependency might not be found.
++ function(_qt_internal_sbom_find_python_and_dependency_helper)
++ set(opt_args)
++ set(single_args
++ OUT_VAR_PYTHON_PATH
++ OUT_VAR_PYTHON_FOUND
++ OUT_VAR_PYTHON_VERSION
++ OUT_VAR_DEP_FOUND
++ OUT_VAR_PYTHON_AND_DEP_FOUND
++ OUT_VAR_PYTHON_FIND_OUTPUT
++ OUT_VAR_DEP_FIND_OUTPUT
++ )
++ set(multi_args
++ PYTHON_ARGS
++ DEPENDENCY_ARGS
++ )
++ cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
++ _qt_internal_validate_all_args_are_parsed(arg)
++
++ set(everything_found_inner FALSE)
++ set(deps_find_output_inner "")
++
++ if(NOT arg_OUT_VAR_PYTHON_PATH)
++ message(FATAL_ERROR "OUT_VAR_PYTHON_PATH var is required")
++ endif()
++
++ if(NOT arg_OUT_VAR_PYTHON_FOUND)
++ message(FATAL_ERROR "OUT_VAR_PYTHON_FOUND var is required")
++ endif()
++
++ if(NOT arg_OUT_VAR_DEP_FOUND)
++ message(FATAL_ERROR "OUT_VAR_DEP_FOUND var is required")
++ endif()
++
++ if(NOT arg_OUT_VAR_PYTHON_AND_DEP_FOUND)
++ message(FATAL_ERROR "OUT_VAR_PYTHON_AND_DEP_FOUND var is required")
++ endif()
++
++ if(NOT arg_OUT_VAR_DEP_FIND_OUTPUT)
++ message(FATAL_ERROR "OUT_VAR_DEP_FIND_OUTPUT var is required")
++ endif()
++
++ _qt_internal_sbom_find_python_helper(
++ ${arg_PYTHON_ARGS}
++ OUT_VAR_PYTHON_PATH python_path_inner
++ OUT_VAR_PYTHON_FOUND python_found_inner
++ OUT_VAR_PYTHON_VERSION python_version_inner
++ OUT_VAR_PYTHON_FIND_OUTPUT python_find_output_inner
++ )
++
++ if(python_found_inner AND python_path_inner)
++ _qt_internal_sbom_find_python_dependency_helper(
++ ${arg_DEPENDENCY_ARGS}
++ PYTHON_PATH "${python_path_inner}"
++ OUT_VAR_FOUND dep_found_inner
++ OUT_VAR_OUTPUT dep_find_output_inner
++ )
++
++ if(dep_found_inner)
++ set(everything_found_inner TRUE)
++ endif()
++ endif()
++
++ set(${arg_OUT_VAR_PYTHON_PATH} "${python_path_inner}" PARENT_SCOPE)
++ set(${arg_OUT_VAR_PYTHON_FOUND} "${python_found_inner}" PARENT_SCOPE)
++ if(arg_OUT_VAR_PYTHON_VERSION)
++ set(${arg_OUT_VAR_PYTHON_VERSION} "${python_version_inner}" PARENT_SCOPE)
++ endif()
++ set(${arg_OUT_VAR_DEP_FOUND} "${dep_found_inner}" PARENT_SCOPE)
++ set(${arg_OUT_VAR_PYTHON_AND_DEP_FOUND} "${everything_found_inner}" PARENT_SCOPE)
++ set(${arg_OUT_VAR_PYTHON_FIND_OUTPUT} "${python_find_output_inner}" PARENT_SCOPE)
++ set(${arg_OUT_VAR_DEP_FIND_OUTPUT} "${dep_find_output_inner}" PARENT_SCOPE)
++ endfunction()
++
++ # Tries to find a python intrepreter for SBOM handling.
++ # Ignores any previously found python.
++ # Returns the python interpreter path and whether it was successfully found, along with the version
++ # found and some debug output when not found.
++ #
++ # This is intentionally a function, and not a macro, to prevent overriding the Python3_EXECUTABLE
++ # non-cache variable in a global scope in case if a different python is found and used for a
++ # different purpose (e.g. qtwebengine or qtinterfaceframework).
++ # The reason to use a different python is that an already found python might not be the version we
++ # need, or might lack the dependencies we need.
++ # https://gitlab.kitware.com/cmake/cmake/-/issues/21797#note_901621 claims that finding multiple
++ # python versions in separate directory scopes is possible, and I claim a function scope is as
++ # good as a directory scope.
++ function(_qt_internal_sbom_find_python_helper)
++ set(opt_args
++ SEARCH_IN_FRAMEWORKS
++ SEARCH_IN_REGISTRY
++ SEARCH_IN_ROOT_DIR
++ SEARCH_IN_INTERPRETER_DIR_PATH
++ FORCE_SET_INTERPRETER_PATH
++ QUIET
++ )
++ set(single_args
++ VERSION
++ INTERPRETER_PATH
++ INTERPRETER_DIR_PATH
++ OUT_VAR_PYTHON_PATH
++ OUT_VAR_PYTHON_FOUND
++ OUT_VAR_PYTHON_VERSION
++ OUT_VAR_PYTHON_FIND_OUTPUT
++ )
++ set(multi_args "")
++ cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
++ _qt_internal_validate_all_args_are_parsed(arg)
++
++ if(NOT arg_OUT_VAR_PYTHON_PATH)
++ message(FATAL_ERROR "OUT_VAR_PYTHON_PATH var is required")
++ endif()
++
++ if(NOT arg_OUT_VAR_PYTHON_FOUND)
++ message(FATAL_ERROR "OUT_VAR_PYTHON_FOUND var is required")
++ endif()
++
++ set(find_output "Search options:")
++
++ # Allow disabling looking for a python interpreter shipped as part of a macOS system framework.
++ if(NOT arg_SEARCH_IN_FRAMEWORKS)
++ set(Python3_FIND_FRAMEWORK NEVER)
++ list(APPEND find_output "Will NOT search in macOS framework locations.")
++ else()
++ list(APPEND find_output "Will search in macOS framework locations.")
++ endif()
++
++ if(NOT arg_SEARCH_IN_REGISTRY)
++ set(Python3_FIND_REGISTRY NEVER)
++ list(APPEND find_output "Will NOT search in Windows registry.")
++ else()
++ list(APPEND find_output "Will search in Windows registry.")
++ endif()
++
++ # Remove the root dir if not requested to search in it.
++ if(NOT arg_SEARCH_IN_ROOT_DIR)
++ unset(Python3_ROOT_DIR)
++
++ # Temporarily also unset the env var.
++ set(python_root_dir_env_value "$ENV{Python3_ROOT_DIR}")
++ if(python_root_dir_env_value AND NOT QT_SBOM_NO_PYTHON_ROOT_DIR_ENV_BACKUP)
++ set(python_root_dir_env_backup "$ENV{Python3_ROOT_DIR}")
++ unset(ENV{Python3_ROOT_DIR})
++ endif()
++
++ list(APPEND find_output "Will NOT search in Python3_ROOT_DIR.")
++ else()
++ _qt_internal_sbom_get_python_root_dir(OUT_VAR_PYTHON_ROOT_DIR_PATH Python3_ROOT_DIR)
++ list(APPEND find_output "Will search in Python3_ROOT_DIR: '${Python3_ROOT_DIR}'.")
++ endif()
++
++ set(force_python_interpreter_path "")
++ if(arg_FORCE_SET_INTERPRETER_PATH AND arg_INTERPRETER_PATH)
++ set(force_python_interpreter_path "${arg_INTERPRETER_PATH}")
++
++ list(APPEND find_output
++ "Will force set Python3_EXECUTABLE to provided INTERPRETER_PATH: "
++ "'${arg_INTERPRETER_PATH}'.")
++ else()
++ list(APPEND find_output "Will NOT force set Python3_EXECUTABLE to INTERPRETER_PATH.")
++ endif()
++
++ if(arg_SEARCH_IN_INTERPRETER_DIR_PATH AND arg_INTERPRETER_DIR_PATH)
++ # Python3_ROOT_DIR expects a directory, not a path.
++ set(Python3_ROOT_DIR "${arg_INTERPRETER_DIR_PATH}")
++
++ list(APPEND find_output
++ "Will search in provided INTERPRETER_DIR_PATH: '${arg_INTERPRETER_DIR_PATH}'.")
++ else()
++ list(APPEND find_output "Will NOT search in INTERPRETER_DIR_PATH.")
++ endif()
++
++ set(required_version "")
++ if(arg_VERSION)
++ set(required_version "${arg_VERSION}")
++ endif()
++
++ set(find_quiet "")
++ if(arg_QUIET AND NOT QT_INTERNAL_SBOM_NO_FIND_PYTHON_QUIET)
++ set(find_quiet "QUIET")
++ endif()
++
++ # When performing a search, locally reset any executable that was possibly already found.
++ # We do this to ensure we always re-do the lookup.
++ # This needs to be set to an empty string, to override any cache variable.
++ # When FORCE_SET_INTERPRETER_PATH is used, set the executable to the given path.
++ if(arg_FORCE_SET_INTERPRETER_PATH
++ AND force_python_interpreter_path
++ AND EXISTS "${force_python_interpreter_path}"
++ )
++ set(Python3_EXECUTABLE "${force_python_interpreter_path}")
++ else()
++ set(Python3_EXECUTABLE "")
++ endif()
++
++ # This needs to be unset, because the Python module checks whether the variable is defined, not
++ # whether it is empty.
++ unset(_Python3_EXECUTABLE)
++
++ find_package(Python3 ${required_version} ${find_quiet} COMPONENTS Interpreter)
++
++ if(python_root_dir_env_backup AND NOT QT_SBOM_NO_PYTHON_ROOT_DIR_ENV_BACKUP)
++ set(ENV{Python3_ROOT_DIR} "${python_root_dir_env_backup}")
++ endif()
++
++ if(Python3_Interpreter_FOUND)
++ list(APPEND find_output
++ "Python interpreter found: '${Python3_EXECUTABLE} (version ${Python3_VERSION})'.")
++ else()
++ list(APPEND find_output "Python interpreter NOT found.")
++ endif()
++
++ list(JOIN find_output "\n" find_output_joined)
++
++ set(${arg_OUT_VAR_PYTHON_PATH} "${Python3_EXECUTABLE}" PARENT_SCOPE)
++ set(${arg_OUT_VAR_PYTHON_FOUND} "${Python3_Interpreter_FOUND}" PARENT_SCOPE)
++ set(${arg_OUT_VAR_PYTHON_FIND_OUTPUT} "${find_output_joined}" PARENT_SCOPE)
++ if(arg_OUT_VAR_PYTHON_VERSION)
++ set(${arg_OUT_VAR_PYTHON_VERSION} "${Python3_VERSION}" PARENT_SCOPE)
++ endif()
++ endfunction()
++
++ # Helper to retrieve the python interpreter path and directory, from either a QT_SBOM_PYTHON_INTERP
++ # env var or regular (cache) var, when one of them is set.
++ # The regular var is preferred.
++ # In the very first implementation, the var expected to be passed an interpreter path, rather
++ # than the dir where the python interpreter is located, which is what FindPython's
++ # Python3_ROOT_DIR expects.
++ # Now both cases are handled properly. So the variable name is a bit of a misnomer, but we keep
++ # it for compatibility.
++ function(_qt_internal_sbom_get_sbom_python_interp_path)
++ set(opt_args "")
++ set(single_args
++ OUT_VAR_FOUND
++ OUT_VAR_PYTHON_PATH
++ OUT_VAR_PYTHON_DIR_PATH
++ )
++ set(multi_args "")
++ cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
++ _qt_internal_validate_all_args_are_parsed(arg)
++
++ set(candidates
++ "${QT_SBOM_PYTHON_INTERP}"
++ "$ENV{QT_SBOM_PYTHON_INTERP}"
++ )
++
++ set(something_found FALSE)
++ foreach(candidate IN LISTS candidates)
++ if(NOT candidate OR NOT EXISTS "${candidate}")
++ continue()
++ endif()
++
++ set(something_found TRUE)
++ if(IS_DIRECTORY "${candidate}")
++ set(interp_dir "${candidate}")
++ set(interp_path "")
++
++ # We need to find the executable in the given directory, to be able to assign it to
++ # Python3_EXECUTABLE when FORCE_SET_INTERPRETER_PATH is used.
++ find_program(QT_INTERNAL_SBOM_PYTHON_INTERP_PATH
++ NAMES python3 python
++ HINTS "${interp_dir}"
++ NO_DEFAULT_PATH
++ )
++ if(QT_INTERNAL_SBOM_PYTHON_INTERP_PATH)
++ set(interp_path "${QT_INTERNAL_SBOM_PYTHON_INTERP_PATH}")
++ message(DEBUG
++ "Found python executable '${interp_path}' in QT_SBOM_PYTHON_INTERP candidate "
++ "directory: '${candidate}'.")
++ else()
++ message(DEBUG
++ "QT_SBOM_PYTHON_INTERP '${candidate}' is a directory, but no "
++ "python executable found in it.")
++ endif()
++ else()
++ get_filename_component(interp_dir "${candidate}" DIRECTORY)
++ set(interp_path "${candidate}")
++ endif()
++ break()
++ endforeach()
++
++ if(arg_OUT_VAR_FOUND)
++ set(${arg_OUT_VAR_FOUND} "${something_found}" PARENT_SCOPE)
++ endif()
++ if(arg_OUT_VAR_PYTHON_PATH)
++ set(${arg_OUT_VAR_PYTHON_PATH} "${interp_path}" PARENT_SCOPE)
++ endif()
++ if(arg_OUT_VAR_PYTHON_DIR_PATH)
++ set(${arg_OUT_VAR_PYTHON_DIR_PATH} "${interp_dir}" PARENT_SCOPE)
++ endif()
++ endfunction()
++
++ # Returns the value of Python3_ROOT_DIR if it's set, either as a cmake variable or env var.
++ function(_qt_internal_sbom_get_python_root_dir)
++ set(opt_args "")
++ set(single_args
++ OUT_VAR_FOUND
++ OUT_VAR_PYTHON_ROOT_DIR_PATH
++ )
++ set(multi_args "")
++ cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
++ _qt_internal_validate_all_args_are_parsed(arg)
++
++ set(candidates
++ "${Python3_ROOT_DIR}"
++ "$ENV{Python3_ROOT_DIR}"
++ )
++
++ set(python_root_dir "")
++
++ set(something_found FALSE)
++ foreach(candidate IN LISTS candidates)
++ if(NOT candidate OR NOT EXISTS "${candidate}")
++ continue()
++ endif()
++
++ set(something_found TRUE)
++ if(IS_DIRECTORY "${candidate}")
++ set(python_root_dir "${candidate}")
++ endif()
++ endforeach()
++
++ if(arg_OUT_VAR_FOUND)
++ set(${arg_OUT_VAR_FOUND} "${something_found}" PARENT_SCOPE)
++ endif()
++ if(arg_OUT_VAR_PYTHON_ROOT_DIR_PATH)
++ set(${arg_OUT_VAR_PYTHON_ROOT_DIR_PATH} "${python_root_dir}" PARENT_SCOPE)
++ endif()
++ endfunction()
++
++ # Helper that takes an python import statement to run using the given python interpreter path,
++ # to confirm that the given python dependency can be found.
++ # Returns whether the dependency was found and the output of running the import, for error handling.
++ function(_qt_internal_sbom_find_python_dependency_helper)
++ set(opt_args "")
++ set(single_args
++ DEPENDENCY_IMPORT_STATEMENT
++ PYTHON_PATH
++ OUT_VAR_FOUND
++ OUT_VAR_OUTPUT
++ )
++ set(multi_args "")
++ cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
++ _qt_internal_validate_all_args_are_parsed(arg)
++
++ if(NOT arg_PYTHON_PATH)
++ message(FATAL_ERROR "Python interpreter path not given.")
++ endif()
++
++ if(NOT arg_DEPENDENCY_IMPORT_STATEMENT)
++ message(FATAL_ERROR "Python depdendency import statement not given.")
++ endif()
++
++ if(NOT arg_OUT_VAR_FOUND)
++ message(FATAL_ERROR "Out var found variable not given.")
++ endif()
++
++ set(python_path "${arg_PYTHON_PATH}")
++ execute_process(
++ COMMAND
++ "${python_path}" -c "${arg_DEPENDENCY_IMPORT_STATEMENT}"
++ RESULT_VARIABLE res
++ OUTPUT_VARIABLE output
++ ERROR_VARIABLE output
++ )
++
++ if("${res}" STREQUAL "0")
++ set(found TRUE)
++ string(CONCAT output
++ "SBOM Python dependency '${arg_DEPENDENCY_IMPORT_STATEMENT}' found. "
++ "Output:\n${output}")
++ else()
++ set(found FALSE)
++ string(CONCAT output
++ "SBOM Python dependency '${arg_DEPENDENCY_IMPORT_STATEMENT}' NOT found. "
++ "Output:\n${output} Exit code: ${res}")
++ endif()
++
++ set(${arg_OUT_VAR_FOUND} "${found}" PARENT_SCOPE)
++ if(arg_OUT_VAR_OUTPUT)
++ set(${arg_OUT_VAR_OUTPUT} "${output}" PARENT_SCOPE)
++ endif()
++ endfunction()
++
++ # Helper to find a python installed CLI utility.
++ # Expected to be in PATH.
++ function(_qt_internal_sbom_find_python_dependency_program)
++ set(opt_args
++ REQUIRED
++ )
++ set(single_args
++ NAME
++ )
++ set(multi_args "")
++ cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
++ _qt_internal_validate_all_args_are_parsed(arg)
++
++ set(program_name "${arg_NAME}")
++ string(TOUPPER "${program_name}" upper_name)
++ set(cache_var "QT_SBOM_PROGRAM_${upper_name}")
++
++ set(hints "")
++
++ # The path to python installed apps is different on Windows compared to UNIX, so we use
++ # a different path than where the python interpreter might be located.
++ if(QT_SBOM_PYTHON_APPS_PATH)
++ list(APPEND hints "${QT_SBOM_PYTHON_APPS_PATH}")
++ endif()
++
++ # Sometimes the installed apps might be in the same location as the interepreter, if both are
++ # in a virtual env. So look also in the interpreter path.
++ _qt_internal_sbom_get_sbom_python_interp_path(OUT_VAR_PYTHON_DIR_PATH sbom_python_interp_dir)
++ if(sbom_python_interp_dir)
++ list(APPEND hints "${sbom_python_interp_dir}")
++ endif()
++
++ # If we already found a python interpreter for sbom purposes, look in its parent directory.
++ if(QT_INTERNAL_SBOM_PYTHON_EXECUTABLE)
++ get_filename_component(python_interp_dir "${QT_INTERNAL_SBOM_PYTHON_EXECUTABLE}" DIRECTORY)
++ list(APPEND hints "${python_interp_dir}")
++ endif()
++
++ # Look in the python root dir as well.
++ _qt_internal_sbom_get_python_root_dir(OUT_VAR_PYTHON_ROOT_DIR_PATH python_root_dir)
++ if(python_root_dir)
++ list(APPEND hints "${python_root_dir}")
++ endif()
++
++ find_program(${cache_var}
++ NAMES ${program_name}
++ HINTS ${hints}
++ )
++
++ if(NOT ${cache_var})
++ if(arg_REQUIRED)
++ set(message_type "FATAL_ERROR")
++ set(prefix "Required ")
++ else()
++ set(message_type "STATUS")
++ set(prefix "Optional ")
++ endif()
++ message(${message_type} "${prefix}SBOM python program '${program_name}' NOT found.")
++ endif()
++ endfunction()