draft: use poetry native dep management for PEP517

Author: abn

src/poetry/inspection/info.py

@@ -4,6 +4,7 @@
 import functools
 import glob
 import logging
+import tempfile
 
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -13,7 +14,7 @@
 
 import pkginfo
 
-from poetry.core.factory import Factory
+from build import BuildBackendException
 from poetry.core.packages.dependency import Dependency
 from poetry.core.packages.package import Package
 from poetry.core.pyproject.toml import PyProjectTOML
@@ -22,9 +23,9 @@
 from poetry.core.version.markers import InvalidMarker
 from poetry.core.version.requirements import InvalidRequirement
 
-from poetry.utils.env import EnvCommandError
-from poetry.utils.env import ephemeral_environment
+from poetry.factory import Factory
 from poetry.utils.helpers import extractall
+from poetry.utils.pep517_build import pep517_builder
 from poetry.utils.setup_reader import SetupReader
 
 
@@ -38,25 +39,6 @@
 
 logger = logging.getLogger(__name__)
 
-PEP517_META_BUILD = """\
-import build
-import build.env
-import pyproject_hooks
-
-source = '{source}'
-dest = '{dest}'
-
-with build.env.DefaultIsolatedEnv() as env:
-    builder = build.ProjectBuilder.from_isolated_env(
-        env, source, runner=pyproject_hooks.quiet_subprocess_runner
-    )
-    env.install(builder.build_system_requires)
-    env.install(builder.get_requires_for_build('wheel'))
-    builder.metadata_path(dest)
-"""
-
-PEP517_META_BUILD_DEPS = ["build==1.1.1", "pyproject_hooks==1.0.0"]
-
 
 class PackageInfoError(ValueError):
     def __init__(self, path: Path, *reasons: BaseException | str) -> None:
@@ -577,28 +559,15 @@ def get_pep517_metadata(path: Path) -> PackageInfo:
         if all(x is not None for x in (info.version, info.name, info.requires_dist)):
             return info
 
-    with ephemeral_environment(
-        flags={"no-pip": False, "no-setuptools": True, "no-wheel": True}
-    ) as venv:
-        # TODO: cache PEP 517 build environment corresponding to each project venv
-        dest_dir = venv.path.parent / "dist"
-        dest_dir.mkdir()
+    with tempfile.TemporaryDirectory() as dist:
+        try:
+            dest = Path(dist)
 
-        pep517_meta_build_script = PEP517_META_BUILD.format(
-            source=path.as_posix(), dest=dest_dir.as_posix()
-        )
+            with pep517_builder(path, "wheel") as builder:
+                builder.metadata_path(dest)
 
-        try:
-            venv.run_pip(
-                "install",
-                "--disable-pip-version-check",
-                "--ignore-installed",
-                "--no-input",
-                *PEP517_META_BUILD_DEPS,
-            )
-            venv.run_python_script(pep517_meta_build_script)
-            info = PackageInfo.from_metadata_directory(dest_dir)
-        except EnvCommandError as e:
+            info = PackageInfo.from_metadata_directory(dest)
+        except BuildBackendException as e:
             logger.debug("PEP517 build failed: %s", e)
             raise PackageInfoError(path, e, "PEP517 build failed")
 

src/poetry/installation/chef.py

@@ -1,27 +1,20 @@
 from __future__ import annotations
 
-import os
 import tempfile
 
-from contextlib import redirect_stdout
-from io import StringIO
 from pathlib import Path
 from typing import TYPE_CHECKING
 
 from build import BuildBackendException
-from build import ProjectBuilder
-from build.env import IsolatedEnv as BaseIsolatedEnv
 from poetry.core.utils.helpers import temporary_directory
-from pyproject_hooks import quiet_subprocess_runner  # type: ignore[import-untyped]
 
 from poetry.utils._compat import decode
-from poetry.utils.env import ephemeral_environment
 from poetry.utils.helpers import extractall
+from poetry.utils.pep517_build import PEP517BuildError
+from poetry.utils.pep517_build import pep517_builder
 
 
 if TYPE_CHECKING:
-    from collections.abc import Collection
-
     from poetry.repositories import RepositoryPool
     from poetry.utils.cache import ArtifactCache
     from poetry.utils.env import Env
@@ -30,78 +23,6 @@
 class ChefError(Exception): ...
 
 
-class ChefBuildError(ChefError): ...
-
-
-class ChefInstallError(ChefError):
-    def __init__(self, requirements: Collection[str], output: str, error: str) -> None:
-        message = "\n\n".join(
-            (
-                f"Failed to install {', '.join(requirements)}.",
-                f"Output:\n{output}",
-                f"Error:\n{error}",
-            )
-        )
-        super().__init__(message)
-        self._requirements = requirements
-
-    @property
-    def requirements(self) -> Collection[str]:
-        return self._requirements
-
-
-class IsolatedEnv(BaseIsolatedEnv):
-    def __init__(self, env: Env, pool: RepositoryPool) -> None:
-        self._env = env
-        self._pool = pool
-
-    @property
-    def python_executable(self) -> str:
-        return str(self._env.python)
-
-    def make_extra_environ(self) -> dict[str, str]:
-        path = os.environ.get("PATH")
-        scripts_dir = str(self._env._bin_dir)
-        return {
-            "PATH": (
-                os.pathsep.join([scripts_dir, path])
-                if path is not None
-                else scripts_dir
-            )
-        }
-
-    def install(self, requirements: Collection[str]) -> None:
-        from cleo.io.buffered_io import BufferedIO
-        from poetry.core.packages.dependency import Dependency
-        from poetry.core.packages.project_package import ProjectPackage
-
-        from poetry.config.config import Config
-        from poetry.installation.installer import Installer
-        from poetry.packages.locker import Locker
-        from poetry.repositories.installed_repository import InstalledRepository
-
-        # We build Poetry dependencies from the requirements
-        package = ProjectPackage("__root__", "0.0.0")
-        package.python_versions = ".".join(str(v) for v in self._env.version_info[:3])
-        for requirement in requirements:
-            dependency = Dependency.create_from_pep_508(requirement)
-            package.add_dependency(dependency)
-
-        io = BufferedIO()
-        installer = Installer(
-            io,
-            self._env,
-            package,
-            Locker(self._env.path.joinpath("poetry.lock"), {}),
-            self._pool,
-            Config.create(),
-            InstalledRepository.load(self._env),
-        )
-        installer.update(True)
-        if installer.run() != 0:
-            raise ChefInstallError(requirements, io.fetch_output(), io.fetch_error())
-
-
 class Chef:
     def __init__(
         self, artifact_cache: ArtifactCache, env: Env, pool: RepositoryPool
@@ -127,46 +48,36 @@ def _prepare(
     ) -> Path:
         from subprocess import CalledProcessError
 
-        with ephemeral_environment(
-            self._env.python,
-            flags={"no-pip": True, "no-setuptools": True, "no-wheel": True},
-        ) as venv:
-            env = IsolatedEnv(venv, self._pool)
-            builder = ProjectBuilder.from_isolated_env(
-                env, directory, runner=quiet_subprocess_runner
-            )
-            env.install(builder.build_system_requires)
-
-            stdout = StringIO()
-            error: Exception | None = None
-            try:
-                with redirect_stdout(stdout):
-                    dist_format = "wheel" if not editable else "editable"
-                    env.install(
-                        builder.build_system_requires
-                        | builder.get_requires_for_build(dist_format)
-                    )
-                    path = Path(
-                        builder.build(
-                            dist_format,
-                            destination.as_posix(),
-                        )
+        distribution = "wheel" if not editable else "editable"
+        error: Exception | None = None
+
+        try:
+            with pep517_builder(
+                source=directory,
+                distribution=distribution,
+                python_executable=self._env.python,
+                pool=self._pool,
+            ) as builder:
+                return Path(
+                    builder.build(
+                        distribution,
+                        destination.as_posix(),
                     )
-            except BuildBackendException as e:
-                message_parts = [str(e)]
-                if isinstance(e.exception, CalledProcessError):
-                    text = e.exception.stderr or e.exception.stdout
-                    if text is not None:
-                        message_parts.append(decode(text))
-                else:
-                    message_parts.append(str(e.exception))
+                )
+        except BuildBackendException as e:
+            message_parts = [str(e)]
 
-                error = ChefBuildError("\n\n".join(message_parts))
+            if isinstance(e.exception, CalledProcessError):
+                text = e.exception.stderr or e.exception.stdout
+                if text is not None:
+                    message_parts.append(decode(text))
+            else:
+                message_parts.append(str(e.exception))
 
-            if error is not None:
-                raise error from None
+            error = PEP517BuildError("\n\n".join(message_parts))
 
-            return path
+        if error is not None:
+            raise error from None
 
     def _prepare_sdist(self, archive: Path, destination: Path | None = None) -> Path:
         from poetry.core.packages.utils.link import Link

src/poetry/installation/executor.py

@@ -18,8 +18,6 @@
 from poetry.core.packages.utils.link import Link
 
 from poetry.installation.chef import Chef
-from poetry.installation.chef import ChefBuildError
-from poetry.installation.chef import ChefInstallError
 from poetry.installation.chooser import Chooser
 from poetry.installation.operations import Install
 from poetry.installation.operations import Uninstall
@@ -34,6 +32,8 @@
 from poetry.utils.helpers import get_highest_priority_hash_type
 from poetry.utils.helpers import pluralize
 from poetry.utils.helpers import remove_directory
+from poetry.utils.pep517_build import PEP517BuildError
+from poetry.utils.pep517_build import PEP517InstallError
 from poetry.utils.pip import pip_install
 
 
@@ -310,7 +310,7 @@ def _execute_operation(self, operation: Operation) -> None:
                     trace = ExceptionTrace(e)
                     trace.render(io)
                     pkg = operation.package
-                    if isinstance(e, ChefBuildError):
+                    if isinstance(e, PEP517BuildError):
                         pip_command = "pip wheel --no-cache-dir --use-pep517"
                         if pkg.develop:
                             requirement = pkg.source_url
@@ -328,7 +328,7 @@ def _execute_operation(self, operation: Operation) -> None:
                             f" running '{pip_command} \"{requirement}\"'."
                             "</info>"
                         )
-                    elif isinstance(e, ChefInstallError):
+                    elif isinstance(e, PEP517InstallError):
                         message = (
                             "<error>"
                             "Cannot install build-system.requires"