pex 2.65.0__tar.gz → 2.66.1__tar.gz

{pex-2.65.0 → pex-2.66.1}/CHANGES.md

@@ -1,5 +1,19 @@
 # Release Notes
 
+## 2.66.1
+
+This release improves upon the local project directory hashing fix in [2.61.1](#2.61.1) by
+avoiding the hashing altogether unless creating a lock, where the resulting fingerprint is
+needed.
+
+* Avoid fingerprinting local projects. (#2975)
+
+## 2.66.0
+
+This release adds support for `--pip-version 25.3`.
+
+* Add support for `--pip-version 25.3`. (#2968)
+
 ## 2.65.0
 
 This release adds support for PEX scies using CPython free-threaded builds. Most such scies should

{pex-2.65.0 → pex-2.66.1}/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: pex
-Version: 2.65.0
+Version: 2.66.1
 Summary: The PEX packaging toolchain.
 Home-page: https://github.com/pex-tool/pex
-Download-URL: https://github.com/pex-tool/pex/releases/download/v2.65.0/pex
+Download-URL: https://github.com/pex-tool/pex/releases/download/v2.66.1/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.65.0/CHANGES.md
+Project-URL: Changelog, https://github.com/pex-tool/pex/blob/v2.66.1/CHANGES.md
 Project-URL: Documentation, https://docs.pex-tool.org/
-Project-URL: Source, https://github.com/pex-tool/pex/tree/v2.65.0
+Project-URL: Source, https://github.com/pex-tool/pex/tree/v2.66.1
 Keywords: package,executable,virtualenv,lock,freeze
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers

{pex-2.65.0 → pex-2.66.1}/pex/hashing.py

@@ -1,7 +1,7 @@
 # Copyright 2022 Pex project contributors.
 # Licensed under the Apache License, Version 2.0 (see LICENSE).
 
-from __future__ import absolute_import
+from __future__ import absolute_import, print_function
 
 import hashlib
 import os
@@ -241,10 +241,12 @@ def dir_hash(
         def iter_files():
             # type: () -> Iterator[Text]
             for root, dirs, files in os.walk(top, followlinks=True):
-                dirs[:] = [d for d in dirs if dir_filter(os.path.join(root, d))]
+                dirs[:] = [
+                    d for d in dirs if dir_filter(os.path.relpath(os.path.join(root, d), top))
+                ]
                 for f in files:
                     path = os.path.join(root, f)
-                    if file_filter(path):
+                    if file_filter(os.path.relpath(path, top)):
                         yield path
 
         file_paths = sorted(iter_files())
@@ -278,16 +280,26 @@ def zip_hash(
             else zf.namelist()
         )
 
-        dirs = frozenset(name.rstrip("/") for name in namelist if name.endswith("/"))
-        accept_dirs = frozenset(d for d in dirs if dir_filter(os.path.basename(d)))
-        reject_dirs = dirs - accept_dirs
-
+        dirs = set()
+        for name in namelist:
+            if name.endswith("/"):
+                dirname = name.rstrip("/")
+            else:
+                dirname = os.path.dirname(name)
+            while dirname:
+                dirs.add(dirname)
+                dirname = os.path.dirname(dirname)
+
+        accept_dirs = frozenset(
+            d for d in dirs if dir_filter(os.path.relpath(d, relpath) if relpath else d)
+        )
+        reject_dirs = tuple("{dir}/".format(dir=path) for path in (dirs - accept_dirs))
         accept_files = sorted(
             name
             for name in namelist
             if not name.endswith("/")
-            and not any(name.startswith(reject_dir) for reject_dir in reject_dirs)
-            and file_filter(os.path.basename(name))
+            and not name.startswith(reject_dirs)
+            and file_filter(os.path.relpath(name, relpath) if relpath else name)
         )
 
         hashed_names = (
@@ -297,3 +309,53 @@ def zip_hash(
 
         for filename in accept_files:
             update_hash(zf.open(filename, "r"), digest)
+
+
+if __name__ == "__main__":
+    import sys
+    import zipfile
+    from argparse import ArgumentParser
+
+    from pex.common import is_pyc_dir, is_pyc_file
+
+    parser = ArgumentParser()
+    parser.add_argument(
+        "--exclude-dir",
+        dest="exclude_dirs",
+        action="append",
+        default=[],
+    )
+    parser.add_argument("--zip-relpath")
+    parser.add_argument("paths", nargs="+")
+
+    options = parser.parse_args()
+    exclude_dirs = frozenset(options.exclude_dirs)
+
+    for path in options.paths:
+        digest = Sha256()
+        if zipfile.is_zipfile(path):
+            zip_hash(
+                path,
+                digest=digest,
+                relpath=options.zip_relpath,
+                dir_filter=(
+                    lambda dir_path: (
+                        not is_pyc_dir(dir_path) and os.path.basename(dir_path) not in exclude_dirs
+                    )
+                ),
+                file_filter=lambda f: not is_pyc_file(f),
+            )
+        elif os.path.isdir(path):
+            dir_hash(
+                path,
+                digest=digest,
+                dir_filter=(
+                    lambda dir_path: (
+                        not is_pyc_dir(dir_path) and os.path.basename(dir_path) not in exclude_dirs
+                    )
+                ),
+                file_filter=lambda f: not is_pyc_file(f),
+            )
+        else:
+            print("Can only hash zip files or directories. Skipping file", path, file=sys.stderr)
+        print(path, digest.hexdigest(), file=sys.stdout)

{pex-2.65.0 → pex-2.66.1}/pex/pex_builder.py

@@ -470,10 +470,7 @@ class PEXBuilder(object):
     def _prepare_code(self):
         chroot_path = self._chroot.path()
         self._pex_info.code_hash = CacheHelper.pex_code_hash(
-            chroot_path,
-            exclude_dirs=tuple(
-                os.path.join(chroot_path, d) for d in (layout.BOOTSTRAP_DIR, layout.DEPS_DIR)
-            ),
+            chroot_path, exclude_dirs=(layout.BOOTSTRAP_DIR, layout.DEPS_DIR)
         )
         self._pex_info.pex_hash = hashlib.sha1(self._pex_info.dump().encode("utf-8")).hexdigest()
         self._chroot.write(self._pex_info.dump().encode("utf-8"), PexInfo.PATH, label="manifest")

{pex-2.65.0 → pex-2.66.1}/pex/pip/tool.py

@@ -552,8 +552,7 @@ class Pip(object):
         )
         return Job(command=command, process=process, finalizer=finalizer, context="pip")
 
-    @staticmethod
-    def _iter_build_configuration_options(build_configuration):
+    def _iter_build_configuration_options(self, build_configuration):
         # type: (BuildConfiguration) -> Iterator[str]
 
         # N.B.: BuildConfiguration maintains invariants that ensure --only-binary, --no-binary,
@@ -576,7 +575,8 @@ class Pip(object):
         if build_configuration.prefer_older_binary:
             yield "--prefer-binary"
 
-        if build_configuration.use_pep517 is not None:
+        # N.B.: In 25.3 `--use-pep517` became the default and only option.
+        if build_configuration.use_pep517 is not None and self.version < PipVersion.v25_3:
             yield "--use-pep517" if build_configuration.use_pep517 else "--no-use-pep517"
 
         if not build_configuration.build_isolation:

pex-2.66.1/pex/pip/vcs.py

@@ -0,0 +1,179 @@
+# Copyright 2022 Pex project contributors.
+# Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+from __future__ import absolute_import
+
+import os
+import re
+
+from pex import hashing
+from pex.artifact_url import VCS, Fingerprint
+from pex.common import is_pyc_dir, is_pyc_file
+from pex.exceptions import reportable_unexpected_error_msg
+from pex.hashing import Sha256
+from pex.pep_440 import Version
+from pex.pep_503 import ProjectName
+from pex.result import Error, try_
+from pex.typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    # N.B.: The `re.Pattern` type is not available in all Python versions Pex supports.
+    from re import Pattern  # type: ignore[attr-defined]
+    from typing import Callable, Optional, Text, Tuple, Union
+
+    from pex.hashing import HintedDigest
+
+
+def _project_name_re(project_name):
+    # type: (ProjectName) -> str
+    return project_name.normalized.replace("-", "[-_.]+")
+
+
+def _built_source_dist_pattern(project_name):
+    # type: (ProjectName) -> Pattern
+    return re.compile(
+        r"(?P<project_name>{project_name_re})-(?P<version>.+)\.zip".format(
+            project_name_re=_project_name_re(project_name)
+        ),
+        re.IGNORECASE,
+    )
+
+
+def _find_built_source_dist(
+    build_dir,  # type: str
+    project_name,  # type: ProjectName
+    version,  # type: 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)
+
+    return Error(
+        "Expected to find built sdist for {project_name} {version} in {build_dir} but only found:\n"
+        "{listing}".format(
+            project_name=project_name.raw,
+            version=version.raw,
+            build_dir=build_dir,
+            listing="\n".join(listing),
+        )
+    )
+
+
+def fingerprint_downloaded_vcs_archive(
+    download_dir,  # type: str
+    project_name,  # type: ProjectName
+    version,  # type: Version
+    vcs,  # type: VCS.Value
+):
+    # type: (...) -> Tuple[Fingerprint, str]
+
+    archive_path = try_(
+        _find_built_source_dist(build_dir=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)
+    return Fingerprint.from_digest(digest), archive_path
+
+
+def _vcs_dir_filter(
+    vcs,  # type: VCS.Value
+    project_name,  # type: ProjectName
+):
+    # type: (...) -> Callable[[Text], bool]
+
+    # Ignore VCS control directories for the purposes of fingerprinting the version controlled
+    # source tree. VCS control directories can contain non-reproducible content (Git at least
+    # has files that contain timestamps).
+    #
+    # We cannot prune these directories from the source archive directly unfortunately since
+    # some build processes use VCS version information to derive their version numbers (C.F.:
+    # https://pypi.org/project/setuptools-scm/). As such, we'll get a stable fingerprint, but be
+    # forced to re-build a wheel each time the VCS requirement is re-locked later, even when it
+    # hashes the same.
+    vcs_control_dir = ".{vcs}".format(vcs=vcs)
+
+    # N.B.: If the VCS project uses setuptools as its build backend, depending on the version of
+    # Pip used, the VCS checkout can have a `<project name>.egg-info/` directory littering its root
+    # left over from Pip generating project metadata to determine version and dependencies. No other
+    # well known build-backend has this problem at this time (checked hatchling, poetry-core,
+    # pdm-backend and uv_build).
+    # C.F.: https://github.com/pypa/pip/pull/13602
+    egg_info_dir_re = re.compile(
+        r"^{project_name_re}\.egg-info$".format(project_name_re=_project_name_re(project_name)),
+        re.IGNORECASE,
+    )
+
+    def vcs_dir_filter(dir_path):
+        # type: (Text) -> bool
+        if is_pyc_dir(dir_path):
+            return False
+
+        base_dir_name = dir_path.split(os.sep)[0]
+        return base_dir_name != vcs_control_dir and not egg_info_dir_re.match(base_dir_name)
+
+    return vcs_dir_filter
+
+
+def _vcs_file_filter(vcs):
+    # type: (VCS.Value) -> Callable[[Text], bool]
+    return lambda f: not is_pyc_file(f)
+
+
+def digest_vcs_archive(
+    project_name,  # type: ProjectName
+    archive_path,  # type: str
+    vcs,  # type: VCS.Value
+    digest,  # type: HintedDigest
+):
+    # type: (...) -> None
+
+    # All VCS requirements are prepared as zip archives as encoded in:
+    # `pip._internal.req.req_install.InstallRequirement.archive` and the archive is already offset
+    # by a subdirectory (if any).
+
+    # 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))
+    if match is None:
+        raise AssertionError(
+            reportable_unexpected_error_msg(
+                "Failed to determine the project name prefix for the VCS zip {zip} with expected "
+                "canonical project name {project_name}".format(
+                    zip=archive_path, project_name=project_name
+                )
+            )
+        )
+    top_dir = match.group("project_name")
+
+    hashing.zip_hash(
+        zip_path=archive_path,
+        digest=digest,
+        relpath=top_dir,
+        dir_filter=_vcs_dir_filter(vcs, project_name),
+        file_filter=_vcs_file_filter(vcs),
+    )
+
+
+def digest_vcs_repo(
+    project_name,  # type: ProjectName
+    repo_path,  # type: str
+    vcs,  # type: VCS.Value
+    digest,  # type: HintedDigest
+    subdirectory=None,  # type: Optional[str]
+):
+    # type: (...) -> None
+
+    hashing.dir_hash(
+        directory=os.path.join(repo_path, subdirectory) if subdirectory else repo_path,
+        digest=digest,
+        dir_filter=_vcs_dir_filter(vcs, project_name),
+        file_filter=_vcs_file_filter(vcs),
+    )

{pex-2.65.0 → pex-2.66.1}/pex/pip/version.py

@@ -369,6 +369,13 @@ class PipVersion(Enum["PipVersionValue"]):
         requires_python=">=3.9,<3.16",
     )
 
+    v25_3 = PipVersionValue(
+        version="25.3",
+        setuptools_version="80.9.0",
+        wheel_version="0.45.1",
+        requires_python=">=3.9,<3.16",
+    )
+
     VENDORED = v20_3_4_patched
     LATEST = LatestPipVersion()
     LATEST_COMPATIBLE = LatestCompatiblePipVersion()

{pex-2.65.0 → pex-2.66.1}/pex/resolve/lock_downloader.py

@@ -154,6 +154,7 @@ class VCSArtifactDownloadManager(DownloadManager[VCSArtifact]):
         local_distribution = downloaded_vcs.local_distributions[0]
         filename = os.path.basename(local_distribution.path)
         digest_vcs_archive(
+            project_name=project_name,
             archive_path=local_distribution.path,
             vcs=artifact.vcs,
             digest=digest,

{pex-2.65.0 → pex-2.66.1}/pex/resolve/locker.py

@@ -30,6 +30,7 @@ from pex.resolve.pep_691.model import Endpoint
 from pex.resolve.resolved_requirement import PartialArtifact, Pin, ResolvedRequirement
 from pex.resolve.resolvers import Resolver
 from pex.resolve.target_system import UniversalTarget
+from pex.result import try_
 from pex.targets import Target
 from pex.typing import TYPE_CHECKING
 
@@ -291,6 +292,16 @@ class Locker(LogAnalyzer):
     def _maybe_record_wheel(self, url):
         # type: (str) -> ArtifactURL
         artifact_url = self.parse_url_and_maybe_record_fingerprint(url)
+
+        # N.B.: Lock resolves driven by `pip install --dry-run --report` will only consult PEP-658
+        # `.whl.metadata` side-car files in the happy path; so we must use these as a proxy for the
+        # `.whl` file they are paired with.
+        # See: https://peps.python.org/pep-0658/
+        if not self._lock_is_via_pip_download and artifact_url.url_info.path.endswith(".metadata"):
+            artifact_url = ArtifactURL.from_url_info(
+                artifact_url.url_info._replace(path=artifact_url.url_info.path[:-9])
+            )
+
         if artifact_url.is_wheel:
             pin, partial_artifact = self._extract_resolve_data(artifact_url)
 
@@ -371,8 +382,8 @@ class Locker(LogAnalyzer):
                 if isinstance(artifact_url.scheme, VCSScheme):
                     source_fingerprint, archive_path = fingerprint_downloaded_vcs_archive(
                         download_dir=self._download_dir,
-                        project_name=str(build_result.pin.project_name),
-                        version=str(build_result.pin.version),
+                        project_name=build_result.pin.project_name,
+                        version=build_result.pin.version,
                         vcs=artifact_url.scheme.vcs,
                     )
                     verified = True
@@ -407,12 +418,14 @@ class Locker(LogAnalyzer):
                             os.path.basename(artifact_url.path)
                         ] = build_result.pin
                     else:
-                        digest_local_project(
-                            directory=artifact_url.path,
-                            digest=digest,
-                            pip_version=self._pip_version,
-                            target=self._target,
-                            resolver=self._resolver,
+                        try_(
+                            digest_local_project(
+                                directory=artifact_url.path,
+                                digest=digest,
+                                pip_version=self._pip_version,
+                                target=self._target,
+                                resolver=self._resolver,
+                            )
                         )
                         self._local_projects.add(artifact_url.path)
                         self._saved.add(build_result.pin)
@@ -445,6 +458,7 @@ class Locker(LogAnalyzer):
                 if isinstance(artifact_url.scheme, VCSScheme):
                     digest = Sha256()
                     digest_vcs_repo(
+                        project_name=build_result.pin.project_name,
                         repo_path=build_result.path,
                         vcs=artifact_url.scheme.vcs,
                         digest=digest,
@@ -479,12 +493,14 @@ class Locker(LogAnalyzer):
                             os.path.basename(artifact_url.path)
                         ] = build_result.pin
                     else:
-                        digest_local_project(
-                            directory=artifact_url.path,
-                            digest=digest,
-                            pip_version=self._pip_version,
-                            target=self._target,
-                            resolver=self._resolver,
+                        try_(
+                            digest_local_project(
+                                directory=artifact_url.path,
+                                digest=digest,
+                                pip_version=self._pip_version,
+                                target=self._target,
+                                resolver=self._resolver,
+                            )
                         )
                         self._local_projects.add(artifact_url.path)
                         self._saved.add(build_result.pin)

{pex-2.65.0 → pex-2.66.1}/pex/resolve/lockfile/create.py

@@ -357,8 +357,6 @@ class LockObserver(ResolveObserver):
                         target=local_distribution.download_target,
                         source_path=local_distribution.path,
                         subdirectory=local_distribution.subdirectory,
-                        resolver=self.resolver,
-                        pip_version=self.package_index_configuration.pip_version,
                     )
                 )
 
@@ -369,10 +367,7 @@ class LockObserver(ResolveObserver):
             lock_result = analysis.analyzer.lock_result
             build_requests.update(
                 BuildRequest.for_directory(
-                    target=analysis.download_target,
-                    source_path=local_project,
-                    resolver=self.resolver,
-                    pip_version=self.package_index_configuration.pip_version,
+                    target=analysis.download_target, source_path=local_project
                 )
                 for local_project in lock_result.local_projects
             )

{pex-2.65.0 → pex-2.66.1}/pex/resolve/pre_resolved_resolver.py

@@ -101,19 +101,13 @@ def resolve_from_dists(
                 extra_pip_requirements=pip_configuration.extra_requirements,
                 keyring_provider=pip_configuration.keyring_provider,
             )
-            resolver = ConfiguredResolver(pip_configuration=pip_configuration)
             build_requests = [
                 BuildRequest.for_file(target=target, source_path=sdist)
                 for sdist in sdists
                 for target in unique_targets
             ]
             build_requests.extend(
-                BuildRequest.for_directory(
-                    target=target,
-                    source_path=local_project.path,
-                    resolver=resolver,
-                    pip_version=pip_configuration.version,
-                )
+                BuildRequest.for_directory(target=target, source_path=local_project.path)
                 for local_project in local_projects
                 for target in unique_targets
             )

{pex-2.65.0 → pex-2.66.1}/pex/resolver.py

@@ -65,6 +65,7 @@ from pex.resolve.resolvers import (
     check_resolve,
 )
 from pex.resolve.target_system import TargetSystem, UniversalTarget
+from pex.result import Error
 from pex.targets import AbbreviatedPlatform, CompletePlatform, LocalInterpreter, Target, Targets
 from pex.third_party.packaging.specifiers import SpecifierSet
 from pex.third_party.packaging.tags import Tag
@@ -309,10 +310,7 @@ class _PipSession(object):
             if isinstance(requirement, LocalProjectRequirement):
                 for request in self.requests:
                     yield BuildRequest.for_directory(
-                        target=request.target,
-                        source_path=requirement.path,
-                        resolver=self.resolver,
-                        pip_version=self.pip_version,
+                        target=request.target, source_path=requirement.path
                     )
 
     def generate_reports(self, max_parallel_jobs=None):
@@ -594,12 +592,17 @@ def _fingerprint_directory(path):
     return CacheHelper.dir_hash(path, digest=_hasher())
 
 
+class BuildError(Exception):
+    pass
+
+
 def _fingerprint_local_project(
     path,  # type: str
     target,  # type: Target
     resolver=None,  # type: Optional[Resolver]
     pip_version=None,  # type: Optional[PipVersionValue]
 ):
+    # type: (...) -> str
     if resolver:
         build_system_resolver = resolver
     else:
@@ -607,17 +610,20 @@ def _fingerprint_local_project(
 
         build_system_resolver = ConfiguredResolver.default()
 
-    return digest_local_project(
+    hasher = _hasher()
+    result = digest_local_project(
         directory=path,
-        digest=_hasher(),
+        digest=hasher,
         target=target,
         resolver=build_system_resolver,
         pip_version=pip_version,
     )
-
-
-class BuildError(Exception):
-    pass
+    if isinstance(result, Error):
+        raise BuildError(
+            "Failed to create an sdist for hashing from the local project at {path}: "
+            "{err}".format(path=path, err=result)
+        )
+    return hasher.hexdigest()
 
 
 def _as_download_target(target):
@@ -649,27 +655,19 @@ class BuildRequest(object):
         target,  # type: Union[DownloadTarget, Target]
         source_path,  # type: str
         subdirectory=None,  # type: Optional[str]
-        resolver=None,  # type: Optional[Resolver]
-        pip_version=None,  # type: Optional[PipVersionValue]
     ):
         # type: (...) -> BuildRequest
         download_target = _as_download_target(target)
-        fingerprint = _fingerprint_local_project(
-            path=source_path,
-            target=download_target.target,
-            resolver=resolver,
-            pip_version=pip_version,
-        )
         return cls(
             download_target=download_target,
             source_path=source_path,
-            fingerprint=fingerprint,
+            fingerprint=None,
             subdirectory=subdirectory,
         )
 
     download_target = attr.ib(converter=_as_download_target)  # type: DownloadTarget
     source_path = attr.ib()  # type: str
-    fingerprint = attr.ib()  # type: str
+    fingerprint = attr.ib()  # type: Optional[str]
     subdirectory = attr.ib()  # type: Optional[str]
 
     @property
@@ -724,12 +722,16 @@ class BuildResult(object):
         source_path=None,  # type: Optional[str]
     ):
         # type: (...) -> BuildResult
-        built_wheel = BuiltWheelDir.create(
-            sdist=source_path or build_request.source_path,
-            fingerprint=build_request.fingerprint,
-            target=build_request.target,
-        )
-        return cls(request=build_request, atomic_dir=AtomicDirectory(built_wheel.dist_dir))
+        if build_request.fingerprint:
+            built_wheel = BuiltWheelDir.create(
+                sdist=source_path or build_request.source_path,
+                fingerprint=build_request.fingerprint,
+                target=build_request.target,
+            )
+            target_dir = built_wheel.dist_dir
+        else:
+            target_dir = os.path.join(safe_mkdtemp(), "build")
+        return cls(request=build_request, atomic_dir=AtomicDirectory(target_dir))
 
     request = attr.ib()  # type: BuildRequest
     _atomic_dir = attr.ib()  # type: AtomicDirectory
@@ -1290,14 +1292,7 @@ class BuildAndInstallRequest(object):
                 if is_wheel(dist_path):
                     to_install.add(InstallRequest.create(install_request.target, dist_path))
                 elif os.path.isdir(dist_path):
-                    to_build.add(
-                        BuildRequest.for_directory(
-                            install_request.target,
-                            dist_path,
-                            resolver=self._resolver,
-                            pip_version=self._pip_version,
-                        )
-                    )
+                    to_build.add(BuildRequest.for_directory(install_request.target, dist_path))
                 else:
                     to_build.add(BuildRequest.for_file(install_request.target, dist_path))
             already_analyzed.add(metadata.project_name)
@@ -1907,11 +1902,21 @@ def download_requests(
     def add_build_requests(requests):
         # type: (Iterable[BuildRequest]) -> None
         for request in requests:
+            if request.fingerprint:
+                fingerprint = request.fingerprint
+            else:
+                production_assert(os.path.isdir(request.source_path))
+                fingerprint = _fingerprint_local_project(
+                    path=request.source_path,
+                    target=request.target,
+                    resolver=resolver,
+                    pip_version=pip_version,
+                )
             local_distributions.append(
                 LocalDistribution(
                     download_target=request.download_target,
                     path=request.source_path,
-                    fingerprint=request.fingerprint,
+                    fingerprint=fingerprint,
                     subdirectory=request.subdirectory,
                 )
             )

{pex-2.65.0 → pex-2.66.1}/pex/version.py

@@ -1,4 +1,4 @@
 # Copyright 2015 Pex project contributors.
 # Licensed under the Apache License, Version 2.0 (see LICENSE).
 
-__version__ = "2.65.0"
+__version__ = "2.66.1"