pex 2.61.0__py2.py3-none-any.whl → 2.62.0__py2.py3-none-any.whl

pex/resolver.py

@@ -46,6 +46,7 @@ from pex.pep_427 import InstallableType, WheelError, install_wheel_chroot
 from pex.pep_503 import ProjectName
 from pex.pip.download_observer import DownloadObserver
 from pex.pip.installation import get_pip
+from pex.pip.local_project import digest_local_project
 from pex.pip.tool import PackageIndexConfiguration
 from pex.pip.version import PipVersionValue
 from pex.requirements import LocalProjectRequirement, URLRequirement
@@ -149,9 +150,9 @@ class DownloadTarget(object):
         return self.target.id
 
 
-def _uniqued_targets(targets=None):
-    # type: (Optional[Iterable[DownloadTarget]]) -> Tuple[DownloadTarget, ...]
-    return tuple(OrderedSet(targets)) if targets is not None else ()
+def _uniqued_download_requests(requests=None):
+    # type: (Optional[Iterable[DownloadRequest]]) -> Tuple[DownloadRequest, ...]
+    return tuple(OrderedSet(requests)) if requests is not None else ()
 
 
 @attr.s(frozen=True)
@@ -238,12 +239,9 @@ class PipLogManager(object):
 
 
 @attr.s(frozen=True)
-class DownloadRequest(object):
-    download_targets = attr.ib(converter=_uniqued_targets)  # type: Tuple[DownloadTarget, ...]
+class _DownloadSession(object):
+    requests = attr.ib(converter=_uniqued_download_requests)  # type: Tuple[DownloadRequest, ...]
     direct_requirements = attr.ib()  # type: Iterable[ParsedRequirement]
-    requirements = attr.ib(default=None)  # type: Optional[Iterable[str]]
-    requirement_files = attr.ib(default=None)  # type: Optional[Iterable[str]]
-    constraint_files = attr.ib(default=None)  # type: Optional[Iterable[str]]
     allow_prereleases = attr.ib(default=False)  # type: bool
     transitive = attr.ib(default=True)  # type: bool
     package_index_configuration = attr.ib(default=None)  # type: Optional[PackageIndexConfiguration]
@@ -260,14 +258,17 @@ class DownloadRequest(object):
         # type: () -> Iterator[BuildRequest]
         for requirement in self.direct_requirements:
             if isinstance(requirement, LocalProjectRequirement):
-                for download_target in self.download_targets:
-                    yield BuildRequest.create(
-                        target=download_target.target, source_path=requirement.path
+                for request in self.requests:
+                    yield BuildRequest.for_directory(
+                        target=request.target,
+                        source_path=requirement.path,
+                        resolver=self.resolver,
+                        pip_version=self.pip_version,
                     )
 
     def download_distributions(self, dest=None, max_parallel_jobs=None):
         # type: (...) -> List[DownloadResult]
-        if not self.requirements and not self.requirement_files:
+        if not self.requests or not any(request.has_requirements for request in self.requests):
             # Nothing to resolve.
             return []
 
@@ -275,48 +276,32 @@ class DownloadRequest(object):
             prefix="resolver_download.", dir=safe_mkdir(CacheDir.DOWNLOADS.path(".tmp"))
         )
 
-        log_manager = PipLogManager.create(self.pip_log, self.download_targets)
+        log_manager = PipLogManager.create(
+            self.pip_log,
+            download_targets=tuple(request.download_target for request in self.requests),
+        )
         if self.pip_log and not self.pip_log.user_specified:
             TRACER.log(
                 "Preserving `pip download` log at {log_path}".format(log_path=self.pip_log.path),
                 V=ENV.PEX_VERBOSE,
             )
 
-        requirement_config = RequirementConfiguration(
-            requirements=self.requirements,
-            requirement_files=self.requirement_files,
-            constraint_files=self.constraint_files,
-        )
-        network_configuration = (
-            self.package_index_configuration.network_configuration
-            if self.package_index_configuration
-            else None
-        )
-        subdirectory_by_filename = {}  # type: Dict[str, str]
-        for parsed_requirement in requirement_config.parse_requirements(network_configuration):
-            if not isinstance(parsed_requirement, URLRequirement):
-                continue
-            subdirectory = parsed_requirement.subdirectory
-            if subdirectory:
-                subdirectory_by_filename[parsed_requirement.filename] = subdirectory
-
         spawn_download = functools.partial(
             self._spawn_download,
             resolved_dists_dir=dest,
             log_manager=log_manager,
-            subdirectory_by_filename=subdirectory_by_filename,
         )
         with TRACER.timed(
             "Resolving for:\n  {}".format(
-                "\n  ".join(target.render_description() for target in self.download_targets)
+                "\n  ".join(request.render_description() for request in self.requests)
             )
         ):
             try:
                 return list(
                     execute_parallel(
-                        inputs=self.download_targets,
+                        inputs=self.requests,
                         spawn_func=spawn_download,
-                        error_handler=Raise[DownloadTarget, DownloadResult](Unsatisfiable),
+                        error_handler=Raise[DownloadRequest, DownloadResult](Unsatisfiable),
                         max_jobs=max_parallel_jobs,
                     )
                 )
@@ -325,13 +310,31 @@ class DownloadRequest(object):
 
     def _spawn_download(
         self,
-        download_target,  # type: DownloadTarget
+        request,  # type: DownloadRequest
         resolved_dists_dir,  # type: str
         log_manager,  # type: PipLogManager
-        subdirectory_by_filename,  # type: Mapping[str, str]
     ):
         # type: (...) -> SpawnedJob[DownloadResult]
 
+        requirement_config = RequirementConfiguration(
+            requirements=request.requirements,
+            requirement_files=request.requirement_files,
+            constraint_files=request.constraint_files,
+        )
+        network_configuration = (
+            self.package_index_configuration.network_configuration
+            if self.package_index_configuration
+            else None
+        )
+        subdirectory_by_filename = {}  # type: Dict[str, str]
+        for parsed_requirement in requirement_config.parse_requirements(network_configuration):
+            if not isinstance(parsed_requirement, URLRequirement):
+                continue
+            subdirectory = parsed_requirement.subdirectory
+            if subdirectory:
+                subdirectory_by_filename[parsed_requirement.filename] = subdirectory
+
+        download_target = request.download_target
         download_dir = os.path.join(resolved_dists_dir, download_target.id(complete=True))
         observer = (
             self.observer.observe_download(
@@ -354,9 +357,9 @@ class DownloadRequest(object):
             ),
         ).spawn_download_distributions(
             download_dir=download_dir,
-            requirements=self.requirements,
-            requirement_files=self.requirement_files,
-            constraint_files=self.constraint_files,
+            requirements=request.requirements,
+            requirement_files=request.requirement_files,
+            constraint_files=request.constraint_files,
             allow_prereleases=self.allow_prereleases,
             transitive=self.transitive,
             target=target,
@@ -396,7 +399,14 @@ class DownloadResult(object):
                 subdirectory = self.subdirectory_by_filename.get(
                     os.path.basename(distribution_path)
                 )
-                yield BuildRequest.create(
+                production_assert(
+                    os.path.isfile(distribution_path),
+                    (
+                        "Pip download results should always be files and never local project "
+                        "directories."
+                    ),
+                )
+                yield BuildRequest.for_file(
                     target=self.download_target,
                     source_path=distribution_path,
                     subdirectory=subdirectory,
@@ -415,26 +425,46 @@ class IntegrityError(Exception):
     pass
 
 
-def fingerprint_path(path):
+if TYPE_CHECKING:
+    from pex.hashing import Hasher
+
+
+def _hasher():
+    # type: () -> Hasher
+
+    return hashlib.sha256()
+
+
+def _fingerprint_file(path):
     # type: (str) -> str
+    return CacheHelper.hash(path, digest=_hasher())
 
-    # We switched from sha1 to sha256 at the transition from using `pip install --target` to
-    # `pip install --prefix` to serve two purposes:
-    # 1. Insulate the new installation scheme from the old.
-    # 2. Move past sha1 which was shown to have practical collision attacks in 2019.
-    #
-    # The installation scheme switch was the primary purpose and switching hashes proved a pragmatic
-    # insulation. If the `pip install --prefix` re-arrangement scheme evolves, then some other
-    # option than switching hashing algorithms will be needed, like post-fixing a running version
-    # integer or just mixing one into the hashed content.
-    #
-    # See: https://github.com/pex-tool/pex/issues/1655 for a general overview of these cache
-    # structure concerns.
-    hasher = hashlib.sha256
 
-    if os.path.isdir(path):
-        return CacheHelper.dir_hash(path, hasher=hasher)
-    return CacheHelper.hash(path, hasher=hasher)
+def _fingerprint_directory(path):
+    # type: (str) -> str
+    return CacheHelper.dir_hash(path, digest=_hasher())
+
+
+def _fingerprint_local_project(
+    path,  # type: str
+    target,  # type: Target
+    resolver=None,  # type: Optional[Resolver]
+    pip_version=None,  # type: Optional[PipVersionValue]
+):
+    if resolver:
+        build_system_resolver = resolver
+    else:
+        from pex.resolve.configured_resolver import ConfiguredResolver
+
+        build_system_resolver = ConfiguredResolver.default()
+
+    return digest_local_project(
+        directory=path,
+        digest=_hasher(),
+        target=target,
+        resolver=build_system_resolver,
+        pip_version=pip_version,
+    )
 
 
 class BuildError(Exception):
@@ -449,14 +479,14 @@ def _as_download_target(target):
 @attr.s(frozen=True)
 class BuildRequest(object):
     @classmethod
-    def create(
+    def for_file(
         cls,
         target,  # type: Union[DownloadTarget, Target]
         source_path,  # type: str
         subdirectory=None,  # type: Optional[str]
     ):
         # type: (...) -> BuildRequest
-        fingerprint = fingerprint_path(source_path)
+        fingerprint = _fingerprint_file(source_path)
         return cls(
             download_target=_as_download_target(target),
             source_path=source_path,
@@ -464,6 +494,30 @@ class BuildRequest(object):
             subdirectory=subdirectory,
         )
 
+    @classmethod
+    def for_directory(
+        cls,
+        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,
+            subdirectory=subdirectory,
+        )
+
     download_target = attr.ib(converter=_as_download_target)  # type: DownloadTarget
     source_path = attr.ib()  # type: str
     fingerprint = attr.ib()  # type: str
@@ -635,7 +689,7 @@ class InstallRequest(object):
         was_built_locally=False,  # type: bool
     ):
         # type: (...) -> InstallRequest
-        fingerprint = fingerprint_path(wheel_path)
+        fingerprint = _fingerprint_file(wheel_path)
         return cls(
             download_target=_as_download_target(target),
             wheel_path=wheel_path,
@@ -768,7 +822,7 @@ class InstallResult(object):
         else:
             cached_fingerprint = installed_wheel.fingerprint
 
-        wheel_dir_hash = cached_fingerprint or fingerprint_path(self.install_chroot)
+        wheel_dir_hash = cached_fingerprint or _fingerprint_directory(self.install_chroot)
         runtime_key_dir = os.path.join(self._installation_root, wheel_dir_hash)
         with atomic_directory(runtime_key_dir) as atomic_dir:
             if not atomic_dir.is_finalized():
@@ -1086,8 +1140,17 @@ 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,
+                        )
+                    )
                 else:
-                    to_build.add(BuildRequest.create(install_request.target, dist_path))
+                    to_build.add(BuildRequest.for_file(install_request.target, dist_path))
             already_analyzed.add(metadata.project_name)
 
         all_install_requests = OrderedSet(install_requests)
@@ -1251,7 +1314,7 @@ def _parse_reqs(
     requirement_files=None,  # type: Optional[Iterable[str]]
     network_configuration=None,  # type: Optional[NetworkConfiguration]
 ):
-    # type: (...) -> Iterable[ParsedRequirement]
+    # type: (...) -> Tuple[ParsedRequirement, ...]
     requirement_configuration = RequirementConfiguration(
         requirements=requirements, requirement_files=requirement_files
     )
@@ -1318,6 +1381,23 @@ def resolve(
     :raises ValueError: If `build=False` and `use_wheel=False`.
     """
 
+    if not build_configuration.allow_wheels:
+        foreign_targets = [
+            target
+            for target in targets.unique_targets()
+            if not isinstance(target, LocalInterpreter)
+        ]
+        if foreign_targets:
+            raise ValueError(
+                "Cannot ignore wheels (use_wheel=False) when resolving for foreign {platforms}: "
+                "{foreign_platforms}".format(
+                    platforms=pluralize(foreign_targets, "platform"),
+                    foreign_platforms=", ".join(
+                        target.render_description() for target in foreign_targets
+                    ),
+                )
+            )
+
     # A resolve happens in four stages broken into two phases:
     # 1. Download phase: resolves sdists and wheels in a single operation per distribution target.
     # 2. Install phase:
@@ -1359,29 +1439,19 @@ def resolve(
         keyring_provider=keyring_provider,
     )
 
-    if not build_configuration.allow_wheels:
-        foreign_targets = [
-            target
-            for target in targets.unique_targets()
-            if not isinstance(target, LocalInterpreter)
-        ]
-        if foreign_targets:
-            raise ValueError(
-                "Cannot ignore wheels (use_wheel=False) when resolving for foreign {platforms}: "
-                "{foreign_platforms}".format(
-                    platforms=pluralize(foreign_targets, "platform"),
-                    foreign_platforms=", ".join(
-                        target.render_description() for target in foreign_targets
-                    ),
-                )
-            )
+    requests = tuple(
+        DownloadRequest(
+            download_target=DownloadTarget(target=target),
+            requirements=requirements,
+            requirement_files=requirement_files,
+            constraint_files=constraint_files,
+        )
+        for target in targets.unique_targets()
+    )
 
     build_requests, download_results = _download_internal(
-        targets=targets,
+        requests=requests,
         direct_requirements=direct_requirements,
-        requirements=requirements,
-        requirement_files=requirement_files,
-        constraint_files=constraint_files,
         allow_prereleases=allow_prereleases,
         transitive=transitive,
         package_index_configuration=package_index_configuration,
@@ -1429,11 +1499,8 @@ def resolve(
 
 
 def _download_internal(
-    targets,  # type: Targets
+    requests,  # type: Tuple[DownloadRequest, ...]
     direct_requirements,  # type: Iterable[ParsedRequirement]
-    requirements=None,  # type: Optional[Iterable[str]]
-    requirement_files=None,  # type: Optional[Iterable[str]]
-    constraint_files=None,  # type: Optional[Iterable[str]]
     allow_prereleases=False,  # type: bool
     transitive=True,  # type: bool
     package_index_configuration=None,  # type: Optional[PackageIndexConfiguration]
@@ -1445,27 +1512,12 @@ def _download_internal(
     pip_version=None,  # type: Optional[PipVersionValue]
     resolver=None,  # type: Optional[Resolver]
     dependency_configuration=DependencyConfiguration(),  # type: DependencyConfiguration
-    universal_targets=(),  # type: Iterable[UniversalTarget]
 ):
     # type: (...) -> Tuple[List[BuildRequest], List[DownloadResult]]
 
-    unique_targets = targets.unique_targets()
-    if universal_targets:
-        production_assert(len(unique_targets) == 1)
-        target = unique_targets.pop()
-        download_targets = tuple(
-            DownloadTarget(target, universal_target=universal_target)
-            for universal_target in universal_targets
-        )
-    else:
-        download_targets = tuple(DownloadTarget(target) for target in unique_targets)
-
-    download_request = DownloadRequest(
-        download_targets=download_targets,
+    download_session = _DownloadSession(
+        requests=requests,
         direct_requirements=direct_requirements,
-        requirements=requirements,
-        requirement_files=requirement_files,
-        constraint_files=constraint_files,
         allow_prereleases=allow_prereleases,
         transitive=transitive,
         package_index_configuration=package_index_configuration,
@@ -1477,8 +1529,8 @@ def _download_internal(
         dependency_configuration=dependency_configuration,
     )
 
-    local_projects = list(download_request.iter_local_projects())
-    download_results = download_request.download_distributions(
+    local_projects = list(download_session.iter_local_projects())
+    download_results = download_session.download_distributions(
         dest=dest, max_parallel_jobs=max_parallel_jobs
     )
     return local_projects, download_results
@@ -1496,10 +1548,6 @@ class LocalDistribution(object):
         # type: () -> Target
         return self.download_target.target
 
-    @fingerprint.default
-    def _calculate_fingerprint(self):
-        return fingerprint_path(self.path)
-
     @property
     def is_wheel(self):
         return is_wheel(self.path) and zipfile.is_zipfile(self.path)
@@ -1542,7 +1590,6 @@ def download(
     extra_pip_requirements=(),  # type: Tuple[Requirement, ...]
     keyring_provider=None,  # type: Optional[str]
     dependency_configuration=DependencyConfiguration(),  # type: DependencyConfiguration
-    universal_targets=(),  # type: Iterable[UniversalTarget]
 ):
     # type: (...) -> Downloaded
     """Downloads all distributions needed to meet requirements for multiple distribution targets.
@@ -1572,7 +1619,114 @@ def download(
     :raises ValueError: If a foreign platform was provided in `platforms`, and `use_wheel=False`.
     :raises ValueError: If `build=False` and `use_wheel=False`.
     """
-    direct_requirements = _parse_reqs(requirements, requirement_files, network_configuration)
+    return download_requests(
+        requests=tuple(
+            DownloadRequest(
+                download_target=DownloadTarget(target),
+                requirements=requirements,
+                requirement_files=requirement_files,
+                constraint_files=constraint_files,
+            )
+            for target in targets.unique_targets()
+        ),
+        direct_requirements=_parse_reqs(requirements, requirement_files, network_configuration),
+        allow_prereleases=allow_prereleases,
+        transitive=transitive,
+        repos_configuration=repos_configuration,
+        resolver_version=resolver_version,
+        network_configuration=network_configuration,
+        build_configuration=build_configuration,
+        dest=dest,
+        max_parallel_jobs=max_parallel_jobs,
+        observer=observer,
+        pip_log=pip_log,
+        pip_version=pip_version,
+        resolver=resolver,
+        use_pip_config=use_pip_config,
+        extra_pip_requirements=extra_pip_requirements,
+        keyring_provider=keyring_provider,
+        dependency_configuration=dependency_configuration,
+    )
+
+
+def _as_str_tuple(items):
+    # type: (Optional[Iterable[str]]) -> Tuple[str, ...]
+    if not items:
+        return ()
+    return items if isinstance(items, tuple) else tuple(items)
+
+
+@attr.s(frozen=True)
+class DownloadRequest(object):
+    @classmethod
+    def create(
+        cls,
+        target,  # type: Target
+        universal_target=None,  # type: Optional[UniversalTarget]
+        requirement_configuration=RequirementConfiguration(),  # type: RequirementConfiguration
+        provenance=None,  # type: Optional[str]
+    ):
+        # type: (...) -> DownloadRequest
+        return cls(
+            download_target=DownloadTarget(target=target, universal_target=universal_target),
+            requirements=requirement_configuration.requirements,
+            requirement_files=requirement_configuration.requirement_files,
+            constraint_files=requirement_configuration.constraint_files,
+            provenance=provenance,
+        )
+
+    download_target = attr.ib()  # type: DownloadTarget
+    requirements = attr.ib(default=(), converter=_as_str_tuple)  # type: Tuple[str, ...]
+    requirement_files = attr.ib(default=(), converter=_as_str_tuple)  # type: Tuple[str, ...]
+    constraint_files = attr.ib(default=(), converter=_as_str_tuple)  # type: Tuple[str, ...]
+    provenance = attr.ib(default=None)  # type: Optional[str]
+
+    def render_description(self):
+        # type: () -> str
+        description = self.download_target.render_description()
+        if not self.provenance:
+            return description
+        return "{description} from {provenance}".format(
+            description=description, provenance=self.provenance
+        )
+
+    @property
+    def target(self):
+        # type: () -> Target
+        return self.download_target.target
+
+    @property
+    def universal_target(self):
+        # type: () -> Optional[UniversalTarget]
+        return self.download_target.universal_target
+
+    @property
+    def has_requirements(self):
+        return bool(self.requirements) or bool(self.requirement_files)
+
+
+def download_requests(
+    requests,  # type: Tuple[DownloadRequest, ...]
+    direct_requirements,  # type: Tuple[ParsedRequirement, ...]
+    allow_prereleases=False,  # type: bool
+    transitive=True,  # type: bool
+    repos_configuration=ReposConfiguration(),  # type: ReposConfiguration
+    resolver_version=None,  # type: Optional[ResolverVersion.Value]
+    network_configuration=None,  # type: Optional[NetworkConfiguration]
+    build_configuration=BuildConfiguration(),  # type: BuildConfiguration
+    dest=None,  # type: Optional[str]
+    max_parallel_jobs=None,  # type: Optional[int]
+    observer=None,  # type: Optional[ResolveObserver]
+    pip_log=None,  # type: Optional[PipLog]
+    pip_version=None,  # type: Optional[PipVersionValue]
+    resolver=None,  # type: Optional[Resolver]
+    use_pip_config=False,  # type: bool
+    extra_pip_requirements=(),  # type: Tuple[Requirement, ...]
+    keyring_provider=None,  # type: Optional[str]
+    dependency_configuration=DependencyConfiguration(),  # type: DependencyConfiguration
+):
+    # type: (...) -> Downloaded
+
     package_index_configuration = PackageIndexConfiguration.create(
         pip_version=pip_version,
         resolver_version=resolver_version,
@@ -1582,12 +1736,10 @@ def download(
         extra_pip_requirements=extra_pip_requirements,
         keyring_provider=keyring_provider,
     )
+
     build_requests, download_results = _download_internal(
-        targets=targets,
+        requests=requests,
         direct_requirements=direct_requirements,
-        requirements=requirements,
-        requirement_files=requirement_files,
-        constraint_files=constraint_files,
         allow_prereleases=allow_prereleases,
         transitive=transitive,
         package_index_configuration=package_index_configuration,
@@ -1599,7 +1751,6 @@ def download(
         pip_version=pip_version,
         resolver=resolver,
         dependency_configuration=dependency_configuration,
-        universal_targets=universal_targets,
     )
 
     local_distributions = []

pex/venv/venv_pex.py

@@ -186,7 +186,7 @@ def boot(
             "_PEX_PATCHED_TAGS_FILE",
             # These are used by Pex's Pip venv to implement universal locks.
             "_PEX_PYTHON_VERSIONS_FILE",
-            "_PEX_TARGET_SYSTEMS_FILE",
+            "_PEX_UNIVERSAL_TARGET_FILE",
             # This is used to implement Pex --exclude and --override support.
             "_PEX_DEP_CONFIG_FILE",
             # This is used to implement --source support.

pex/version.py

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

{pex-2.61.0.dist-info → pex-2.62.0.dist-info}/METADATA

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: pex
-Version: 2.61.0
+Version: 2.62.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.61.0/pex
+Download-URL: https://github.com/pex-tool/pex/releases/download/v2.62.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.61.0/CHANGES.md
+Project-URL: Changelog, https://github.com/pex-tool/pex/blob/v2.62.0/CHANGES.md
 Project-URL: Documentation, https://docs.pex-tool.org/
-Project-URL: Source, https://github.com/pex-tool/pex/tree/v2.61.0
+Project-URL: Source, https://github.com/pex-tool/pex/tree/v2.62.0
 Keywords: package,executable,virtualenv,lock,freeze
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers