PEP660 frontend for editable build

news/612.refactor.md

@@ -0,0 +1 @@
+Build editable packages are into wheels via PEP 660 build backend. Now all installations are unified into wheels.

pdm/builders/base.py

@@ -128,14 +128,18 @@ def __init__(self, executable: str, shared: str, overlay: str) -> None:
 class EnvBuilder:
     """A simple PEP 517 builder for an isolated environment"""
 
-    _shared_envs: dict[int, str] = {}
-    _overlay_envs: dict[str, str] = {}
-
     DEFAULT_BACKEND = {
         "build-backend": "setuptools.build_meta:__legacy__",
         "requires": ["setuptools >= 40.8.0", "wheel"],
     }
 
+    _shared_envs: dict[int, str] = {}
+    _overlay_envs: dict[str, str] = {}
+
+    if TYPE_CHECKING:
+        _hook: Pep517HookCaller
+        _requires: list[str]
+
     @classmethod
     def get_shared_env(cls, key: int) -> str:
         if key in cls._shared_envs:
@@ -164,29 +168,31 @@ def __init__(self, src_dir: str | Path, environment: Environment) -> None:
             spec = {}
         except Exception as e:
             raise BuildError(e) from e
-        self._build_system = spec.get("build-system", self.DEFAULT_BACKEND)
+        build_system = spec.get("build-system", self.DEFAULT_BACKEND)
 
-        if "build-backend" not in self._build_system:
-            self._build_system["build-backend"] = self.DEFAULT_BACKEND["build-backend"]
+        if "build-backend" not in build_system:
+            build_system["build-backend"] = self.DEFAULT_BACKEND["build-backend"]
 
-        if "requires" not in self._build_system:
+        if "requires" not in build_system:
             raise BuildError("Missing 'build-system.requires' in pyproject.toml")
 
-        self._backend = self._build_system["build-backend"]
-
+        self.init_build_system(build_system)
         self._prefix = _Prefix(
             self.executable,
-            shared=self.get_shared_env(hash(frozenset(self._build_system["requires"]))),
+            shared=self.get_shared_env(hash(frozenset(self._requires))),
             overlay=self.get_overlay_env(os.path.normcase(self.src_dir).rstrip("\\/")),
         )
 
+    def init_build_system(self, build_system: dict[str, Any]) -> None:
+        """Initialize the build system and requires list from the PEP 517 spec"""
         self._hook = Pep517HookCaller(
-            src_dir,
-            self._backend,
-            backend_path=self._build_system.get("backend-path"),
+            self.src_dir,
+            build_system["build-backend"],
+            backend_path=build_system.get("backend-path"),
             runner=self.subprocess_runner,
             python_executable=self.executable,
         )
+        self._requires = build_system["requires"]
 
     @property
     def _env_vars(self) -> dict[str, str]:

pdm/builders/editable.py

@@ -1,30 +1,53 @@
 import os
 from typing import Any, Mapping, Optional
 
-from pdm.builders.base import EnvBuilder
-from pdm.exceptions import BuildError
+from pep517.wrappers import HookMissing
 
-_SETUPTOOLS_SHIM = (
-    "import sys, setuptools, tokenize; sys.argv[0] = {0!r}; __file__={0!r};"
-    "f=getattr(tokenize, 'open', open)(__file__);"
-    "code=f.read().replace('\\r\\n', '\\n');"
-    "f.close();"
-    "exec(compile(code, __file__, 'exec'))"
-)
+from pdm.builders.base import EnvBuilder
 
 
 class EditableBuilder(EnvBuilder):
     """Build egg-info in isolated env with managed Python."""
 
-    @staticmethod
-    def _find_egg_info(directory: str) -> str:
-        filename = next(
-            (f for f in os.listdir(directory) if f.endswith(".egg-info")),
-            None,
-        )
-        if not filename:
-            raise BuildError("No egg info is generated.")
-        return filename
+    FALLBACK_BACKEND = {
+        "build-backend": "setuptools_pep660",
+        "requires": ["setuptools_pep660"],
+    }
+
+    def prepare_metadata(
+        self, out_dir: str, config_settings: Optional[Mapping[str, Any]] = None
+    ) -> str:
+        self.install(self._requires, shared=True)
+        try:
+            requires = self._hook.get_requires_for_build_editable(config_settings)
+            self.install(requires)
+            filename = self._hook.prepare_metadata_for_build_editable(
+                out_dir, config_settings
+            )
+        except HookMissing:
+            self.init_build_system(self.FALLBACK_BACKEND)
+            self.ensure_setup_py()
+            return self.prepare_metadata(out_dir, config_settings)
+        return os.path.join(out_dir, filename)
+
+    def build(
+        self,
+        out_dir: str,
+        config_settings: Optional[Mapping[str, Any]] = None,
+        metadata_directory: Optional[str] = None,
+    ) -> str:
+        self.install(self._requires, shared=True)
+        try:
+            requires = self._hook.get_requires_for_build_editable(config_settings)
+            self.install(requires)
+            filename = self._hook.build_editable(
+                out_dir, config_settings, metadata_directory
+            )
+        except HookMissing:
+            self.init_build_system(self.FALLBACK_BACKEND)
+            self.ensure_setup_py()
+            return self.build(out_dir, config_settings, metadata_directory)
+        return os.path.join(out_dir, filename)
 
     def ensure_setup_py(self) -> str:
         from pdm.pep517.base import Builder
@@ -39,14 +62,3 @@ def ensure_setup_py(self) -> str:
             except ValueError:
                 builder._meta = None
         return builder.ensure_setup_py().as_posix()
-
-    def prepare_metadata(
-        self, out_dir: str, config_settings: Optional[Mapping[str, Any]] = None
-    ) -> str:
-        setup_py_path = self.ensure_setup_py()
-        self.install(["setuptools"])
-        args = [self.executable, "-c", _SETUPTOOLS_SHIM.format(setup_py_path)]
-        args.extend(["egg_info", "--egg-base", out_dir])
-        self.subprocess_runner(args, cwd=self.src_dir)
-        filename = self._find_egg_info(out_dir)
-        return os.path.join(out_dir, filename)

pdm/builders/sdist.py

@@ -13,7 +13,7 @@ def build(
         config_settings: Optional[Mapping[str, Any]] = None,
         metadata_directory: Optional[str] = None,
     ) -> str:
-        self.install(self._build_system["requires"], shared=True)
+        self.install(self._requires, shared=True)
         requires = self._hook.get_requires_for_build_sdist(config_settings)
         self.install(requires)
         filename = self._hook.build_sdist(out_dir, config_settings)

pdm/builders/wheel.py

@@ -10,7 +10,7 @@ class WheelBuilder(EnvBuilder):
     def prepare_metadata(
         self, out_dir: str, config_settings: Optional[Mapping[str, Any]] = None
     ) -> str:
-        self.install(self._build_system["requires"], shared=True)
+        self.install(self._requires, shared=True)
         requires = self._hook.get_requires_for_build_wheel(config_settings)
         self.install(requires)
         filename = self._hook.prepare_metadata_for_build_wheel(out_dir, config_settings)
@@ -22,7 +22,7 @@ def build(
         config_settings: Optional[Mapping[str, Any]] = None,
         metadata_directory: Optional[str] = None,
     ) -> str:
-        self.install(self._build_system["requires"], shared=True)
+        self.install(self._requires, shared=True)
         requires = self._hook.get_requires_for_build_wheel(config_settings)
         self.install(requires)
         filename = self._hook.build_wheel(out_dir, config_settings, metadata_directory)