pex 2.58.1__tar.gz → 2.59.1__tar.gz

{pex-2.58.1 → pex-2.59.1}/CHANGES.md

@@ -1,5 +1,21 @@
 # Release Notes
 
+## 2.59.1
+
+This release fixes a regression in VCS URL handling introduced by Pex 2.38.0 when VCS URLs included
+user info in the authority.
+
+* Fix `pex3 lock create/export` for VCS URLs with userinfo (#2918)
+
+## 2.59.0
+
+This release adds support for a `--venv-repository` resolution source. This allows creating a PEX
+from a pre-existing venv. By default, all installed venv distributions are included in the PEX, but
+by specifying requirements, the venv can be subset. The `--venv-repository` source is also supported
+by `pex3 venv create` allowing subsetting an existing venv directly into a new venv as well.
+
+* Add support for `--venv-repository` resolver. (#2916)
+
 ## 2.58.1
 
 This release fixes a bug building source distributions from locks of local project directories when

{pex-2.58.1 → pex-2.59.1}/PKG-INFO

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

{pex-2.58.1 → pex-2.59.1}/pex/bin/pex.py

@@ -144,6 +144,7 @@ def configure_clp_pex_resolution(parser):
         include_pex_lock=True,
         include_pylock=True,
         include_pre_resolved=True,
+        include_venv_repository=True,
     )
 
     group.add_argument(

{pex-2.58.1 → pex-2.59.1}/pex/cli/commands/venv.py

@@ -8,7 +8,7 @@ import logging
 import os.path
 from argparse import ArgumentParser, _ActionsContainer
 
-from pex import pex_warnings
+from pex import dependency_configuration, pex_warnings
 from pex.cli.command import BuildTimeCommand
 from pex.commands.command import JsonMixin, OutputMixin
 from pex.common import CopyMode, open_zip, pluralize
@@ -123,8 +123,10 @@ class Venv(OutputMixin, JsonMixin, BuildTimeCommand):
             include_pex_lock=True,
             include_pylock=True,
             include_pre_resolved=True,
+            include_venv_repository=True,
         )
         requirement_options.register(parser)
+        dependency_configuration.register(parser)
 
     @classmethod
     def add_extra_arguments(
@@ -285,11 +287,13 @@ class Venv(OutputMixin, JsonMixin, BuildTimeCommand):
                 )
 
         requirement_configuration = requirement_options.configure(self.options)
+        dependency_config = dependency_configuration.configure(self.options)
         with TRACER.timed("Resolving distributions"):
             resolved = configured_resolve.resolve(
                 targets=targets,
                 requirement_configuration=requirement_configuration,
                 resolver_configuration=resolver_configuration,
+                dependency_configuration=dependency_config,
             )
 
         pex = None  # type: Optional[PEX]

{pex-2.58.1 → pex-2.59.1}/pex/dependency_configuration.py

@@ -141,8 +141,12 @@ class DependencyConfiguration(object):
         # type: (Requirement) -> Tuple[Requirement, ...]
         return self.overridden.get(requirement.project_name, ())
 
-    def overridden_by(self, requirement, target):
-        # type: (Requirement, Target) -> Optional[Requirement]
+    def overridden_by(
+        self,
+        requirement,  # type: Requirement
+        target,  # type: Target
+    ):
+        # type: (...) -> Optional[Requirement]
         overrides = self.overrides_for(requirement)
         applicable_overrides = [
             override for override in overrides if target.requirement_applies(override)

{pex-2.58.1 → pex-2.59.1}/pex/dist_metadata.py

@@ -152,15 +152,24 @@ class DistMetadataFile(object):
     version = attr.ib()  # type: Version
     pkg_info = attr.ib(eq=False)  # type: Message
 
-    def render_description(self):
-        # type: () -> str
+    def render_metadata_file_description(self, metadata_file_rel_path):
+        # type: (Text) -> str
         return "{project_name} {version} metadata from {rel_path} at {location}".format(
             project_name=self.project_name,
             version=self.version,
-            rel_path=self.rel_path,
+            rel_path=metadata_file_rel_path,
             location=self.location,
         )
 
+    def render_description(self):
+        # type: () -> str
+        return self.render_metadata_file_description(self.rel_path)
+
+    @property
+    def path(self):
+        # type: () -> Text
+        return os.path.join(self.location, self.rel_path)
+
 
 @attr.s(frozen=True)
 class MetadataFiles(object):
@@ -182,6 +191,14 @@ class MetadataFiles(object):
             return None
         return self._read_function(rel_path)
 
+    def render_description(self, metadata_file_name):
+        # type: (Text) -> str
+        rel_path = self.metadata_file_rel_path(metadata_file_name)
+        return self.metadata.render_metadata_file_description(
+            rel_path
+            or "{metadata_file_name} not found".format(metadata_file_name=metadata_file_name)
+        )
+
 
 class MetadataType(Enum["MetadataType.Value"]):
     class Value(Enum.Value):
@@ -210,6 +227,15 @@ class MetadataKey(object):
     location = attr.ib()  # type: Text
 
 
+def _read_function(
+    location,  # type: Text
+    rel_path,  # type: Text
+):
+    # type: (...) -> bytes
+    with open(os.path.join(location, rel_path), "rb") as fp:
+        return fp.read()
+
+
 def _find_installed_metadata_files(
     location,  # type: Text
     metadata_type,  # type: MetadataType.Value
@@ -218,6 +244,7 @@ def _find_installed_metadata_files(
 ):
     # type: (...) -> Iterator[MetadataFiles]
     metadata_files = glob.glob(os.path.join(location, metadata_dir_glob, metadata_file_name))
+    read_function = functools.partial(_read_function, location)
     for path in metadata_files:
         with open(path, "rb") as fp:
             metadata = parse_message(fp.read())
@@ -225,11 +252,6 @@ def _find_installed_metadata_files(
                 source=path, pkg_info=metadata
             )
 
-            def read_function(rel_path):
-                # type: (Text) -> bytes
-                with open(os.path.join(location, rel_path), "rb") as fp:
-                    return fp.read()
-
             yield MetadataFiles(
                 metadata=DistMetadataFile(
                     type=metadata_type,

{pex-2.58.1 → pex-2.59.1}/pex/environment.py

@@ -66,6 +66,22 @@ def _import_pkg_resources():
             return None, False
 
 
+def _fd_lt(
+    self,  # type: FingerprintedDistribution
+    other,  # type: FingerprintedDistribution
+):
+    # type: (...) -> bool
+    if self.project_name.normalized < other.project_name.normalized:
+        return True
+
+    # Since we want to rank higher versions higher (earlier) we need to reverse the natural
+    # ordering of Version in Distribution which is least to greatest.
+    if self.distribution.metadata.version >= other.distribution.metadata.version:
+        return True
+
+    return self.fingerprint < other.fingerprint
+
+
 @attr.s(frozen=True)
 class _RankedDistribution(object):
     # N.B.: A distribution implements rich comparison with the leading component being the
@@ -77,9 +93,7 @@ class _RankedDistribution(object):
     # The attr project type stub file simply misses this.
     _fd_cmp = attr.cmp_using(  # type: ignore[attr-defined]
         eq=FingerprintedDistribution.__eq__,
-        # Since we want to rank higher versions higher (earlier) we need to reverse the natural
-        # ordering of Version in Distribution which is least to greatest.
-        lt=FingerprintedDistribution.__ge__,
+        lt=_fd_lt,
     )
 
     @classmethod

{pex-2.58.1 → pex-2.59.1}/pex/pep_425.py

@@ -6,11 +6,12 @@ from __future__ import absolute_import
 import itertools
 import os.path
 
-from pex.dist_metadata import is_wheel
+from pex.dist_metadata import Distribution, is_wheel
 from pex.orderedset import OrderedSet
 from pex.rank import Rank
 from pex.third_party.packaging.tags import Tag, parse_tag
 from pex.typing import TYPE_CHECKING, cast, overload
+from pex.wheel import WHEEL
 
 if TYPE_CHECKING:
     from typing import (
@@ -66,7 +67,13 @@ class CompatibilityTags(object):
 
     @classmethod
     def from_wheel(cls, wheel):
-        # type: (Text) -> CompatibilityTags
+        # type: (Union[Text, Distribution]) -> CompatibilityTags
+
+        if isinstance(wheel, Distribution):
+            if not is_wheel(wheel.location):
+                return cls(tags=WHEEL.from_distribution(wheel).tags)
+            wheel = wheel.location
+
         if not is_wheel(wheel):
             raise ValueError(
                 "Can only calculate wheel tags from a filename that ends in .whl per "
@@ -74,6 +81,7 @@ class CompatibilityTags(object):
                     wheel=wheel
                 )
             )
+
         wheel_stem, _ = os.path.splitext(os.path.basename(wheel))
         # Wheel filename format: https://peps.python.org/pep-0427/#file-name-convention
         # `{distribution}-{version}(-{build tag})?-{python tag}-{abi tag}-{platform tag}.whl`
@@ -86,6 +94,7 @@ class CompatibilityTags(object):
                     pattern=pattern, wheel=wheel
                 )
             )
+
         return cls(tags=tuple(parse_tag("-".join(wheel_components[-3:]))))
 
     @classmethod

{pex-2.58.1 → pex-2.59.1}/pex/pep_427.py

@@ -9,20 +9,23 @@ import re
 import shutil
 import subprocess
 import sys
+import zipfile
 from contextlib import closing
 from fileinput import FileInput
 from textwrap import dedent
 
 from pex import pex_warnings, windows
-from pex.common import is_pyc_file, iter_copytree, open_zip, safe_open, touch
+from pex.common import is_pyc_file, iter_copytree, open_zip, safe_mkdir, safe_open, touch
 from pex.compatibility import commonpath, get_stdout_bytes_buffer, safe_commonpath
 from pex.dist_metadata import (
     CallableEntryPoint,
+    DistMetadata,
     Distribution,
+    MetadataFiles,
     NamedEntryPoint,
-    ProjectNameAndVersion,
 )
 from pex.enum import Enum
+from pex.exceptions import reportable_unexpected_error_msg
 from pex.executables import chmod_plus_x
 from pex.interpreter import PythonInterpreter
 from pex.os import WINDOWS
@@ -43,6 +46,7 @@ if TYPE_CHECKING:
         Optional,
         Text,
         Tuple,
+        Union,
     )
 
     import attr  # vendor:skip
@@ -69,6 +73,7 @@ InstallableType.seal()
 class InstallPaths(object):
 
     CHROOT_STASH = ".prefix"
+    PATHS = "purelib", "platlib", "headers", "scripts", "data"
 
     @classmethod
     def chroot(
@@ -118,30 +123,121 @@ class InstallPaths(object):
             return self.data
         raise KeyError("Not a known install path: {item}".format(item=item))
 
+    def __str__(self):
+        # type: () -> str
+        return "\n".join(
+            "{path}={value}".format(path=item, value=self[item]) for item in InstallPaths.PATHS
+        )
+
+
+@attr.s(frozen=True)
+class InstallableWheel(object):
+    @classmethod
+    def from_installation(
+        cls,
+        interpreter,  # type: PythonInterpreter
+        distribution,  # type: Distribution
+    ):
+        # type: (...) -> InstallableWheel
+        return cls(
+            wheel=Wheel.from_distribution(distribution),
+            install_paths=InstallPaths.interpreter(interpreter),
+        )
+
+    @classmethod
+    def from_whl(cls, whl):
+        # type: (str) -> InstallableWheel
+        return cls(wheel=Wheel.load(whl))
+
+    wheel = attr.ib()  # type: Wheel
+    is_whl = attr.ib(init=False)  # type: bool
+    install_paths = attr.ib(default=None)  # type: Optional[InstallPaths]
+
+    def __attrs_post_init__(self):
+        is_whl = zipfile.is_zipfile(self.wheel.location)
+
+        if is_whl and self.install_paths:
+            raise ValueError(
+                "A wheel file should have no installed paths but given the following paths for "
+                "{wheel}:\n"
+                "{install_paths}".format(
+                    wheel=self.wheel.location, install_paths=self.install_paths
+                )
+            )
+
+        if not is_whl and not self.install_paths:
+            raise ValueError(
+                "The wheel for {source} is installed but not given its install paths".format(
+                    source=self.source
+                )
+            )
+
+        object.__setattr__(self, "is_whl", is_whl)
+
+    @property
+    def location(self):
+        # type: () -> str
+        return self.wheel.location
+
+    @property
+    def source(self):
+        # type: () -> str
+        return self.wheel.source
+
+    @property
+    def metadata_files(self):
+        # type: () -> MetadataFiles
+        return self.wheel.metadata_files
+
+    @property
+    def root_is_purelib(self):
+        # type: () -> bool
+        return self.wheel.root_is_purelib
+
+    @property
+    def data_dir(self):
+        # type: () -> str
+        return self.wheel.data_dir
+
+    @property
+    def wheel_file_name(self):
+        # type: () -> str
+        return self.wheel.wheel_file_name
+
+    def dist_metadata(self):
+        # type: () -> DistMetadata
+        return self.wheel.dist_metadata()
+
+    def metadata_path(self, *components):
+        # type: (*str) -> str
+        return self.wheel.metadata_path(*components)
+
 
 class WheelInstallError(WheelError):
     """Indicates an error installing a `.whl` file."""
 
 
 def install_wheel_chroot(
-    wheel_path,  # type: str
+    wheel,  # type: Union[str, InstallableWheel]
     destination,  # type: str
     compile=False,  # type: bool
     requested=True,  # type: bool
 ):
     # type: (...) -> InstalledWheel
 
-    wheel = install_wheel(
-        wheel_path,
+    wheel_to_install = (
+        wheel if isinstance(wheel, InstallableWheel) else InstallableWheel.from_whl(wheel)
+    )
+    install_wheel(
+        wheel_to_install,
         InstallPaths.chroot(
-            destination,
-            project_name=ProjectNameAndVersion.from_filename(wheel_path).canonicalized_project_name,
+            destination, project_name=wheel_to_install.metadata_files.metadata.project_name
         ),
         compile=compile,
         requested=requested,
     )
 
-    record_relpath = wheel.metadata_files.metadata_file_rel_path("RECORD")
+    record_relpath = wheel_to_install.metadata_files.metadata_file_rel_path("RECORD")
     assert (
         record_relpath is not None
     ), "The {module}.install_wheel function should always create a RECORD.".format(module=__name__)
@@ -149,20 +245,23 @@ def install_wheel_chroot(
         prefix_dir=destination,
         stash_dir=InstallPaths.CHROOT_STASH,
         record_relpath=record_relpath,
-        root_is_purelib=wheel.root_is_purelib,
+        root_is_purelib=wheel_to_install.root_is_purelib,
     )
 
 
 def install_wheel_interpreter(
-    wheel_path,  # type: str
+    wheel,  # type: Union[str, InstallableWheel]
     interpreter,  # type: PythonInterpreter
     compile=True,  # type: bool
     requested=True,  # type: bool
 ):
-    # type: (...) -> Wheel
+    # type: (...) -> None
 
-    return install_wheel(
-        wheel_path,
+    wheel_to_install = (
+        wheel if isinstance(wheel, InstallableWheel) else InstallableWheel.from_whl(wheel)
+    )
+    install_wheel(
+        wheel_to_install,
         InstallPaths.interpreter(interpreter),
         interpreter=interpreter,
         compile=compile,
@@ -171,16 +270,15 @@ def install_wheel_interpreter(
 
 
 def install_wheel(
-    wheel_path,  # type: str
+    wheel,  # type: InstallableWheel
     install_paths,  # type: InstallPaths
     interpreter=None,  # type: Optional[PythonInterpreter]
     compile=False,  # type: bool
     requested=True,  # type: bool
 ):
-    # type: (...) -> Wheel
+    # type: (...) -> None
 
     # See: https://packaging.python.org/en/latest/specifications/binary-distribution-format/#installing-a-wheel-distribution-1-0-py32-none-any-whl
-    wheel = Wheel.load(wheel_path)
     dest = install_paths.purelib if wheel.root_is_purelib else install_paths.platlib
 
     record_relpath = wheel.metadata_path("RECORD")
@@ -203,68 +301,117 @@ def install_wheel(
                 continue
             file_abspath = os.path.join(root_dir, name)
             if record_relpath == name:
-                # We'll generate a new RECORD below.
+                # We'll generate a new RECORD below as needed.
                 os.unlink(file_abspath)
                 continue
             installed_files.append(
                 InstalledWheel.create_installed_file(path=file_abspath, dest_dir=dest)
             )
 
-    with open_zip(wheel_path) as zf:
-        zf.extractall(dest)
-        # TODO(John Sirois): Consider verifying signatures.
-        # N.B.: Pip does not and its also not clear what good this does. A zip can be easily poked
-        # on a per-entry basis allowing forging a RECORD entry and its associated file. Only an
-        # outer fingerprint of the whole wheel really solves this sort of tampering.
-        record_files(
-            root_dir=dest,
-            names=[
-                name
-                for name in zf.namelist()
-                if not name.endswith("/")
-                and data_rel_path != safe_commonpath((data_rel_path, name))
-            ],
-        )
-        if os.path.isdir(data_path):
-            for entry in sorted(os.listdir(data_path)):
-                try:
-                    dest_dir = install_paths[entry]
-                except KeyError as e:
-                    raise WheelInstallError(
-                        "The wheel at {wheel_path} is invalid and cannot be installed: "
-                        "{err}".format(wheel_path=wheel_path, err=e)
+    if wheel.is_whl:
+        with open_zip(wheel.location) as zf:
+            # 1. Unpack
+            zf.extractall(dest)
+            # TODO(John Sirois): Consider verifying signatures.
+            # N.B.: Pip does not and its also not clear what good this does. A zip can be easily
+            # poked on a per-entry basis allowing forging a RECORD entry and its associated file.
+            # Only an outer fingerprint of the whole wheel really solves this sort of tampering.
+            record_files(
+                root_dir=dest,
+                names=[
+                    name
+                    for name in zf.namelist()
+                    if not name.endswith("/")
+                    and data_rel_path != safe_commonpath((data_rel_path, name))
+                ],
+            )
+            if os.path.isdir(data_path):
+                # 2. Spread
+                for entry in sorted(os.listdir(data_path)):
+                    try:
+                        dest_dir = install_paths[entry]
+                    except KeyError as e:
+                        raise WheelInstallError(
+                            "The wheel at {wheel_path} is invalid and cannot be installed: "
+                            "{err}".format(wheel_path=wheel.source, err=e)
+                        )
+                    entry_path = os.path.join(data_path, entry)
+                    copied = [dst for _, dst in iter_copytree(entry_path, dest_dir)]
+                    if copied and "scripts" == entry:
+                        for script in copied:
+                            chmod_plus_x(script)
+                        if interpreter:
+                            with closing(
+                                FileInput(files=copied, inplace=True, mode="rb")
+                            ) as script_fi:
+                                for line in cast("Iterator[bytes]", script_fi):
+                                    buffer = get_stdout_bytes_buffer()
+                                    if script_fi.isfirstline() and re.match(br"^#!pythonw?", line):
+                                        _, _, shebang_args = line.partition(b" ")
+                                        buffer.write(
+                                            "{shebang}\n".format(
+                                                shebang=interpreter.shebang(
+                                                    args=shebang_args.decode("utf-8")
+                                                )
+                                            ).encode("utf-8")
+                                        )
+                                    else:
+                                        # N.B.: These lines include the newline already.
+                                        buffer.write(cast(bytes, line))
+
+                    record_files(
+                        root_dir=dest_dir,
+                        names=[
+                            os.path.relpath(os.path.join(root, f), entry_path)
+                            for root, _, files in os.walk(entry_path)
+                            for f in files
+                        ],
+                    )
+                shutil.rmtree(data_path)
+    elif wheel.install_paths:
+        record_data = wheel.metadata_files.read("RECORD")
+        if not record_data:
+            raise WheelInstallError(
+                "Cannot re-install installed wheel for {source} because it has no installation "
+                "RECORD metadata.".format(source=wheel.source)
+            )
+
+        for installed_file in Record.read(iter(record_data.decode("utf-8").splitlines())):
+            if installed_file.path == record_relpath:
+                # We'll generate a new RECORD below as needed.
+                continue
+            src_file = os.path.realpath(os.path.join(wheel.location, installed_file.path))
+            dst_file = os.path.realpath(os.path.join(dest, installed_file.path))
+            if dest == commonpath((dest, dst_file)):
+                safe_mkdir(os.path.dirname(dst_file))
+                shutil.copy(src_file, dst_file)
+                installed_files.append(installed_file)
+                continue
+
+            for path in InstallPaths.PATHS:
+                installed_path = wheel.install_paths[path]
+                if installed_path == commonpath((installed_path, src_file)):
+                    dst_file = os.path.join(
+                        install_paths[path], os.path.relpath(src_file, installed_path)
                     )
-                entry_path = os.path.join(data_path, entry)
-                copied = [dst for _, dst in iter_copytree(entry_path, dest_dir)]
-                if copied and "scripts" == entry:
-                    for script in copied:
-                        chmod_plus_x(script)
-                    if interpreter:
-                        with closing(FileInput(files=copied, inplace=True, mode="rb")) as script_fi:
-                            for line in cast("Iterator[bytes]", script_fi):
-                                buffer = get_stdout_bytes_buffer()
-                                if script_fi.isfirstline() and re.match(br"^#!pythonw?", line):
-                                    _, _, shebang_args = line.partition(b" ")
-                                    buffer.write(
-                                        "{shebang}\n".format(
-                                            shebang=interpreter.shebang(
-                                                args=shebang_args.decode("utf-8")
-                                            )
-                                        ).encode("utf-8")
-                                    )
-                                else:
-                                    # N.B.: These lines include the newline already.
-                                    buffer.write(cast(bytes, line))
-
-                record_files(
-                    root_dir=dest_dir,
-                    names=[
-                        os.path.relpath(os.path.join(root, f), entry_path)
-                        for root, _, files in os.walk(entry_path)
-                        for f in files
-                    ],
+                    break
+            else:
+                raise WheelInstallError(
+                    "Encountered a file from {source} with no identifiable target install path: "
+                    "{file}".format(source=wheel.source, file=installed_file.path)
                 )
-            shutil.rmtree(data_path)
+
+            safe_mkdir(os.path.dirname(dst_file))
+            shutil.copy(src_file, dst_file)
+            installed_files.append(
+                InstalledFile(
+                    path=os.path.relpath(dst_file, dest),
+                    hash=installed_file.hash,
+                    size=installed_file.size,
+                )
+            )
+    else:
+        raise AssertionError(reportable_unexpected_error_msg())
 
     if compile:
         args = [
@@ -285,7 +432,7 @@ def install_wheel(
         if process.returncode != 0:
             pex_warnings.warn(
                 "Failed to compile some .py files for install of {wheel} to {dest}:\n"
-                "{stderr}".format(wheel=wheel_path, dest=dest, stderr=stderr.decode("utf-8"))
+                "{stderr}".format(wheel=wheel.source, dest=dest, stderr=stderr.decode("utf-8"))
             )
         for root, _, files in os.walk(commonpath(py_files)):
             for f in files:
@@ -316,8 +463,6 @@ def install_wheel(
         installed_files.append(InstalledFile(path=record_relpath, hash=None, size=None))
         Record.write(dst=record_abspath, installed_files=installed_files)
 
-    return wheel
-
 
 def install_scripts(
     install_paths,  # type: InstallPaths

{pex-2.58.1 → pex-2.59.1}/pex/pip/installation.py

@@ -221,7 +221,7 @@ def _install_wheel(wheel_path):
     with atomic_directory(installed_wheel_dir) as atomic_dir:
         if not atomic_dir.is_finalized():
             installed_wheel = pep_427.install_wheel_chroot(
-                wheel_path=wheel_path, destination=atomic_dir.work_dir
+                wheel=wheel_path, destination=atomic_dir.work_dir
             )
             runtime_key_dir = InstalledWheelDir.create(
                 wheel_name=wheel_name,