conan: Migrate to conan v2 tools

Co-authored-by: Dean Moldovan <[email protected]>

Author: hellozee

.github/workflows/test_package.yml

@@ -24,7 +24,7 @@ jobs:
         echo CXX=/usr/bin/clang++ >> $GITHUB_ENV
     - name: Install Conan
       run: | 
-        python -m pip install conan==1.53
+        python -m pip install conan==1.59
         conan config set general.revisions_enabled=True
         conan profile new default --detect
         conan profile update settings.compiler.cppstd=17 default

changelog.md

@@ -1,8 +1,9 @@
 # Changelog
 
-## v1.4.6 | In progress
+## v1.5.0 | 2023-02-28
 
 - Fixed symlink re-creation, in case already existing symlink was invalid
+- Updated to conan v2 methods
 
 ## v1.4.5 | 2022-07-15
 

conanfile.py

@@ -1,12 +1,16 @@
 import os
 import pathlib
-from conans import ConanFile, tools
+from conan import ConanFile
+from conan.tools.files import get, replace_in_file, download, rmdir, copy
+from conan.tools.scm import Version
+
+required_conan_version = ">=1.56.0"
 
 
 # noinspection PyUnresolvedReferences
 class EmbeddedPython(ConanFile):
     name = "embedded_python"
-    version = "1.4.5"  # of the Conan package, `options.version` is the Python version
+    version = "1.5.0"  # of the Conan package, `options.version` is the Python version
     license = "PSFL"
     description = "Embedded distribution of Python"
     topics = "embedded", "python"
@@ -50,23 +54,26 @@ def build_requirements(self):
         if self.settings.os == "Windows":
             return
 
-        self.build_requires("sqlite3/3.35.5")
-        self.build_requires("bzip2/1.0.8")
-        self.build_requires("xz_utils/5.2.5")
-        self.build_requires("mpdecimal/2.4.2")
-        self.build_requires("zlib/1.2.11")
+        self.tool_requires("sqlite3/3.35.5")
+        self.tool_requires("bzip2/1.0.8")
+        self.tool_requires("xz_utils/5.2.5")
+        self.tool_requires("zlib/1.2.11")
         if self.settings.os == "Linux":
-            self.build_requires("libffi/3.4.2")
-            self.build_requires("libuuid/1.0.3")
+            self.tool_requires("libffi/3.4.2")
+            self.tool_requires("libuuid/1.0.3")
+            if Version(self.pyversion) < "3.8":
+                self.tool_requires("mpdecimal/2.4.2")
+            else:
+                self.tool_requires("mpdecimal/2.5.0")
 
         # The pre-conan-center-index version of `openssl` was capitalized as `OpenSSL`.
         # Both versions can't live in the same Conan cache so we need this compatibility
         # option to pick the available version. The cache case-sensitivity issue should
         # be solved in Conan 2.0, but we need this for now.
         if self.options.openssl_variant == "lowercase":
-            self.build_requires("openssl/1.1.1k")
+            self.tool_requires("openssl/1.1.1k")
         else:
-            self.build_requires("OpenSSL/1.1.1f")
+            self.tool_requires("OpenSSL/1.1.1f")
 
     @property
     def pyversion(self):
@@ -129,7 +136,7 @@ def _gather_licenses(self, bootstrap):
         )
 
     def build(self):
-        tools.replace_in_file("embedded_python.cmake", "${self.pyversion}", str(self.pyversion))
+        replace_in_file(self, "embedded_python.cmake", "${self.pyversion}", str(self.pyversion))
 
         prefix = pathlib.Path(self.build_folder) / "embedded_python"
         if self.settings.os == "Windows":
@@ -155,18 +162,18 @@ def build(self):
         )
 
     def package(self):
-        self.copy("embedded_python/*", keep_path=True)
-        self.copy("embedded_python_tools.py")
-        self.copy("embedded_python.cmake")
-        self.copy("embedded_python/LICENSE.txt", dst="licenses", keep_path=False)
-        self.copy("package_licenses.txt", dst="licenses")
+        src = self.build_folder
+        license_folder = pathlib.Path(self.package_folder, "licenses")
+        copy(self, "embedded_python*", src, self.package_folder)
+        copy(self, "embedded_python/LICENSE.txt", src, license_folder, keep_path=False)
+        copy(self, "package_licenses.txt", src, license_folder, keep_path=False)
 
     def package_info(self):
         self.env_info.PYTHONPATH.append(self.package_folder)
+        self.cpp_info.set_property("cmake_build_modules", ["embedded_python.cmake"])
         self.cpp_info.build_modules = ["embedded_python.cmake"]
-        self.user_info.pyversion = self.pyversion
-
         prefix = pathlib.Path(self.package_folder) / "embedded_python"
+        self.cpp_info.includedirs = [str(prefix / "include")]
         if self.settings.os == "Windows":
             self.cpp_info.bindirs = [str(prefix)]
         else:
@@ -181,15 +188,15 @@ def __init__(self, conanfile, prefix_dir):
     def _get_binaries(self, dest_dir):
         """Get the binaries from the special embeddable Python package"""
         url = "https://www.python.org/ftp/python/{0}/python-{0}-embed-amd64.zip"
-        tools.get(url.format(self.conanfile.pyversion), destination=dest_dir)
+        get(self.conanfile, url.format(self.conanfile.pyversion), destination=dest_dir)
 
     def _get_headers_and_lib(self, dest_dir):
         """We also need headers and the `python3.lib` file to link against"""
         url = f"https://www.python.org/ftp/python/{self.conanfile.pyversion}/amd64/dev.msi"
-        tools.download(url, filename="tmp\\dev.msi")
+        download(self.conanfile, url, filename="tmp\\dev.msi")
         build_folder = self.conanfile.build_folder
         self.conanfile.run(f"msiexec.exe /a {build_folder}\\tmp\\dev.msi targetdir={dest_dir}")
-        tools.rmdir("tmp")
+        rmdir(self.conanfile, "tmp")
 
     def build_embedded(self):
         self._get_binaries(self.prefix_dir)
@@ -198,7 +205,7 @@ def build_embedded(self):
     def enable_site_packages(self):
         """Enable site-packages, i.e. additional non-system packages"""
         dst = self.prefix_dir / f"python{self.conanfile.pyver}._pth"
-        tools.replace_in_file(dst, "#import site", "import site")
+        replace_in_file(self.conanfile, dst, "#import site", "import site")
 
     def build_bootstrap(self):
         """Set up a special embedded Python environment for bootstrapping
@@ -217,7 +224,7 @@ def build_bootstrap(self):
 
         # We need pip to install packages
         python_exe = build_folder / "bootstrap/python.exe"
-        tools.download("https://bootstrap.pypa.io/get-pip.py", filename="get-pip.py")
+        download(self.conanfile, "https://bootstrap.pypa.io/get-pip.py", filename="get-pip.py")
         self.conanfile.run(f"{python_exe} get-pip.py")
 
         specs = [
@@ -237,15 +244,15 @@ def __init__(self, conanfile, prefix_dir):
 
     def _get_source(self):
         url = f"https://github.com/python/cpython/archive/v{self.conanfile.pyversion}.tar.gz"
-        tools.get(url)
-        os.rename(f"cpython-{self.conanfile.pyversion}", "src")
+        get(self.conanfile, url, strip_root=True)
 
         # Patch a build issue with clang 13: https://bugs.python.org/issue45405. We simply apply
         # the patch for all clang versions since the flag never did anything on clang/apple-clang anyway.
         compiler = self.conanfile.settings.compiler
-        if "clang" in str(compiler) and tools.Version(self.conanfile.pyversion) < "3.9.8":
-            tools.replace_in_file(
-                "src/configure",
+        if "clang" in str(compiler) and Version(self.conanfile.pyversion) < "3.9.8":
+            replace_in_file(
+                self.conanfile,
+                "configure",
                 "MULTIARCH=$($CC --print-multiarch 2>/dev/null)",
                 "MULTIARCH=''",
                 strict=False,
@@ -260,32 +267,33 @@ def _openssl_path(self):
         return self.conanfile.deps_cpp_info[pck].rootpath
 
     def _build(self, dest_dir):
-        from conans import AutoToolsBuildEnvironment
+        from conan.tools.gnu import AutotoolsToolchain, Autotools
+
+        tc = AutotoolsToolchain(self.conanfile, prefix=dest_dir)
+        tc.configure_args.extend(["--enable-shared", f"--with-openssl={self._openssl_path}"])
+        tc.make_args.append("-j8")
 
-        autotools = AutoToolsBuildEnvironment(self.conanfile)
-        env_vars = autotools.vars
+        # We need to do this manually because `AutotoolsDeps` doesn't add `tools_requires` deps
+        for dep in self.conanfile.deps_cpp_info.deps:
+            info = self.conanfile.deps_cpp_info[dep]
+            tc.extra_cflags.extend([f"-I{x}" for x in info.include_paths])
+            tc.extra_ldflags.extend([f"-L{x}" for x in info.lib_paths])
 
         # On Linux, we need to set RPATH so that `root/bin/python3` can correctly find the `.so`
         # file in `root/lib` no matter where `root` is. We need it to be portable. We explicitly
         # set `--disable-new-dtags` to use RPATH instead of RUNPATH. RUNPATH can be overridden by
         # the LD_LIBRARY_PATH env variable which is not at all what we want for this self-contained
         # package. Unlike RUNPATH, RPATH takes precedence over LD_LIBRARY_PATH.
         if self.conanfile.settings.os == "Linux":
-            env_vars["LDFLAGS"] += " -Wl,-rpath,'$$ORIGIN/../lib' -Wl,--disable-new-dtags"
-
-        config_args = " ".join(
-            [
-                "--enable-shared",
-                f"--prefix={dest_dir}",
-                f"--with-openssl={self._openssl_path}",
-            ]
-        )
+            tc.extra_ldflags.extend(["-Wl,-rpath,'$$ORIGIN/../lib'", "-Wl,--disable-new-dtags"])
+
+        tc.generate()
 
-        tools.mkdir("./build")
-        with tools.chdir("./build"), tools.environment_append(env_vars):
-            self.conanfile.run(f"../src/configure {config_args}")
-            self.conanfile.run("make -j8")
-            self.conanfile.run("make install -j8")
+        with tc.environment().vars(self.conanfile).apply():
+            autotools = Autotools(self.conanfile)
+            autotools.configure()
+            autotools.make()
+            autotools.install(args=["DESTDIR=''"])  # already handled by `prefix=dest_dir`
 
         ver = ".".join(self.conanfile.pyversion.split(".")[:2])
         exe = str(dest_dir / f"bin/python{ver}")

embedded_python_tools.py

@@ -1,6 +1,7 @@
 import os
 import shutil
 import pathlib
+from conan.tools.files import copy
 
 
 def _symlink_compat(conanfile, src, dst):
@@ -52,7 +53,7 @@ def imports(self):
     _symlink_compat(conanfile, src, dst)
 
     bin = pathlib.Path(bin).absolute()
-    conanfile.copy("python*.dll", dst=bin, src="embedded_python", keep_path=False)
-    conanfile.copy("libpython*.so*", dst=bin, src="embedded_python/lib", keep_path=False)
-    conanfile.copy("libpython*.dylib", dst=bin, src="embedded_python/lib", keep_path=False)
-    conanfile.copy("python*.zip", dst=bin, src="embedded_python", keep_path=False)
+    copy(conanfile, "python*.dll", src, bin, keep_path=False)
+    copy(conanfile, "libpython*.so*", src / "lib", bin, keep_path=False)
+    copy(conanfile, "libpython*.dylib", src / "lib", bin, keep_path=False)
+    copy(conanfile, "python*.zip", src, bin, keep_path=False)

test_package/CMakeLists.txt

@@ -1,21 +1,10 @@
 cmake_minimum_required(VERSION 3.18)
 project(test_package)
 
-# `cmake` generator
-include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
-conan_basic_setup(KEEP_RPATHS)
-
-if(NOT Python_VERSION VERSION_EQUAL CONAN_USER_EMBEDDED_PYTHON_pyversion)
-    message(FATAL_ERROR "`cmake` failed to find the correct Python version")
-endif()
-
-# `cmake_find_package` generator
-unset(Python_ROOT_DIR)
-unset(Python_VERSION)
 find_package(embedded_python)
 
-if(NOT Python_VERSION VERSION_EQUAL CONAN_USER_EMBEDDED_PYTHON_pyversion)
-    message(FATAL_ERROR "`cmake_find_package` failed to find the correct Python version")
+if(NOT Python_EXECUTABLE MATCHES "embedded_python")
+    message(FATAL_ERROR "`cmake` failed to find the correct Python")
 endif()
 
 add_executable(test_package src/main.cpp)

test_package/conanfile.py

@@ -1,6 +1,7 @@
 import pathlib
 import sys
-from conans import ConanFile, CMake
+from conan import ConanFile
+from conan.tools.cmake import CMake, CMakeToolchain
 
 project_root = pathlib.Path(__file__).parent
 
@@ -14,7 +15,7 @@ def _read_env(name):
 class TestEmbeddedPython(ConanFile):
     name = "test_embedded_python"
     settings = "os", "compiler", "build_type", "arch"
-    generators = "cmake", "cmake_find_package"
+    generators = "CMakeDeps"
     options = {"env": "ANY"}
     default_options = {
         "env": None,
@@ -25,13 +26,17 @@ def configure(self):
         if self.options.env:
             self.options["embedded_python"].packages = _read_env(self.options.env)
 
-    def imports(self):
+    def generate(self):
+        build_type = self.settings.build_type.value
+        tc = CMakeToolchain(self)
+        tc.variables[f"CMAKE_RUNTIME_OUTPUT_DIRECTORY_{build_type.upper()}"] = "bin"
+        tc.generate()
+
+    def build(self):
         import embedded_python_tools
 
         embedded_python_tools.symlink_import(self, dst="bin/python")
-        self.copy("licenses/*", dst="licenses", folder=True, ignore_case=True, keep_path=False)
 
-    def build(self):
         cmake = CMake(self)
         cmake.configure()
         cmake.build()
@@ -43,18 +48,18 @@ def _test_env(self):
         else:
             python_exe = str(pathlib.Path("./bin/python/bin/python3").resolve())
 
-        self.run([python_exe, "-c", "import sys; print(sys.version);"])
+        self.run(f'{python_exe} -c "import sys; print(sys.version);"')
 
         name = str(self.options.env) if self.options.env else "baseline"
-        self.run([python_exe, str(project_root / f"{name}/test.py")], run_environment=True)
+        self.run(f"{python_exe} {project_root / name / 'test.py'}", run_environment=True)
 
     def _test_embed(self):
         """Ensure that everything is available to compile and link to the embedded Python"""
         self.run(pathlib.Path("bin", "test_package"), run_environment=True)
 
     def _test_licenses(self):
         """Ensure that the licenses have been gathered"""
-        license_dir = pathlib.Path("./licenses/embedded_python")
+        license_dir = pathlib.Path(self.deps_cpp_info["embedded_python"].rootpath, "licenses")
         license_files = [license_dir / "LICENSE.txt"]
         if self.options.env:
             license_files += [license_dir / "package_licenses.txt"]