pex 2.97.2__tar.gz → 2.98.0__tar.gz

{pex-2.97.2 → pex-2.98.0}/CHANGES.md

@@ -1,5 +1,20 @@
 # Release Notes
 
+## 2.98.0
+
+This release adds proper support for windowed PEX scies targeting Windows. When you specify at least
+one of `--scie-icon`, `--scie-desktop-file` or `--scie-windowed` and a scie is generated targeting
+Windows, that scie will behave like a proper Windows windowed app and will not launch a background
+console when opened.
+
+* Add support for windowed PEX scies on Windows. (#3212)
+
+## 2.97.3
+
+This release fixes concurrent Pex use of artifact downloads.
+
+* Fix concurrent Pex use of artifact downloads. (#3207)
+
 ## 2.97.2
 
 This release updates vendored Pip's vendored certifi's cacert.pem to that from certifi 2026.6.17.

{pex-2.97.2 → pex-2.98.0}/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: pex
-Version: 2.97.2
+Version: 2.98.0
 Summary: The PEX packaging toolchain.
 Home-page: https://github.com/pex-tool/pex
-Download-URL: https://github.com/pex-tool/pex/releases/download/v2.97.2/pex
+Download-URL: https://github.com/pex-tool/pex/releases/download/v2.98.0/pex
 Author: The PEX developers
 Author-email: developers@pex-tool.org
 License-Expression: Apache-2.0
-Project-URL: Changelog, https://github.com/pex-tool/pex/blob/v2.97.2/CHANGES.md
+Project-URL: Changelog, https://github.com/pex-tool/pex/blob/v2.98.0/CHANGES.md
 Project-URL: Documentation, https://docs.pex-tool.org/
-Project-URL: Source, https://github.com/pex-tool/pex/tree/v2.97.2
+Project-URL: Source, https://github.com/pex-tool/pex/tree/v2.98.0
 Keywords: package,executable,virtualenv,lock,freeze
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers

{pex-2.97.2 → pex-2.98.0}/pex/atomic_directory.py

@@ -14,7 +14,6 @@ import pex
 from pex import pex_warnings
 from pex.common import safe_mkdir, safe_rmtree
 from pex.fs import lock
-from pex.fs.lock import FileLockStyle
 from pex.typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -124,14 +123,14 @@ class AtomicDirectory(object):
         # type: () -> str
         return self._lockfile
 
-    def lock(self, lock_style=None):
-        # type: (Optional[FileLockStyle.Value]) -> Callable[[], None]
-        return _LOCK_MANAGER.lock(self._lockfile, lock_style=lock_style)
+    def lock(self):
+        # type: () -> Callable[[], None]
+        return _LOCK_MANAGER.lock(self._lockfile)
 
     @contextmanager
-    def locked(self, lock_style=None):
-        # type: (Optional[FileLockStyle.Value]) -> Iterator[None]
-        unlock = self.lock(lock_style=lock_style)
+    def locked(self):
+        # type: () -> Iterator[None]
+        unlock = self.lock()
         try:
             yield
         finally:
@@ -174,31 +173,15 @@ class AtomicDirectory(object):
         safe_rmtree(self._work_dir)
 
 
-def _lock_style(lock_style=None):
-    # type: (Optional[FileLockStyle.Value]) -> FileLockStyle.Value
-
-    # The atomic_directory file locking has used POSIX locks since inception. These have maximum
-    # compatibility across OSes and stand a decent chance of working over modern NFS. With the
-    # introduction of `pex3 lock ...` a limited set of atomic_directory uses started asking for BSD
-    # locks since they operate in a thread pool. Only those uses actually pass an explicit value for
-    # `lock_style` to atomic_directory. In order to allow experimenting with / debugging possible
-    # file locking bugs, we allow a `_PEX_FILE_LOCK_STYLE` back door private ~API to upgrade all
-    # locks to BSD style locks. This back door can be removed at any time.
-    return lock_style or FileLockStyle.for_value(
-        os.environ.get("_PEX_FILE_LOCK_STYLE", FileLockStyle.POSIX.value)
-    )
-
-
 @attr.s(frozen=True)
 class _FileLock(object):
     _path = attr.ib()  # type: str
-    _style = attr.ib(default=None)  # type: Optional[FileLockStyle.Value]
     _in_process_lock = attr.ib(factory=threading.Lock, init=False, eq=False)
 
     def acquire(self):
         # type: () -> Callable[[], None]
         self._in_process_lock.acquire()
-        file_lock = lock.acquire(self._path, exclusive=True, style=_lock_style(self._style))
+        file_lock = lock.acquire(self._path, exclusive=True)
 
         def release():
             # type: () -> None
@@ -215,12 +198,8 @@ class _LockManager(object):
     _lock = attr.ib(factory=threading.Lock, init=False)  # type: threading.Lock
     _file_locks = attr.ib(factory=dict, init=False)  # type: Dict[str, _FileLock]
 
-    def lock(
-        self,
-        file_path,  # type: str
-        lock_style=None,  # type: Optional[FileLockStyle.Value]
-    ):
-        # type: (...) -> Callable[[], None]
+    def lock(self, file_path):
+        # type: (str) -> Callable[[], None]
         """Locks file path exclusively and returns a callable that can be invoked to unlock it.
 
         The lock obtained is cross-thread and cross-process and is automatically released when
@@ -229,7 +208,7 @@ class _LockManager(object):
         with self._lock:
             file_lock = self._file_locks.get(file_path)
             if file_lock is None:
-                file_lock = _FileLock(file_path, style=lock_style)
+                file_lock = _FileLock(file_path)
                 self._file_locks[file_path] = file_lock
 
         return file_lock.acquire()
@@ -241,14 +220,12 @@ _LOCK_MANAGER = _LockManager()
 @contextmanager
 def atomic_directory(
     target_dir,  # type: str
-    lock_style=None,  # type: Optional[FileLockStyle.Value]
     source=None,  # type: Optional[str]
 ):
     # type: (...) -> Iterator[AtomicDirectory]
     """A context manager that yields an exclusively locked AtomicDirectory.
 
     :param target_dir: The target directory to atomically update.
-    :param lock_style: By default, a POSIX fcntl lock will be used to ensure exclusivity.
     :param source: An optional source offset into the work directory to use for the atomic update
                    of the target directory. By default, the whole work directory is used.
 
@@ -269,7 +246,7 @@ def atomic_directory(
         yield atomic_dir
         return
 
-    unlock = atomic_dir.lock(lock_style=lock_style)
+    unlock = atomic_dir.lock()
     if atomic_dir.is_finalized():
         # We lost the double-checked locking race and our work was done for us by the race
         # winner so exit early.

{pex-2.97.2 → pex-2.98.0}/pex/cache/access.py

@@ -9,7 +9,6 @@ from contextlib import contextmanager
 
 from pex.common import touch
 from pex.fs import lock
-from pex.fs.lock import FileLockStyle
 from pex.os import WINDOWS
 from pex.typing import TYPE_CHECKING
 from pex.variables import ENV
@@ -72,7 +71,7 @@ def _lock(exclusive):
 
     lock_file = os.path.join(ENV.PEX_ROOT, "access.lck")
 
-    file_lock = lock.acquire(lock_file, exclusive=exclusive, style=FileLockStyle.BSD, fd=lock_fd)
+    file_lock = lock.acquire(lock_file, exclusive=exclusive, fd=lock_fd)
     _LOCK = exclusive, file_lock.fd, lock_file
     return lock_file
 

{pex-2.97.2 → pex-2.98.0}/pex/cache/dirs.py

@@ -139,7 +139,7 @@ class CacheDir(Enum["CacheDir.Value"]):
 
     DOWNLOADS = Value(
         "downloads",
-        version=1,
+        version=2,
         name="Lock Artifact Downloads",
         description="Distributions downloaded when resolving from a Pex lock file.",
     )
@@ -166,7 +166,7 @@ class CacheDir(Enum["CacheDir.Value"]):
 
     INTERPRETERS = Value(
         "interpreters",
-        version=1,
+        version=2,
         name="Interpreters",
         description="Information about interpreters found on the system.",
     )

{pex-2.97.2 → pex-2.98.0}/pex/cli/commands/scie.py

@@ -54,7 +54,8 @@ def _narrow_interpreter_constraints(
                     or (
                         user_interpreter_constraint.implementation
                         and pex_interpreter_constraint.implementation.includes(
-                            user_interpreter_constraint.implementation
+                            user_interpreter_constraint.implementation,
+                            user_interpreter_constraint.specifier,
                         )
                     )
                 )

{pex-2.97.2 → pex-2.98.0}/pex/finders.py

@@ -122,13 +122,16 @@ def get_entry_point_from_console_script(
     # Check all distributions for the console_script "script". De-dup by dist key to allow for a
     # duplicate console script IFF the distribution is platform-specific and this is a
     # multi-platform pex.
-    def get_entrypoint(dist):
-        # type: (Distribution) -> Optional[NamedEntryPoint]
-        return dist.get_entry_map().get("console_scripts", {}).get(script)
+    def get_entrypoint(
+        dist,  # type: Distribution
+        gui=False,  # type: bool
+    ):
+        # type: (...) -> Optional[NamedEntryPoint]
+        return dist.get_entry_map().get("gui_scripts" if gui else "console_scripts", {}).get(script)
 
     entries = {}  # type: Dict[ProjectName, DistributionEntryPoint]
     for dist in dists:
-        named_entry_point = get_entrypoint(dist)
+        named_entry_point = get_entrypoint(dist) or get_entrypoint(dist, gui=True)
         if named_entry_point is not None:
             entries[dist.metadata.project_name] = DistributionEntryPoint(
                 dist=dist, name=named_entry_point.name, entry_point=named_entry_point.entry_point

{pex-2.97.2 → pex-2.98.0}/pex/fs/__init__.py

@@ -5,12 +5,14 @@ from __future__ import absolute_import
 
 import os
 import sys
+from contextlib import contextmanager
+from uuid import uuid4
 
 from pex.os import WINDOWS
-from pex.typing import TYPE_CHECKING
+from pex.typing import TYPE_CHECKING, cast
 
 if TYPE_CHECKING:
-    from typing import Text
+    from typing import IO, BinaryIO, Iterator, Text, TextIO
 
 if WINDOWS and not hasattr(os, "replace"):
     _MOVEFILE_REPLACE_EXISTING = 0x1
@@ -123,3 +125,29 @@ if WINDOWS and not hasattr(os, "link"):
 
 else:
     safe_link = getattr(os, "link")
+
+
+@contextmanager
+def atomic_binary_file(path):
+    # type: (Text) -> Iterator[BinaryIO]
+    with _atomic_file(path, "wb") as fp:
+        yield cast("BinaryIO", fp)
+
+
+@contextmanager
+def atomic_text_file(path):
+    # type: (Text) -> Iterator[TextIO]
+    with _atomic_file(path, "w") as fp:
+        yield cast("TextIO", fp)
+
+
+@contextmanager
+def _atomic_file(
+    path,  # type: Text
+    mode,  # type: str
+):
+    # type: (...) -> Iterator[IO]
+
+    with open("{path}.{suffix}".format(path=path, suffix=uuid4().hex), mode) as fp:
+        yield fp
+    safe_rename(fp.name, path)

pex-2.98.0/pex/fs/_unix.py

@@ -0,0 +1,36 @@
+# Copyright 2025 Pex project contributors.
+# Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+from __future__ import absolute_import
+
+import fcntl
+
+from pex.fs.lock import FileLock
+
+# N.B.: Some locks are used under thread pools; so we need to use BSD style locks to work in these
+# scenarios instead of POSIX locks.
+#
+# BSD style locks (`flock`) are not as portable as POSIX style locks (`fcntl`) - POSIX style locks
+# can work under some NFS implementations - but work with threading unlike POSIX locks which are
+# subject to threading-unaware deadlock detection per the standard. Linux, in fact, implements
+# deadlock detection for POSIX locks; so we can (and have) run afoul of false EDEADLCK errors under
+# the right interleaving of processes and threads.
+
+
+class UnixFileLock(FileLock):
+    @classmethod
+    def acquire(
+        cls,
+        fd,  # type: int
+        exclusive,  # type: bool
+    ):
+        # type: (...) -> UnixFileLock
+
+        fcntl.flock(fd, fcntl.LOCK_EX if exclusive else fcntl.LOCK_SH)
+        return cls(locked_fd=fd, unlock=lambda: cls.release_lock(fd))
+
+    @classmethod
+    def release_lock(cls, fd):
+        # type: (int) -> None
+
+        fcntl.flock(fd, fcntl.LOCK_UN)

{pex-2.97.2 → pex-2.98.0}/pex/fs/lock.py

@@ -6,7 +6,6 @@ from __future__ import absolute_import
 import os
 
 from pex.common import safe_mkdir
-from pex.enum import Enum
 from pex.os import WINDOWS
 from pex.typing import TYPE_CHECKING
 
@@ -18,17 +17,6 @@ else:
     from pex.third_party import attr
 
 
-class FileLockStyle(Enum["FileLockStyle.Value"]):
-    class Value(Enum.Value):
-        pass
-
-    BSD = Value("bsd")
-    POSIX = Value("posix")
-
-
-FileLockStyle.seal()
-
-
 @attr.s(frozen=True)
 class FileLock(object):
     _locked_fd = attr.ib()  # type: int
@@ -50,7 +38,6 @@ class FileLock(object):
 def acquire(
     path,  # type: str
     exclusive=True,  # type: bool
-    style=FileLockStyle.POSIX,  # type: FileLockStyle.Value
     fd=None,  # type: Optional[int]
 ):
     # type: (...) -> FileLock
@@ -68,22 +55,19 @@ def acquire(
 
         return WindowsFileLock.acquire(lock_fd, exclusive=exclusive)
     else:
-        from pex.fs._posix import PosixFileLock
+        from pex.fs._unix import UnixFileLock
 
-        return PosixFileLock.acquire(lock_fd, exclusive=exclusive, style=style)
+        return UnixFileLock.acquire(lock_fd, exclusive=exclusive)
 
 
-def release(
-    fd,  # type: int
-    style=FileLockStyle.POSIX,  # type: FileLockStyle.Value
-):
-    # type: (...) -> None
+def release(fd):
+    # type: (int) -> None
 
     if WINDOWS:
         from pex.fs._windows import WindowsFileLock
 
         WindowsFileLock.release_lock(fd)
     else:
-        from pex.fs._posix import PosixFileLock
+        from pex.fs._unix import UnixFileLock
 
-        PosixFileLock.release_lock(fd, style=style)
+        UnixFileLock.release_lock(fd)

{pex-2.97.2 → pex-2.98.0}/pex/hashing.py

@@ -199,9 +199,8 @@ def lock_pex_project_dir():
         return
 
     from pex.fs import lock
-    from pex.fs.lock import FileLockStyle
 
-    lck = lock.acquire(__file__ + ".lck", exclusive=True, style=FileLockStyle.BSD)
+    lck = lock.acquire(__file__ + ".lck", exclusive=True)
     os.environ["_PEX_LOCKED_PROJECT_DIR"] = str(os.getpid())
     try:
         yield

{pex-2.97.2 → pex-2.98.0}/pex/interpreter.py

@@ -269,12 +269,9 @@ class PythonIdentity(object):
             "Optional[Tuple[int, int, int]]",
             tuple(getattr(sys, "pypy_version_info", ())[:3]) or None,
         )
-        if pypy_version is None:
-            free_threaded = (
-                sys.version_info[:2] >= (3, 13) and sys_config_vars.get("Py_GIL_DISABLED", 0) == 1
-            )  # type: Optional[bool]
-        else:
-            free_threaded = None
+        free_threaded = None  # type: Optional[bool]
+        if pypy_version is None and sys.version_info[:2] >= (3, 13):
+            free_threaded = sys_config_vars.get("Py_GIL_DISABLED", 0) == 1
 
         # Pex identifies interpreters using a bit of Pex code injected via an extraction of that
         # code under the `PEX_ROOT` adjoined to `sys.path` via `PYTHONPATH`. Pex also exposes the

{pex-2.97.2 → pex-2.98.0}/pex/interpreter_constraints.py

@@ -126,7 +126,9 @@ class InterpreterConstraint(object):
     def __contains__(self, interpreter):
         # type: (PythonInterpreter) -> bool
         python_identity = interpreter.identity
-        if self.implementation and not self.implementation.includes(python_identity.implementation):
+        if self.implementation and not self.implementation.includes(
+            python_identity.implementation, python_identity.version
+        ):
             return False
         return python_identity.version_str in self.specifier
 

{pex-2.97.2 → pex-2.98.0}/pex/interpreter_implementation.py

@@ -3,11 +3,13 @@
 
 from __future__ import absolute_import
 
+from pex import specifier_sets
 from pex.enum import Enum
+from pex.third_party.packaging.specifiers import SpecifierSet
 from pex.typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import FrozenSet, List, Optional, Tuple
+    from typing import FrozenSet, List, Optional, Tuple, Union
 
 
 class _InterpreterImplementationValue(Enum.Value):
@@ -16,6 +18,7 @@ class _InterpreterImplementationValue(Enum.Value):
         value,  # type: str
         abbr,  # type: str
         binary_name,  # type: str
+        platform_python_implementation=None,  # type: Optional[str]
         alias=None,  # type: Optional[str]
         free_threaded=None,  # type: Optional[bool]
         initial_version=None,  # type: Optional[Tuple[int, ...]]
@@ -23,6 +26,7 @@ class _InterpreterImplementationValue(Enum.Value):
         # type: (...) -> None
         super(_InterpreterImplementationValue, self).__init__(value)
         self.abbr = abbr
+        self.platform_python_implementation = platform_python_implementation or value
         self.binary_name = binary_name
         self.alias = alias
         self.free_threaded = free_threaded
@@ -45,15 +49,34 @@ class _InterpreterImplementationValue(Enum.Value):
 
 class InterpreterImplementation(Enum["InterpreterImplementation.Value"]):
     class Value(_InterpreterImplementationValue):
-        def includes(self, implementation):
-            # type: (InterpreterImplementation.Value) -> bool
+        def includes(
+            self,
+            implementation,  # type: InterpreterImplementation.Value
+            version,  # type: Union[Tuple[int, int], Tuple[int, int, int], SpecifierSet]
+        ):
+            # type: (...) -> bool
+
             if self is implementation:
                 return True
+
             if self is InterpreterImplementation.CPYTHON and implementation in (
                 InterpreterImplementation.CPYTHON_FREE_THREADED,
                 InterpreterImplementation.CPYTHON_GIL,
             ):
                 return True
+
+            if (
+                self is InterpreterImplementation.CPYTHON_GIL
+                # N.B.: CPython means CPython[gil] / CPython-t prior to the 3.13 release, which
+                # introduced free-threading.
+                and implementation is InterpreterImplementation.CPYTHON
+                and (
+                    (isinstance(version, tuple) and version[:2] < (3, 13))
+                    or (specifier_sets.includes("<3.13", version))
+                )
+            ):
+                return True
+
             return False
 
     @classmethod
@@ -86,11 +109,19 @@ class InterpreterImplementation(Enum["InterpreterImplementation.Value"]):
         "CPython+t",
         "cp",
         "python",
+        platform_python_implementation="CPython",
         alias="CPython[free-threaded]",
         free_threaded=True,
         initial_version=(3, 13),
     )
-    CPYTHON_GIL = Value("CPython-t", "cp", "python", alias="CPython[gil]", free_threaded=False)
+    CPYTHON_GIL = Value(
+        "CPython-t",
+        "cp",
+        "python",
+        platform_python_implementation="CPython",
+        alias="CPython[gil]",
+        free_threaded=False,
+    )
     PYPY = Value("PyPy", "pp", "pypy")
 
 

{pex-2.97.2 → pex-2.98.0}/pex/pep_508.py

@@ -4,7 +4,7 @@
 from __future__ import absolute_import
 
 from pex.interpreter_implementation import InterpreterImplementation
-from pex.platforms import Platform
+from pex.platforms import PlatformSpec
 from pex.third_party.packaging import markers
 from pex.typing import TYPE_CHECKING
 
@@ -49,7 +49,7 @@ class MarkerEnvironment(object):
 
     @classmethod
     def from_platform(cls, platform):
-        # type: (Platform) -> MarkerEnvironment
+        # type: (PlatformSpec) -> MarkerEnvironment
         """Populate a partial marker environment given what we know from platform information.
 
         Since Pex support is (currently) restricted to:
@@ -117,10 +117,10 @@ class MarkerEnvironment(object):
             platform_system = "Windows"
             sys_platform = "win32"
 
-        platform_python_implementation = None
         for implementation in InterpreterImplementation.values():
             if implementation.abbr == platform.impl:
-                platform_python_implementation = implementation.value
+                platform_python_implementation = implementation.platform_python_implementation
+                break
 
         python_version = ".".join(map(str, platform.version_info[:2]))
 

{pex-2.97.2 → pex-2.98.0}/pex/pip/local_project.py

@@ -34,7 +34,7 @@ def digest_local_project(
         with temporary_dir() as td:
             sdist_path_or_error = pep_517.build_sdist(
                 project_directory=directory,
-                dist_dir=os.path.join(td, "dists"),
+                dist_dir=dest_dir or os.path.join(td, "dists"),
                 pip_version=pip_version,
                 target=target,
                 resolver=resolver,
@@ -43,7 +43,7 @@ def digest_local_project(
                 return sdist_path_or_error
             sdist_path = sdist_path_or_error
 
-            extract_dir = dest_dir or os.path.join(td, "extracted")
+            extract_dir = os.path.join(td, "extracted")
             project_dir = sdist.extract_tarball(sdist_path, dest_dir=extract_dir)
             hashing.dir_hash(directory=project_dir, digest=digest)
-            return os.path.join(extract_dir, project_dir)
+            return sdist_path

{pex-2.97.2 → pex-2.98.0}/pex/pip/vcs.py

@@ -29,7 +29,7 @@ def _project_name_re(project_name):
     return project_name.normalized.replace("-", "[-_.]+")
 
 
-def _built_source_dist_pattern(project_name):
+def _vcs_archive_pattern(project_name):
     # type: (ProjectName) -> Pattern
     return re.compile(
         r"(?P<project_name>{project_name_re})-(?P<version>.+)\.zip".format(
@@ -39,29 +39,54 @@ def _built_source_dist_pattern(project_name):
     )
 
 
-def _find_built_source_dist(
-    build_dir,  # type: str
-    project_name,  # type: ProjectName
-    version,  # type: Version
+def find_vcs_archive(
+    directory,  # type: str
+    project_name=None,  # type: Optional[ProjectName]
+    version=None,  # type: Optional[Version]
 ):
     # type: (...) -> Union[str, Error]
 
     # All VCS requirements are prepared as zip archives with this naming scheme as
     # encoded in: `pip._internal.req.req_install.InstallRequirement.archive`.
 
-    listing = os.listdir(build_dir)
-    pattern = _built_source_dist_pattern(project_name)
-    for name in listing:
-        match = pattern.match(name)
-        if match and Version(match.group("version")) == version:
-            return os.path.join(build_dir, name)
+    listing = os.listdir(directory)
+    if not project_name:
+        vcs_archives = [name for name in listing if name.endswith(".zip")]
+        if not vcs_archives:
+            return Error(
+                "Found no VCS archive in directory {directory}.".format(directory=directory)
+            )
+        if len(vcs_archives) > 1:
+            return Error(
+                "Found more than one VCS archive in directory {directory}:\n"
+                "{archives}".format(
+                    directory=directory,
+                    archives="\n".join(
+                        "{idx}. {archive}".format(idx=idx, archive=archive)
+                        for idx, archive in enumerate(vcs_archives, start=1)
+                    ),
+                )
+            )
+        return os.path.join(directory, vcs_archives[0])
+    else:
+        pattern = _vcs_archive_pattern(project_name)
+        for name in listing:
+            match = pattern.match(name)
+            if match and (not version or Version(match.group("version")) == version):
+                return os.path.join(directory, name)
 
     return Error(
-        "Expected to find built sdist for {project_name} {version} in {build_dir} but only found:\n"
+        "Expected to find built sdist for {project_name_and_version} in {directory} but only "
+        "found:\n"
         "{listing}".format(
-            project_name=project_name.raw,
-            version=version.raw,
-            build_dir=build_dir,
+            project_name_and_version=(
+                "{project_name} {version}".format(
+                    project_name=project_name.raw, version=version.raw
+                )
+                if version
+                else project_name.raw
+            ),
+            directory=directory,
             listing="\n".join(listing),
         )
     )
@@ -76,7 +101,7 @@ def fingerprint_downloaded_vcs_archive(
     # type: (...) -> Tuple[Fingerprint, str]
 
     archive_path = try_(
-        _find_built_source_dist(build_dir=download_dir, project_name=project_name, version=version)
+        find_vcs_archive(directory=download_dir, project_name=project_name, version=version)
     )
     digest = Sha256()
     digest_vcs_archive(project_name=project_name, archive_path=archive_path, vcs=vcs, digest=digest)
@@ -141,7 +166,7 @@ def digest_vcs_archive(
 
     # The zip archives created by Pip have a single project name top-level directory housing
     # the full clone. We look for that to get a consistent clone hash with a bare clone.
-    match = _built_source_dist_pattern(project_name).match(os.path.basename(archive_path))
+    match = _vcs_archive_pattern(project_name).match(os.path.basename(archive_path))
     if match is None:
         raise AssertionError(
             reportable_unexpected_error_msg(

{pex-2.97.2 → pex-2.98.0}/pex/rc/pexrc.py

@@ -32,7 +32,7 @@ if TYPE_CHECKING:
 
 
 PEXRC_RELEASES_URL = "https://github.com/pex-tool/pex.rc/releases"
-MIN_PEXRC_VERSION = Version("0.12.5")
+MIN_PEXRC_VERSION = Version("0.16.2")
 PEXRC_REQUIREMENT = SpecifierSet("~={min_version}".format(min_version=MIN_PEXRC_VERSION))