relenv 0.22.2__tar.gz → 0.22.3__tar.gz

{relenv-0.22.2/relenv.egg-info → relenv-0.22.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: relenv
-Version: 0.22.2
+Version: 0.22.3
 Project-URL: Source Code, https://github.com/saltstack/relative-environment-for-python
 Project-URL: Documentation, https://relenv.readthedocs.io/en/latest/
 Project-URL: Changelog, https://relenv.readthedocs.io/en/latest/changelog.html

relenv-0.22.3/relenv/_resources/xz/crc32_table.c

@@ -0,0 +1,22 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       crc32_table.c
+/// \brief      Precalculated CRC32 table with correct endianness
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "common.h"
+
+// Having the declaration here silences clang -Wmissing-variable-declarations.
+extern const uint32_t lzma_crc32_table[8][256];
+
+#ifdef WORDS_BIGENDIAN
+#	include "crc32_table_be.h"
+#else
+#	include "crc32_table_le.h"
+#endif

relenv-0.22.3/relenv/_resources/xz/crc64_table.c

@@ -0,0 +1,33 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       crc64_table.c
+/// \brief      Precalculated CRC64 table with correct endianness
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "common.h"
+
+
+// FIXME: Compared to crc64_fast.c this has to check for __x86_64__ too
+// so that in 32-bit builds crc64_x86.S won't break due to a missing table.
+#if (defined(__x86_64__) && defined(__SSSE3__) \
+			&& defined(__SSE4_1__) && defined(__PCLMUL__)) \
+		|| (defined(__e2k__) && __iset__ >= 6)
+// No table needed. Use a typedef to avoid an empty translation unit.
+typedef void lzma_crc64_dummy;
+
+#else
+// Having the declaration here silences clang -Wmissing-variable-declarations.
+extern const uint64_t lzma_crc64_table[4][256];
+
+#	if defined(WORDS_BIGENDIAN)
+#		include "crc64_table_be.h"
+#	else
+#		include "crc64_table_le.h"
+#	endif
+#endif

relenv-0.22.3/relenv/_resources/xz/readme.md

@@ -0,0 +1,13 @@
+The config.h file was removed from XZ-Utils starting with version 5.5.0.
+XZ-Utils switched to CMake and removed Visual Studio project files and
+pre-generated headers/sources.
+
+We include the following files from XZ 5.4.7 to maintain compatibility with
+Python's MSBuild-based build system on Windows (PCbuild/liblzma.vcxproj):
+
+- config.h (src/common/config.h)
+- crc32_table.c (src/liblzma/check/crc32_table.c)
+- crc64_table.c (src/liblzma/check/crc64_table.c)
+
+These files are copied into the extracted XZ source directory during the
+Windows build process if they are missing.

{relenv-0.22.2 → relenv-0.22.3}/relenv/build/windows.py

@@ -197,6 +197,14 @@ def update_xz(dirs: Dirs, env: EnvMapping) -> None:
     config_file_source = dirs.root / "_resources" / "xz" / "config.h"
     if not config_file.exists():
         shutil.copy(str(config_file_source), str(config_file))
+
+    # Also copy crc32_table.c and crc64_table.c which are missing in newer XZ tarballs
+    check_dir = target_dir / "src" / "liblzma" / "check"
+    for filename in ["crc32_table.c", "crc64_table.c"]:
+        target_file = check_dir / filename
+        source_file = dirs.root / "_resources" / "xz" / filename
+        if not target_file.exists():
+            shutil.copy(str(source_file), str(target_file))
     # Update externals.spdx.json with the correct version, url, and hash
     # This became a thing in 3.12
     if env["RELENV_PY_MAJOR_VERSION"] in ["3.12", "3.13", "3.14"]:

{relenv-0.22.2 → relenv-0.22.3}/relenv/common.py

@@ -34,7 +34,7 @@ from typing import (
 )
 
 # relenv package version
-__version__ = "0.22.2"
+__version__ = "0.22.3"
 
 log = logging.getLogger(__name__)
 

{relenv-0.22.2 → relenv-0.22.3}/relenv/python-versions.json

@@ -203,6 +203,14 @@
      "linux",
      "darwin"
     ]
+   },
+   "3.6.1": {
+    "url": "https://github.com/openssl/openssl/releases/download/openssl-{version}/openssl-{version}.tar.gz",
+    "sha256": "b1bfedcd5b289ff22aee87c9d600f515767ebf45f77168cb6d64f231f518a82e",
+    "platforms": [
+     "linux",
+     "darwin"
+    ]
    }
   },
   "sqlite": {
@@ -225,6 +233,16 @@
      "darwin",
      "win32"
     ]
+   },
+   "3.51.2.0": {
+    "url": "https://sqlite.org/2026/sqlite-autoconf-{version}.tar.gz",
+    "sha256": "fbd89f866b1403bb66a143065440089dd76100f2238314d92274a082d4f2b7bb",
+    "sqliteversion": "3510200",
+    "platforms": [
+     "linux",
+     "darwin",
+     "win32"
+    ]
    }
   },
   "xz": {
@@ -235,6 +253,15 @@
      "linux",
      "darwin"
     ]
+   },
+   "5.8.2": {
+    "url": "http://tukaani.org/xz/xz-{version}.tar.gz",
+    "sha256": "ce09c50a5962786b83e5da389c90dd2c15ecd0980a258dd01f70f9e7ce58a8f1",
+    "platforms": [
+     "linux",
+     "darwin",
+     "win32"
+    ]
    }
   },
   "libffi": {
@@ -262,6 +289,13 @@
     "platforms": [
      "linux"
     ]
+   },
+   "6.6": {
+    "url": "https://mirrors.ocf.berkeley.edu/gnu/ncurses/ncurses-{version}.tar.gz",
+    "sha256": "355b4cbbed880b0381a04c46617b7656e362585d52e9cf84a67e2009b749ff11",
+    "platforms": [
+     "linux"
+    ]
    }
   },
   "readline": {
@@ -344,6 +378,15 @@
      "darwin",
      "win32"
     ]
+   },
+   "2.7.4": {
+    "url": "https://github.com/libexpat/libexpat/releases/download/R_2_7_4/expat-{version}.tar.xz",
+    "sha256": "9e9cabb457c1e09de91db2706d8365645792638eb3be1f94dbb2149301086ac0",
+    "platforms": [
+     "linux",
+     "darwin",
+     "win32"
+    ]
    }
   }
  }

{relenv-0.22.2 → relenv-0.22.3}/relenv/relocate.py

@@ -11,6 +11,7 @@ import os as _os
 import pathlib
 import shutil as _shutil
 import subprocess as _subprocess
+import sys as _sys
 from typing import Optional
 
 log = logging.getLogger(__name__)
@@ -18,6 +19,7 @@ log = logging.getLogger(__name__)
 os = _os
 shutil = _shutil
 subprocess = _subprocess
+sys = _sys
 
 __all__ = [
     "is_macho",
@@ -70,6 +72,83 @@ LC_ID_DYLIB = "LC_ID_DYLIB"
 LC_LOAD_DYLIB = "LC_LOAD_DYLIB"
 LC_RPATH = "LC_RPATH"
 
+# Cache for readelf binary path
+_READELF_BINARY: Optional[str] = None
+
+# Cache for patchelf binary path
+_PATCHELF_BINARY: Optional[str] = None
+
+
+def _get_readelf_binary() -> str:
+    """
+    Get the path to readelf binary, preferring toolchain version.
+
+    Returns the cached value if already computed. On Linux, prefers the
+    toolchain's readelf over the system version. Falls back to "readelf"
+    from PATH if toolchain is unavailable.
+
+    :return: Path to readelf binary
+    :rtype: str
+    """
+    global _READELF_BINARY
+    if _READELF_BINARY is not None:
+        return _READELF_BINARY
+
+    # Only Linux has the toolchain with readelf
+    if sys.platform == "linux":
+        try:
+            from relenv.common import get_toolchain, get_triplet
+
+            toolchain = get_toolchain()
+            if toolchain:
+                triplet = get_triplet()
+                toolchain_readelf = toolchain / "bin" / f"{triplet}-readelf"
+                if toolchain_readelf.exists():
+                    _READELF_BINARY = str(toolchain_readelf)
+                    return _READELF_BINARY
+        except Exception:
+            # Fall through to system readelf
+            pass
+
+    # Fall back to system readelf
+    _READELF_BINARY = "readelf"
+    return _READELF_BINARY
+
+
+def _get_patchelf_binary() -> str:
+    """
+    Get the path to patchelf binary, preferring toolchain version.
+
+    Returns the cached value if already computed. On Linux, prefers the
+    toolchain's patchelf over the system version. Falls back to "patchelf"
+    from PATH if toolchain is unavailable.
+
+    :return: Path to patchelf binary
+    :rtype: str
+    """
+    global _PATCHELF_BINARY
+    if _PATCHELF_BINARY is not None:
+        return _PATCHELF_BINARY
+
+    # Only Linux has the toolchain with patchelf
+    if sys.platform == "linux":
+        try:
+            from relenv.common import get_toolchain
+
+            toolchain = get_toolchain()
+            if toolchain:
+                toolchain_patchelf = toolchain / "bin" / "patchelf"
+                if toolchain_patchelf.exists():
+                    _PATCHELF_BINARY = str(toolchain_patchelf)
+                    return _PATCHELF_BINARY
+        except Exception:
+            # Fall through to system patchelf
+            pass
+
+    # Fall back to system patchelf
+    _PATCHELF_BINARY = "patchelf"
+    return _PATCHELF_BINARY
+
 
 def is_macho(path: str | os.PathLike[str]) -> bool:
     """
@@ -192,8 +271,9 @@ def parse_rpath(path: str | os.PathLike[str]) -> list[str]:
     :return: The RPATH's found.
     :rtype: list
     """
+    readelf = _get_readelf_binary()
     proc = subprocess.run(
-        ["readelf", "-d", path], stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        [readelf, "-d", path], stdout=subprocess.PIPE, stderr=subprocess.PIPE
     )
     return parse_readelf_d(proc.stdout.decode())
 
@@ -280,8 +360,9 @@ def remove_rpath(path: str | os.PathLike[str]) -> bool:
         return True
 
     log.info("Remove RPATH from %s (was: %s)", path, old_rpath)
+    patchelf = _get_patchelf_binary()
     proc = subprocess.run(
-        ["patchelf", "--remove-rpath", path],
+        [patchelf, "--remove-rpath", path],
         stderr=subprocess.PIPE,
         stdout=subprocess.PIPE,
     )
@@ -319,8 +400,9 @@ def patch_rpath(
     if new_rpath not in old_rpath:
         patched_rpath = ":".join([new_rpath] + old_rpath)
         log.info("Set RPATH=%s %s", patched_rpath, path)
+        patchelf = _get_patchelf_binary()
         proc = subprocess.run(
-            ["patchelf", "--force-rpath", "--set-rpath", patched_rpath, path],
+            [patchelf, "--force-rpath", "--set-rpath", patched_rpath, path],
             stderr=subprocess.PIPE,
             stdout=subprocess.PIPE,
         )

{relenv-0.22.2 → relenv-0.22.3}/relenv/runtime.py

@@ -384,25 +384,30 @@ def install_wheel_wrapper(func: Callable[..., Any]) -> Callable[..., Any]:
             direct_url,
             requested,
         )
-        plat = pathlib.Path(scheme.platlib)
-        rootdir = relenv_root()
-        with open(plat / info_dir / "RECORD") as fp:
-            for line in fp.readlines():
-                file = plat / line.split(",", 1)[0]
-                if not file.exists():
-                    debug(f"Relenv - File not found {file}")
-                    continue
-                if relocate().is_elf(file):
-                    debug(f"Relenv - Found elf {file}")
-                    relocate().handle_elf(plat / file, rootdir / "lib", True, rootdir)
-                elif relocate().is_macho(file):
-                    otool_bin = shutil.which("otool")
-                    if otool_bin:
-                        relocate().handle_macho(str(plat / file), str(rootdir), True)
-                    else:
-                        debug(
-                            "The otool command is not available, please run `xcode-select --install`"
+        if "RELENV_BUILDENV" in os.environ:
+            plat = pathlib.Path(scheme.platlib)
+            rootdir = relenv_root()
+            with open(plat / info_dir / "RECORD") as fp:
+                for line in fp.readlines():
+                    file = plat / line.split(",", 1)[0]
+                    if not file.exists():
+                        debug(f"Relenv - File not found {file}")
+                        continue
+                    if relocate().is_elf(file):
+                        debug(f"Relenv - Found elf {file}")
+                        relocate().handle_elf(
+                            plat / file, rootdir / "lib", True, rootdir
                         )
+                    elif relocate().is_macho(file):
+                        otool_bin = shutil.which("otool")
+                        if otool_bin:
+                            relocate().handle_macho(
+                                str(plat / file), str(rootdir), True
+                            )
+                        else:
+                            debug(
+                                "The otool command is not available, please run `xcode-select --install`"
+                            )
 
     return wrapper
 
@@ -1022,7 +1027,11 @@ def install_cargo_config() -> None:
     cargo_home = dirs.data / "cargo"
     triplet = common().get_triplet()
 
-    toolchain = common().get_toolchain()
+    try:
+        toolchain = common().get_toolchain()
+    except PermissionError:
+        pass
+
     if not toolchain:
         debug("Unable to set CARGO_HOME ppbt package not installed")
         return

{relenv-0.22.2 → relenv-0.22.3/relenv.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: relenv
-Version: 0.22.2
+Version: 0.22.3
 Project-URL: Source Code, https://github.com/saltstack/relative-environment-for-python
 Project-URL: Documentation, https://relenv.readthedocs.io/en/latest/
 Project-URL: Changelog, https://relenv.readthedocs.io/en/latest/changelog.html

{relenv-0.22.2 → relenv-0.22.3}/relenv.egg-info/SOURCES.txt

@@ -25,6 +25,8 @@ relenv.egg-info/entry_points.txt
 relenv.egg-info/requires.txt
 relenv.egg-info/top_level.txt
 relenv/_resources/xz/config.h
+relenv/_resources/xz/crc32_table.c
+relenv/_resources/xz/crc64_table.c
 relenv/_resources/xz/readme.md
 relenv/_scripts/install_vc_build.ps1
 relenv/build/__init__.py
@@ -50,5 +52,6 @@ tests/test_module_imports.py
 tests/test_pyversions_runtime.py
 tests/test_relocate.py
 tests/test_relocate_module.py
+tests/test_relocate_tools.py
 tests/test_runtime.py
 tests/test_verify_build.py

{relenv-0.22.2 → relenv-0.22.3}/tests/test_build.py

@@ -154,8 +154,8 @@ def test_get_dependency_version_sqlite_all_platforms() -> None:
 def test_get_dependency_version_xz_all_platforms() -> None:
     """Test getting XZ version for various platforms."""
     # XZ 5.5.0+ removed MSBuild support, so Windows uses a fallback version
-    # and XZ is not in JSON for win32
-    for platform in ["linux", "darwin"]:
+    # BUT we now have XZ 5.8.2 in python-versions.json for win32 too
+    for platform in ["linux", "darwin", "win32"]:
         result = get_dependency_version("xz", platform)
         assert result is not None, f"XZ should be available for {platform}"
         assert isinstance(result, dict)
@@ -166,10 +166,6 @@ def test_get_dependency_version_xz_all_platforms() -> None:
         assert "xz" in result["url"].lower()
         assert isinstance(result["sha256"], str)
 
-    # Windows should return None (uses hardcoded fallback in windows.py)
-    result = get_dependency_version("xz", "win32")
-    assert result is None, "XZ should not be in JSON for win32 (uses fallback)"
-
 
 def test_get_dependency_version_nonexistent() -> None:
     """Test that nonexistent dependency returns None."""

relenv-0.22.3/tests/test_relocate_tools.py

@@ -0,0 +1,152 @@
+# Copyright 2022-2026 Broadcom.
+# SPDX-License-Identifier: Apache-2.0
+
+import pathlib
+from typing import Iterator
+from unittest.mock import patch
+
+import pytest
+
+from relenv import relocate
+
+
+@pytest.fixture(autouse=True)  # type: ignore[misc]
+def reset_globals() -> Iterator[None]:
+    """Reset global caches in relocate module before and after each test."""
+    relocate._READELF_BINARY = None
+    relocate._PATCHELF_BINARY = None
+    yield
+    relocate._READELF_BINARY = None
+    relocate._PATCHELF_BINARY = None
+
+
+def test_get_readelf_binary_toolchain_exists(tmp_path: pathlib.Path) -> None:
+    """Test that toolchain readelf is used when available."""
+    toolchain_root = tmp_path / "toolchain"
+    toolchain_root.mkdir()
+    triplet = "x86_64-linux-gnu"
+
+    # Create the fake toolchain binary
+    bin_dir = toolchain_root / "bin"
+    bin_dir.mkdir(parents=True)
+    toolchain_readelf = bin_dir / f"{triplet}-readelf"
+    toolchain_readelf.touch()
+
+    with patch("relenv.relocate.sys.platform", "linux"):
+        # We need to mock relenv.common.get_toolchain and get_triplet
+        # Since they are imported inside the function, we can patch the module if it's already imported
+        # or use patch.dict(sys.modules)
+
+        # Ensure relenv.common is imported so we can patch it
+        import relenv.common  # noqa: F401
+
+        with patch("relenv.common.get_toolchain", return_value=toolchain_root):
+            with patch("relenv.common.get_triplet", return_value=triplet):
+                readelf = relocate._get_readelf_binary()
+
+                assert readelf == str(toolchain_readelf)
+                assert relocate._READELF_BINARY == str(toolchain_readelf)
+
+
+def test_get_readelf_binary_toolchain_missing(tmp_path: pathlib.Path) -> None:
+    """Test that system readelf is used when toolchain binary is missing."""
+    toolchain_root = tmp_path / "toolchain"
+    toolchain_root.mkdir()
+    triplet = "x86_64-linux-gnu"
+
+    # Do NOT create the binary
+
+    with patch("relenv.relocate.sys.platform", "linux"):
+        # Ensure relenv.common is imported so we can patch it
+        import relenv.common  # noqa: F401
+
+        with patch("relenv.common.get_toolchain", return_value=toolchain_root):
+            with patch("relenv.common.get_triplet", return_value=triplet):
+                readelf = relocate._get_readelf_binary()
+
+                assert readelf == "readelf"
+                assert relocate._READELF_BINARY == "readelf"
+
+
+def test_get_readelf_binary_no_toolchain() -> None:
+    """Test that system readelf is used when get_toolchain returns None."""
+    with patch("relenv.relocate.sys.platform", "linux"):
+        # Ensure relenv.common is imported so we can patch it
+        import relenv.common  # noqa: F401
+
+        with patch("relenv.common.get_toolchain", return_value=None):
+            readelf = relocate._get_readelf_binary()
+
+            assert readelf == "readelf"
+            assert relocate._READELF_BINARY == "readelf"
+
+
+def test_get_readelf_binary_not_linux() -> None:
+    """Test that system readelf is used on non-Linux platforms."""
+    with patch("relenv.relocate.sys.platform", "darwin"):
+        readelf = relocate._get_readelf_binary()
+
+        assert readelf == "readelf"
+        assert relocate._READELF_BINARY == "readelf"
+
+
+def test_get_patchelf_binary_toolchain_exists(tmp_path: pathlib.Path) -> None:
+    """Test that toolchain patchelf is used when available."""
+    toolchain_root = tmp_path / "toolchain"
+    toolchain_root.mkdir()
+
+    # Create the fake toolchain binary
+    bin_dir = toolchain_root / "bin"
+    bin_dir.mkdir(parents=True)
+    toolchain_patchelf = bin_dir / "patchelf"
+    toolchain_patchelf.touch()
+
+    with patch("relenv.relocate.sys.platform", "linux"):
+        # Ensure relenv.common is imported so we can patch it
+        import relenv.common  # noqa: F401
+
+        with patch("relenv.common.get_toolchain", return_value=toolchain_root):
+            patchelf = relocate._get_patchelf_binary()
+
+            assert patchelf == str(toolchain_patchelf)
+            assert relocate._PATCHELF_BINARY == str(toolchain_patchelf)
+
+
+def test_get_patchelf_binary_toolchain_missing(tmp_path: pathlib.Path) -> None:
+    """Test that system patchelf is used when toolchain binary is missing."""
+    toolchain_root = tmp_path / "toolchain"
+    toolchain_root.mkdir()
+
+    # Do NOT create the binary
+
+    with patch("relenv.relocate.sys.platform", "linux"):
+        # Ensure relenv.common is imported so we can patch it
+        import relenv.common  # noqa: F401
+
+        with patch("relenv.common.get_toolchain", return_value=toolchain_root):
+            patchelf = relocate._get_patchelf_binary()
+
+            assert patchelf == "patchelf"
+            assert relocate._PATCHELF_BINARY == "patchelf"
+
+
+def test_get_patchelf_binary_no_toolchain() -> None:
+    """Test that system patchelf is used when get_toolchain returns None."""
+    with patch("relenv.relocate.sys.platform", "linux"):
+        # Ensure relenv.common is imported so we can patch it
+        import relenv.common  # noqa: F401
+
+        with patch("relenv.common.get_toolchain", return_value=None):
+            patchelf = relocate._get_patchelf_binary()
+
+            assert patchelf == "patchelf"
+            assert relocate._PATCHELF_BINARY == "patchelf"
+
+
+def test_get_patchelf_binary_not_linux() -> None:
+    """Test that system patchelf is used on non-Linux platforms."""
+    with patch("relenv.relocate.sys.platform", "darwin"):
+        patchelf = relocate._get_patchelf_binary()
+
+        assert patchelf == "patchelf"
+        assert relocate._PATCHELF_BINARY == "patchelf"

{relenv-0.22.2 → relenv-0.22.3}/tests/test_runtime.py

@@ -374,6 +374,7 @@ def test_finalize_options_wrapper_appends_include(
 def test_install_wheel_wrapper_processes_record(
     tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
+    monkeypatch.setenv("RELENV_BUILDENV", "1")
     plat_dir = tmp_path / "plat"
     info_dir = plat_dir / "demo.dist-info"
     info_dir.mkdir(parents=True)
@@ -440,6 +441,7 @@ def test_install_wheel_wrapper_processes_record(
 def test_install_wheel_wrapper_missing_file(
     tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
+    monkeypatch.setenv("RELENV_BUILDENV", "1")
     plat_dir = tmp_path / "plat"
     info_dir = plat_dir / "demo.dist-info"
     info_dir.mkdir(parents=True)
@@ -477,6 +479,7 @@ def test_install_wheel_wrapper_missing_file(
 def test_install_wheel_wrapper_macho_with_otool(
     tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
+    monkeypatch.setenv("RELENV_BUILDENV", "1")
     plat_dir = tmp_path / "plat"
     info_dir = plat_dir / "demo.dist-info"
     info_dir.mkdir(parents=True)
@@ -520,6 +523,7 @@ def test_install_wheel_wrapper_macho_with_otool(
 def test_install_wheel_wrapper_macho_without_otool(
     tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
+    monkeypatch.setenv("RELENV_BUILDENV", "1")
     plat_dir = tmp_path / "plat"
     info_dir = plat_dir / "demo.dist-info"
     info_dir.mkdir(parents=True)
@@ -565,6 +569,74 @@ def test_install_wheel_wrapper_macho_without_otool(
     assert any("otool command is not available" in msg for msg in messages)
 
 
+def test_install_wheel_wrapper_skips_without_buildenv(
+    tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.delenv("RELENV_BUILDENV", raising=False)
+    plat_dir = tmp_path / "plat"
+    info_dir = plat_dir / "demo.dist-info"
+    info_dir.mkdir(parents=True)
+    record = info_dir / "RECORD"
+    record.write_text("libdemo.so,,\n")
+    binary = plat_dir / "libdemo.so"
+    binary.touch()
+
+    # If relocation runs, this mock will raise an error or capture calls
+    handled: list[tuple[pathlib.Path, pathlib.Path]] = []
+    monkeypatch.setattr(
+        relenv.runtime,
+        "relocate",
+        lambda: SimpleNamespace(
+            is_elf=lambda path: path.name.endswith(".so"),
+            is_macho=lambda path: False,
+            handle_elf=lambda file, lib_dir, fix, root: handled.append((file, lib_dir)),
+            handle_macho=lambda *args, **kwargs: None,
+        ),
+    )
+
+    wheel_utils = ModuleType("pip._internal.utils.wheel")
+    wheel_utils.parse_wheel = lambda _zf, _name: ("demo.dist-info", {})
+    monkeypatch.setitem(sys.modules, wheel_utils.__name__, wheel_utils)
+
+    class DummyZip:
+        def __init__(self, path: pathlib.Path) -> None:
+            self.path = path
+
+        def __enter__(self) -> DummyZip:
+            return self
+
+        def __exit__(self, *exc: object) -> bool:
+            return False
+
+    monkeypatch.setattr("zipfile.ZipFile", DummyZip)
+
+    install_module = ModuleType("pip._internal.operations.install.wheel")
+
+    def original_install(*_args: object, **_kwargs: object) -> str:
+        return "original"
+
+    install_module.install_wheel = original_install  # type: ignore[attr-defined]
+    monkeypatch.setitem(sys.modules, install_module.__name__, install_module)
+
+    wrapped_module = relenv.runtime.wrap_pip_install_wheel(install_module.__name__)
+
+    scheme = SimpleNamespace(
+        platlib=str(plat_dir),
+    )
+    wrapped_module.install_wheel(
+        "demo",
+        tmp_path / "wheel.whl",
+        scheme,
+        "desc",
+        None,
+        None,
+        None,
+        None,
+    )
+
+    assert not handled
+
+
 def test_install_legacy_wrapper_prefix(
     monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
 ) -> None:

{relenv-0.22.2 → relenv-0.22.3}/tests/test_verify_build.py

@@ -519,6 +519,9 @@ def test_pip_install_pyzmq(
     env["RELENV_BUILDENV"] = "yes"
     env["USE_STATIC_REQUIREMENTS"] = "1"
 
+    if pyzmq_version == "26.2.0":
+        env["CMAKE_ARGS"] = "-DCMAKE_POLICY_VERSION_MINIMUM=3.5"
+
     if sys.platform == "linux":
         fake_bsd_root = tmp_path / "fake_libbsd"
         (fake_bsd_root / "bsd").mkdir(parents=True, exist_ok=True)

relenv-0.22.2/relenv/_resources/xz/readme.md

@@ -1,4 +0,0 @@
-The config.h file was removed from XZ-Utils tarting with version 5.5.0.
-XZ-Utils seems to build just fine with the config.h file from 5.4.7, so we're
-including it here. This will be copied into the src/windows directory in the
-extracted source for XZ-Utils.