PEP-660 support (#21)

Author: gaborbernat

docs/changelog.rst

@@ -1,6 +1,10 @@
 Release History
 ===============
 
+v1.1.0 - (2022-09-10)
+---------------------
+- PEP-660 support
+
 v1.0.0 - (2022-09-10)
 ---------------------
 - Use hatchling as build backend

pyproject.toml

@@ -65,9 +65,9 @@ html.show_contexts = true
 html.skip_covered = false
 paths.source = [
   "src",
-  ".pyproject_api*/*/lib/python*/site-packages",
-  ".pyproject_api*/pypy*/site-packages",
-  ".pyproject_api*\\*\\Lib\\site-packages",
+  ".tox*/*/lib/python*/site-packages",
+  ".tox*/pypy*/site-packages",
+  ".tox*\\*\\Lib\\site-packages",
   "*/src",
   "*\\src",
 ]

src/pyproject_api/_frontend.py

@@ -59,6 +59,17 @@ class RequiresBuildWheelResult(NamedTuple):
     err: str
 
 
+class RequiresBuildEditableResult(NamedTuple):
+    """Information collected while acquiring the wheel build dependencies"""
+
+    #: editable wheel build dependencies
+    requires: tuple[Requirement, ...]
+    #: backend standard output while acquiring the editable wheel build dependencies
+    out: str
+    #: backend standard error while acquiring the editable wheel build dependencies
+    err: str
+
+
 class MetadataForBuildWheelResult(NamedTuple):
     """Information collected while acquiring the wheel metadata"""
 
@@ -70,6 +81,17 @@ class MetadataForBuildWheelResult(NamedTuple):
     err: str
 
 
+class MetadataForBuildEditableResult(NamedTuple):
+    """Information collected while acquiring the editable metadata"""
+
+    #: path to the wheel metadata
+    metadata: Path
+    #: backend standard output while generating the editable wheel metadata
+    out: str
+    #: backend standard output while generating the editable wheel metadata
+    err: str
+
+
 class SdistResult(NamedTuple):
     """Information collected while building a source distribution"""
 
@@ -92,6 +114,17 @@ class WheelResult(NamedTuple):
     err: str
 
 
+class EditableResult(NamedTuple):
+    """Information collected while building an editable wheel"""
+
+    #: path to the built wheel artifact
+    wheel: Path
+    #: backend standard output while building the wheel
+    out: str
+    #: backend standard error while building the wheel
+    err: str
+
+
 class BackendFailed(RuntimeError):
     """An error of the build backend."""
 
@@ -240,6 +273,23 @@ def get_requires_for_build_wheel(self, config_settings: ConfigSettings | None =
             self._unexpected_response("get_requires_for_build_wheel", result, "list of string", out, err)
         return RequiresBuildWheelResult(tuple(Requirement(r) for r in cast(List[str], result)), out, err)
 
+    def get_requires_for_build_editable(
+        self, config_settings: ConfigSettings | None = None
+    ) -> RequiresBuildEditableResult:
+        """
+        Get build requirements for an editable wheel build (per PEP-660).
+
+        :param config_settings: run arguments
+        :return: outcome
+        """
+        try:
+            result, out, err = self._send(cmd="get_requires_for_build_editable", config_settings=config_settings)
+        except BackendFailed as exc:
+            result, out, err = [], exc.out, exc.err
+        if not isinstance(result, list) or not all(isinstance(i, str) for i in result):
+            self._unexpected_response("get_requires_for_build_editable", result, "list of string", out, err)
+        return RequiresBuildEditableResult(tuple(Requirement(r) for r in cast(List[str], result)), out, err)
+
     def prepare_metadata_for_build_wheel(
         self, metadata_directory: Path, config_settings: ConfigSettings | None = None
     ) -> MetadataForBuildWheelResult:
@@ -250,24 +300,52 @@ def prepare_metadata_for_build_wheel(
         :param config_settings: build arguments
         :return: metadata generation result
         """
+        self._check_metadata_dir(metadata_directory)
+        try:
+            basename, out, err = self._send(
+                cmd="prepare_metadata_for_build_wheel",
+                metadata_directory=metadata_directory,
+                config_settings=config_settings,
+            )
+        except BackendFailed:
+            # if backend does not provide it acquire it from the wheel
+            basename, err, out = self._metadata_from_built_wheel(config_settings, metadata_directory, "build_wheel")
+        if not isinstance(basename, str):
+            self._unexpected_response("prepare_metadata_for_build_wheel", basename, str, out, err)
+        result = metadata_directory / basename
+        return MetadataForBuildWheelResult(result, out, err)
+
+    def _check_metadata_dir(self, metadata_directory: Path) -> None:
         if metadata_directory == self._root:
             raise RuntimeError(f"the project root and the metadata directory can't be the same {self._root}")
         if metadata_directory.exists():  # start with fresh
             ensure_empty_dir(metadata_directory)
         metadata_directory.mkdir(parents=True, exist_ok=True)
+
+    def prepare_metadata_for_build_editable(
+        self, metadata_directory: Path, config_settings: ConfigSettings | None = None
+    ) -> MetadataForBuildEditableResult:
+        """
+        Build editable wheel metadata (per PEP-660).
+
+        :param metadata_directory: where to generate the metadata
+        :param config_settings: build arguments
+        :return: metadata generation result
+        """
+        self._check_metadata_dir(metadata_directory)
         try:
             basename, out, err = self._send(
-                cmd="prepare_metadata_for_build_wheel",
+                cmd="prepare_metadata_for_build_editable",
                 metadata_directory=metadata_directory,
                 config_settings=config_settings,
             )
         except BackendFailed:
             # if backend does not provide it acquire it from the wheel
-            basename, err, out = self._metadata_from_built_wheel(config_settings, metadata_directory)
+            basename, err, out = self._metadata_from_built_wheel(config_settings, metadata_directory, "build_editable")
         if not isinstance(basename, str):
             self._unexpected_response("prepare_metadata_for_build_wheel", basename, str, out, err)
         result = metadata_directory / basename
-        return MetadataForBuildWheelResult(result, out, err)
+        return MetadataForBuildEditableResult(result, out, err)
 
     def build_sdist(self, sdist_directory: Path, config_settings: ConfigSettings | None = None) -> SdistResult:
         """
@@ -294,7 +372,7 @@ def build_wheel(
         metadata_directory: Path | None = None,
     ) -> WheelResult:
         """
-        Build a source distribution (per PEP-517).
+        Build a wheel file (per PEP-517).
 
         :param wheel_directory: the folder where to build the wheel
         :param config_settings: build arguments
@@ -312,15 +390,40 @@ def build_wheel(
             self._unexpected_response("build_wheel", basename, str, out, err)
         return WheelResult(wheel_directory / basename, out, err)
 
+    def build_editable(
+        self,
+        wheel_directory: Path,
+        config_settings: ConfigSettings | None = None,
+        metadata_directory: Path | None = None,
+    ) -> EditableResult:
+        """
+        Build an editable wheel file (per PEP-660).
+
+        :param wheel_directory: the folder where to build the editable wheel
+        :param config_settings: build arguments
+        :param metadata_directory: wheel metadata folder
+        :return: wheel build result
+        """
+        wheel_directory.mkdir(parents=True, exist_ok=True)
+        basename, out, err = self._send(
+            cmd="build_editable",
+            wheel_directory=wheel_directory,
+            config_settings=config_settings,
+            metadata_directory=metadata_directory,
+        )
+        if not isinstance(basename, str):
+            self._unexpected_response("build_editable", basename, str, out, err)
+        return EditableResult(wheel_directory / basename, out, err)
+
     def _unexpected_response(self, cmd: str, got: Any, expected_type: Any, out: str, err: str) -> NoReturn:
         msg = f"{cmd!r} on {self.backend!r} returned {got!r} but expected type {expected_type!r}"
         raise BackendFailed({"code": None, "exc_type": TypeError.__name__, "exc_msg": msg}, out, err)
 
     def _metadata_from_built_wheel(
-        self, config_settings: ConfigSettings | None, metadata_directory: Path | None
+        self, config_settings: ConfigSettings | None, metadata_directory: Path | None, cmd: str
     ) -> tuple[str, str, str]:
         with self._wheel_directory() as wheel_directory:
-            wheel_result = self.build_wheel(
+            wheel_result = getattr(self, cmd)(
                 wheel_directory=wheel_directory,
                 config_settings=config_settings,
                 metadata_directory=metadata_directory,

tests/demo_pkg_inline/build.py

@@ -81,3 +81,30 @@ def build_sdist(sdist_directory, config_settings=None):  # noqa: U100
 
 def get_requires_for_build_sdist(config_settings=None):  # noqa: U100
     return []  # pragma: no cover # only executed in non-host pythons
+
+
+if "HAS_REQUIRES_EDITABLE" in os.environ:
+
+    def get_requires_for_build_editable(config_settings=...):  # noqa: U100
+        return [1] if "REQUIRES_EDITABLE_BAD_RETURN" in os.environ else ["editables"]
+
+
+if "HAS_PREPARE_EDITABLE" in os.environ:
+
+    def prepare_metadata_for_build_editable(metadata_directory: str, config_settings=None) -> str:  # noqa: U100
+        dest = os.path.join(metadata_directory, dist_info)
+        os.mkdir(dest)
+        for arc_name, data in content.items():
+            if arc_name.startswith(dist_info):
+                with open(os.path.join(metadata_directory, arc_name), "wt") as file_handler:
+                    file_handler.write(dedent(data).strip())
+        print("created metadata {}".format(dest))
+        if "PREPARE_EDITABLE_BAD" in os.environ:
+            return 1  # type: ignore # checking bad type on purpose
+        return dist_info
+
+
+def build_editable(wheel_directory, metadata_directory=None, config_settings=None) -> str:
+    if "BUILD_EDITABLE_BAD" in os.environ:
+        return 1  # type: ignore # checking bad type on purpose
+    return build_wheel(wheel_directory, metadata_directory, config_settings)

tests/demo_pkg_inline/build.pyi

@@ -5,10 +5,15 @@ dist_info: str = ...
 content: dict[str, str] = ...
 
 def build_wheel(
-    wheel_directory: str,
-    metadata_directory: str | None = ...,
-    config_settings: dict[str, str] | None = ...,
+    wheel_directory: str, metadata_directory: str | None = ..., config_settings: dict[str, str] | None = ...
 ) -> str: ...
 def get_requires_for_build_wheel(config_settings: dict[str, str] | None = ...) -> list[str]: ...
 def build_sdist(sdist_directory: str, config_settings: dict[str, str] | None = ...) -> str: ...
 def get_requires_for_build_sdist(config_settings: dict[str, str] | None = ...) -> list[str]: ...
+def get_requires_for_build_editable(config_settings: dict[str, str] | None = ...) -> list[str]: ...
+def prepare_metadata_for_build_editable(
+    metadata_directory: str, config_settings: dict[str, str] | None = None
+) -> str: ...
+def build_editable(
+    wheel_directory: str, metadata_directory: str | None = ..., config_settings: dict[str, str] | None = ...
+) -> str: ...

tests/demo_pkg_inline/pyproject.toml

@@ -2,3 +2,6 @@
 requires = []
 build-backend = "build"
 backend-path = ["."]
+
+[tool.black]
+line-length = 120

tests/test_fronted.py

@@ -211,3 +211,98 @@ def test_create_no_pyproject(tmp_path: Path) -> None:
     assert all(isinstance(i, Requirement) for i in result[4])
     assert [str(i) for i in result[4]] == ["setuptools>=40.8.0", "wheel"]
     assert result[5] is True
+
+
+def test_backend_get_requires_for_build_editable(demo_pkg_inline: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("HAS_REQUIRES_EDITABLE", "1")
+    monkeypatch.delenv("REQUIRES_EDITABLE_BAD_RETURN", raising=False)
+    fronted = SubprocessFrontend(*SubprocessFrontend.create_args_from_folder(demo_pkg_inline)[:-1])
+    result = fronted.get_requires_for_build_editable()
+    assert [str(i) for i in result.requires] == ["editables"]
+    assert isinstance(result.requires[0], Requirement)
+    assert " get_requires_for_build_editable " in result.out
+    assert not result.err
+
+
+def test_backend_get_requires_for_build_editable_miss(demo_pkg_inline: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("HAS_REQUIRES_EDITABLE", raising=False)
+    fronted = SubprocessFrontend(*SubprocessFrontend.create_args_from_folder(demo_pkg_inline)[:-1])
+    result = fronted.get_requires_for_build_editable()
+    assert not result.requires
+    assert " get_requires_for_build_editable " in result.out
+    assert not result.err
+
+
+def test_backend_get_requires_for_build_editable_bad(demo_pkg_inline: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("HAS_REQUIRES_EDITABLE", "1")
+    monkeypatch.setenv("REQUIRES_EDITABLE_BAD_RETURN", "1")
+    fronted = SubprocessFrontend(*SubprocessFrontend.create_args_from_folder(demo_pkg_inline)[:-1])
+    with pytest.raises(BackendFailed) as context:
+        fronted.get_requires_for_build_editable()
+    exc = context.value
+    assert exc.code is None
+    assert not exc.err
+    assert " get_requires_for_build_editable " in exc.out
+    assert not exc.args
+    assert exc.exc_type == "TypeError"
+    assert exc.exc_msg == "'get_requires_for_build_editable' on 'build' returned [1] but expected type 'list of string'"
+
+
+def test_backend_prepare_editable(tmp_path: Path, demo_pkg_inline: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("HAS_PREPARE_EDITABLE", "1")
+    monkeypatch.delenv("PREPARE_EDITABLE_BAD", raising=False)
+    fronted = SubprocessFrontend(*SubprocessFrontend.create_args_from_folder(demo_pkg_inline)[:-1])
+    result = fronted.prepare_metadata_for_build_editable(tmp_path)
+    assert result.metadata.name == "demo_pkg_inline-1.0.0.dist-info"
+    assert " prepare_metadata_for_build_editable " in result.out
+    assert " build_editable " not in result.out
+    assert not result.err
+
+
+def test_backend_prepare_editable_miss(tmp_path: Path, demo_pkg_inline: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("HAS_PREPARE_EDITABLE", raising=False)
+    monkeypatch.delenv("BUILD_EDITABLE_BAD", raising=False)
+    fronted = SubprocessFrontend(*SubprocessFrontend.create_args_from_folder(demo_pkg_inline)[:-1])
+    result = fronted.prepare_metadata_for_build_editable(tmp_path)
+    assert result.metadata.name == "demo_pkg_inline-1.0.0.dist-info"
+    assert " prepare_metadata_for_build_editable " not in result.out
+    assert " build_editable " in result.out
+    assert not result.err
+
+
+def test_backend_prepare_editable_bad(tmp_path: Path, demo_pkg_inline: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("HAS_PREPARE_EDITABLE", "1")
+    monkeypatch.setenv("PREPARE_EDITABLE_BAD", "1")
+    fronted = SubprocessFrontend(*SubprocessFrontend.create_args_from_folder(demo_pkg_inline)[:-1])
+    with pytest.raises(BackendFailed) as context:
+        fronted.prepare_metadata_for_build_editable(tmp_path)
+    exc = context.value
+    assert exc.code is None
+    assert not exc.err
+    assert " prepare_metadata_for_build_editable " in exc.out
+    assert not exc.args
+    assert exc.exc_type == "TypeError"
+    assert exc.exc_msg == "'prepare_metadata_for_build_wheel' on 'build' returned 1 but expected type <class 'str'>"
+
+
+def test_backend_build_editable(tmp_path: Path, demo_pkg_inline: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("BUILD_EDITABLE_BAD", raising=False)
+    fronted = SubprocessFrontend(*SubprocessFrontend.create_args_from_folder(demo_pkg_inline)[:-1])
+    result = fronted.build_editable(tmp_path)
+    assert result.wheel.name == "demo_pkg_inline-1.0.0-py3-none-any.whl"
+    assert " build_editable " in result.out
+    assert not result.err
+
+
+def test_backend_build_editable_bad(tmp_path: Path, demo_pkg_inline: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("BUILD_EDITABLE_BAD", "1")
+    fronted = SubprocessFrontend(*SubprocessFrontend.create_args_from_folder(demo_pkg_inline)[:-1])
+    with pytest.raises(BackendFailed) as context:
+        fronted.build_editable(tmp_path)
+    exc = context.value
+    assert exc.code is None
+    assert not exc.err
+    assert " build_editable " in exc.out
+    assert not exc.args
+    assert exc.exc_type == "TypeError"
+    assert exc.exc_msg == "'build_editable' on 'build' returned 1 but expected type <class 'str'>"

whitelist.txt

@@ -1,6 +1,7 @@
 autoclass
 autodoc
 cfg
+delenv
 extlinks
 intersphinx
 iterdir
@@ -16,6 +17,7 @@ py38
 pygments
 pyproject
 sdist
+setenv
 tmpdir
 toml
 tomli