Use pkg_resources.Distribution derived from wheel directly

We now extract all metadata files from the wheel directly into memory
and make them available to the wrapping pkg_resources.Distribution via
the DictMetadata introduced earlier.

Author: chrahunt

src/pip/_internal/distributions/wheel.py

@@ -1,7 +1,8 @@
-from pip._vendor import pkg_resources
+from zipfile import ZipFile
 
 from pip._internal.distributions.base import AbstractDistribution
 from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.wheel import pkg_resources_distribution_for_wheel
 
 if MYPY_CHECK_RUNNING:
     from pip._vendor.pkg_resources import Distribution
@@ -16,8 +17,15 @@ class WheelDistribution(AbstractDistribution):
 
     def get_pkg_resources_distribution(self):
         # type: () -> Distribution
-        return list(pkg_resources.find_distributions(
-                    self.req.source_dir))[0]
+        # Set as part of preparation during download.
+        assert self.req.local_file_path
+        # Wheels are never unnamed.
+        assert self.req.name
+
+        with ZipFile(self.req.local_file_path, allowZip64=True) as z:
+            return pkg_resources_distribution_for_wheel(
+                z, self.req.name, self.req.local_file_path
+            )
 
     def prepare_distribution_metadata(self, finder, build_isolation):
         # type: (PackageFinder, bool) -> None

src/pip/_internal/utils/wheel.py

@@ -8,14 +8,18 @@
 from zipfile import ZipFile
 
 from pip._vendor.packaging.utils import canonicalize_name
+from pip._vendor.pkg_resources import DistInfoDistribution
 from pip._vendor.six import PY2, ensure_str
 
 from pip._internal.exceptions import UnsupportedWheel
+from pip._internal.utils.pkg_resources import DictMetadata
 from pip._internal.utils.typing import MYPY_CHECK_RUNNING
 
 if MYPY_CHECK_RUNNING:
     from email.message import Message
-    from typing import Tuple
+    from typing import Dict, Tuple
+
+    from pip._vendor.pkg_resources import Distribution
 
 if PY2:
     from zipfile import BadZipfile as BadZipFile
@@ -29,6 +33,65 @@
 logger = logging.getLogger(__name__)
 
 
+class WheelMetadata(DictMetadata):
+    """Metadata provider that maps metadata decoding exceptions to our
+    internal exception type.
+    """
+    def __init__(self, metadata, wheel_name):
+        # type: (Dict[str, bytes], str) -> None
+        super(WheelMetadata, self).__init__(metadata)
+        self._wheel_name = wheel_name
+
+    def get_metadata(self, name):
+        # type: (str) -> str
+        try:
+            return super(WheelMetadata, self).get_metadata(name)
+        except UnicodeDecodeError as e:
+            # Augment the default error with the origin of the file.
+            raise UnsupportedWheel(
+                "Error decoding metadata for {}: {}".format(
+                    self._wheel_name, e
+                )
+            )
+
+
+def pkg_resources_distribution_for_wheel(wheel_zip, name, location):
+    # type: (ZipFile, str, str) -> Distribution
+    """Get a pkg_resources distribution given a wheel.
+
+    :raises UnsupportedWheel: on any errors
+    """
+    info_dir, _ = parse_wheel(wheel_zip, name)
+
+    metadata_files = [
+        p for p in wheel_zip.namelist() if p.startswith("{}/".format(info_dir))
+    ]
+
+    metadata_text = {}  # type: Dict[str, bytes]
+    for path in metadata_files:
+        # If a flag is set, namelist entries may be unicode in Python 2.
+        # We coerce them to native str type to match the types used in the rest
+        # of the code. This cannot fail because unicode can always be encoded
+        # with UTF-8.
+        full_path = ensure_str(path)
+        _, metadata_name = full_path.split("/", 1)
+
+        try:
+            metadata_text[metadata_name] = read_wheel_metadata_file(
+                wheel_zip, full_path
+            )
+        except UnsupportedWheel as e:
+            raise UnsupportedWheel(
+                "{} has an invalid wheel, {}".format(name, str(e))
+            )
+
+    metadata = WheelMetadata(metadata_text, location)
+
+    return DistInfoDistribution(
+        location=location, metadata=metadata, project_name=name
+    )
+
+
 def parse_wheel(wheel_zip, name):
     # type: (ZipFile, str) -> Tuple[str, Message]
     """Extract information from the provided wheel, ensuring it meets basic

tests/functional/test_install_wheel.py

@@ -534,3 +534,34 @@ def test_wheel_installs_ok_with_nested_dist_info(script):
     script.pip(
         "install", "--no-cache-dir", "--no-index", package
     )
+
+
+def test_wheel_installs_ok_with_badly_encoded_irrelevant_metadata(script):
+    package = create_basic_wheel_for_package(
+        script,
+        "simple",
+        "0.1.0",
+        extra_files={
+            "simple-0.1.0.dist-info/AUTHORS.txt": b"\xff"
+        },
+    )
+    script.pip(
+        "install", "--no-cache-dir", "--no-index", package
+    )
+
+
+def test_wheel_install_fails_with_badly_encoded_metadata(script):
+    package = create_basic_wheel_for_package(
+        script,
+        "simple",
+        "0.1.0",
+        extra_files={
+            "simple-0.1.0.dist-info/METADATA": b"\xff"
+        },
+    )
+    result = script.pip(
+        "install", "--no-cache-dir", "--no-index", package, expect_error=True
+    )
+    assert "Error decoding metadata for" in result.stderr
+    assert "simple-0.1.0-py2.py3-none-any.whl" in result.stderr
+    assert "METADATA" in result.stderr

tests/lib/__init__.py

@@ -15,7 +15,7 @@
 from zipfile import ZipFile
 
 import pytest
-from pip._vendor.six import PY2
+from pip._vendor.six import PY2, ensure_binary
 from scripttest import FoundDir, TestFileEnvironment
 
 from pip._internal.index.collector import LinkCollector
@@ -1018,9 +1018,6 @@ def hello():
         "{dist_info}/RECORD": ""
     }
 
-    if extra_files:
-        files.update(extra_files)
-
     # Some useful shorthands
     archive_name = "{name}-{version}-py2.py3-none-any.whl".format(
         name=name, version=version
@@ -1046,10 +1043,14 @@ def hello():
             name=name, version=version, requires_dist=requires_dist
         ).strip()
 
+    # Add new files after formatting
+    if extra_files:
+        files.update(extra_files)
+
     for fname in files:
         path = script.temp_path / fname
         path.parent.mkdir(exist_ok=True, parents=True)
-        path.write_text(files[fname])
+        path.write_bytes(ensure_binary(files[fname]))
 
     retval = script.scratch_path / archive_name
     generated = shutil.make_archive(retval, 'zip', script.temp_path)