python.cmake

# Use latest Python3 module (3.18)
cmake_minimum_required(VERSION 3.18)

# Find Python 3
find_package(Python3 REQUIRED COMPONENTS Interpreter Development.Module)

# Find if the python module is available,
# otherwise install it (PACKAGE_NAME) to the Python3 user install directory.
# If CMake option FETCH_PYTHON_DEPS is OFF then issue a fatal error instead.
# e.g
# search_python_module(
#   NAME
#     mypy_protobuf
#   PACKAGE
#     mypy-protobuf
#   NO_VERSION
# )
function(search_python_module)
  set(options NO_VERSION)
  set(oneValueArgs NAME PACKAGE)
  set(multiValueArgs "")
  cmake_parse_arguments(MODULE
    "${options}"
    "${oneValueArgs}"
    "${multiValueArgs}"
    ${ARGN}
  )
  message(STATUS "Searching python module: \"${MODULE_NAME}\"")
  if(${MODULE_NO_VERSION})
    execute_process(
      COMMAND ${Python3_EXECUTABLE} -c "import ${MODULE_NAME}"
      RESULT_VARIABLE _RESULT
      ERROR_QUIET
      OUTPUT_STRIP_TRAILING_WHITESPACE
    )
    set(MODULE_VERSION "unknown")
  else()
    execute_process(
      COMMAND ${Python3_EXECUTABLE} -c "import ${MODULE_NAME}; print(${MODULE_NAME}.__version__)"
      RESULT_VARIABLE _RESULT
      OUTPUT_VARIABLE MODULE_VERSION
      ERROR_QUIET
      OUTPUT_STRIP_TRAILING_WHITESPACE
    )
  endif()
  if(${_RESULT} STREQUAL "0")
    message(STATUS "Found python module: \"${MODULE_NAME}\" (found version \"${MODULE_VERSION}\")")
  else()
    if(FETCH_PYTHON_DEPS)
      message(WARNING "Can't find python module: \"${MODULE_NAME}\", install it using pip...")
      execute_process(
        COMMAND ${Python3_EXECUTABLE} -m pip install --user ${MODULE_PACKAGE}
        OUTPUT_STRIP_TRAILING_WHITESPACE
        COMMAND_ERROR_IS_FATAL ANY
      )
    else()
      message(FATAL_ERROR "Can't find python module: \"${MODULE_NAME}\", please install it using your system package manager.")
    endif()
  endif()
endfunction()

# Find if a python builtin module is available.
# e.g
# search_python_internal_module(
#   NAME
#     mypy_protobuf
# )
function(search_python_internal_module)
  set(options "")
  set(oneValueArgs NAME)
  set(multiValueArgs "")
  cmake_parse_arguments(MODULE
    "${options}"
    "${oneValueArgs}"
    "${multiValueArgs}"
    ${ARGN}
  )
  message(STATUS "Searching python module: \"${MODULE_NAME}\"")
  execute_process(
    COMMAND ${Python3_EXECUTABLE} -c "import ${MODULE_NAME}"
    RESULT_VARIABLE _RESULT
    ERROR_QUIET
    OUTPUT_STRIP_TRAILING_WHITESPACE
    )
  if(${_RESULT} STREQUAL "0")
    message(STATUS "Found python internal module: \"${MODULE_NAME}\"")
  else()
    message(FATAL_ERROR "Can't find python internal module \"${MODULE_NAME}\", please install it using your system package manager.")
  endif()
endfunction()

###################
##  Python Test  ##
###################
if(BUILD_TESTING)
  #search_python_module(NAME virtualenv PACKAGE virtualenv)
  # venv not working on github windows runners
  search_python_internal_module(NAME venv)
  # Testing using a vitual environment
  #set(VENV_EXECUTABLE ${Python3_EXECUTABLE} -m virtualenv)
  set(VENV_EXECUTABLE ${Python3_EXECUTABLE} -m venv)
  set(VENV_DIR ${CMAKE_CURRENT_BINARY_DIR}/python/venv)
  if(WIN32)
    set(VENV_Python3_EXECUTABLE ${VENV_DIR}/Scripts/python.exe)
  else()
    set(VENV_Python3_EXECUTABLE ${VENV_DIR}/bin/python)
  endif()
endif()

# add_python_test()
# CMake function to generate and build python test.
# Parameters:
#  FILE_NAME: the python filename
#  COMPONENT_NAME: name of the ortools/ subdir where the test is located
#  note: automatically determined if located in ortools/<component>/python/
# e.g.:
# add_python_test(
#   FILE_NAME
#     ${PROJECT_SOURCE_DIR}/ortools/foo/python/bar_test.py
#   COMPONENT_NAME
#     foo
# )
function(add_python_test)
  if(NOT BUILD_TESTING)
   return()
  endif()

  set(options "")
  set(oneValueArgs FILE_NAME)
  set(multiValueArgs "")
  cmake_parse_arguments(TEST
    "${options}"
    "${oneValueArgs}"
    "${multiValueArgs}"
    ${ARGN}
  )
  if(NOT TEST_FILE_NAME)
    message(FATAL_ERROR "no FILE_NAME provided")
  endif()
  get_filename_component(TEST_NAME ${TEST_FILE_NAME} NAME_WE)

  message(STATUS "Configuring test ${TEST_FILE_NAME} ...")

  add_test(
    NAME python_test_${TEST_NAME}
    COMMAND ${VENV_Python3_EXECUTABLE} -m pytest ${TEST_FILE_NAME}
    WORKING_DIRECTORY ${VENV_DIR})
  message(STATUS "Configuring test ${TEST_FILE_NAME} ...DONE")
endfunction()

#######################
##  PYTHON WRAPPERS  ##
#######################
set(PYTHON_PROJECT ${PROJECT_NAMESPACE})
message(STATUS "Python project: ${PYTHON_PROJECT}")
set(PYTHON_PROJECT_DIR ${PROJECT_BINARY_DIR}/python/${PYTHON_PROJECT})
message(STATUS "Python project build path: ${PYTHON_PROJECT_DIR}")

#######################
## Python Packaging  ##
#######################
#file(MAKE_DIRECTORY python/${PYTHON_PROJECT})
configure_file(
  ${PROJECT_SOURCE_DIR}/python/__init__.py.in
  ${PROJECT_BINARY_DIR}/python/__init__.py.in
  @ONLY)
file(GENERATE
  OUTPUT ${PYTHON_PROJECT_DIR}/__init__.py
  INPUT ${PROJECT_BINARY_DIR}/python/__init__.py.in)

file(GENERATE OUTPUT ${PYTHON_PROJECT_DIR}/foo/__init__.py CONTENT "")
file(GENERATE OUTPUT ${PYTHON_PROJECT_DIR}/foo/python/__init__.py CONTENT "")
file(GENERATE OUTPUT ${PYTHON_PROJECT_DIR}/bar/__init__.py CONTENT "")
file(GENERATE OUTPUT ${PYTHON_PROJECT_DIR}/bar/python/__init__.py CONTENT "")
file(GENERATE OUTPUT ${PYTHON_PROJECT_DIR}/foobar/__init__.py CONTENT "")
file(GENERATE OUTPUT ${PYTHON_PROJECT_DIR}/foobar/python/__init__.py CONTENT "")

# Adds py.typed to make typed packages.
file(GENERATE OUTPUT ${PYTHON_PROJECT_DIR}/foo/py.typed CONTENT "")
file(GENERATE OUTPUT ${PYTHON_PROJECT_DIR}/foo/python/py.typed CONTENT "")
file(GENERATE OUTPUT ${PYTHON_PROJECT_DIR}/bar/py.typed CONTENT "")
file(GENERATE OUTPUT ${PYTHON_PROJECT_DIR}/bar/python/py.typed CONTENT "")
file(GENERATE OUTPUT ${PYTHON_PROJECT_DIR}/foobar/py.typed CONTENT "")
file(GENERATE OUTPUT ${PYTHON_PROJECT_DIR}/foobar/python/py.typed CONTENT "")

# setup.py.in contains cmake variable e.g. @PYTHON_PROJECT@ and
# generator expression e.g. $<TARGET_FILE_NAME:pyFoo>
configure_file(
  ${PROJECT_SOURCE_DIR}/python/setup.py.in
  ${PROJECT_BINARY_DIR}/python/setup.py.in
  @ONLY)
file(GENERATE
  OUTPUT ${PROJECT_BINARY_DIR}/python/setup.py
  INPUT ${PROJECT_BINARY_DIR}/python/setup.py.in)

#add_custom_command(
#  OUTPUT python/setup.py
#  DEPENDS ${PROJECT_BINARY_DIR}/python/setup.py
#  COMMAND ${CMAKE_COMMAND} -E copy setup.py setup.py
#  WORKING_DIRECTORY python)

set(is_windows "$<PLATFORM_ID:Windows>")
set(is_not_windows "$<NOT:$<PLATFORM_ID:Windows>>")

set(need_unix_absl_lib "$<AND:${is_not_windows},$<BOOL:${BUILD_absl}>>")
set(need_windows_absl_lib "$<AND:${is_windows},$<BOOL:${BUILD_absl}>>")

set(is_foo_shared "$<STREQUAL:$<TARGET_PROPERTY:Foo,TYPE>,SHARED_LIBRARY>")
set(need_unix_foo_lib "$<AND:${is_not_windows},${is_foo_shared}>")
set(need_windows_foo_lib "$<AND:${is_windows},${is_foo_shared}>")

set(is_bar_shared "$<STREQUAL:$<TARGET_PROPERTY:Bar,TYPE>,SHARED_LIBRARY>")
set(need_unix_bar_lib "$<AND:${is_not_windows},${is_bar_shared}>")
set(need_windows_bar_lib "$<AND:${is_windows},${is_bar_shared}>")

set(is_foobar_shared "$<STREQUAL:$<TARGET_PROPERTY:FooBar,TYPE>,SHARED_LIBRARY>")
set(need_unix_foobar_lib "$<AND:${is_not_windows},${is_foobar_shared}>")
set(need_windows_foobar_lib "$<AND:${is_windows},${is_foobar_shared}>")

add_custom_command(
  OUTPUT python/libs_timestamp
  COMMAND ${CMAKE_COMMAND} -E remove -f libs_timestamp
  COMMAND ${CMAKE_COMMAND} -E make_directory ${PYTHON_PROJECT}/.libs

  COMMAND ${CMAKE_COMMAND} -E
    $<IF:$<BOOL:${BUILD_absl}>,copy,true>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::base>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::city>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::civil_time>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::cord>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::cord_internal>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::cordz_functions>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::cordz_handle>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::cordz_info>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::crc32c>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::crc_cord_state>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::crc_cpu_detect>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::crc_internal>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::debugging_internal>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::decode_rust_punycode>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::demangle_internal>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::demangle_rust>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::die_if_null>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::examine_stack>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::exponential_biased>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::flags_commandlineflag>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::flags_commandlineflag_internal>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::flags_config>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::flags_internal>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::flags_marshalling>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::flags_parse>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::flags_private_handle_accessor>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::flags_program_name>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::flags_reflection>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::flags_usage>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::flags_usage_internal>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::graphcycles_internal>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::hash>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::hashtablez_sampler>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::int128>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::kernel_timeout_internal>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::leak_check>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_entry>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_flags>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_globals>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_initialize>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_internal_check_op>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_internal_conditions>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_internal_fnmatch>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_internal_format>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_internal_globals>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_internal_log_sink_set>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_internal_structured_proto>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_internal_message>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_internal_nullguard>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_internal_proto>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_severity>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_sink>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::malloc_internal>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::random_distributions>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::random_internal_entropy_pool>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::random_internal_platform>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::random_internal_randen>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::random_internal_randen_hwaes>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::random_internal_randen_hwaes_impl>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::random_internal_randen_slow>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::random_internal_seed_material>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::random_seed_gen_exception>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::random_seed_sequences>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::raw_hash_set>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::raw_logging_internal>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::spinlock_wait>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::stacktrace>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::status>>
    #$<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::statusor>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::str_format_internal>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::strerror>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::string_view>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::strings>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::strings_internal>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::symbolize>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::synchronization>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::throw_delegate>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::time>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::time_zone>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::tracing_internal>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::utf8_for_code_point>>
    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::vlog_config_internal>>
    $<${need_windows_absl_lib}:$<TARGET_FILE:absl::abseil_dll>>
    ${PYTHON_PROJECT}/.libs

  COMMAND ${CMAKE_COMMAND} -E
    $<IF:${is_foo_shared},copy,true>
    $<${need_unix_foo_lib}:$<TARGET_SONAME_FILE:Foo>>
    $<${need_windows_foo_lib}:$<TARGET_FILE:Foo>>
    ${PYTHON_PROJECT}/.libs

  COMMAND ${CMAKE_COMMAND} -E
    $<IF:${is_bar_shared},copy,true>
    $<${need_unix_bar_lib}:$<TARGET_SONAME_FILE:Bar>>
    $<${need_windows_bar_lib}:$<TARGET_FILE:Bar>>
    ${PYTHON_PROJECT}/.libs

  COMMAND ${CMAKE_COMMAND} -E
    $<IF:${is_foobar_shared},copy,true>
    $<${need_unix_foobar_lib}:$<TARGET_SONAME_FILE:FooBar>>
    $<${need_windows_foobar_lib}:$<TARGET_FILE:FooBar>>
    ${PYTHON_PROJECT}/.libs

  COMMAND ${CMAKE_COMMAND} -E touch ${PROJECT_BINARY_DIR}/python/libs_timestamp
  MAIN_DEPENDENCY
    python/setup.py.in
  DEPENDS
    python/setup.py
    ${PROJECT_NAMESPACE}::Foo
    ${PROJECT_NAMESPACE}::Bar
    ${PROJECT_NAMESPACE}::FooBar
  WORKING_DIRECTORY python
  COMMAND_EXPAND_LISTS)

add_custom_command(
  OUTPUT python/pybind11_timestamp
  COMMAND ${CMAKE_COMMAND} -E remove -f pybind11_timestamp
  COMMAND ${CMAKE_COMMAND} -E copy
    $<TARGET_FILE:pyFoo> ${PYTHON_PROJECT}/foo/python
  COMMAND ${CMAKE_COMMAND} -E copy
    $<TARGET_FILE:pyBar> ${PYTHON_PROJECT}/bar/python
  COMMAND ${CMAKE_COMMAND} -E copy
    $<TARGET_FILE:pyFooBar> ${PYTHON_PROJECT}/foobar/python
  COMMAND ${CMAKE_COMMAND} -E touch ${PROJECT_BINARY_DIR}/python/pybind11_timestamp
  MAIN_DEPENDENCY
    python/setup.py.in
  DEPENDS
    ${PROJECT_NAMESPACE}::pyFoo
    ${PROJECT_NAMESPACE}::pyBar
    ${PROJECT_NAMESPACE}::pyFooBar
  WORKING_DIRECTORY python
  COMMAND_EXPAND_LISTS)

# Generate Stub
if(GENERATE_PYTHON_STUB)
# Look for required python modules
search_python_module(
  NAME mypy
  PACKAGE mypy
  NO_VERSION)

find_program(
  stubgen_EXECUTABLE
  NAMES stubgen stubgen.exe
  REQUIRED
)
message(STATUS "Python: stubgen: ${stubgen_EXECUTABLE}")

add_custom_command(
  OUTPUT python/stub_timestamp
  COMMAND ${CMAKE_COMMAND} -E remove -f stub_timestamp
  COMMAND ${stubgen_EXECUTABLE} -p ${PYTHON_PROJECT}.foo.python.pyfoo --output .
  COMMAND ${stubgen_EXECUTABLE} -p ${PYTHON_PROJECT}.bar.python.pyBar --output .
  COMMAND ${stubgen_EXECUTABLE} -p ${PYTHON_PROJECT}.foobar.python.pyfoobar --output .
  COMMAND ${CMAKE_COMMAND} -E touch ${PROJECT_BINARY_DIR}/python/stub_timestamp
  MAIN_DEPENDENCY
    python/setup.py.in
  DEPENDS
    python/libs_timestamp
    python/pybind11_timestamp
  WORKING_DIRECTORY python
  COMMAND_EXPAND_LISTS)
endif()

# Look for required python modules
search_python_module(
  NAME setuptools
  PACKAGE setuptools)
search_python_module(
  NAME wheel
  PACKAGE wheel)

add_custom_command(
  OUTPUT python/dist_timestamp
  COMMAND ${CMAKE_COMMAND} -E remove_directory dist
  #COMMAND ${Python3_EXECUTABLE} setup.py bdist_egg bdist_wheel
  COMMAND ${Python3_EXECUTABLE} setup.py bdist_wheel
  COMMAND ${CMAKE_COMMAND} -E touch ${PROJECT_BINARY_DIR}/python/dist_timestamp
  MAIN_DEPENDENCY
    python/setup.py.in
  DEPENDS
    python/setup.py
    python/libs_timestamp
    python/pybind11_timestamp
    $<$<BOOL:${GENERATE_PYTHON_STUB}>:python/stub_timestamp>
  BYPRODUCTS
    python/${PYTHON_PROJECT}
    python/${PYTHON_PROJECT}.egg-info
    python/build
    python/dist
  WORKING_DIRECTORY python
  COMMAND_EXPAND_LISTS)

# Main Target
add_custom_target(python_package ALL
  DEPENDS
    python/dist_timestamp
  WORKING_DIRECTORY python)

if(BUILD_TESTING)
  # make a virtualenv to install our python package in it
  add_custom_command(TARGET python_package POST_BUILD
    # Clean previous install otherwise pip install may do nothing
    COMMAND ${CMAKE_COMMAND} -E remove_directory ${VENV_DIR}
    #COMMAND ${VENV_EXECUTABLE} -p ${Python3_EXECUTABLE}
    COMMAND ${VENV_EXECUTABLE}
      $<$<BOOL:${VENV_USE_SYSTEM_SITE_PACKAGES}>:--system-site-packages>
      ${VENV_DIR}
    #COMMAND ${VENV_EXECUTABLE} ${VENV_DIR}
    # Must NOT call it in a folder containing the setup.py otherwise pip call it
    # (i.e. "python setup.py bdist") while we want to consume the wheel package
    COMMAND ${VENV_Python3_EXECUTABLE} -m pip install
      --find-links=${CMAKE_CURRENT_BINARY_DIR}/python/dist ${PYTHON_PROJECT}==${PROJECT_VERSION}
    # install modules only required to run examples
    COMMAND ${VENV_Python3_EXECUTABLE} -m pip install
      pytest
    BYPRODUCTS ${VENV_DIR}
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    COMMENT "Create venv and install ${PYTHON_PROJECT}"
    VERBATIM)
endif()

######################
##  Python Example  ##
######################
# add_python_example()
# CMake function to generate and build python example.
# Parameters:
#  FILE_NAME: the Python filename
# e.g.:
# add_python_example(
#   FILE_NAME
#     foo.py
# )
function(add_python_example)
  if(NOT BUILD_TESTING)
    return()
  endif()

  set(options "")
  set(oneValueArgs FILE_NAME)
  set(multiValueArgs "")
  cmake_parse_arguments(EXAMPLE
    "${options}"
    "${oneValueArgs}"
    "${multiValueArgs}"
    ${ARGN}
  )
  if(NOT EXAMPLE_FILE_NAME)
    message(FATAL_ERROR "no FILE_NAME provided")
  endif()
  get_filename_component(EXAMPLE_NAME ${EXAMPLE_FILE_NAME} NAME_WE)

  message(STATUS "Configuring example ${EXAMPLE_FILE_NAME} ...")

  add_test(
    NAME python_example_${EXAMPLE_NAME}
    COMMAND ${VENV_Python3_EXECUTABLE} ${EXAMPLE_FILE_NAME}
    WORKING_DIRECTORY ${VENV_DIR})
  message(STATUS "Configuring example ${EXAMPLE_FILE_NAME} ...DONE")
endfunction()