relenv 0.20.6__tar.gz → 0.20.8__tar.gz

{relenv-0.20.6/relenv.egg-info → relenv-0.20.8}/PKG-INFO

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

@@ -152,7 +152,7 @@ def main(args):
         build_version = requested
     else:
         pyversions = python_versions(args.python)
-        build_version = pyversions[0]
+        build_version = pyversions.keys()[0]
 
     # print(pyversions)
     # print(pyversions[0].major)
@@ -168,6 +168,7 @@ def main(args):
     build.version = str(build_version)
     build.dirs.version = str(build_version)
     build.recipies["python"]["download"].version = str(build_version)
+    build.recipies["python"]["download"].checksum = pyversions[build_version]
 
     if args.check_versions:
         if not CHECK_VERSIONS_SUPPORT:

{relenv-0.20.6 → relenv-0.20.8}/relenv/build/common.py

@@ -535,6 +535,7 @@ class Download:
             if self.fallback_url:
                 print(f"Download failed {self.url} ({exc}); trying fallback url")
                 return download_url(self.fallback_url, self.destination, CICD), True
+            raise
 
     def fetch_signature(self, version):
         """

{relenv-0.20.6 → relenv-0.20.8}/relenv/build/darwin.py

@@ -28,7 +28,6 @@ def populate_env(env, dirs):
     env["LDFLAGS"] = " ".join(ldflags).format(prefix=dirs.prefix)
     env["MACOSX_DEPLOYMENT_TARGET"] = MACOS_DEVELOPMENT_TARGET
     cflags = [
-        "-L{prefix}/lib",
         "-I{prefix}/include",
         "-I{prefix}/include/readline",
     ]
@@ -79,8 +78,8 @@ build.add(
     build_func=build_openssl,
     download={
         "url": "https://github.com/openssl/openssl/releases/download/openssl-{version}/openssl-{version}.tar.gz",
-        "version": "3.2.4",
-        "checksum": "2247802a1193c0f8eb41c870e8de45a2241422d5",
+        "version": "3.5.4",
+        "checksum": "b75daac8e10f189abe28a076ba5905d363e4801f",
     },
 )
 
@@ -88,8 +87,8 @@ build.add(
     "XZ",
     download={
         "url": "http://tukaani.org/xz/xz-{version}.tar.gz",
-        "version": "5.6.2",
-        "checksum": "0d6b10e4628fe08e19293c65e8dbcaade084a083",
+        "version": "5.8.1",
+        "checksum": "ed4d5589c4cfe84e1697bd02a9954b76af336931",
     },
 )
 

{relenv-0.20.6 → relenv-0.20.8}/relenv/build/linux.py

@@ -6,7 +6,7 @@ The linux build process.
 import pathlib
 import tempfile
 from .common import *
-from ..common import arches, LINUX
+from ..common import arches, LINUX, Version
 
 
 ARCHES = arches[LINUX]
@@ -393,6 +393,43 @@ def build_python(env, dirs, logfp):
     env["OPENSSL_LDFLAGS"] = f"-L{dirs.prefix}/lib"
     env["CFLAGS"] = f"-Wno-coverage-mismatch {env['CFLAGS']}"
 
+    runcmd(
+        [
+            "sed",
+            "-i",
+            "s/#readline readline.c -lreadline -ltermcap/readline readline.c -lreadline -ltinfow/g",
+            "Modules/Setup",
+        ]
+    )
+    if Version.parse_string(env["RELENV_PY_MAJOR_VERSION"]) <= Version.parse_string(
+        "3.10"
+    ):
+        runcmd(
+            [
+                "sed",
+                "-i",
+                (
+                    "s/#_curses -lncurses -lncursesw -ltermcap _cursesmodule.c"
+                    "/_curses -lncursesw -ltinfow _cursesmodule.c/g"
+                ),
+                "Modules/Setup",
+            ]
+        )
+        runcmd(
+            [
+                "sed",
+                "-i",
+                (
+                    "s/#_curses_panel _curses_panel.c -lpanel -lncurses"
+                    "/_curses_panel _curses_panel.c -lpanelw -lncursesw/g"
+                ),
+                "Modules/Setup",
+            ]
+        )
+    else:
+        env["CURSES_LIBS"] = "-lncursesw -ltinfow"
+        env["PANEL_LIBS"] = "-lpanelw"
+
     cmd = [
         "./configure",
         "-v",
@@ -421,14 +458,7 @@ def build_python(env, dirs, logfp):
     ]
 
     runcmd(cmd, env=env, stderr=logfp, stdout=logfp)
-    runcmd(
-        [
-            "sed",
-            "-i",
-            "s/#readline readline.c -lreadline -ltermcap/readline readline.c -lreadline -ltinfow/g",
-            "Modules/Setup",
-        ]
-    )
+
     with io.open("Modules/Setup", "a+") as fp:
         fp.seek(0, io.SEEK_END)
         fp.write("*disabled*\n" "_tkinter\n" "nsl\n" "nis\n")
@@ -452,14 +482,13 @@ build.add(
     build_func=build_openssl,
     download={
         "url": "https://github.com/openssl/openssl/releases/download/openssl-{version}/openssl-{version}.tar.gz",
-        "version": "3.2.4",
-        "checksum": "2247802a1193c0f8eb41c870e8de45a2241422d5",
+        "version": "3.5.4",
+        "checksum": "b75daac8e10f189abe28a076ba5905d363e4801f",
         "checkfunc": tarball_version,
         "checkurl": "https://www.openssl.org/source/",
     },
 )
 
-
 build.add(
     "openssl-fips-module",
     build_func=build_openssl_fips,
@@ -489,8 +518,8 @@ build.add(
     "XZ",
     download={
         "url": "http://tukaani.org/xz/xz-{version}.tar.gz",
-        "version": "5.6.2",
-        "checksum": "0d6b10e4628fe08e19293c65e8dbcaade084a083",
+        "version": "5.8.1",
+        "checksum": "ed4d5589c4cfe84e1697bd02a9954b76af336931",
         "checkfunc": tarball_version,
     },
 )
@@ -522,7 +551,7 @@ build.add(
     name="gdbm",
     build_func=build_gdbm,
     download={
-        "url": "https://ftp.gnu.org/gnu/gdbm/gdbm-{version}.tar.gz",
+        "url": "https://mirrors.ocf.berkeley.edu/gnu/gdbm/gdbm-{version}.tar.gz",
         "version": "1.26",
         "checksum": "6cee3657de948e691e8df26509157be950cef4d4",
         "checkfunc": tarball_version,
@@ -533,12 +562,9 @@ build.add(
     name="ncurses",
     build_func=build_ncurses,
     download={
-        "url": "https://ftp.gnu.org/pub/gnu/ncurses/ncurses-{version}.tar.gz",
-        # XXX: Need to work out tinfo linkage
-        # "version": "6.5",
-        # "checksum": "cde3024ac3f9ef21eaed6f001476ea8fffcaa381",
-        "version": "6.4",
-        "checksum": "bb5eb3f34b3ecd5bac8d0b58164b847f135b3d62",
+        "url": "https://mirrors.ocf.berkeley.edu/gnu/ncurses/ncurses-{version}.tar.gz",
+        "version": "6.5",
+        "checksum": "cde3024ac3f9ef21eaed6f001476ea8fffcaa381",
         "checkfunc": tarball_version,
     },
 )
@@ -594,7 +620,7 @@ build.add(
     build_func=build_readline,
     wait_on=["ncurses"],
     download={
-        "url": "https://ftp.gnu.org/gnu/readline/readline-{version}.tar.gz",
+        "url": "https://mirrors.ocf.berkeley.edu/gnu/readline/readline-{version}.tar.gz",
         "version": "8.3",
         "checksum": "2c05ae9350b695f69d70b47f17f092611de2081f",
         "checkfunc": tarball_version,

{relenv-0.20.6 → relenv-0.20.8}/relenv/build/windows.py

@@ -91,6 +91,7 @@ def build_python(env, dirs, logfp):
         "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",

{relenv-0.20.6 → relenv-0.20.8}/relenv/common.py

@@ -18,7 +18,7 @@ import threading
 import time
 
 # relenv package version
-__version__ = "0.20.6"
+__version__ = "0.20.8"
 
 MODULE_DIR = pathlib.Path(__file__).resolve().parent
 
@@ -105,7 +105,7 @@ def format_shebang(python, tpl=SHEBANG_TPL):
     """
     Return a formatted shebang.
     """
-    return tpl.format(python).strip()
+    return tpl.format(python).strip() + "\n"
 
 
 def build_arch():
@@ -727,3 +727,107 @@ def sanitize_sys_path(sys_path_entries):
                 if p not in __sys_path:
                     __sys_path.append(p)
     return __sys_path
+
+
+class Version:
+    """
+    Version comparisons.
+    """
+
+    def __init__(self, data):
+        self.major, self.minor, self.micro = self.parse_string(data)
+        self._data = data
+
+    def __str__(self):
+        """
+        Version as string.
+        """
+        _ = f"{self.major}"
+        if self.minor is not None:
+            _ += f".{self.minor}"
+            if self.micro is not None:
+                _ += f".{self.micro}"
+        # XXX What if minor was None but micro was an int.
+        return _
+
+    def __hash__(self):
+        """
+        Hash of the version.
+
+        Hash the major, minor, and micro attributes.
+        """
+        return hash((self.major, self.minor, self.micro))
+
+    @staticmethod
+    def parse_string(data):
+        """
+        Parse a version string into major, minor, and micro integers.
+        """
+        parts = data.split(".")
+        if len(parts) == 1:
+            return int(parts[0]), None, None
+        elif len(parts) == 2:
+            return int(parts[0]), int(parts[1]), None
+        elif len(parts) == 3:
+            return int(parts[0]), int(parts[1]), int(parts[2])
+        else:
+            raise RuntimeError("Too many parts to  parse")
+
+    def __eq__(self, other):
+        """
+        Equality comparisons.
+        """
+        mymajor = 0 if self.major is None else self.major
+        myminor = 0 if self.minor is None else self.minor
+        mymicro = 0 if self.micro is None else self.micro
+        major = 0 if other.major is None else other.major
+        minor = 0 if other.minor is None else other.minor
+        micro = 0 if other.micro is None else other.micro
+        return mymajor == major and myminor == minor and mymicro == micro
+
+    def __lt__(self, other):
+        """
+        Less than comparrison.
+        """
+        mymajor = 0 if self.major is None else self.major
+        myminor = 0 if self.minor is None else self.minor
+        mymicro = 0 if self.micro is None else self.micro
+        major = 0 if other.major is None else other.major
+        minor = 0 if other.minor is None else other.minor
+        micro = 0 if other.micro is None else other.micro
+        if mymajor < major:
+            return True
+        elif mymajor == major:
+            if myminor < minor:
+                return True
+            if myminor == minor and mymicro < micro:
+                return True
+        return False
+
+    def __le__(self, other):
+        """
+        Less than or equal to comparrison.
+        """
+        mymajor = 0 if self.major is None else self.major
+        myminor = 0 if self.minor is None else self.minor
+        mymicro = 0 if self.micro is None else self.micro
+        major = 0 if other.major is None else other.major
+        minor = 0 if other.minor is None else other.minor
+        micro = 0 if other.micro is None else other.micro
+        if mymajor <= major:
+            if myminor <= minor:
+                if mymicro <= micro:
+                    return True
+        return False
+
+    def __gt__(self, other):
+        """
+        Greater than comparrison.
+        """
+        return not self.__le__(other)
+
+    def __ge__(self, other):
+        """
+        Greater than or equal to comparrison.
+        """
+        return not self.__lt__(other)

{relenv-0.20.6 → relenv-0.20.8}/relenv/pyversions.py

@@ -21,7 +21,7 @@ import subprocess
 import sys
 import time
 
-from relenv.common import check_url, download_url, fetch_url_content
+from relenv.common import Version, check_url, download_url, fetch_url_content
 
 log = logging.getLogger(__name__)
 
@@ -43,102 +43,6 @@ def _ref_path(x):
     return x.split('href="')[1].split('"')[0]
 
 
-class Version:
-    """
-    Version comparrisons.
-    """
-
-    def __init__(self, data):
-        self.major, self.minor, self.micro = self.parse_string(data)
-        self._data = data
-
-    def __str__(self):
-        """
-        Version as string.
-        """
-        _ = f"{self.major}"
-        if self.minor is not None:
-            _ += f".{self.minor}"
-            if self.micro is not None:
-                _ += f".{self.micro}"
-        # XXX What if minor was None but micro was an int.
-        return _
-
-    @staticmethod
-    def parse_string(data):
-        """
-        Parse a version string into major, minor, and micro integers.
-        """
-        parts = data.split(".")
-        if len(parts) == 1:
-            return int(parts[0]), None, None
-        elif len(parts) == 2:
-            return int(parts[0]), int(parts[1]), None
-        elif len(parts) == 3:
-            return int(parts[0]), int(parts[1]), int(parts[2])
-        else:
-            raise RuntimeError("Too many parts to  parse")
-
-    def __eq__(self, other):
-        """
-        Equality comparrison.
-        """
-        mymajor = 0 if self.major is None else self.major
-        myminor = 0 if self.minor is None else self.minor
-        mymicro = 0 if self.micro is None else self.micro
-        major = 0 if other.major is None else other.major
-        minor = 0 if other.minor is None else other.minor
-        micro = 0 if other.micro is None else other.micro
-        return mymajor == major and myminor == minor and mymicro == micro
-
-    def __lt__(self, other):
-        """
-        Less than comparrison.
-        """
-        mymajor = 0 if self.major is None else self.major
-        myminor = 0 if self.minor is None else self.minor
-        mymicro = 0 if self.micro is None else self.micro
-        major = 0 if other.major is None else other.major
-        minor = 0 if other.minor is None else other.minor
-        micro = 0 if other.micro is None else other.micro
-        if mymajor < major:
-            return True
-        elif mymajor == major:
-            if myminor < minor:
-                return True
-            if myminor == minor and mymicro < micro:
-                return True
-        return False
-
-    def __le__(self, other):
-        """
-        Less than or equal to comparrison.
-        """
-        mymajor = 0 if self.major is None else self.major
-        myminor = 0 if self.minor is None else self.minor
-        mymicro = 0 if self.micro is None else self.micro
-        major = 0 if other.major is None else other.major
-        minor = 0 if other.minor is None else other.minor
-        micro = 0 if other.micro is None else other.micro
-        if mymajor <= major:
-            if myminor <= minor:
-                if mymicro <= micro:
-                    return True
-        return False
-
-    def __gt__(self, other):
-        """
-        Greater than comparrison.
-        """
-        return not self.__le__(other)
-
-    def __ge__(self, other):
-        """
-        Greater than or equal to comparrison.
-        """
-        return not self.__lt__(other)
-
-
 def _release_urls(version, gzip=False):
     if gzip:
         tarball = f"https://www.python.org/ftp/python/{version}/Python-{version}.tgz"
@@ -206,7 +110,7 @@ def digest(file):
     """
     SHA-256 digest of file.
     """
-    hsh = hashlib.sha256()
+    hsh = hashlib.sha1()
     with open(file, "rb") as fp:
         hsh.update(fp.read())
     return hsh.hexdigest()
@@ -301,9 +205,9 @@ def _main():
                         out[str(version)] = {url: digest(path)}
 
     if PRINT:
-        vfile.write_text(json.dumps(pyversions))
+        vfile.write_text(json.dumps(pyversions, indent=1))
     elif not CHECK and out:
-        vfile.write_text(json.dumps(out))
+        vfile.write_text(json.dumps(out, indent=1))
 
 
 def create_pyversions(path):
@@ -313,9 +217,41 @@ def create_pyversions(path):
     url = "https://www.python.org/downloads/"
     content = fetch_url_content(url)
     matched = re.findall(r'<a href="/downloads/.*">Python.*</a>', content)
+    cwd = os.getcwd()
     parsed_versions = sorted([_ref_version(_) for _ in matched], reverse=True)
     versions = [_ for _ in parsed_versions if _.major >= 3]
-    path.write_text(json.dumps({"versions": [str(_) for _ in versions]}))
+
+    if path.exists():
+        data = json.loads(path.read_text())
+    else:
+        data = {}
+
+    for version in versions:
+
+        if str(version) in data:
+            continue
+
+        if version <= Version("3.2") and version.micro == 0:
+            url_version = Version(f"{version.major}.{version.minor}")
+        else:
+            url_version = version
+        if version >= Version("3.1.4"):
+            url = ARCHIVE.format(version=url_version, ext="tar.xz")
+        else:
+            url = ARCHIVE.format(version=url_version, ext="tgz")
+        download_path = download_url(url, cwd)
+        sig_path = download_url(f"{url}.asc", cwd)
+        verified = verify_signature(download_path, sig_path)
+        if verified:
+            print(f"Version {version} has digest {digest(download_path)}")
+            data[str(version)] = digest(download_path)
+        else:
+            raise Exception("Signature failed to verify: {url}")
+
+        path.write_text(json.dumps(data, indent=1))
+
+    # path.write_text(json.dumps({"versions": [str(_) for _ in versions]}))
+    path.write_text(json.dumps(data, indent=1))
 
 
 def python_versions(minor=None, create=False, update=False):
@@ -337,11 +273,11 @@ def python_versions(minor=None, create=False, update=False):
     else:
         raise RuntimeError("No versions file found")
     pyversions = json.loads(readfrom.read_text())
-    versions = [Version(_) for _ in pyversions["versions"]]
+    versions = [Version(_) for _ in pyversions]
     if minor:
         mv = Version(minor)
         versions = [_ for _ in versions if _.major == mv.major and _.minor == mv.minor]
-    return versions
+    return {_: pyversions[str(_)] for _ in versions}
 
 
 def setup_parser(subparsers):
@@ -402,7 +338,7 @@ def main(args):
             if not pyversions:
                 print(f"Unknown minor version {requested}")
                 sys.exit(1)
-            build_version = pyversions[0]
+            build_version = list(pyversions.keys())[0]
         print(build_version)
         sys.exit()
 

{relenv-0.20.6 → relenv-0.20.8/relenv.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: relenv
-Version: 0.20.6
+Version: 0.20.8
 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.20.6 → relenv-0.20.8}/tests/test_common.py

@@ -179,6 +179,10 @@ def test_shebang_tpl_macos():
     assert proc.returncode == 0
 
 
+def test_format_shebang_newline():
+    assert format_shebang("python3", SHEBANG_TPL_LINUX).endswith("\n")
+
+
 def test_relative_interpreter_default_location():
     assert relative_interpreter(
         "/tmp/relenv", "/tmp/relenv/bin", "/tmp/relenv/bin/python3"

{relenv-0.20.6 → relenv-0.20.8}/tests/test_verify_build.py

@@ -665,20 +665,75 @@ def test_pip_install_m2crypto_system_ssl(pipexec, pyexec):
     assert p.returncode == 0, p.stderr
 
 
+SSLVERSION = """
+import ctypes
+import ctypes.util
+import platform
+
+def get_openssl_version():
+    '''
+    Programmatically discovers the OpenSSL version using ctypes.
+    '''
+    # Determine the library name based on the operating system
+    if platform.system() == "Windows":
+        lib_name = ctypes.util.find_library("libcrypto-3") or ctypes.util.find_library("libcrypto-1_1")
+    else:
+        lib_name = ctypes.util.find_library("crypto")
+
+    if not lib_name:
+        print("Could not find OpenSSL libcrypto library.")
+        return None, None
+
+    libcrypto = ctypes.CDLL(lib_name)
+
+    # Define the C function prototypes
+    libcrypto.OpenSSL_version_num.restype = ctypes.c_ulong
+    libcrypto.OpenSSL_version.argtypes = [ctypes.c_int]
+    libcrypto.OpenSSL_version.restype = ctypes.c_char_p
+
+    # Call the C functions
+    version_num_hex = libcrypto.OpenSSL_version_num()
+    version_str = libcrypto.OpenSSL_version(0).decode("utf-8")
+
+    # Parse the numeric version
+    # The version number format is MNNFFPPS
+    major = (version_num_hex >> 28) & 0xFF
+    minor = (version_num_hex >> 20) & 0xFF
+    patch = (version_num_hex >> 4) & 0xFF
+
+    return (major, minor, patch)
+
+if __name__ == "__main__":
+    print(
+        ",".join([str(x) for x in get_openssl_version()]
+        )
+    )
+"""
+
+
+@pytest.fixture
+def ssl_version(pyexec, tmp_path):
+    file = tmp_path / "script.py"
+    file.write_text(SSLVERSION)
+    ret = subprocess.run([pyexec, str(file)], capture_output=True)
+    print(ret)
+    return tuple([int(x) for x in ret.stdout.decode().strip().split(",")])
+
+
 @pytest.mark.skip_unless_on_linux
 @pytest.mark.parametrize(
     "m2crypto_version",
-    [
-        "0.38.0",
-        "0.44.0",
-    ],
+    ["0.38.0", "0.44.0", "0.46.0"],
 )
 def test_pip_install_m2crypto_relenv_ssl(
-    m2crypto_version, pipexec, pyexec, build, build_version, minor_version
+    m2crypto_version, pipexec, pyexec, build, build_version, minor_version, ssl_version
 ):
     if m2crypto_version == "0.38.0" and minor_version in ["3.12", "3.13"]:
         pytest.xfail("Fails due to no distutils")
 
+    if ssl_version >= (3, 5) and m2crypto_version in ["0.38.0", "0.44.0"]:
+        pytest.xfail("Openssl Needs newer m2crypto")
+
     _install_ppbt(pyexec)
 
     p = subprocess.run(
@@ -1169,6 +1224,40 @@ def test_install_with_target_shebang(pipexec, build, minor_version):
     )
 
 
+@pytest.mark.skip_unless_on_linux
+def test_install_shebang_pip_24_2(pipexec, build, minor_version):
+    subprocess.run(
+        [str(pipexec), "install", "--upgrade", "pip==24.2"],
+        check=True,
+    )
+    subprocess.run(
+        [str(pipexec), "install", "cowsay"],
+        check=True,
+    )
+    ret = subprocess.run(
+        [str(build / "bin" / "cowsay"), "-t", "moo"],
+        check=False,
+    )
+    assert ret.returncode == 0
+
+
+@pytest.mark.skip_unless_on_linux
+def test_install_shebang_pip_25_2(pipexec, build, minor_version):
+    subprocess.run(
+        [str(pipexec), "install", "--upgrade", "pip==25.2"],
+        check=True,
+    )
+    subprocess.run(
+        [str(pipexec), "install", "cowsay"],
+        check=True,
+    )
+    ret = subprocess.run(
+        [str(build / "bin" / "cowsay"), "-t", "moo"],
+        check=False,
+    )
+    assert ret.returncode == 0
+
+
 @pytest.mark.skip_unless_on_linux
 def test_install_with_target_uninstall(pipexec, build):
     env = os.environ.copy()