fixup! ae0bda5

src/pip/_internal/distributions/sdist.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Set, Tuple
+from typing import Iterable, Set, Tuple
 
 from pip._internal.build_env import BuildEnvironment
 from pip._internal.distributions.base import AbstractDistribution
@@ -37,23 +37,17 @@ def prepare_distribution_metadata(
  self.req.prepare_metadata()
 
  def _setup_isolation(self, finder: PackageFinder) -> None:
- def _raise_conflicts(
- conflicting_with: str, conflicting_reqs: Set[Tuple[str, str]]
- ) -> None:
- format_string = (
- "Some build dependencies for {requirement} "
- "conflict with {conflicting_with}: {description}."
- )
- error_message = format_string.format(
- requirement=self.req,
- conflicting_with=conflicting_with,
- description=", ".join(
- f"{installed} is incompatible with {wanted}"
- for installed, wanted in sorted(conflicting)
- ),
- )
- raise InstallationError(error_message)
+ self._prepare_build_backend(finder)
+ # Install any extra build dependencies that the backend requests.
+ # This must be done in a second pass, as the pyproject.toml
+ # dependencies must be installed before we can call the backend.
+ if self.req.editable and not self.req.no_build_editable:
+ build_reqs = self._get_build_requires_editable()
+ else:
+ build_reqs = self._get_build_requires_wheel()
+ self._install_build_reqs(finder, build_reqs)
 
+ def _prepare_build_backend(self, finder: PackageFinder) -> None:
  # Isolate in a BuildEnvironment and install the build-time
  # requirements.
  pyproject_requires = self.req.pyproject_requires
@@ -67,7 +61,7 @@ def _raise_conflicts(
  self.req.requirements_to_check
  )
  if conflicting:
- _raise_conflicts("PEP 517/518 supported requirements", conflicting)
+ self._raise_conflicts("PEP 517/518 supported requirements", conflicting)
  if missing:
  logger.warning(
  "Missing build requirements in pyproject.toml for %s.",
@@ -78,26 +72,46 @@ def _raise_conflicts(
  "pip cannot fall back to setuptools without %s.",
  " and ".join(map(repr, sorted(missing))),
  )
- # Install any extra build dependencies that the backend requests.
- # This must be done in a second pass, as the pyproject.toml
- # dependencies must be installed before we can call the backend.
+
+ def _get_build_requires_wheel(self) -> Iterable[str]:
+ with self.req.build_env:
+ runner = runner_with_spinner_message("Getting requirements to build wheel")
+ backend = self.req.pep517_backend
+ assert backend is not None
+ with backend.subprocess_runner(runner):
+ return backend.get_requires_for_build_wheel()
+
+ def _get_build_requires_editable(self) -> Iterable[str]:
  with self.req.build_env:
  runner = runner_with_spinner_message(
- "Getting requirements to build {}".format(
- "editable" if self.req.editable else "wheel"
- )
+ "Getting requirements to build editable"
  )
  backend = self.req.pep517_backend
  assert backend is not None
  with backend.subprocess_runner(runner):
- if self.req.editable and not self.req.no_build_editable:
- reqs = backend.get_requires_for_build_editable()
- else:
- reqs = backend.get_requires_for_build_wheel()
+ return backend.get_requires_for_build_editable()
 
+ def _install_build_reqs(self, finder: PackageFinder, reqs: Iterable[str]) -> None:
  conflicting, missing = self.req.build_env.check_requirements(reqs)
  if conflicting:
- _raise_conflicts("the backend dependencies", conflicting)
+ self._raise_conflicts("the backend dependencies", conflicting)
  self.req.build_env.install_requirements(
  finder, missing, "normal", "Installing backend dependencies"
  )
+
+ def _raise_conflicts(
+ self, conflicting_with: str, conflicting_reqs: Set[Tuple[str, str]]
+ ) -> None:
+ format_string = (
+ "Some build dependencies for {requirement} "
+ "conflict with {conflicting_with}: {description}."
+ )
+ error_message = format_string.format(
+ requirement=self.req,
+ conflicting_with=conflicting_with,
+ description=", ".join(
+ f"{installed} is incompatible with {wanted}"
+ for installed, wanted in sorted(conflicting_reqs)
+ ),
+ )
+ raise InstallationError(error_message)

src/pip/_internal/operations/build/metadata.py

@@ -10,10 +10,8 @@
 from pip._internal.utils.temp_dir import TempDirectory
 
 
-def generate_metadata(
- build_env: BuildEnvironment, backend: Pep517HookCaller, editable: bool
-) -> str:
- """Generate metadata using mechanisms described in PEP 517 and PEP 660.
+def generate_metadata(build_env: BuildEnvironment, backend: Pep517HookCaller) -> str:
+ """Generate metadata using mechanisms described in PEP 517.
 
  Returns the generated metadata directory.
  """
@@ -23,15 +21,10 @@ def generate_metadata(
 
  with build_env:
  # Note that Pep517HookCaller implements a fallback for
- # prepare_metadata_for_build_wheel/editable, so we don't have to
+ # prepare_metadata_for_build_wheel, so we don't have to
  # consider the possibility that this hook doesn't exist.
- runner = runner_with_spinner_message(
- "Preparing {} metadata".format("editable" if editable else "wheel")
- )
+ runner = runner_with_spinner_message("Preparing wheel metadata")
  with backend.subprocess_runner(runner):
- if editable:
- distinfo_dir = backend.prepare_metadata_for_build_editable(metadata_dir)
- else:
- distinfo_dir = backend.prepare_metadata_for_build_wheel(metadata_dir)
+ distinfo_dir = backend.prepare_metadata_for_build_wheel(metadata_dir)
 
  return os.path.join(metadata_dir, distinfo_dir)

src/pip/_internal/operations/build/metadata_editable.py

@@ -0,0 +1,32 @@
+"""Metadata generation logic for source distributions.
+"""
+
+import os
+
+from pip._vendor.pep517.wrappers import Pep517HookCaller
+
+from pip._internal.build_env import BuildEnvironment
+from pip._internal.utils.subprocess import runner_with_spinner_message
+from pip._internal.utils.temp_dir import TempDirectory
+
+
+def generate_editable_metadata(
+ build_env: BuildEnvironment, backend: Pep517HookCaller
+) -> str:
+ """Generate metadata using mechanisms described in PEP 517 and PEP 660.
+
+ Returns the generated metadata directory.
+ """
+ metadata_tmpdir = TempDirectory(kind="modern-metadata", globally_managed=True)
+
+ metadata_dir = metadata_tmpdir.path
+
+ with build_env:
+ # Note that Pep517HookCaller implements a fallback for
+ # prepare_metadata_for_build_wheel/editable, so we don't have to
+ # consider the possibility that this hook doesn't exist.
+ runner = runner_with_spinner_message("Preparing editable metadata")
+ with backend.subprocess_runner(runner):
+ distinfo_dir = backend.prepare_metadata_for_build_editable(metadata_dir)
+
+ return os.path.join(metadata_dir, distinfo_dir)

src/pip/_internal/operations/build/wheel.py

@@ -2,7 +2,7 @@
 import os
 from typing import Optional
 
-from pip._vendor.pep517.wrappers import HookMissing, Pep517HookCaller
+from pip._vendor.pep517.wrappers import Pep517HookCaller
 
 from pip._internal.utils.subprocess import runner_with_spinner_message
 
@@ -14,7 +14,6 @@ def build_wheel_pep517(
  backend: Pep517HookCaller,
  metadata_directory: str,
  tempd: str,
- editable: bool,
 ) -> Optional[str]:
  """Build one InstallRequirement using the PEP 517 build process.
 
@@ -24,33 +23,13 @@ def build_wheel_pep517(
  try:
  logger.debug("Destination directory: %s", tempd)
 
- artifact = "editable" if editable else "wheel"
- pep = "660" if editable else "517"
- runner = runner_with_spinner_message(
- f"Building {artifact} for {name} (PEP {pep})"
- )
+ runner = runner_with_spinner_message(f"Building wheel for {name} (PEP 517)")
  with backend.subprocess_runner(runner):
- if editable:
- try:
- wheel_name = backend.build_editable(
- tempd,
- metadata_directory=metadata_directory,
- )
- except HookMissing as e:
- logger.warning(
- "Cannot build %s %s because the build "
- "backend does not have the %s hook",
- artifact,
- name,
- e,
- )
- return None
- else:
- wheel_name = backend.build_wheel(
- tempd,
- metadata_directory=metadata_directory,
- )
+ wheel_name = backend.build_wheel(
+ tempd,
+ metadata_directory=metadata_directory,
+ )
  except Exception:
- logger.exception("Failed building %s for %s", artifact, name, exc_info=True)
+ logger.error("Failed building wheel for %s", name)
  return None
  return os.path.join(tempd, wheel_name)

src/pip/_internal/operations/build/wheel_editable.py

@@ -0,0 +1,46 @@
+import logging
+import os
+from typing import Optional
+
+from pip._vendor.pep517.wrappers import HookMissing, Pep517HookCaller
+
+from pip._internal.utils.subprocess import runner_with_spinner_message
+
+logger = logging.getLogger(__name__)
+
+
+def build_editable_pep660(
+ name: str,
+ backend: Pep517HookCaller,
+ metadata_directory: str,
+ tempd: str,
+) -> Optional[str]:
+ """Build one InstallRequirement using the PEP 660 build process.
+
+ Returns path to wheel if successfully built. Otherwise, returns None.
+ """
+ assert metadata_directory is not None
+ try:
+ logger.debug("Destination directory: %s", tempd)
+
+ runner = runner_with_spinner_message(
+ f"Building editable for {name} (pyproject.toml)"
+ )
+ with backend.subprocess_runner(runner):
+ try:
+ wheel_name = backend.build_editable(
+ tempd,
+ metadata_directory=metadata_directory,
+ )
+ except HookMissing as e:
+ logger.warning(
+ "Cannot build editable %s because the build "
+ "backend does not have the %s hook",
+ name,
+ e,
+ )
+ return None
+ except Exception:
+ logger.error("Failed building editable for %s", name)
+ return None
+ return os.path.join(tempd, wheel_name)

src/pip/_internal/req/req_install.py

@@ -24,6 +24,7 @@
 from pip._internal.locations import get_scheme
 from pip._internal.models.link import Link
 from pip._internal.operations.build.metadata import generate_metadata
+from pip._internal.operations.build.metadata_editable import generate_editable_metadata
 from pip._internal.operations.build.metadata_legacy import (
  generate_metadata as generate_metadata_legacy,
 )
@@ -195,7 +196,8 @@ def __init__(
  # Setting an explicit value before loading pyproject.toml is supported,
  # but after loading this flag should be treated as read only.
  self.use_pep517 = use_pep517
- # Supports_pep660 will be set to True or False when we try to prepare
+
+ # supports_pep660 will be set to True or False when we try to prepare
  # editable metadata or build an editable wheel. None means "we don't know yet".
  self.supports_pep660: Optional[bool] = None
 
@@ -501,18 +503,15 @@ def load_pyproject_toml(self) -> None:
  backend_path=backend_path,
  )
 
- def _generate_metadata_for_editable(self) -> str:
+ def _generate_editable_metadata(self) -> str:
  """Invokes metadata generator functions, with the required arguments."""
  if self.use_pep517:
  assert self.pep517_backend is not None
  try:
- metadata_directory = generate_metadata(
+ metadata_directory = generate_editable_metadata(
  build_env=self.build_env,
  backend=self.pep517_backend,
- editable=True,
  )
- self.supports_pep660 = True
- return metadata_directory
  except HookMissing as e:
  self.supports_pep660 = False
  if not os.path.exists(self.setup_py_path) and not os.path.exists(
@@ -528,6 +527,9 @@ def _generate_metadata_for_editable(self) -> str:
  # At this point we have determined that the build_editable hook
  # is missing, and there is a setup.py or setup.cfg
  # so we fallback to the legacy metadata generation
+ else:
+ self.supports_pep660 = True
+ return metadata_directory
  else:
  if not os.path.exists(self.setup_py_path) and not os.path.exists(
  self.setup_cfg_path
@@ -554,7 +556,6 @@ def _generate_metadata(self) -> str:
  return generate_metadata(
  build_env=self.build_env,
  backend=self.pep517_backend,
- editable=False,
  )
  except HookMissing as e:
  raise InstallationError(
@@ -584,7 +585,7 @@ def prepare_metadata(self) -> None:
 
  with indent_log():
  if self.editable and not self.no_build_editable:
- self.metadata_directory = self._generate_metadata_for_editable()
+ self.metadata_directory = self._generate_editable_metadata()
  else:
  self.metadata_directory = self._generate_metadata()
 

src/pip/_internal/wheel_builder.py

@@ -16,6 +16,7 @@
 from pip._internal.models.link import Link
 from pip._internal.models.wheel import Wheel
 from pip._internal.operations.build.wheel import build_wheel_pep517
+from pip._internal.operations.build.wheel_editable import build_editable_pep660
 from pip._internal.operations.build.wheel_legacy import build_wheel_legacy
 from pip._internal.req.req_install import InstallRequirement
 from pip._internal.utils.logging import indent_log
@@ -252,13 +253,20 @@ def _build_one_inside_env(
  logger.warning(
  "Ignoring --build-option when building %s using PEP 517", req.name
  )
- wheel_path = build_wheel_pep517(
- name=req.name,
- backend=req.pep517_backend,
- metadata_directory=req.metadata_directory,
- tempd=temp_dir.path,
- editable=editable,
- )
+ if editable:
+ wheel_path = build_editable_pep660(
+ name=req.name,
+ backend=req.pep517_backend,
+ metadata_directory=req.metadata_directory,
+ tempd=temp_dir.path,
+ )
+ else:
+ wheel_path = build_wheel_pep517(
+ name=req.name,
+ backend=req.pep517_backend,
+ metadata_directory=req.metadata_directory,
+ tempd=temp_dir.path,
+ )
  else:
  wheel_path = build_wheel_legacy(
  name=req.name,