relenv 0.21.0__tar.gz → 0.21.2__tar.gz

{relenv-0.21.0/relenv.egg-info → relenv-0.21.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: relenv
-Version: 0.21.0
+Version: 0.21.2
 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.21.0 → relenv-0.21.2}/relenv/build/__init__.py

@@ -152,7 +152,7 @@ def main(args):
         build_version = requested
     else:
         pyversions = python_versions(args.python)
-        build_version = pyversions.keys()[0]
+        build_version = sorted(list(pyversions.keys()))[-1]
 
     # print(pyversions)
     # print(pyversions[0].major)

{relenv-0.21.0 → relenv-0.21.2}/relenv/build/common.py

@@ -38,6 +38,7 @@ from relenv.common import (
     runcmd,
     work_dirs,
     fetch_url,
+    Version,
 )
 import relenv.relocate
 
@@ -358,6 +359,99 @@ def build_sqlite(env, dirs, logfp):
     runcmd(["make", "install"], env=env, stderr=logfp, stdout=logfp)
 
 
+def update_ensurepip(directory):
+    """
+    Update bundled dependencies for ensurepip (pip & setuptools).
+    """
+    # ensurepip bundle location
+    bundle_dir = directory / "ensurepip" / "_bundled"
+
+    # Make sure the destination directory exists
+    bundle_dir.mkdir(parents=True, exist_ok=True)
+
+    # Detect existing whl. Later versions of python don't include setuptools. We
+    # only want to update whl files that python expects to be there
+    pip_version = "25.2"
+    setuptools_version = "80.9.0"
+    update_pip = False
+    update_setuptools = False
+    for file in bundle_dir.glob("*.whl"):
+
+        log.debug("Checking whl: %s", str(file))
+        if file.name.startswith("pip-"):
+            found_version = file.name.split("-")[1]
+            log.debug("Found version %s", found_version)
+            if Version(found_version) >= Version(pip_version):
+                log.debug("Found correct pip version or newer: %s", found_version)
+            else:
+                file.unlink()
+                update_pip = True
+        if file.name.startswith("setuptools-"):
+            found_version = file.name.split("-")[1]
+            log.debug("Found version %s", found_version)
+            if Version(found_version) >= Version(setuptools_version):
+                log.debug(
+                    "Found correct setuptools version or newer: %s", found_version
+                )
+            else:
+                file.unlink()
+                update_setuptools = True
+
+    # Download whl files and update __init__.py
+    init_file = directory / "ensurepip" / "__init__.py"
+    if update_pip:
+        whl = f"pip-{pip_version}-py3-none-any.whl"
+        whl_path = "b7/3f/945ef7ab14dc4f9d7f40288d2df998d1837ee0888ec3659c813487572faa"
+        url = f"https://files.pythonhosted.org/packages/{whl_path}/{whl}"
+        download_url(url=url, dest=bundle_dir)
+        assert (bundle_dir / whl).exists()
+
+        # Update __init__.py
+        old = "^_PIP_VERSION.*"
+        new = f'_PIP_VERSION = "{pip_version}"'
+        patch_file(path=init_file, old=old, new=new)
+
+    # setuptools
+    if update_setuptools:
+        whl = f"setuptools-{setuptools_version}-py3-none-any.whl"
+        whl_path = "a3/dc/17031897dae0efacfea57dfd3a82fdd2a2aeb58e0ff71b77b87e44edc772"
+        url = f"https://files.pythonhosted.org/packages/{whl_path}/{whl}"
+        download_url(url=url, dest=bundle_dir)
+        assert (bundle_dir / whl).exists()
+
+        # setuptools
+        old = "^_SETUPTOOLS_VERSION.*"
+        new = f'_SETUPTOOLS_VERSION = "{setuptools_version}"'
+        patch_file(path=init_file, old=old, new=new)
+
+    log.debug("ensurepip __init__.py contents:")
+    log.debug(init_file.read_text())
+
+
+def patch_file(path, old, new):
+    """
+    Search a file line by line for a string to replace.
+
+    :param path: Location of the file to search
+    :type path: str
+    :param old: The value that will be replaced
+    :type path: str
+    :param new: The value that will replace the 'old' value.
+    :type path: str
+    """
+    log.debug("Patching file: %s", path)
+    import re
+
+    with open(path, "r") as fp:
+        content = fp.read()
+    new_content = ""
+    for line in content.splitlines():
+        line = re.sub(old, new, line)
+        new_content += line + "\n"
+    with open(path, "w") as fp:
+        fp.write(new_content)
+
+
 def tarball_version(href):
     if href.endswith("tar.gz"):
         try:
@@ -1457,6 +1551,9 @@ def finalize(env, dirs, logfp):
 
     pymodules = libdir / find_pythonlib(libdir)
 
+    # update ensurepip
+    update_ensurepip(pymodules)
+
     cwd = os.getcwd()
     modname = find_sysconfigdata(pymodules)
     path = sys.path
@@ -1474,6 +1571,7 @@ def finalize(env, dirs, logfp):
     bindir = pathlib.Path(dirs.prefix) / "bin"
     sitepackages = pymodules / "site-packages"
     install_runtime(sitepackages)
+
     # Install pip
     python = dirs.prefix / "bin" / "python3"
     if env["RELENV_HOST_ARCH"] != env["RELENV_BUILD_ARCH"]:

{relenv-0.21.0 → relenv-0.21.2}/relenv/build/linux.py

@@ -379,11 +379,11 @@ def build_python(env, dirs, logfp):
     )
 
     if pathlib.Path("setup.py").exists():
-        with tempfile.NamedTemporaryFile(mode="w", suffix="_patch") as patch_file:
-            patch_file.write(PATCH)
-            patch_file.flush()
+        with tempfile.NamedTemporaryFile(mode="w", suffix="_patch") as p_file:
+            p_file.write(PATCH)
+            p_file.flush()
             runcmd(
-                ["patch", "-p0", "-i", patch_file.name],
+                ["patch", "-p0", "-i", p_file.name],
                 env=env,
                 stderr=logfp,
                 stdout=logfp,

relenv-0.21.2/relenv/build/windows.py

@@ -0,0 +1,519 @@
+# Copyright 2022-2025 Broadcom.
+# SPDX-License-Identifier: Apache-2
+"""
+The windows build process.
+"""
+import glob
+import json
+import logging
+import os
+import pathlib
+import shutil
+import sys
+import tarfile
+
+from .common import (
+    builds,
+    create_archive,
+    download_url,
+    extract_archive,
+    install_runtime,
+    MODULE_DIR,
+    patch_file,
+    runcmd,
+    update_ensurepip,
+)
+from ..common import arches, WIN32, Version
+
+log = logging.getLogger(__name__)
+
+ARCHES = arches[WIN32]
+
+if sys.platform == WIN32:
+    import ctypes
+
+    kernel32 = ctypes.windll.kernel32
+    kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
+
+
+def populate_env(env, dirs):
+    """
+    Make sure we have the correct environment variables set.
+
+    :param env: The environment dictionary
+    :type env: dict
+    :param dirs: The working directories
+    :type dirs: ``relenv.build.common.Dirs``
+    """
+    env["MSBUILDDISABLENODEREUSE"] = "1"
+
+
+def update_props(source, old, new):
+    """
+    Overwrite a dependency string for Windows PCBuild.
+
+    :param source: Python's source directory
+    :type source: str
+    :param old: Regular expression to search for
+    :type old: str
+    :param new: Replacement text
+    :type new: str
+    """
+    patch_file(source / "PCbuild" / "python.props", old, new)
+    patch_file(source / "PCbuild" / "get_externals.bat", old, new)
+
+
+def get_externals_source(externals_dir, url):
+    """
+    Download external source code dependency.
+
+    Download source code and extract to the "externals" directory in the root of
+    the python source. Only works with a tarball
+    """
+    zips_dir = externals_dir / "zips"
+    zips_dir.mkdir(parents=True, exist_ok=True)
+    local_file = download_url(url=url, dest=str(zips_dir))
+    extract_archive(archive=str(local_file), to_dir=str(externals_dir))
+    try:
+        os.remove(local_file)
+    except OSError:
+        log.exception("Failed to remove temporary file")
+
+
+def get_externals_bin(source_root, url):
+    """
+    Download external binary dependency.
+
+    Download binaries to the "externals" directory in the root of the python
+    source.
+    """
+    pass
+
+
+def update_sqlite(dirs, env):
+    """
+    Update the SQLITE library.
+    """
+    version = "3.50.4.0"
+    url = "https://sqlite.org/2025/sqlite-autoconf-3500400.tar.gz"
+    sha256 = "a3db587a1b92ee5ddac2f66b3edb41b26f9c867275782d46c3a088977d6a5b18"
+    ref_loc = f"cpe:2.3:a:sqlite:sqlite:{version}:*:*:*:*:*:*:*"
+    target_dir = dirs.source / "externals" / f"sqlite-{version}"
+    target_dir.parent.mkdir(parents=True, exist_ok=True)
+    if not target_dir.exists():
+        update_props(dirs.source, r"sqlite-\d+.\d+.\d+.\d+", f"sqlite-{version}")
+        get_externals_source(externals_dir=dirs.source / "externals", url=url)
+        # # we need to fix the name of the extracted directory
+        extracted_dir = dirs.source / "externals" / "sqlite-autoconf-3500400"
+        shutil.move(str(extracted_dir), str(target_dir))
+    # 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"]:
+        spdx_json = dirs.source / "Misc" / "externals.spdx.json"
+        with open(str(spdx_json), "r") as f:
+            data = json.load(f)
+            for pkg in data["packages"]:
+                if pkg["name"] == "sqlite":
+                    pkg["versionInfo"] = version
+                    pkg["downloadLocation"] = url
+                    pkg["checksums"][0]["checksumValue"] = sha256
+                    pkg["externalRefs"][0]["referenceLocator"] = ref_loc
+        with open(str(spdx_json), "w") as f:
+            json.dump(data, f, indent=2)
+
+
+def update_xz(dirs, env):
+    """
+    Update the XZ library.
+    """
+    version = "5.6.2"
+    url = f"https://github.com/tukaani-project/xz/releases/download/v{version}/xz-{version}.tar.xz"
+    sha256 = "8bfd20c0e1d86f0402f2497cfa71c6ab62d4cd35fd704276e3140bfb71414519"
+    ref_loc = f"cpe:2.3:a:tukaani:xz:{version}:*:*:*:*:*:*:*"
+    target_dir = dirs.source / "externals" / f"xz-{version}"
+    target_dir.parent.mkdir(parents=True, exist_ok=True)
+    if not target_dir.exists():
+        update_props(dirs.source, r"xz-\d+.\d+.\d+", f"xz-{version}")
+        get_externals_source(externals_dir=dirs.source / "externals", url=url)
+    # Starting with version v5.5.0, XZ-Utils removed the ability to compile
+    # with MSBuild. We are bringing the config.h from the last version that
+    # had it, 5.4.7
+    config_file = target_dir / "src" / "common" / "config.h"
+    config_file_source = dirs.root / "_resources" / "xz" / "config.h"
+    if not config_file.exists():
+        shutil.copy(str(config_file_source), str(config_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"]:
+        spdx_json = dirs.source / "Misc" / "externals.spdx.json"
+        with open(str(spdx_json), "r") as f:
+            data = json.load(f)
+            for pkg in data["packages"]:
+                if pkg["name"] == "xz":
+                    pkg["versionInfo"] = version
+                    pkg["downloadLocation"] = url
+                    pkg["checksums"][0]["checksumValue"] = sha256
+                    pkg["externalRefs"][0]["referenceLocator"] = ref_loc
+        with open(str(spdx_json), "w") as f:
+            json.dump(data, f, indent=2)
+
+
+def update_expat(dirs, env):
+    """
+    Update the EXPAT library.
+    """
+    # Patch <src>/Modules/expat/refresh.sh. When the SBOM is created, refresh.sh
+    # is scanned for the expat version, even though it doesn't run on Windows.
+    version = "2.7.3"
+    hash = "821ac9710d2c073eaf13e1b1895a9c9aa66c1157a99635c639fbff65cdbdd732"
+    url = f'https://github.com/libexpat/libexpat/releases/download/R_{version.replace(".", "_")}/expat-{version}.tar.xz'
+    bash_refresh = dirs.source / "Modules" / "expat" / "refresh.sh"
+    old = r'expected_libexpat_tag="R_\d+_\d+_\d"'
+    new = f'expected_libexpat_tag="R_{version.replace(".", "_")}"'
+    patch_file(bash_refresh, old=old, new=new)
+    old = r'expected_libexpat_version="\d+.\d+.\d"'
+    new = f'expected_libexpat_version="{version}"'
+    patch_file(bash_refresh, old=old, new=new)
+    old = 'expected_libexpat_sha256=".*"'
+    new = f'expected_libexpat_sha256="{hash}"'
+    patch_file(bash_refresh, old=old, new=new)
+    get_externals_source(externals_dir=dirs.source / "Modules" / "expat", url=url)
+    # Copy *.h and *.c to expat directory
+    expat_lib_dir = dirs.source / "Modules" / "expat" / f"expat-{version}" / "lib"
+    expat_dir = dirs.source / "Modules" / "expat"
+    for file in glob.glob(str(expat_lib_dir / "*.h")):
+        if expat_dir / os.path.basename(file):
+            (expat_dir / os.path.basename(file)).unlink()
+        shutil.move(file, str(expat_dir))
+    for file in glob.glob(str(expat_lib_dir / "*.c")):
+        if expat_dir / os.path.basename(file):
+            (expat_dir / os.path.basename(file)).unlink()
+        shutil.move(file, str(expat_dir))
+    # Update sbom.spdx.json with the correct hashes. This became a thing in 3.12
+    # python Tools/build/generate_sbom.py doesn't work because it requires a git
+    # repository, so we have to do it manually.
+    if env["RELENV_PY_MAJOR_VERSION"] in ["3.12", "3.13", "3.14"]:
+        checksums = {
+            "Modules/expat/expat.h": [
+                {
+                    "algorithm": "SHA1",
+                    "checksumValue": "a4395dd0589a97aab0904f7a5f5dc5781a086aa2",
+                },
+                {
+                    "algorithm": "SHA256",
+                    "checksumValue": "610b844bbfa3ec955772cc825db4d4db470827d57adcb214ad372d0eaf00e591",
+                },
+            ],
+            "Modules/expat/expat_external.h": [
+                {
+                    "algorithm": "SHA1",
+                    "checksumValue": "8fdf2e79a7ab46a3c76c74ed7e5fe641cbef308d",
+                },
+                {
+                    "algorithm": "SHA256",
+                    "checksumValue": "ffb960af48b80935f3856a16e87023524b104f7fc1e58104f01db88ba7bfbcc9",
+                },
+            ],
+            "Modules/expat/internal.h": [
+                {
+                    "algorithm": "SHA1",
+                    "checksumValue": "7dce7d98943c5db33ae05e54801dcafb4547b9dd",
+                },
+                {
+                    "algorithm": "SHA256",
+                    "checksumValue": "6bfe307d52e7e4c71dbc30d3bd902a4905cdd83bbe4226a7e8dfa8e4c462a157",
+                },
+            ],
+            "Modules/expat/refresh.sh": [
+                {
+                    "algorithm": "SHA1",
+                    "checksumValue": "71812ca27328697a8dcae1949cd638717538321a",
+                },
+                {
+                    "algorithm": "SHA256",
+                    "checksumValue": "64fd1368de41e4ebc14593c65f5a676558aed44bd7d71c43ae05d06f9086d3b0",
+                },
+            ],
+            "Modules/expat/xmlparse.c": [
+                {
+                    "algorithm": "SHA1",
+                    "checksumValue": "4c81a1f04fc653877c63c834145c18f93cd95f3e",
+                },
+                {
+                    "algorithm": "SHA256",
+                    "checksumValue": "04a379615f476d55f95ca1853107e20627b48ca4afe8d0fd5981ac77188bf0a6",
+                },
+            ],
+            "Modules/expat/xmlrole.h": [
+                {
+                    "algorithm": "SHA1",
+                    "checksumValue": "ac2964cca107f62dd133bfd4736a9a17defbc401",
+                },
+                {
+                    "algorithm": "SHA256",
+                    "checksumValue": "92e41f373b67f6e0dcd7735faef3c3f1e2c17fe59e007e6b74beef6a2e70fa88",
+                },
+            ],
+            "Modules/expat/xmltok.c": [
+                {
+                    "algorithm": "SHA1",
+                    "checksumValue": "1e2d35d90a1c269217f83d3bdf3c71cc22cb4c3f",
+                },
+                {
+                    "algorithm": "SHA256",
+                    "checksumValue": "98d0fc735041956cc2e7bbbe2fb8f03130859410e0aee5e8015f406a37c02a3c",
+                },
+            ],
+            "Modules/expat/xmltok.h": [
+                {
+                    "algorithm": "SHA1",
+                    "checksumValue": "d126831eaa5158cff187a8c93f4bc1c8118f3b17",
+                },
+                {
+                    "algorithm": "SHA256",
+                    "checksumValue": "91bf003a725a675761ea8d92cebc299a76fd28c3a950572f41bc7ce5327ee7b5",
+                },
+            ],
+        }
+        spdx_json = dirs.source / "Misc" / "sbom.spdx.json"
+        with open(str(spdx_json), "r") as f:
+            data = json.load(f)
+            for file in data["files"]:
+                if file["fileName"] in checksums.keys():
+                    print(file["fileName"])
+                    file["checksums"] = checksums[file["fileName"]]
+        with open(str(spdx_json), "w") as f:
+            json.dump(data, f, indent=2)
+
+
+def update_expat_check(env):
+    """
+    Check if the given python version should get an updated libexpat.
+
+    Patch libexpat on these versions and below:
+      - 3.9.23
+      - 3.10.18
+      - 3.11.13
+      - 3.12.11
+      - 3.13.7
+    """
+    relenv_version = Version(env["RELENV_PY_VERSION"])
+    if relenv_version.minor == 9 and relenv_version.micro <= 23:
+        return True
+    elif relenv_version.minor == 10 and relenv_version.micro <= 18:
+        return True
+    elif relenv_version.minor == 11 and relenv_version.micro <= 13:
+        return True
+    elif relenv_version.minor == 12 and relenv_version.micro <= 11:
+        return True
+    elif relenv_version.minor == 13 and relenv_version.micro <= 7:
+        return True
+    return False
+
+
+def build_python(env, dirs, logfp):
+    """
+    Run the commands to build Python.
+
+    :param env: The environment dictionary
+    :type env: dict
+    :param dirs: The working directories
+    :type dirs: ``relenv.build.common.Dirs``
+    :param logfp: A handle for the log file
+    :type logfp: file
+    """
+    # Override default versions
+
+    # Create externals directory
+    externals_dir = dirs.source / "externals"
+    externals_dir.mkdir(parents=True, exist_ok=True)
+
+    # SQLITE
+    # TODO: Python 3.12 started creating an SBOM. We're doing something wrong
+    # TODO: updating sqlite so SBOM creation is failing. Gating here until we
+    # TODO: fix this. Here's the original gate:
+    # if env["RELENV_PY_MAJOR_VERSION"] in ["3.10", "3.11", "3.12"]:
+    if env["RELENV_PY_MAJOR_VERSION"] in ["3.10", "3.11"]:
+        update_sqlite(dirs=dirs, env=env)
+
+    # XZ-Utils
+    # TODO: Python 3.12 started creating an SBOM. We're doing something wrong
+    # TODO: updating XZ so SBOM creation is failing. Gating here until we fix
+    # TODO: this. Here's the original gate:
+    # if env["RELENV_PY_MAJOR_VERSION"] in ["3.10", "3.11", "3.12", "3.13", "3.14"]:
+    if env["RELENV_PY_MAJOR_VERSION"] in ["3.10", "3.11"]:
+        update_xz(dirs=dirs, env=env)
+
+    # TODO: This was my attempt to fix the expat error during build... it failed
+    # TODO: so we're just skipping for now.
+    if env["RELENV_PY_MAJOR_VERSION"] in ["3.10", "3.11"]:
+        if update_expat_check(env=env):
+            update_expat(dirs=dirs, env=env)
+
+    arch_to_plat = {
+        "amd64": "x64",
+        "x86": "win32",
+        "arm64": "arm64",
+    }
+    arch = env["RELENV_HOST_ARCH"]
+    plat = arch_to_plat[arch]
+    cmd = [
+        str(dirs.source / "PCbuild" / "build.bat"),
+        "-p",
+        plat,
+        "--no-tkinter",
+    ]
+
+    log.info("Start PCbuild")
+    runcmd(cmd, env=env, stderr=logfp, stdout=logfp)
+    log.info("PCbuild finished")
+
+    # This is where build.bat puts everything
+    # TODO: For now we'll only support 64bit
+    if arch == "amd64":
+        build_dir = dirs.source / "PCbuild" / arch
+    else:
+        build_dir = dirs.source / "PCbuild" / plat
+    bin_dir = dirs.prefix / "Scripts"
+    bin_dir.mkdir(parents=True, exist_ok=True)
+
+    # Move python binaries
+    binaries = [
+        "py.exe",
+        "pyw.exe",
+        "python.exe",
+        "pythonw.exe",
+        "python3.dll",
+        f"python{ env['RELENV_PY_MAJOR_VERSION'].replace('.', '') }.dll",
+        "vcruntime140.dll",
+        "venvlauncher.exe",
+        "venvwlauncher.exe",
+    ]
+    for binary in binaries:
+        shutil.move(src=str(build_dir / binary), dst=str(bin_dir / binary))
+
+    # Create DLLs directory
+    (dirs.prefix / "DLLs").mkdir(parents=True, exist_ok=True)
+    # Move all library files to DLLs directory (*.pyd, *.dll)
+    for file in glob.glob(str(build_dir / "*.pyd")):
+        shutil.move(src=file, dst=str(dirs.prefix / "DLLs"))
+    for file in glob.glob(str(build_dir / "*.dll")):
+        shutil.move(src=file, dst=str(dirs.prefix / "DLLs"))
+
+    # Copy include directory
+    shutil.copytree(
+        src=str(dirs.source / "Include"),
+        dst=str(dirs.prefix / "Include"),
+        dirs_exist_ok=True,
+    )
+    if "3.13" not in env["RELENV_PY_MAJOR_VERSION"]:
+        shutil.copy(
+            src=str(dirs.source / "PC" / "pyconfig.h"),
+            dst=str(dirs.prefix / "Include"),
+        )
+
+    # Copy library files
+    shutil.copytree(
+        src=str(dirs.source / "Lib"),
+        dst=str(dirs.prefix / "Lib"),
+        dirs_exist_ok=True,
+    )
+    os.makedirs(str(dirs.prefix / "Lib" / "site-packages"), exist_ok=True)
+
+    # Create libs directory
+    (dirs.prefix / "libs").mkdir(parents=True, exist_ok=True)
+    # Copy lib files
+    shutil.copy(
+        src=str(build_dir / "python3.lib"),
+        dst=str(dirs.prefix / "libs" / "python3.lib"),
+    )
+    pylib = f"python{ env['RELENV_PY_MAJOR_VERSION'].replace('.', '') }.lib"
+    shutil.copy(
+        src=str(build_dir / pylib),
+        dst=str(dirs.prefix / "libs" / pylib),
+    )
+
+
+build = builds.add("win32", populate_env=populate_env)
+
+build.add(
+    "python",
+    build_func=build_python,
+    download={
+        "url": "https://www.python.org/ftp/python/{version}/Python-{version}.tar.xz",
+        "version": build.version,
+        "checksum": "d31d548cd2c5ca2ae713bebe346ba15e8406633a",
+    },
+)
+
+
+def finalize(env, dirs, logfp):
+    """
+    Finalize sitecustomize, relenv runtime, and pip for Windows.
+
+    :param env: The environment dictionary
+    :type env: dict
+    :param dirs: The working directories
+    :type dirs: ``relenv.build.common.Dirs``
+    :param logfp: A handle for the log file
+    :type logfp: file
+    """
+    # Lay down site customize
+    sitepackages = dirs.prefix / "Lib" / "site-packages"
+    install_runtime(sitepackages)
+
+    # update ensurepip
+    update_ensurepip(dirs.prefix / "Lib")
+
+    # Install pip
+    python = dirs.prefix / "Scripts" / "python.exe"
+    runcmd([str(python), "-m", "ensurepip"], env=env, stderr=logfp, stdout=logfp)
+
+    def runpip(pkg):
+        # XXX Support cross pip installs on windows
+        env = os.environ.copy()
+        target = None
+        cmd = [
+            str(python),
+            "-m",
+            "pip",
+            "install",
+            str(pkg),
+        ]
+        if target:
+            cmd.append("--target={}".format(target))
+        runcmd(cmd, env=env, stderr=logfp, stdout=logfp)
+
+    runpip("wheel")
+    # This needs to handle running from the root of the git repo and also from
+    # an installed Relenv
+    if (MODULE_DIR.parent / ".git").exists():
+        runpip(MODULE_DIR.parent)
+    else:
+        runpip("relenv")
+
+    for root, _, files in os.walk(dirs.prefix):
+        for file in files:
+            if file.endswith(".pyc"):
+                os.remove(pathlib.Path(root) / file)
+
+    globs = [
+        "*.exe",
+        "*.py",
+        "*.pyd",
+        "*.dll",
+        "*.lib",
+        "*.whl",
+        "/Include/*",
+        "/Lib/site-packages/*",
+    ]
+    archive = f"{dirs.prefix}.tar.xz"
+    with tarfile.open(archive, mode="w:xz") as fp:
+        create_archive(fp, dirs.prefix, globs, logfp)
+
+
+build.add(
+    "relenv-finalize",
+    build_func=finalize,
+    wait_on=["python"],
+)

{relenv-0.21.0 → relenv-0.21.2}/relenv/common.py

@@ -18,7 +18,7 @@ import threading
 import time
 
 # relenv package version
-__version__ = "0.21.0"
+__version__ = "0.21.2"
 
 MODULE_DIR = pathlib.Path(__file__).resolve().parent
 
@@ -336,12 +336,19 @@ def extract_archive(to_dir, archive):
     :type archive: str
     """
     if archive.endswith("tgz"):
+        log.debug("Found tgz archive")
+        read_type = "r:gz"
+    elif archive.endswith("tar.gz"):
+        log.debug("Found tar.gz archive")
         read_type = "r:gz"
     elif archive.endswith("xz"):
+        log.debug("Found xz archive")
         read_type = "r:xz"
     elif archive.endswith("bz2"):
+        log.debug("Found bz2 archive")
         read_type = "r:bz2"
     else:
+        log.warning("Found unknown archive type: %s", archive)
         read_type = "r"
     with tarfile.open(archive, read_type) as t:
         t.extractall(to_dir)
@@ -411,6 +418,7 @@ def fetch_url(url, fp, backoff=3, timeout=30):
         n += 1
         try:
             fin = urllib.request.urlopen(url, timeout=timeout)
+            break
         except (
             urllib.error.HTTPError,
             urllib.error.URLError,
@@ -420,6 +428,8 @@ def fetch_url(url, fp, backoff=3, timeout=30):
                 raise RelenvException(f"Error fetching url {url} {exc}")
             log.debug("Unable to connect %s", url)
             time.sleep(n * 10)
+    else:
+        raise RelenvException(f"Error fetching url: {url}")
     log.info("url opened %s", url)
     try:
         total = 0
@@ -434,7 +444,6 @@ def fetch_url(url, fp, backoff=3, timeout=30):
             block = fin.read(10240)
     finally:
         fin.close()
-        # fp.close()
     log.info("Download complete %s", url)
 
 
@@ -514,18 +523,21 @@ def download_url(url, dest, verbose=True, backoff=3, timeout=60):
     """
     local = get_download_location(url, dest)
     if verbose:
-        print(f"Downloading {url} -> {local}")
+        log.debug(f"Downloading {url} -> {local}")
     fout = open(local, "wb")
     try:
         fetch_url(url, fout, backoff, timeout)
     except Exception as exc:
         if verbose:
-            print(f"Unable to download: {url} {exc}", file=sys.stderr, flush=True)
+            log.error("Unable to download: %s\n%s", url, exc)
         try:
             os.unlink(local)
         except OSError:
             pass
         raise
+    finally:
+        fout.close()
+        log.debug(f"Finished downloading {url} -> {local}")
     return local
 
 

{relenv-0.21.0 → relenv-0.21.2}/relenv/pyversions.py

@@ -340,7 +340,7 @@ def main(args):
             if not pyversions:
                 print(f"Unknown minor version {requested}")
                 sys.exit(1)
-            build_version = list(pyversions.keys())[0]
+            build_version = sorted(list(pyversions.keys()))[-1]
         print(build_version)
         sys.exit()
 

{relenv-0.21.0 → relenv-0.21.2}/relenv/runtime.py

@@ -750,12 +750,39 @@ def wrap_req_install(name):
     mod = importlib.import_module(name)
 
     def wrap(func):
-        if mod.InstallRequirement.install.__code__.co_argcount == 9:
+        if mod.InstallRequirement.install.__code__.co_argcount == 7:
+
+            @functools.wraps(func)
+            def wrapper(
+                self,
+                root=None,
+                home=None,
+                prefix=None,
+                warn_script_location=True,
+                use_user_site=False,
+                pycompile=True,
+            ):
+                try:
+                    if TARGET.TARGET:
+                        TARGET.INSTALL = True
+                        home = TARGET.PATH
+                    return func(
+                        self,
+                        root,
+                        home,
+                        prefix,
+                        warn_script_location,
+                        use_user_site,
+                        pycompile,
+                    )
+                finally:
+                    TARGET.INSTALL = False
+
+        elif mod.InstallRequirement.install.__code__.co_argcount == 8:
 
             @functools.wraps(func)
             def wrapper(
                 self,
-                install_options,
                 global_options=None,
                 root=None,
                 home=None,
@@ -770,7 +797,6 @@ def wrap_req_install(name):
                         home = TARGET.PATH
                     return func(
                         self,
-                        install_options,
                         global_options,
                         root,
                         home,
@@ -783,10 +809,12 @@ def wrap_req_install(name):
                     TARGET.INSTALL = False
 
         else:
+            # Oldest version of this method sigature with 9 arguments.
 
             @functools.wraps(func)
             def wrapper(
                 self,
+                install_options,
                 global_options=None,
                 root=None,
                 home=None,
@@ -801,6 +829,7 @@ def wrap_req_install(name):
                         home = TARGET.PATH
                     return func(
                         self,
+                        install_options,
                         global_options,
                         root,
                         home,
@@ -845,8 +874,8 @@ def install_cargo_config():
     # load the ssl module. Causing out setup_openssl method to fail to load
     # fips module.
     dirs = common().work_dirs()
-    triplet = common().get_triplet()
     cargo_home = dirs.data / "cargo"
+    triplet = common().get_triplet()
 
     toolchain = common().get_toolchain()
     if not toolchain:

{relenv-0.21.0 → relenv-0.21.2/relenv.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: relenv
-Version: 0.21.0
+Version: 0.21.2
 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.21.0 → relenv-0.21.2}/tests/test_verify_build.py

@@ -1859,3 +1859,26 @@ def test_import_ssl_module(pyexec):
     assert proc.returncode == 0
     assert proc.stdout.decode() == ""
     assert proc.stderr.decode() == ""
+
+
+@pytest.mark.skip_unless_on_linux
+@pytest.mark.parametrize("pip_version", ["25.2", "25.3"])
+def test_install_setuptools_25_2_to_25_3(pipexec, build, minor_version, pip_version):
+    """
+    Validate we handle the changes to pip._internal.req.InstallRequirement.install signature.
+    """
+    subprocess.run(
+        [str(pipexec), "install", "--upgrade", f"pip=={pip_version}"],
+        check=True,
+    )
+    subprocess.run(
+        [
+            str(pipexec),
+            "install",
+            "--upgrade",
+            "--no-binary=:all:",
+            "--no-cache-dir",
+            "setuptools",
+        ],
+        check=True,
+    )

relenv-0.21.0/relenv/build/windows.py

@@ -1,258 +0,0 @@
-# Copyright 2022-2025 Broadcom.
-# SPDX-License-Identifier: Apache-2
-"""
-The windows build process.
-"""
-import glob
-import shutil
-import sys
-import os
-import pathlib
-import tarfile
-import logging
-from .common import runcmd, create_archive, MODULE_DIR, builds, install_runtime
-from ..common import arches, WIN32
-
-log = logging.getLogger(__name__)
-
-ARCHES = arches[WIN32]
-
-if sys.platform == WIN32:
-    import ctypes
-
-    kernel32 = ctypes.windll.kernel32
-    kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
-
-
-def populate_env(env, dirs):
-    """
-    Make sure we have the correct environment variables set.
-
-    :param env: The environment dictionary
-    :type env: dict
-    :param dirs: The working directories
-    :type dirs: ``relenv.build.common.Dirs``
-    """
-    env["MSBUILDDISABLENODEREUSE"] = "1"
-
-
-def patch_file(path, old, new):
-    """
-    Search a file line by line for a string to replace.
-
-    :param path: Location of the file to search
-    :type path: str
-    :param old: The value that will be replaced
-    :type path: str
-    :param new: The value that will replace the 'old' value.
-    :type path: str
-    """
-    import re
-
-    with open(path, "r") as fp:
-        content = fp.read()
-    new_content = ""
-    for line in content.splitlines():
-        re.sub(old, new, line)
-        new_content += line + os.linesep
-    with open(path, "w") as fp:
-        fp.write(new_content)
-
-
-def override_dependency(source, old, new):
-    """
-    Overwrite a dependency string for Windoes PCBuild.
-
-    :param source: Python's source directory
-    :type path: str
-    :param old: Regular expression to search for
-    :type path: str
-    :param new: Replacement text
-    :type path: str
-    """
-    patch_file(source / "PCbuild" / "python.props", old, new)
-    patch_file(source / "PCbuild" / "get_externals.bat", old, new)
-
-
-def build_python(env, dirs, logfp):
-    """
-    Run the commands to build Python.
-
-    :param env: The environment dictionary
-    :type env: dict
-    :param dirs: The working directories
-    :type dirs: ``relenv.build.common.Dirs``
-    :param logfp: A handle for the log file
-    :type logfp: file
-    """
-    # Override default versions
-    if env["RELENV_PY_MAJOR_VERSION"] in [
-        "3.10",
-        "3.11",
-    ]:
-        override_dependency(dirs.source, r"sqlite-\d+.\d+.\d+.\d+", "sqlite-3.50.4.0")
-        override_dependency(dirs.source, r"xz-\d+.\d+.\d+", "xz-5.6.2")
-
-    arch_to_plat = {
-        "amd64": "x64",
-        "x86": "win32",
-        "arm64": "arm64",
-    }
-    arch = env["RELENV_HOST_ARCH"]
-    plat = arch_to_plat[arch]
-    cmd = [
-        str(dirs.source / "PCbuild" / "build.bat"),
-        "-p",
-        plat,
-        "--no-tkinter",
-    ]
-    log.info("Start PCbuild")
-    runcmd(cmd, env=env, stderr=logfp, stdout=logfp)
-    log.info("PCbuild finished")
-
-    # This is where build.bat puts everything
-    # TODO: For now we'll only support 64bit
-    if arch == "amd64":
-        build_dir = dirs.source / "PCbuild" / arch
-    else:
-        build_dir = dirs.source / "PCbuild" / plat
-    bin_dir = dirs.prefix / "Scripts"
-    bin_dir.mkdir(parents=True, exist_ok=True)
-
-    # Move python binaries
-    binaries = [
-        "py.exe",
-        "pyw.exe",
-        "python.exe",
-        "pythonw.exe",
-        "python3.dll",
-        f"python{ env['RELENV_PY_MAJOR_VERSION'].replace('.', '') }.dll",
-        "vcruntime140.dll",
-        "venvlauncher.exe",
-        "venvwlauncher.exe",
-    ]
-    for binary in binaries:
-        shutil.move(src=str(build_dir / binary), dst=str(bin_dir / binary))
-
-    # Create DLLs directory
-    (dirs.prefix / "DLLs").mkdir(parents=True, exist_ok=True)
-    # Move all library files to DLLs directory (*.pyd, *.dll)
-    for file in glob.glob(str(build_dir / "*.pyd")):
-        shutil.move(src=file, dst=str(dirs.prefix / "DLLs"))
-    for file in glob.glob(str(build_dir / "*.dll")):
-        shutil.move(src=file, dst=str(dirs.prefix / "DLLs"))
-
-    # Copy include directory
-    shutil.copytree(
-        src=str(dirs.source / "Include"),
-        dst=str(dirs.prefix / "Include"),
-        dirs_exist_ok=True,
-    )
-    if "3.13" not in env["RELENV_PY_MAJOR_VERSION"]:
-        shutil.copy(
-            src=str(dirs.source / "PC" / "pyconfig.h"),
-            dst=str(dirs.prefix / "Include"),
-        )
-
-    # Copy library files
-    shutil.copytree(
-        src=str(dirs.source / "Lib"),
-        dst=str(dirs.prefix / "Lib"),
-        dirs_exist_ok=True,
-    )
-    os.makedirs(str(dirs.prefix / "Lib" / "site-packages"), exist_ok=True)
-
-    # Create libs directory
-    (dirs.prefix / "libs").mkdir(parents=True, exist_ok=True)
-    # Copy lib files
-    shutil.copy(
-        src=str(build_dir / "python3.lib"),
-        dst=str(dirs.prefix / "libs" / "python3.lib"),
-    )
-    pylib = f"python{ env['RELENV_PY_MAJOR_VERSION'].replace('.', '') }.lib"
-    shutil.copy(
-        src=str(build_dir / pylib),
-        dst=str(dirs.prefix / "libs" / pylib),
-    )
-
-
-build = builds.add("win32", populate_env=populate_env)
-
-build.add(
-    "python",
-    build_func=build_python,
-    download={
-        "url": "https://www.python.org/ftp/python/{version}/Python-{version}.tar.xz",
-        "version": build.version,
-        "checksum": "d31d548cd2c5ca2ae713bebe346ba15e8406633a",
-    },
-)
-
-
-def finalize(env, dirs, logfp):
-    """
-    Finalize sitecustomize, relenv runtime, and pip for Windows.
-
-    :param env: The environment dictionary
-    :type env: dict
-    :param dirs: The working directories
-    :type dirs: ``relenv.build.common.Dirs``
-    :param logfp: A handle for the log file
-    :type logfp: file
-    """
-    # Lay down site customize
-    sitepackages = dirs.prefix / "Lib" / "site-packages"
-
-    install_runtime(sitepackages)
-
-    # Install pip
-    python = dirs.prefix / "Scripts" / "python.exe"
-    runcmd([str(python), "-m", "ensurepip"], env=env, stderr=logfp, stdout=logfp)
-
-    def runpip(pkg):
-        # XXX Support cross pip installs on windows
-        env = os.environ.copy()
-        target = None
-        cmd = [
-            str(python),
-            "-m",
-            "pip",
-            "install",
-            str(pkg),
-        ]
-        if target:
-            cmd.append("--target={}".format(target))
-        runcmd(cmd, env=env, stderr=logfp, stdout=logfp)
-
-    runpip("wheel")
-    # This needs to handle running from the root of the git repo and also from
-    # an installed Relenv
-    if (MODULE_DIR.parent / ".git").exists():
-        runpip(MODULE_DIR.parent)
-    else:
-        runpip("relenv")
-
-    for root, _, files in os.walk(dirs.prefix):
-        for file in files:
-            if file.endswith(".pyc"):
-                os.remove(pathlib.Path(root) / file)
-
-    globs = [
-        "*.exe",
-        "*.py",
-        "*.pyd",
-        "*.dll",
-        "*.lib",
-        "/Include/*",
-        "/Lib/site-packages/*",
-    ]
-    archive = f"{dirs.prefix}.tar.xz"
-    with tarfile.open(archive, mode="w:xz") as fp:
-        create_archive(fp, dirs.prefix, globs, logfp)
-
-
-build.add(
-    "relenv-finalize",
-    build_func=finalize,
-    wait_on=["python"],
-)