CHANGELOG.md

 # Master (will become release 2.8)
 
+- Add backport of `FindPkgConfig.cmake` from cmake 3.19.4 since there was a bug in
+  an older find module leading to problems finding tbb in debian:10.
+
+- Update the FindTBB cmake module to search for the `TBBConfig.cmake` or the `tbb.pc`
+  file containing the configuration. Add the `AddTBBFlags.cmake` file containing
+  the macro `add_dune_tbb_flags` that must be called to use TBB.
+
 - Set minimal required MPI version in cmake to >= 3.0.
 
 - Previous versions of dune-common imported `std::shared_ptr` and `std::make_shared`
@@ -60,6 +67,11 @@
 - Remove incomplete CPack support that was never used to make an official
   build or tarball.
 
+- Both macros `DUNE_DEPRECATED` and `DUNE_DEPRECATED_MSG(text)` are
+  deprecated and will be removed after Dune 2.8. Use C++14 attribute
+  `[[deprecated]]` but be aware that it is no drop-in replacement,
+  as it must be sometimes placed at different position in the code.
+
 # Release 2.7
 
 - Added fallback implementation to C++20 feature: `std::identity`.

bin/setup-dunepy.py

@@ -10,7 +10,7 @@ import logging
 logger = logging.getLogger(__name__)
 
 try:
-    from dune.common.module import build_dune_py_module, get_dune_py_dir, make_dune_py_module, select_modules, resolve_dependencies
+    from dune.common.module import build_dune_py_module, get_dune_py_dir, make_dune_py_module, select_modules, resolve_dependencies, resolve_order
 except ImportError:
     import os
     here = os.path.dirname(os.path.abspath(__file__))
@@ -19,7 +19,7 @@ except ImportError:
     sys.path.append(modsB)
     sys.path.append(modsA)
     if os.path.exists(os.path.join(modsB, "module.py")):
-        from module import build_dune_py_module, get_dune_py_dir, make_dune_py_module, select_modules, resolve_dependencies
+        from module import build_dune_py_module, get_dune_py_dir, make_dune_py_module, select_modules, resolve_dependencies, resolve_order
     else:
         raise
 
@@ -62,11 +62,7 @@ def main(argv):
         command = ['bash', '-c', 'source ' + optsfile + ' && echo "$CMAKE_FLAGS"']
         proc = subprocess.Popen(command, stdout = subprocess.PIPE)
         stdout, _ = proc.communicate()
-        for arg in shlex.split(buffer_to_str(stdout)):
-            key, value = arg.split('=', 1)
-            if key.startswith('-D'):
-                key = key[2:]
-            definitions[key] = value
+        cmake_args = shlex.split(buffer_to_str(stdout))
         if builddir is None:
             # get the build dir (check for BUILDDIR, DUNE_BUILDDIR in opts file
             # and then DUNE_BUILDDIR in environment variable
@@ -82,7 +78,7 @@ def main(argv):
                 if not builddir:
                     builddir = os.environ.get('DUNE_BUILDDIR', 'build-cmake')
     else:
-        definitions = None
+        cmake_args = None
         if builddir is None:
             builddir = os.environ.get('DUNE_BUILDDIR', 'build-cmake')
 
@@ -98,14 +94,16 @@ def main(argv):
     # use mod and all its dependencies only. Otherwise use all found modules
     # as dependencies.
     if masterModule is None:
-        deps = [m[0] for m in duneModules[0].items()]
+        deps = resolve_order(duneModules[0])
     else:
-        deps = resolve_dependencies(duneModules[0], masterModule)
-        deps.add(masterModule)
+        depsList = resolve_dependencies(duneModules[0], masterModule)
+        deps = {k:v for k,v in duneModules[0].items() if k in depsList}
+        deps = resolve_order(deps)
+        deps += [masterModule]
 
     foundModule = make_dune_py_module(dunepy, deps)
 
-    output = build_dune_py_module(dunepy, definitions, None, builddir)
+    output = build_dune_py_module(dunepy, cmake_args, None, builddir, deps)
 
     print("CMake output")
     print(output)
@@ -116,16 +114,17 @@ def main(argv):
     f.close()
 
     if execute == "install":
-        if deps is None:
-            deps = duneModules[0].items()
         for m in deps:
             moddir = duneModules[1][m]
             pythonModule = toBuildDir(builddir,moddir,m)
-            print("calling install_python in",moddir)
-            command = ['cmake', '--build', '.', '--target', 'install_python']
-            proc = subprocess.Popen(command, cwd=pythonModule, stdout = subprocess.PIPE)
-            stdout, stderr = proc.communicate()
-            logger.debug(buffer_to_str(stdout))
+            print("calling install_python for %s (%s)" % (m,pythonModule))
+            try:
+                command = ['cmake', '--build', '.', '--target', 'install_python']
+                proc = subprocess.Popen(command, cwd=pythonModule, stdout = subprocess.PIPE)
+                stdout, stderr = proc.communicate()
+                logger.debug(buffer_to_str(stdout))
+            except FileNotFoundError:
+                print("Warning: build dir not found possibly module is installed then python bindings should be already available")
 
 if __name__ == "__main__":
     main(sys.argv[1:])

cmake/modules/AddTBBFlags.cmake

+# Defines the functions to use TBB
+#
+# .. cmake_function:: add_dune_tbb_flags
+#
+#    .. cmake_param:: targets
+#       :positional:
+#       :single:
+#       :required:
+#
+#       A list of targets to use TBB with.
+#
+
+# set variable for config.h
+set(HAVE_TBB ${TBB_FOUND})
+
+# perform DUNE-specific setup tasks
+if (TBB_FOUND)
+  dune_register_package_flags(
+    COMPILE_DEFINITIONS ENABLE_TBB=1
+    LIBRARIES TBB::tbb
+    )
+endif()
+
+# function for adding TBB flags to a list of targets
+function(add_dune_tbb_flags _targets)
+  if(TBB_FOUND)
+    foreach(_target ${_targets})
+      target_link_libraries(${_target} PUBLIC TBB::tbb)
+      target_compile_definitions(${_target} PUBLIC ENABLE_TBB=1)
+    endforeach(_target)
+  endif()
+endfunction(add_dune_tbb_flags)

cmake/modules/CMakeLists.txt

+add_subdirectory(FindPkgConfig)
+add_subdirectory(FindPython3)
+
 install(FILES
   AddGMPFlags.cmake
   AddMETISFlags.cmake
   AddParMETISFlags.cmake
   AddPTScotchFlags.cmake
   AddQuadMathFlags.cmake
+  AddTBBFlags.cmake
   AddThreadsFlags.cmake
   AddSuiteSparseFlags.cmake
   AddVcFlags.cmake
@@ -26,7 +30,6 @@ install(FILES
   DunePythonFindPackage.cmake
   DunePythonInstallPackage.cmake
   DunePythonMacros.cmake
-  DunePythonRequireVersion.cmake
   DunePythonTestCommand.cmake
   DunePythonVirtualenv.cmake
   DuneSphinxDoc.cmake

cmake/modules/DuneCommonMacros.cmake

@@ -38,7 +38,9 @@ include(AddThreadsFlags)
 set_package_properties("Threads" PROPERTIES
   DESCRIPTION "Multi-threading library")
 
-find_package(TBB OPTIONAL_COMPONENTS cpf allocator)
+# find library for Threading Building Blocks
+find_package(TBB)
+include(AddTBBFlags)
 
 # find libraries for graph partitioning
 find_package(METIS)

cmake/modules/DuneMacros.cmake

@@ -139,6 +139,11 @@ enable_language(C) # Enable C to skip CXX bindings for some tests.
 # find_package(Threads) everywhere
 set(THREADS_PREFER_PTHREAD_FLAG TRUE CACHE BOOL "Prefer -pthread compiler and linker flag")
 
+# Add a backport of cmakes FindPkgConfig module
+if(${CMAKE_VERSION} VERSION_LESS "3.19.4")
+  list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/FindPkgConfig")
+endif()
+
 include(FeatureSummary)
 include(DuneEnableAllPackages)
 include(DuneTestMacros)

cmake/modules/DunePythonCommonMacros.cmake

@@ -63,37 +63,36 @@
 #    the presence of the configure time virtualenv described in :ref:`DunePythonVirtualenv`.
 #
 
+# unless the user has defined the variable, unversioned names (like python3) are found
+# first, to match what users most probably use later on to call the executable
+if(NOT DEFINED Python3_FIND_UNVERSIONED_NAMES)
+  set(Python3_FIND_UNVERSIONED_NAMES "FIRST")
+endif()
+
+# include code from CMake 3.20 to back-port using unversioned Python first
+if(${CMAKE_VERSION} VERSION_LESS "3.20")
+  list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/FindPython3")
+endif()
+
 # Include all the other parts of the python extension to avoid that users need
 # to explicitly include parts of our build system.
 include(DunePythonFindPackage)
 include(DunePythonInstallPackage)
-include(DunePythonRequireVersion)
 include(DunePythonTestCommand)
 
-# Update the list of valid python versions, the shipped CMake modules tend to outdate...
-# Mention all those not present in CMake 2.8.12
-set(Python_ADDITIONAL_VERSIONS 3.8 3.7 3.6 3.5 3.4)
-
-# Find the Python Interpreter
-find_package(PythonInterp 3)
-
-# interpreter was found set available version of library to that version
-if(PYTHONINTERP_FOUND)
-  set(Python_ADDITIONAL_VERSIONS ${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR})
-endif()
+# Find the Python Interpreter and libraries
+find_package(Python3 COMPONENTS Interpreter Development)
 
-# Find the Python libraries
-find_package(PythonLibs)
 
 # Determine whether the given interpreter is running inside a virtualenv
-if(PYTHONINTERP_FOUND)
+if(Python3_Interpreter_FOUND)
   include(DuneExecuteProcess)
   include(DunePathHelper)
   dune_module_path(MODULE dune-common
                    RESULT scriptdir
                    SCRIPT_DIR)
 
-  dune_execute_process(COMMAND "${PYTHON_EXECUTABLE}" "${scriptdir}/envdetect.py"
+  dune_execute_process(COMMAND "${Python3_EXECUTABLE}" "${scriptdir}/envdetect.py"
                        RESULT_VARIABLE DUNE_PYTHON_SYSTEM_IS_VIRTUALENV
                        )
 endif()

cmake/modules/DunePythonFindPackage.cmake

@@ -36,7 +36,7 @@
 #       :single:
 #
 #       The python interpreter, whose paths are searched for the package.
-#       Defaults to :code:`${PYTHON_EXECUTABLE}`, might differ when dealing with
+#       Defaults to :code:`${Python3_EXECUTABLE}`, might differ when dealing with
 #       the configure-time virtualenv set up with :ref:`DUNE_PYTHON_VIRTUALENV_SETUP`.
 #
 #    Find a given python package on the system.
@@ -58,7 +58,7 @@ function(dune_python_find_package)
     set(PYPACKAGE_RESULT DUNE_PYTHON_${PYPACKAGE_PACKAGE}_FOUND)
   endif()
   if(NOT PYPACKAGE_INTERPRETER)
-    set(PYPACKAGE_INTERPRETER "${PYTHON_EXECUTABLE}")
+    set(PYPACKAGE_INTERPRETER "${Python3_EXECUTABLE}")
   endif()
   if(PYPACKAGE_EXACT AND NOT PYPACKAGE_VERSION)
     message(FATAL_ERROR "dune_python_find_package: EXACT given, but no VERSION specified.")

cmake/modules/DunePythonInstallPackage.cmake

@@ -28,6 +28,12 @@
 #    Set this variable to have all installations of python packages use
 #    :code:`pip --editable`.
 #
+#
+# .. cmake_variable:: DUNE_PYTHON_ADDITIONAL_PIP_PARAMS
+#
+#    Use this variable to set additional flags for pip in this build. This can e.g.
+#    be used to point pip to alternative package indices in restricted environments.
+#
 
 function(dune_python_install_package)
   # Parse Arguments
@@ -79,7 +85,7 @@ function(dune_python_install_package)
   endif()
 
   set(INSTALL_CMDLINE -m pip install
-                      "${INSTALL_OPTION}" --upgrade "${WHEEL_OPTION}" "${EDIT_OPTION}" ${PYINST_ADDITIONAL_PIP_PARAMS}
+                      "${INSTALL_OPTION}" --upgrade "${WHEEL_OPTION}" "${EDIT_OPTION}" ${PYINST_ADDITIONAL_PIP_PARAMS} ${DUNE_PYTHON_ADDITIONAL_PIP_PARAMS}
                       "${PYINST_FULLPATH}")
 
 
@@ -121,7 +127,7 @@ function(dune_python_install_package)
 
   # Add a custom target that globally installs this package if requested
   add_custom_target(${targetname}
-                    COMMAND ${PYTHON_EXECUTABLE} ${INSTALL_CMDLINE}
+                    COMMAND ${Python3_EXECUTABLE} ${INSTALL_CMDLINE}
                     COMMENT "Installing the python package at ${PYINST_FULLPATH}"
                     )
 
@@ -135,7 +141,7 @@ function(dune_python_install_package)
   #
 
   # Construct the wheel installation commandline
-  set(WHEEL_COMMAND ${PYTHON_EXECUTABLE} -m pip wheel -w ${DUNE_PYTHON_WHEELHOUSE} ${PYINST_FULLPATH})
+  set(WHEEL_COMMAND ${Python3_EXECUTABLE} -m pip wheel -w ${DUNE_PYTHON_WHEELHOUSE} ${PYINST_FULLPATH})
 
   # Add the installation rule
   install(CODE "message(\"Installing wheel for python package at ${PYINST_FULLPATH}...\")

cmake/modules/DunePythonMacros.cmake

@@ -2,14 +2,14 @@
 option(DUNE_ENABLE_PYTHONBINDINGS "Enable Python bindings for DUNE" OFF)
 
 if( DUNE_ENABLE_PYTHONBINDINGS )
-  if(NOT PYTHONINTERP_FOUND)
-    message(FATAL_ERROR "Module dune-python requires a Python interpreter")
+  if(NOT Python3_Interpreter_FOUND)
+    message(FATAL_ERROR "Python bindings require a Python 3 interpreter")
   endif()
-  if(NOT PYTHONLIBS_FOUND)
-    message(FATAL_ERROR "Found a Python interpreter but module dune-python also requires the Python libraries (e.g. a python-dev package)")
+  if(NOT Python3_INCLUDE_DIRS)
+    message(FATAL_ERROR "Found a Python interpreter but the Python bindings also requires the Python libraries (a package named like python-dev package or python3-devel)")
   endif()
 
-  include_directories("${PYTHON_INCLUDE_DIRS}")
+  include_directories("${Python3_INCLUDE_DIRS}")
 
   function(add_python_targets base)
     include(DuneSymlinkOrCopy)

cmake/modules/DunePythonRequireVersion.cmake

-# This module provided functions to implement constraints on the major version of the python interpreter.
-# With Python2 support being dropped from Dune these are not needed anymore.
-
-if(DUNE_PYTHON_FORCE_PYTHON2 OR DUNE_PYTHON_FORCE_PYTHON3 OR DUNE_PYTHON_FORCE_PYTHON_VERSION)
-  message(WARNING "Python 2 support has been dropped from Dune. The variables DUNE_PYTHON_FORCE_PYTHON2, DUNE_PYTHON_FORCE_PYTHON3 and DUNE_PYTHON_FORCE_PYTHON_VERSION variables are not doing anything anymore.")
-endif()
-
-function(dune_python_require_version)
-  message(WARNING "Dune has dropped Python2 support. The function dune_python_require_version is now no-op, is deprecated, and will be removed after Dune 2.7.")
-endfunction()
-
-function(dune_python_force_version)
-  message(WARNING "Dune has dropped Python2 support. The function dune_python_force_version is now no-op, is deprecated, and will be removed after Dune 2.7.")
-endfunction()

cmake/modules/DunePythonTestCommand.cmake

@@ -2,20 +2,32 @@
 #
 # .. cmake_function:: dune_python_add_test
 #
-#    .. cmake_param:: COMMAND
+#    .. cmake_param:: SCRIPT
 #       :multi:
-#       :required:
 #
-#       The command to run. It will be executed during :code:`make test_python`
-#       and during `ctest`.
+#       The script to execute using the python interpreter. It will be executed during :code:`make test_python`
+#       and during `ctest`. You are required to either pass SCRIPT or MODULE.
 #
 #       .. note::
 #
-#          If your testing command involves an invocation of the python
-#          interpreter you should use :code:`${PYTHON_EXECUTABLE}` for that.
-#          Also calling python executables through :code:`-m` is generally to
-#          be favored, e.g. :code:`${PYTHON_EXECUTABLE} -m pytest` instead of
-#          :code:`py.test`.
+#          The script will be executed using :code:`${Python3_EXECUTABLE} SCRIPT`. If the INTERPRETER
+#          option is given, that interpreter is used instead.
+#
+#    .. cmake_param:: MODULE
+#       :multi:
+#
+#       The Python module to be executed.  It will be executed during :code:`make test_python`
+#       and during `ctest`. You are required to either pass SCRIPT or MODULE.
+#
+#       .. note::
+#
+#          The script will be executed using :code:`${Python3_EXECUTABLE} -m MODULE`. If the INTERPRETER
+#          option is given, that interpreter is used instead.
+#
+#    .. cmake_param:: INTERPRETER
+#       :single:
+#
+#       The Python interpreter to use for this test. It defaults to the one found by CMake.
 #
 #    .. cmake_param:: WORKING_DIRECTORY
 #       :single:
@@ -39,23 +51,36 @@ function(dune_python_add_test)
   # Parse Arguments
   include(CMakeParseArguments)
   set(OPTION)
-  set(SINGLE WORKING_DIRECTORY NAME)
-  set(MULTI COMMAND LABELS)
+  set(SINGLE WORKING_DIRECTORY NAME INTERPRETER)
+  set(MULTI SCRIPT COMMAND LABELS MODULE)
+
   cmake_parse_arguments(PYTEST "${OPTION}" "${SINGLE}" "${MULTI}" ${ARGN})
+  if(PYTEST_COMMAND)
+    message(FATAL_ERROR "dune_python_add_test: COMMAND argument should not be used, use SCRIPT instead providing only the Python script and not the Python interpreter")
+  endif()
   if(PYTEST_UNPARSED_ARGUMENTS)
     message(WARNING "Unparsed arguments in dune_python_add_test: This often indicates typos!")
   endif()
 
   # Apply defaults
+  if(NOT PYTEST_INTERPRETER)
+    set(PYTEST_INTERPRETER ${Python3_EXECUTABLE})
+  endif()
   if(NOT PYTEST_WORKING_DIRECTORY)
     set(PYTEST_WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
   endif()
-  if(NOT PYTEST_COMMAND)
-    message(FATAL_ERROR "dune_python_add_test: no COMMAND to execute specified!")
+  if((NOT PYTEST_MODULE) AND (NOT PYTEST_SCRIPT))
+    message(FATAL_ERROR "dune_python_add_test: Either SCRIPT or MODULE need to be specified!")
+  endif()
+  if(PYTEST_MODULE AND PYTEST_SCRIPT)
+    message(FATAL_ERROR "dune_python_add_test: You can only specify either SCRIPT or MODULE, not both!")
+  endif()
+  if(PYTEST_MODULE)
+    set(PYTEST_SCRIPT -m ${PYTEST_MODULE})
   endif()
   if(NOT PYTEST_NAME)
     set(commandstr "")
-    foreach(comm ${PYTEST_COMMAND})
+    foreach(comm ${PYTEST_SCRIPT})
       set(commandstr "${commandstr}_${comm}")
     endforeach()
     set(commandstr "${commandstr}_${PYTEST_WORKING_DIRECTORY}")
@@ -64,7 +89,7 @@ function(dune_python_add_test)
 
   # Actually run the command
   add_custom_target(target_${PYTEST_NAME}
-                    COMMAND ${PYTEST_COMMAND}
+                    COMMAND ${PYTEST_INTERPRETER} ${PYTEST_SCRIPT}
                     WORKING_DIRECTORY ${PYTEST_WORKING_DIRECTORY})
 
   # Build this during make test_python
@@ -74,7 +99,7 @@ function(dune_python_add_test)
   dune_declare_test_label(LABELS ${PYTEST_LABELS})
   # Also build this during ctest
   _add_test(NAME ${PYTEST_NAME}
-            COMMAND ${PYTEST_COMMAND}
+            COMMAND ${PYTEST_INTERPRETER} ${PYTEST_SCRIPT}
             WORKING_DIRECTORY ${PYTEST_WORKING_DIRECTORY}
             )
   # Set the labels on the test

cmake/modules/DunePythonVirtualenv.cmake

@@ -128,7 +128,7 @@ if(NOT IS_DIRECTORY "${DUNE_PYTHON_VIRTUALENV_PATH}")
   if(DUNE_PYTHON_virtualenv_FOUND)
     set(VIRTUALENV_PACKAGE_NAME virtualenv)
     set(NOPIP_OPTION --no-pip)
-    set(INTERPRETER_OPTION -p "${PYTHON_EXECUTABLE}")
+    set(INTERPRETER_OPTION -p "${Python3_EXECUTABLE}")
   endif()
 
   if(("${VIRTUALENV_PACKAGE_NAME}" STREQUAL "venv") AND DUNE_PYTHON_SYSTEM_IS_VIRTUALENV)
@@ -140,7 +140,7 @@ if(NOT IS_DIRECTORY "${DUNE_PYTHON_VIRTUALENV_PATH}")
   message("-- Building a virtualenv in ${DUNE_PYTHON_VIRTUALENV_PATH}")
   # First, try to build it with pip installed, but only if the user has not set DUNE_PYTHON_ALLOW_GET_PIP
   if(NOT DUNE_PYTHON_ALLOW_GET_PIP)
-    dune_execute_process(COMMAND ${PYTHON_EXECUTABLE}
+    dune_execute_process(COMMAND ${Python3_EXECUTABLE}
                                   -m ${VIRTUALENV_PACKAGE_NAME}
                                   ${INTERPRETER_OPTION}
                                   "${DUNE_PYTHON_VIRTUALENV_PATH}"
@@ -160,7 +160,7 @@ if(NOT IS_DIRECTORY "${DUNE_PYTHON_VIRTUALENV_PATH}")
     file(REMOVE_RECURSE "${DUNE_PYTHON_VIRTUALENV_PATH}")
 
     # try to build the env without pip
-    dune_execute_process(COMMAND ${PYTHON_EXECUTABLE}
+    dune_execute_process(COMMAND ${Python3_EXECUTABLE}
                                   -m ${VIRTUALENV_PACKAGE_NAME}
                                   ${INTERPRETER_OPTION}
                                   ${NOPIP_OPTION}

cmake/modules/DuneSphinxCMakeDoc.cmake

@@ -68,7 +68,7 @@ function(dune_cmake_sphinx_doc)
   endif()
 
   # Only proceed if the python interpreter was found by cmake
-  if(NOT PYTHONINTERP_FOUND)
+  if(NOT Python3_Interpreter_FOUND)
     message("-- Skipping building CMake API documentation (Python interpreter was not found!)")
     return()
   endif()
@@ -156,7 +156,7 @@ function(dune_cmake_sphinx_doc)
   foreach(module ${SPHINX_DOC_MODULE_LIST})
     get_filename_component(modname ${module} NAME)
     add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/modules/${modname}
-                       COMMAND ${PYTHON_EXECUTABLE} ${DUNE_SPHINX_EXT_PATH}/extract_cmake_data.py
+                       COMMAND ${Python3_EXECUTABLE} ${DUNE_SPHINX_EXT_PATH}/extract_cmake_data.py
                          --module=${module}
                          --builddir=${CMAKE_CURRENT_BINARY_DIR}
                        DEPENDS ${module}

cmake/modules/DuneSphinxDoc.cmake

 find_package(Sphinx)
-find_package(PythonInterp)
+find_package(Python3 COMPONENTS Interpreter Development)
 
 function(dune_sphinx_doc)
   # Only proceed if Sphinx was found on the system
@@ -9,7 +9,7 @@ function(dune_sphinx_doc)
   endif()
 
   # Only proceed if the python interpreter was found by cmake
-  if(NOT PYTHONINTERP_FOUND)
+  if(NOT Python3_Interpreter_FOUND)
     message("-- Skipping building Sphinx documentation (Python interpreter was not found!)")
     return()
   endif()

cmake/modules/FindPkgConfig/CMakeLists.txt

+install(FILES
+  FindPkgConfig.cmake
+  DESTINATION ${DUNE_INSTALL_MODULEDIR}/FindPkgConfig)
\ No newline at end of file

cmake/modules/FindPython3/CMakeLists.txt

+install(FILES
+  FindPython3.cmake
+  Support.cmake
+  DESTINATION ${DUNE_INSTALL_MODULEDIR}/FindPython3)

cmake/modules/FindPython3/FindPython3.cmake

+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+FindPython3
+-----------
+
+.. versionadded:: 3.12
+
+Find Python 3 interpreter, compiler and development environment (include
+directories and libraries).
+
+When a version is requested, it can be specified as a simple value or as a
+range. For a detailed description of version range usage and capabilities,
+refer to the :command:`find_package` command.
+
+The following components are supported:
+
+* ``Interpreter``: search for Python 3 interpreter
+* ``Compiler``: search for Python 3 compiler. Only offered by IronPython.
+* ``Development``: search for development artifacts (include directories and
+  libraries). This component includes two sub-components which can be specified
+  independently:
+
+  * ``Development.Module``: search for artifacts for Python 3 module
+    developments.
+  * ``Development.Embed``: search for artifacts for Python 3 embedding
+    developments.
+
+* ``NumPy``: search for NumPy include directories.
+
+If no ``COMPONENTS`` are specified, ``Interpreter`` is assumed.
+
+If component ``Development`` is specified, it implies sub-components
+``Development.Module`` and ``Development.Embed``.
+
+To ensure consistent versions between components ``Interpreter``, ``Compiler``,
+``Development`` (or one of its sub-components) and ``NumPy``, specify all
+components at the same time::
+
+  find_package (Python3 COMPONENTS Interpreter Development)
+
+This module looks only for version 3 of Python. This module can be used
+concurrently with :module:`FindPython2` module to use both Python versions.
+
+The :module:`FindPython` module can be used if Python version does not matter
+for you.
+
+.. note::
+
+  If components ``Interpreter`` and ``Development`` (or one of its
+  sub-components) are both specified, this module search only for interpreter
+  with same platform architecture as the one defined by ``CMake``
+  configuration. This constraint does not apply if only ``Interpreter``
+  component is specified.
+
+Imported Targets
+^^^^^^^^^^^^^^^^
+
+This module defines the following :ref:`Imported Targets <Imported Targets>`
+(when :prop_gbl:`CMAKE_ROLE` is ``PROJECT``):
+
+``Python3::Interpreter``
+  Python 3 interpreter. Target defined if component ``Interpreter`` is found.
+``Python3::Compiler``
+  Python 3 compiler. Target defined if component ``Compiler`` is found.
+``Python3::Module``
+  Python 3 library for Python module. Target defined if component
+  ``Development.Module`` is found.
+``Python3::Python``
+  Python 3 library for Python embedding. Target defined if component
+  ``Development.Embed`` is found.
+``Python3::NumPy``
+  NumPy library for Python 3. Target defined if component ``NumPy`` is found.
+
+Result Variables
+^^^^^^^^^^^^^^^^
+
+This module will set the following variables in your project
+(see :ref:`Standard Variable Names <CMake Developer Standard Variable Names>`):
+
+``Python3_FOUND``
+  System has the Python 3 requested components.
+``Python3_Interpreter_FOUND``
+  System has the Python 3 interpreter.
+``Python3_EXECUTABLE``
+  Path to the Python 3 interpreter.
+``Python3_INTERPRETER_ID``
+  A short string unique to the interpreter. Possible values include:
+    * Python
+    * ActivePython
+    * Anaconda
+    * Canopy
+    * IronPython
+    * PyPy
+``Python3_STDLIB``
+  Standard platform independent installation directory.
+
+  Information returned by
+  ``distutils.sysconfig.get_python_lib(plat_specific=False,standard_lib=True)``
+  or else ``sysconfig.get_path('stdlib')``.
+``Python3_STDARCH``
+  Standard platform dependent installation directory.
+
+  Information returned by
+  ``distutils.sysconfig.get_python_lib(plat_specific=True,standard_lib=True)``
+  or else ``sysconfig.get_path('platstdlib')``.
+``Python3_SITELIB``
+  Third-party platform independent installation directory.
+
+  Information returned by
+  ``distutils.sysconfig.get_python_lib(plat_specific=False,standard_lib=False)``
+  or else ``sysconfig.get_path('purelib')``.
+``Python3_SITEARCH``
+  Third-party platform dependent installation directory.
+
+  Information returned by
+  ``distutils.sysconfig.get_python_lib(plat_specific=True,standard_lib=False)``
+  or else ``sysconfig.get_path('platlib')``.
+``Python3_SOABI``
+  Extension suffix for modules.
+
+  Information returned by
+  ``distutils.sysconfig.get_config_var('SOABI')`` or computed from
+  ``distutils.sysconfig.get_config_var('EXT_SUFFIX')`` or
+  ``python3-config --extension-suffix``. If package ``distutils.sysconfig`` is
+  not available, ``sysconfig.get_config_var('SOABI')`` or
+  ``sysconfig.get_config_var('EXT_SUFFIX')`` are used.
+``Python3_Compiler_FOUND``
+  System has the Python 3 compiler.
+``Python3_COMPILER``
+  Path to the Python 3 compiler. Only offered by IronPython.
+``Python3_COMPILER_ID``
+  A short string unique to the compiler. Possible values include:
+    * IronPython
+``Python3_DOTNET_LAUNCHER``
+  The ``.Net`` interpreter. Only used by ``IronPython`` implementation.
+``Python3_Development_FOUND``
+  System has the Python 3 development artifacts.
+``Python3_Development.Module_FOUND``
+  System has the Python 3 development artifacts for Python module.
+``Python3_Development.Embed_FOUND``
+  System has the Python 3 development artifacts for Python embedding.
+``Python3_INCLUDE_DIRS``
+  The Python 3 include directories.
+``Python3_LINK_OPTIONS``
+  The Python 3 link options. Some configurations require specific link options
+  for a correct build and execution.
+``Python3_LIBRARIES``
+  The Python 3 libraries.
+``Python3_LIBRARY_DIRS``
+  The Python 3 library directories.
+``Python3_RUNTIME_LIBRARY_DIRS``
+  The Python 3 runtime library directories.
+``Python3_VERSION``
+  Python 3 version.
+``Python3_VERSION_MAJOR``
+  Python 3 major version.
+``Python3_VERSION_MINOR``
+  Python 3 minor version.
+``Python3_VERSION_PATCH``
+  Python 3 patch version.
+``Python3_PyPy_VERSION``
+  Python 3 PyPy version.
+``Python3_NumPy_FOUND``
+  System has the NumPy.
+``Python3_NumPy_INCLUDE_DIRS``
+  The NumPy include directories.
+``Python3_NumPy_VERSION``
+  The NumPy version.
+
+Hints
+^^^^^
+
+``Python3_ROOT_DIR``
+  Define the root directory of a Python 3 installation.
+
+``Python3_USE_STATIC_LIBS``
+  * If not defined, search for shared libraries and static libraries in that
+    order.
+  * If set to TRUE, search **only** for static libraries.
+  * If set to FALSE, search **only** for shared libraries.
+
+``Python3_FIND_ABI``
+  This variable defines which ABIs, as defined in
+  `PEP 3149 <https://www.python.org/dev/peps/pep-3149/>`_, should be searched.
+
+  .. note::
+
+    If ``Python3_FIND_ABI`` is not defined, any ABI will be searched.
+
+  The ``Python3_FIND_ABI`` variable is a 3-tuple specifying, in that order,
+  ``pydebug`` (``d``), ``pymalloc`` (``m``) and ``unicode`` (``u``) flags.
+  Each element can be set to one of the following:
+
+  * ``ON``: Corresponding flag is selected.
+  * ``OFF``: Corresponding flag is not selected.
+  * ``ANY``: The two possibilities (``ON`` and ``OFF``) will be searched.
+
+  From this 3-tuple, various ABIs will be searched starting from the most
+  specialized to the most general. Moreover, ``debug`` versions will be
+  searched **after** ``non-debug`` ones.
+
+  For example, if we have::
+
+    set (Python3_FIND_ABI "ON" "ANY" "ANY")
+
+  The following flags combinations will be appended, in that order, to the
+  artifact names: ``dmu``, ``dm``, ``du``, and ``d``.
+
+  And to search any possible ABIs::
+
+    set (Python3_FIND_ABI "ANY" "ANY" "ANY")
+
+  The following combinations, in that order, will be used: ``mu``, ``m``,
+  ``u``, ``<empty>``, ``dmu``, ``dm``, ``du`` and ``d``.
+
+  .. note::
+
+    This hint is useful only on ``POSIX`` systems. So, on ``Windows`` systems,
+    when ``Python3_FIND_ABI`` is defined, ``Python`` distributions from
+    `python.org <https://www.python.org/>`_ will be found only if value for
+    each flag is ``OFF`` or ``ANY``.
+
+``Python3_FIND_STRATEGY``
+  This variable defines how lookup will be done.
+  The ``Python3_FIND_STRATEGY`` variable can be set to one of the following:
+
+  * ``VERSION``: Try to find the most recent version in all specified
+    locations.
+    This is the default if policy :policy:`CMP0094` is undefined or set to
+    ``OLD``.
+  * ``LOCATION``: Stops lookup as soon as a version satisfying version
+    constraints is founded.
+    This is the default if policy :policy:`CMP0094` is set to ``NEW``.
+
+``Python3_FIND_REGISTRY``
+  On Windows the ``Python3_FIND_REGISTRY`` variable determine the order
+  of preference between registry and environment variables.
+  The ``Python3_FIND_REGISTRY`` variable can be set to one of the following:
+
+  * ``FIRST``: Try to use registry before environment variables.
+    This is the default.
+  * ``LAST``: Try to use registry after environment variables.
+  * ``NEVER``: Never try to use registry.
+
+``Python3_FIND_FRAMEWORK``
+  On macOS the ``Python3_FIND_FRAMEWORK`` variable determine the order of
+  preference between Apple-style and unix-style package components.
+  This variable can take same values as :variable:`CMAKE_FIND_FRAMEWORK`
+  variable.
+
+  .. note::
+
+    Value ``ONLY`` is not supported so ``FIRST`` will be used instead.
+
+  If ``Python3_FIND_FRAMEWORK`` is not defined, :variable:`CMAKE_FIND_FRAMEWORK`
+  variable will be used, if any.
+
+``Python3_FIND_VIRTUALENV``
+  This variable defines the handling of virtual environments managed by
+  ``virtualenv`` or ``conda``. It is meaningful only when a virtual environment
+  is active (i.e. the ``activate`` script has been evaluated). In this case, it
+  takes precedence over ``Python3_FIND_REGISTRY`` and ``CMAKE_FIND_FRAMEWORK``
+  variables.  The ``Python3_FIND_VIRTUALENV`` variable can be set to one of the
+  following:
+
+  * ``FIRST``: The virtual environment is used before any other standard
+    paths to look-up for the interpreter. This is the default.
+  * ``ONLY``: Only the virtual environment is used to look-up for the
+    interpreter.
+  * ``STANDARD``: The virtual environment is not used to look-up for the
+    interpreter but environment variable ``PATH`` is always considered.
+    In this case, variable ``Python3_FIND_REGISTRY`` (Windows) or
+    ``CMAKE_FIND_FRAMEWORK`` (macOS) can be set with value ``LAST`` or
+    ``NEVER`` to select preferably the interpreter from the virtual
+    environment.
+
+  .. note::
+
+    If the component ``Development`` is requested, it is **strongly**
+    recommended to also include the component ``Interpreter`` to get expected
+    result.
+
+``Python3_FIND_IMPLEMENTATIONS``
+  This variable defines, in an ordered list, the different implementations
+  which will be searched. The ``Python3_FIND_IMPLEMENTATIONS`` variable can
+  hold the following values:
+
+  * ``CPython``: this is the standard implementation. Various products, like
+    ``Anaconda`` or ``ActivePython``, rely on this implementation.
+  * ``IronPython``: This implementation use the ``CSharp`` language for
+    ``.NET Framework`` on top of the `Dynamic Language Runtime` (``DLR``).
+    See `IronPython <http://ironpython.net>`_.
+  * ``PyPy``: This implementation use ``RPython`` language and
+    ``RPython translation toolchain`` to produce the python interpreter.
+    See `PyPy <https://www.pypy.org>`_.
+
+  The default value is:
+
+  * Windows platform: ``CPython``, ``IronPython``
+  * Other platforms: ``CPython``
+
+  .. note::
+
+    This hint has the lowest priority of all hints, so even if, for example,
+    you specify ``IronPython`` first and ``CPython`` in second, a python
+    product based on ``CPython`` can be selected because, for example with
+    ``Python3_FIND_STRATEGY=LOCATION``, each location will be search first for
+    ``IronPython`` and second for ``CPython``.
+
+  .. note::
+
+    When ``IronPython`` is specified, on platforms other than ``Windows``, the
+    ``.Net`` interpreter (i.e. ``mono`` command) is expected to be available
+    through the ``PATH`` variable.
+
+``Python3_FIND_UNVERSIONED_NAMES``
+  .. versionadded:: 3.20
+
+  This variable defines how the generic names will be searched. Currently, it
+  only applies to the generic names of the interpreter, namely, ``python3`` and
+  ``python``.
+  The ``Python3_FIND_UNVERSIONED_NAMES`` variable can be set to one of the
+  following values:
+
+  * ``FIRST``: The generic names are searched before the more specialized ones
+    (such as ``python3.5`` for example).
+  * ``LAST``: The generic names are searched after the more specialized ones.
+    This is the default.
+  * ``NEVER``: The generic name are not searched at all.
+
+Artifacts Specification
+^^^^^^^^^^^^^^^^^^^^^^^
+
+To solve special cases, it is possible to specify directly the artifacts by
+setting the following variables:
+
+``Python3_EXECUTABLE``
+  The path to the interpreter.
+
+``Python3_COMPILER``
+  The path to the compiler.
+
+``Python3_DOTNET_LAUNCHER``
+  The ``.Net`` interpreter. Only used by ``IronPython`` implementation.
+
+``Python3_LIBRARY``
+  The path to the library. It will be used to compute the
+  variables ``Python3_LIBRARIES``, ``Python3_LIBRARY_DIRS`` and
+  ``Python3_RUNTIME_LIBRARY_DIRS``.
+
+``Python3_INCLUDE_DIR``
+  The path to the directory of the ``Python`` headers. It will be used to
+  compute the variable ``Python3_INCLUDE_DIRS``.
+
+``Python3_NumPy_INCLUDE_DIR``
+  The path to the directory of the ``NumPy`` headers. It will be used to
+  compute the variable ``Python3_NumPy_INCLUDE_DIRS``.
+
+.. note::
+
+  All paths must be absolute. Any artifact specified with a relative path
+  will be ignored.
+
+.. note::
+
+  When an artifact is specified, all ``HINTS`` will be ignored and no search
+  will be performed for this artifact.
+
+  If more than one artifact is specified, it is the user's responsibility to
+  ensure the consistency of the various artifacts.
+
+By default, this module supports multiple calls in different directories of a
+project with different version/component requirements while providing correct
+and consistent results for each call. To support this behavior, ``CMake`` cache
+is not used in the traditional way which can be problematic for interactive
+specification. So, to enable also interactive specification, module behavior
+can be controlled with the following variable:
+
+``Python3_ARTIFACTS_INTERACTIVE``
+  Selects the behavior of the module. This is a boolean variable:
+
+  * If set to ``TRUE``: Create CMake cache entries for the above artifact
+    specification variables so that users can edit them interactively.
+    This disables support for multiple version/component requirements.
+  * If set to ``FALSE`` or undefined: Enable multiple version/component
+    requirements.
+
+Commands
+^^^^^^^^
+
+This module defines the command ``Python3_add_library`` (when
+:prop_gbl:`CMAKE_ROLE` is ``PROJECT``), which has the same semantics as
+:command:`add_library` and adds a dependency to target ``Python3::Python`` or,
+when library type is ``MODULE``, to target ``Python3::Module`` and takes care
+of Python module naming rules::
+
+  Python3_add_library (<name> [STATIC | SHARED | MODULE [WITH_SOABI]]
+                       <source1> [<source2> ...])
+
+If the library type is not specified, ``MODULE`` is assumed.
+
+For ``MODULE`` library type, if option ``WITH_SOABI`` is specified, the
+module suffix will include the ``Python3_SOABI`` value, if any.
+#]=======================================================================]
+
+
+set (_PYTHON_PREFIX Python3)
+
+set (_Python3_REQUIRED_VERSION_MAJOR 3)
+
+include (${CMAKE_CURRENT_LIST_DIR}/Support.cmake)
+
+if (COMMAND __Python3_add_library)
+  macro (Python3_add_library)
+    __Python3_add_library (Python3 ${ARGV})
+  endmacro()
+endif()
+
+unset (_PYTHON_PREFIX)