Add support for Conan v2

Author: dean0x7d

.github/workflows/test_package.yml

@@ -8,8 +8,14 @@ jobs:
       matrix:
         os: [windows-latest, ubuntu-latest, macos-latest]
         embedded-py: [3.9.8, 3.11.5]
+        conan:
+          - version: 1
+            args: lumicks/testing --build=missing
+          - version: 2
+            args: --user=lumicks --channel=testing --build=missing
+    name: "${{ matrix.os }}, ${{ matrix.embedded-py }}, v${{ matrix.conan.version }}"
     env:
-      create_pck: conan create . lumicks/testing -o embedded_python-core:version=${{ matrix.embedded-py }} --build=missing
+      create_pck: conan create . ${{ matrix.conan.args }} -o embedded_python-core/*:version=${{ matrix.embedded-py }}
     steps:
     - if: runner.os == 'Windows' # `pylake` git clone goes over the limit
       run: git config --system core.longpaths true
@@ -18,24 +24,28 @@ jobs:
       uses: actions/setup-python@v5
       with:
         python-version: "3.11"
-    - name: Set up CXX/C env
-      if: ${{ matrix.os  == 'macos-latest' }}
+    - if: runner.os == 'macOS'
+      name: Set up CC/CXX env
       run: |
         echo CC=/usr/bin/clang >> $GITHUB_ENV
         echo CXX=/usr/bin/clang++ >> $GITHUB_ENV
-    - name: Install Conan
+    - if: matrix.conan.version == '1'
+      name: Install Conan v1
       run: | 
         python -m pip install conan==1.64.0
-        conan config set general.revisions_enabled=True
         conan profile new default --detect
-        conan profile update settings.compiler.cppstd=17 default
+    - if: matrix.conan.version == '2'
+      name: Install Conan v2
+      run: |
+        python -m pip install conan==2.2.3
+        conan profile detect
     - name: Test core
-      run: conan create ./core lumicks/testing -o embedded_python-core:version=${{ matrix.embedded-py }} --build=missing
+      run: conan create ./core ${{ matrix.conan.args }} -o embedded_python-core/*:version=${{ matrix.embedded-py }}
     - name: Test baseline
       run: ${{ env.create_pck }}
     - name: Test with numpy env
-      run: ${{ env.create_pck }} -o test_embedded_python:env=numpy
+      run: ${{ env.create_pck }} -o test_embedded_python/*:env=numpy
     - name: Test with nbconvert env
-      run: ${{ env.create_pck }} -o test_embedded_python:env=nbconvert
+      run: ${{ env.create_pck }} -o test_embedded_python/*:env=nbconvert
     - name: Test with pylake env
-      run: ${{ env.create_pck }} -o test_embedded_python:env=pylake
+      run: ${{ env.create_pck }} -o test_embedded_python/*:env=pylake

.gitignore

@@ -1,2 +1,4 @@
 *.pyc
 __pycache__/
+*/test_package/build
+CMakeUserPresets.json

changelog.md

@@ -2,6 +2,7 @@
 
 ## v1.9.0 | In development
 
+- Added support for Conan v2.
 - Removed the obsolete `openssl_variant` option.
 - Removed redundant `embedded_python:version` option. Use `embedded_python-core:version`.
 

conanfile.py

@@ -35,7 +35,7 @@ class EmbeddedPython(ConanFile):
     exports_sources = "embedded_python.cmake"
 
     def requirements(self):
-        self.requires(f"embedded_python-core/1.2.2@{self.user}/{self.channel}")
+        self.requires(f"embedded_python-core/1.3.0@{self.user}/{self.channel}")
 
     @property
     def pyversion(self):

core/conanfile.py

@@ -1,9 +1,10 @@
-import io
 import os
+import subprocess
 import sys
 import shutil
 import pathlib
 from conan import ConanFile
+from conan.errors import ConanInvalidConfiguration
 from conan.tools import files, scm
 
 required_conan_version = ">=1.59.0"
@@ -12,7 +13,7 @@
 # noinspection PyUnresolvedReferences
 class EmbeddedPythonCore(ConanFile):
     name = "embedded_python-core"
-    version = "1.2.2"  # of the Conan package, `options.version` is the Python version
+    version = "1.3.0"  # of the Conan package, `options.version` is the Python version
     license = "PSFL"
     description = "The core embedded Python (no extra pip packages)"
     topics = "embedded", "python"
@@ -154,9 +155,8 @@ def _patch_libpython_path(self, dst):
             return
 
         exe = dst / f"python{self.short_pyversion}"
-        buffer = io.StringIO()
-        self.run(f"otool -L {exe}", output=buffer)
-        lines = buffer.getvalue().strip().split("\n")[1:]
+        p = subprocess.run(["otool", "-L", str(exe)], check=True, text=True, capture_output=True)
+        lines = str(p.stdout).strip().split("\n")[1:]
         libraries = [line.split()[0] for line in lines]
         hardcoded_libraries = [lib for lib in libraries if lib.startswith(str(dst))]
         for lib in hardcoded_libraries:

core/embedded_python_tools.py

@@ -1,7 +1,7 @@
 import os
 import shutil
 import pathlib
-from conan.tools.files import copy
+from conan.tools import files
 
 
 def _symlink_compat(conanfile, src, dst):
@@ -12,7 +12,7 @@ def _symlink_compat(conanfile, src, dst):
         try:
             _winapi.CreateJunction(str(src), str(dst))
         except OSError:
-            copy(conanfile, "*", src, dst)
+            files.copy(conanfile, "*", src, dst)
     else:
         os.symlink(src, dst)
 
@@ -56,7 +56,7 @@ def imports(self):
     _symlink_compat(conanfile, src, dst)
 
     bin = pathlib.Path(bin).absolute()
-    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)
+    files.copy(conanfile, "python*.dll", src, bin, keep_path=False)
+    files.copy(conanfile, "libpython*.so*", src / "lib", bin, keep_path=False)
+    files.copy(conanfile, "libpython*.dylib", src / "lib", bin, keep_path=False)
+    files.copy(conanfile, "python*.zip", src, bin, keep_path=False)

core/test_package/CMakeLists.txt

@@ -4,8 +4,8 @@ project(test_package)
 find_package(embedded_python-core)
 
 message(STATUS "Python_EXECUTABLE: ${Python_EXECUTABLE}")
-if(NOT Python_EXECUTABLE MATCHES "embedded_python-core")
-    message(FATAL_ERROR "CMake failed to find the correct Python")
+if(NOT Python_EXECUTABLE MATCHES "${EXPECTED_PYTHON_CORE_PATH}")
+    message(FATAL_ERROR "CMake failed to find the correct Python: ${EXPECTED_PYTHON_CORE_PATH}")
 endif()
 
 add_executable(test_package src/main.cpp)

core/test_package/conanfile.py

@@ -1,17 +1,22 @@
+import sys
 import pathlib
-from io import StringIO
+import subprocess
+import conan
 from conan import ConanFile
-from conan.tools.cmake import CMake, CMakeToolchain
+from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
 
 
 # noinspection PyUnresolvedReferences
 class TestEmbeddedPythonCore(ConanFile):
     name = "test_embedded_python"
     settings = "os", "compiler", "build_type", "arch"
-    generators = "CMakeDeps"
-    default_options = {"embedded_python-core:version": "3.11.3"}
+    generators = "CMakeDeps", "VirtualRunEnv"
+    default_options = {"embedded_python-core/*:version": "3.11.3"}
     test_type = "explicit"
 
+    def layout(self):
+        cmake_layout(self)
+
     def requirements(self):
         self.requires(self.tested_reference_str)
 
@@ -22,11 +27,13 @@ def generate(self):
         tc.generate()
 
     def build(self):
+        sys.path.append(str(self._core_package_path))
+
         import embedded_python_tools
 
         embedded_python_tools.symlink_import(self, dst="bin/python")
         cmake = CMake(self)
-        cmake.configure()
+        cmake.configure(variables={"EXPECTED_PYTHON_CORE_PATH": self._core_package_path.as_posix()})
         cmake.build()
 
     @property
@@ -36,6 +43,13 @@ def _py_exe(self):
         else:
             return pathlib.Path(self.build_folder, "bin/python/bin/python3")
 
+    @property
+    def _core_package_path(self):
+        if conan.__version__.startswith("2"):
+            return pathlib.Path(self.dependencies["embedded_python-core"].package_folder)
+        else:
+            return pathlib.Path(self.deps_cpp_info["embedded_python-core"].rootpath)
+
     def _test_stdlib(self):
         """Ensure that Python runs and built the optional stdlib modules"""
         self.run(f'{self._py_exe} -c "import sys; print(sys.version);"')
@@ -46,9 +60,10 @@ def _test_libpython_path(self):
         if self.settings.os != "Macos":
             return
 
-        buffer = StringIO()
-        self.run(f"otool -L {self._py_exe}", run_environment=True, output=buffer)
-        lines = buffer.getvalue().strip().split("\n")[1:]
+        p = subprocess.run(
+            ["otool", "-L", str(self._py_exe)], check=True, text=True, capture_output=True
+        )
+        lines = str(p.stdout).strip().split("\n")[1:]
         libraries = [line.split()[0] for line in lines]
         candidates = [lib for lib in libraries if "libpython" in lib]
         assert candidates, f"libpython dependency not found in 'otool' output: {libraries}"
@@ -57,12 +72,11 @@ def _test_libpython_path(self):
 
     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)
+        self.run(pathlib.Path("bin", "test_package"), env="conanrun")
 
     def _test_licenses(self):
         """Ensure that the license file is included"""
-        license_dir = pathlib.Path(self.deps_cpp_info["embedded_python-core"].rootpath, "licenses")
-        file = license_dir / "LICENSE.txt"
+        file = self._core_package_path / "licenses/LICENSE.txt"
         print(f"{file}: {file.stat().st_size}")
 
     def test(self):

test_package/CMakeLists.txt

@@ -4,15 +4,15 @@ project(test_package)
 find_package(embedded_python)
 
 message(STATUS "Python_EXECUTABLE: ${Python_EXECUTABLE}")
-if(NOT Python_EXECUTABLE MATCHES "embedded_python-core")
-    message(FATAL_ERROR "CMake failed to find the correct Python")
+if(NOT Python_EXECUTABLE MATCHES "${EXPECTED_PYTHON_CORE_PATH}")
+    message(FATAL_ERROR "CMake failed to find the correct Python: ${EXPECTED_PYTHON_CORE_PATH}")
 endif()
 message(STATUS "EmbeddedPython_EXECUTABLE: ${EmbeddedPython_EXECUTABLE}")
-if(EmbeddedPython_EXECUTABLE MATCHES "embedded_python-core")
-    message(FATAL_ERROR "CMake found the `-core` package instead of the full environment")
+if(EmbeddedPython_EXECUTABLE MATCHES "${EXPECTED_PYTHON_CORE_PATH}")
+    message(FATAL_ERROR "CMake found the `-core` package instead of the full environment: ${EXPECTED_PYTHON_PATH}")
 endif()
-if(NOT EmbeddedPython_EXECUTABLE MATCHES "embedded_python")
-    message(FATAL_ERROR "CMake failed to find the correct Python")
+if(NOT EmbeddedPython_EXECUTABLE MATCHES "${EXPECTED_PYTHON_PATH}")
+    message(FATAL_ERROR "CMake failed to find the correct Python: ${EXPECTED_PYTHON_PATH}")
 endif()
 
 add_executable(test_package ../core/test_package/src/main.cpp)

test_package/conanfile.py

@@ -1,8 +1,9 @@
-import pathlib
 import sys
-from io import StringIO
+import pathlib
+import subprocess
+import conan
 from conan import ConanFile
-from conan.tools.cmake import CMake, CMakeToolchain
+from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
 
 project_root = pathlib.Path(__file__).parent
 
@@ -16,13 +17,33 @@ def _read_env(name):
 class TestEmbeddedPython(ConanFile):
     name = "test_embedded_python"
     settings = "os", "compiler", "build_type", "arch"
-    generators = "CMakeDeps"
+    generators = "CMakeDeps", "VirtualRunEnv"
     options = {"env": [None, "ANY"]}
     default_options = {
         "env": None,
-        "embedded_python-core:version": "3.11.5",
+        "embedded_python-core/*:version": "3.11.5",
     }
 
+    @property
+    def _core_package_path(self):
+        if conan.__version__.startswith("2"):
+            return pathlib.Path(self.dependencies["embedded_python-core"].package_folder)
+        else:
+            return pathlib.Path(self.deps_cpp_info["embedded_python-core"].rootpath)
+
+    @property
+    def _package_path(self):
+        if conan.__version__.startswith("2"):
+            return pathlib.Path(self.dependencies["embedded_python"].package_folder)
+        else:
+            return pathlib.Path(self.deps_cpp_info["embedded_python"].rootpath)
+
+    def layout(self):
+        cmake_layout(self)
+
+    def requirements(self):
+        self.requires(self.tested_reference_str)
+
     def configure(self):
         if self.options.env:
             self.options["embedded_python"].packages = _read_env(self.options.env)
@@ -34,12 +55,19 @@ def generate(self):
         tc.generate()
 
     def build(self):
+        sys.path.append(str(self._package_path))
+
         import embedded_python_tools
 
         embedded_python_tools.symlink_import(self, dst="bin/python")
 
         cmake = CMake(self)
-        cmake.configure()
+        cmake.configure(
+            variables={
+                "EXPECTED_PYTHON_CORE_PATH": self._core_package_path.as_posix(),
+                "EXPECTED_PYTHON_PATH": self._package_path.as_posix(),
+            }
+        )
         cmake.build()
 
     def _test_env(self):
@@ -52,16 +80,15 @@ def _test_env(self):
         self.run(f'{python_exe} -c "import sys; print(sys.version);"')
 
         name = str(self.options.env) if self.options.env else "baseline"
-        self.run(f"{python_exe} {project_root / name / 'test.py'}", run_environment=True)
+        self.run(f"{python_exe} {project_root / name / 'test.py'}", env="conanrun")
 
     def _test_libpython_path(self):
         if self.settings.os != "Macos":
             return
 
         python_exe = str(pathlib.Path("./bin/python/bin/python3").resolve())
-        buffer = StringIO()
-        self.run(f"otool -L {python_exe}", run_environment=True, output=buffer)
-        lines = buffer.getvalue().strip().split("\n")[1:]
+        p = subprocess.run(["otool", "-L", python_exe], check=True, text=True, capture_output=True)
+        lines = str(p.stdout).strip().split("\n")[1:]
         libraries = [line.split()[0] for line in lines]
         candidates = [lib for lib in libraries if "libpython" in lib]
         assert candidates, f"libpython dependency not found in 'otool' output: {libraries}"
@@ -71,11 +98,11 @@ def _test_libpython_path(self):
 
     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)
+        self.run(pathlib.Path("bin", "test_package"), env="conanrun")
 
     def _test_licenses(self):
         """Ensure that the licenses have been gathered"""
-        license_dir = pathlib.Path(self.deps_cpp_info["embedded_python"].rootpath, "licenses")
+        license_dir = self._package_path / "licenses"
         license_files = [license_dir / "LICENSE.txt"]
         if self.options.env:
             license_files += [license_dir / "package_licenses.txt"]