pyproject-api 1.11.6__tar.gz → 1.12.0__tar.gz

{pyproject_api-1.11.6 → pyproject_api-1.12.0}/.github/workflows/release.yaml

@@ -27,7 +27,7 @@ jobs:
       - name: Build package
         run: uv build --python 3.15 --python-preference only-managed --sdist --wheel . --out-dir dist
       - name: Store the distribution packages
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
         with:
           name: ${{ env.dists-artifact-name }}
           path: dist/*
@@ -43,7 +43,7 @@ jobs:
       id-token: write
     steps:
       - name: Download all the dists
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
         with:
           name: ${{ env.dists-artifact-name }}
           path: dist/

{pyproject_api-1.11.6 → pyproject_api-1.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyproject-api
-Version: 1.11.6
+Version: 1.12.0
 Summary: API to interact with the python pyproject.toml based projects
 Project-URL: Changelog, https://github.com/tox-dev/pyproject-api/releases
 Project-URL: Homepage, https://pyproject-api.readthedocs.io

{pyproject_api-1.11.6 → pyproject_api-1.12.0}/src/pyproject_api/_backend.py

@@ -23,7 +23,8 @@ class BackendProxy:
         self.backend_object = backend_obj
         backend = importlib.import_module(self.backend_module)
         if self.backend_object:
-            backend = getattr(backend, self.backend_object)
+            for name in self.backend_object.split("."):
+                backend = getattr(backend, name)
         self.backend = backend
 
     def __call__(self, name, *args, **kwargs):
@@ -87,23 +88,39 @@ def run(argv):  # ruff:ignore[complex-structure, too-many-branches, too-many-sta
             flush()
         else:
             result = {}
+            response = None
             try:
                 cmd = parsed_message["cmd"]
                 print("Backend: run command {} with args {}".format(cmd, parsed_message["kwargs"]))
                 result["return"] = backend_proxy(cmd, **parsed_message["kwargs"])
-                if cmd == "_exit":
-                    break
+                response = json.dumps(result)
             except BaseException as exception:  # ruff:ignore[blind-except]
-                result["code"] = exception.code if isinstance(exception, SystemExit) else 1
-                result["exc_type"] = exception.__class__.__name__
-                result["exc_msg"] = str(exception)
+                try:
+                    result = {
+                        "code": exception.code if isinstance(exception, SystemExit) else 1,
+                        "exc_type": exception.__class__.__name__,
+                        "exc_msg": str(exception),
+                    }
+                    response = json.dumps(result)
+                except BaseException:  # ruff:ignore[blind-except]
+                    result = {
+                        "code": 1,
+                        "exc_type": "RuntimeError",
+                        "exc_msg": "Failed to serialize backend exception",
+                    }
+                    response = json.dumps(result)
                 if not isinstance(exception, MissingCommand):  # for missing command do not print stack
                     traceback.print_exc()
+            else:
+                if cmd == "_exit":
+                    break
             finally:
                 try:
                     encoding = locale.getpreferredencoding(do_setlocale=False)
-                    with open(result_file, "w", encoding=encoding) as file_handler:  # ruff:ignore[builtin-open]
-                        json.dump(result, file_handler)
+                    with open(  # ruff:ignore[builtin-open, write-whole-file]  # Python 2.7 compatible
+                        result_file, "w", encoding=encoding
+                    ) as file_handler:
+                        file_handler.write(response)
                 except Exception:  # ruff:ignore[blind-except]
                     traceback.print_exc()
                 finally:

{pyproject_api-1.11.6 → pyproject_api-1.12.0}/src/pyproject_api/_frontend.py

@@ -9,7 +9,7 @@ from contextlib import contextmanager
 from pathlib import Path
 from tempfile import NamedTemporaryFile, TemporaryDirectory
 from time import sleep
-from typing import TYPE_CHECKING, Any, Literal, NamedTuple, NoReturn, TypedDict, cast
+from typing import TYPE_CHECKING, Any, Final, Literal, NamedTuple, NoReturn, TypedDict, cast
 from zipfile import ZipFile
 
 from packaging.requirements import Requirement
@@ -211,13 +211,16 @@ class Frontend(ABC):
 
         :param folder: the python project folder
         :return: the frontend creation args
-        :raises ValueError: if ``build-system`` is not a table, or one of its keys has a type PEP-518 rules out
+        :raises ValueError: if ``build-system`` is not a table, one of its keys has a type PEP-518 rules out, or a
+            ``backend-path`` entry does not resolve inside the project (PEP-517 in-tree backends)
 
         E.g., to create a frontend from a python project folder:
 
         .. code:: python
 
-            frontend = Frontend(*Frontend.create_args_from_folder(project_folder))
+            from pyproject_api import SubprocessFrontend
+
+            frontend = SubprocessFrontend(*SubprocessFrontend.create_args_from_folder(project_folder)[:-1])
         """
         folder = folder.absolute()
         py_project_toml = folder / "pyproject.toml"
@@ -228,7 +231,9 @@ class Frontend(ABC):
                 msg = f"build-system must be a table, got {build_system!r}"
                 raise ValueError(msg)
             if "backend-path" in build_system:
-                backend_paths: tuple[Path, ...] = tuple(folder / p for p in _str_list(build_system, "backend-path"))
+                backend_paths: tuple[Path, ...] = tuple(
+                    _in_tree_path(folder, entry) for entry in _str_list(build_system, "backend-path")
+                )
             else:
                 backend_paths = ()
             if "requires" in build_system:
@@ -343,9 +348,16 @@ class Frontend(ABC):
         return MetadataForBuildWheelResult(metadata_directory / basename, out, err)
 
     def _check_metadata_dir(self, metadata_directory: Path) -> None:
-        if metadata_directory.resolve() == self._root.resolve():
-            msg = f"the project root and the metadata directory can't be the same {self._root}"
-            raise RuntimeError(msg)
+        metadata_path: Final[Path] = metadata_directory.resolve()
+        project_root: Final[Path] = self._root.resolve()
+        if metadata_path == project_root:
+            same_root_message: Final[str] = (
+                f"the project root and the metadata directory can't be the same {self._root}"
+            )
+            raise RuntimeError(same_root_message)
+        if metadata_path in project_root.parents:
+            ancestor_message: Final[str] = f"the metadata directory can't contain the project root {self._root}"
+            raise RuntimeError(ancestor_message)
         if metadata_directory.exists():  # start with fresh
             ensure_empty_dir(metadata_directory)
         metadata_directory.mkdir(parents=True, exist_ok=True)
@@ -539,6 +551,19 @@ def _str_list(build_system: dict[str, Any], key: str) -> list[str]:
     return value
 
 
+def _in_tree_path(folder: Path, entry: str) -> Path:
+    path = folder / entry
+    # Python 3.15 on Windows resolves a path containing NUL instead of raising
+    try:
+        inside = "\0" not in entry and not Path(entry).is_absolute() and path.resolve().is_relative_to(folder.resolve())
+    except (OSError, RuntimeError):  # RuntimeError: symlink loop before Python 3.13
+        inside = False
+    if not inside:
+        msg = f"build-system.backend-path entry {entry!r} must be a relative path inside the project {folder}"
+        raise ValueError(msg)
+    return path
+
+
 __all__ = [
     "BackendFailed",
     "CmdStatus",

{pyproject_api-1.11.6 → pyproject_api-1.12.0}/src/pyproject_api/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.11.6'
-__version_tuple__ = version_tuple = (1, 11, 6)
+__version__ = version = '1.12.0'
+__version_tuple__ = version_tuple = (1, 12, 0)
 
 __commit_id__ = commit_id = None

{pyproject_api-1.11.6 → pyproject_api-1.12.0}/tests/test_backend.py

@@ -2,10 +2,14 @@ from __future__ import annotations
 
 import json
 import os
+import subprocess  # ruff:ignore[suspicious-subprocess-import]
+import sys
+from textwrap import dedent
 from typing import TYPE_CHECKING, Any
 
 import pytest
 
+from pyproject_api import _backend
 from pyproject_api._backend import BackendProxy, read_line, run
 
 if TYPE_CHECKING:
@@ -130,6 +134,62 @@ def test_reuse_process(mocker: pytest_mock.MockerFixture, capsys: pytest.Capture
     assert "SystemExit: 2" in captured.err
 
 
+@pytest.mark.parametrize("code", ["Path('failure.txt')", "b'failure'"])
+@pytest.mark.parametrize("previous_success", [False, True])
+def test_reused_process_non_serializable_exit(tmp_path: Path, code: str, previous_success: bool) -> None:
+    (tmp_path / "exit_backend.py").write_text(
+        dedent(f"""
+        import os
+        from pathlib import Path
+
+        calls = 0
+
+        def build_wheel(wheel_directory, config_settings=None, metadata_directory=None):
+            global calls
+            calls += 1
+            print("hook pid={{}} calls={{}}".format(os.getpid(), calls))
+            if config_settings["fail"]:
+                raise SystemExit({code})
+            return "demo-{{}}.whl".format(calls)
+        """)
+    )
+    failures = [False, True, False] if previous_success else [True, False]
+    requests = [
+        {"cmd": "build_wheel", "kwargs": {"wheel_directory": str(tmp_path), "config_settings": {"fail": fail}}}
+        for fail in failures
+    ]
+    requests.append({"cmd": "_exit", "kwargs": {}})
+    result_files = [tmp_path / f"response-{index}.json" for index in range(len(requests))]
+    messages = [
+        json.dumps({**request, "result": str(path)}) for request, path in zip(requests, result_files, strict=True)
+    ]
+    completed = subprocess.run(
+        [sys.executable, _backend.__file__, "True", "exit_backend"],
+        input="\n".join(messages) + "\n",
+        capture_output=True,
+        text=True,
+        cwd=tmp_path,
+        env={**os.environ, "PYTHONPATH": str(tmp_path)},
+        timeout=30,
+        check=False,
+    )
+
+    # Inspect the failed request first: the previous candidate returns the earlier wheel here.
+    failed = json.loads(result_files[failures.index(True)].read_text())
+    assert "return" not in failed
+    assert failed == {"code": 1, "exc_type": "RuntimeError", "exc_msg": "Failed to serialize backend exception"}
+    assert completed.returncode == 0, completed.stderr
+    for index, fail in enumerate(failures):
+        if not fail:
+            assert json.loads(result_files[index].read_text()) == {"return": f"demo-{index + 1}.whl"}
+    assert json.loads(result_files[-1].read_text()) == {"return": 0}
+    hook_lines = [line for line in completed.stdout.splitlines() if line.startswith("hook pid=")]
+    assert len(hook_lines) == len(failures)
+    assert len({line.split()[1] for line in hook_lines}) == 1
+    assert [line.split()[2] for line in hook_lines] == [f"calls={index + 1}" for index in range(len(failures))]
+    assert "SystemExit" in completed.stderr
+
+
 def test_read_line_success() -> None:
     r, w = os.pipe()
     try:

{pyproject_api-1.11.6 → pyproject_api-1.12.0}/tests/test_frontend.py

@@ -5,7 +5,7 @@ import subprocess  # ruff:ignore[suspicious-subprocess-import]
 import sys
 from pathlib import Path
 from textwrap import dedent
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Final, Literal
 
 import pytest
 from packaging.requirements import Requirement
@@ -16,6 +16,8 @@ from pyproject_api._via_fresh_subprocess import SubprocessFrontend
 if TYPE_CHECKING:
     from collections.abc import Callable
 
+    import pytest_mock
+
 
 @pytest.fixture
 def local_builder(tmp_path: Path) -> Callable[[str], Path]:
@@ -183,6 +185,38 @@ def test_empty_pyproject(tmp_path: Path) -> None:
         assert str(left) == str(right)
 
 
+@pytest.mark.parametrize(
+    "backend_path",
+    [
+        pytest.param("../outside", id="parent"),
+        pytest.param("{tmp}/outside", id="absolute-outside"),
+        pytest.param("{tmp}/project", id="absolute-inside"),
+        pytest.param("link", id="symlink-outside"),
+        pytest.param("\\u0000", id="nul"),
+    ],
+)
+def test_create_args_from_folder_rejects_out_of_tree_backend_path(tmp_path: Path, backend_path: str) -> None:
+    project = tmp_path / "project"
+    project.mkdir()
+    (project / "link").symlink_to(tmp_path, target_is_directory=True)
+    (project / "pyproject.toml").write_text(
+        f'[build-system]\nbackend-path = ["{backend_path.format(tmp=tmp_path.as_posix())}"]\nbuild-backend = "b"\n'
+    )
+
+    with pytest.raises(ValueError, match=r"backend-path entry .* must be a relative path inside the project"):
+        SubprocessFrontend.create_args_from_folder(project)
+
+
+def test_create_args_from_folder_rejects_unresolvable_backend_path(
+    tmp_path: Path, mocker: pytest_mock.MockerFixture
+) -> None:
+    (tmp_path / "pyproject.toml").write_text('[build-system]\nbackend-path = ["."]\nbuild-backend = "b"\n')
+    mocker.patch.object(Path, "resolve", autospec=True, side_effect=RuntimeError("Symlink loop"))
+
+    with pytest.raises(ValueError, match=r"backend-path entry '\.' must be a relative path inside the project"):
+        SubprocessFrontend.create_args_from_folder(tmp_path)
+
+
 @pytest.fixture(scope="session")
 def demo_pkg_inline() -> Path:
     return Path(__file__).absolute().parent / "demo_pkg_inline"
@@ -232,19 +266,31 @@ def test_create_args_from_folder_rejects_bad_build_system_type(tmp_path: Path, t
         SubprocessFrontend.create_args_from_folder(tmp_path)
 
 
-def test_backend_obj(tmp_path: Path) -> None:
-    toml = """
+@pytest.mark.parametrize(
+    "backend_obj",
+    [
+        pytest.param("backend", id="attribute"),
+        pytest.param("backend:", id="trailing-colon"),
+        pytest.param("holder.backend", id="nested"),
+        pytest.param("holder.nested.backend", id="deeply-nested"),
+    ],
+)
+def test_backend_obj(tmp_path: Path, backend_obj: str) -> None:
+    toml = f"""
         [build-system]
         requires=[]
-        build-backend = "build.api:backend:"
+        build-backend = "build.api:{backend_obj}"
         backend-path=["."]
         """
     api = """
+        from types import SimpleNamespace
+
         class A:
             def get_requires_for_build_sdist(self, config_settings=None):
                 return ["a"]
 
         backend = A()
+        holder = SimpleNamespace(backend=backend, nested=SimpleNamespace(backend=backend))
         """
     (tmp_path / "pyproject.toml").write_text(dedent(toml))
     build = tmp_path / "build"
@@ -253,9 +299,7 @@ def test_backend_obj(tmp_path: Path) -> None:
     (build / "api.py").write_text(dedent(api))
     frontend = SubprocessFrontend(*SubprocessFrontend.create_args_from_folder(tmp_path)[:-1])
     result = frontend.get_requires_for_build_sdist()
-    for left, right in zip(result.requires, (Requirement("a"),), strict=False):
-        assert isinstance(left, Requirement)
-        assert str(left) == str(right)
+    assert result.requires == (Requirement("a"),)
 
 
 @pytest.mark.parametrize("of_type", ["wheel", "sdist"])
@@ -305,6 +349,35 @@ def test_bad_return_type_build_wheel(local_builder: Callable[[str], Path]) -> No
     assert exc.exc_type == "TypeError"
 
 
+@pytest.mark.parametrize("value", ["Path('demo.whl')", "b'demo.whl'", "{'demo.whl'}"])
+def test_non_serializable_hook_result(value: str, local_builder: Callable[[str], Path]) -> None:
+    root = local_builder(f"""
+        import sys
+        from pathlib import Path
+
+        def build_wheel(wheel_directory, config_settings=None, metadata_directory=None):
+            print("hook stdout")
+            print("hook stderr", file=sys.stderr)
+            if config_settings is None:
+                return {value}
+            return "demo-1.0-py3-none-any.whl"
+        """)
+    frontend = SubprocessFrontend(*SubprocessFrontend.create_args_from_folder(root)[:-1])
+
+    with pytest.raises(BackendFailed) as context:
+        frontend.build_wheel(root / "dist")
+
+    exc = context.value
+    assert exc.code == 1
+    assert exc.exc_type == "TypeError"
+    assert "not JSON serializable" in exc.exc_msg
+    assert "hook stdout" in exc.out
+    assert "hook stderr" in exc.err
+    assert "TypeError" in exc.err
+    result = frontend.build_wheel(root / "dist", config_settings={})
+    assert result.wheel.name == "demo-1.0-py3-none-any.whl"
+
+
 def test_bad_return_type_prepare_metadata_for_build_wheel(local_builder: Callable[[str], Path]) -> None:
     tmp_path = local_builder("def prepare_metadata_for_build_wheel(metadata_directory, config_settings=None): return 1")
     frontend = SubprocessFrontend(*SubprocessFrontend.create_args_from_folder(tmp_path)[:-1])
@@ -327,6 +400,46 @@ def test_prepare_metadata_for_build_wheel_meta_is_root(local_builder: Callable[[
     assert str(context.value) == f"the project root and the metadata directory can't be the same {tmp_path}"
 
 
+@pytest.mark.parametrize("hook", ["prepare_metadata_for_build_wheel", "prepare_metadata_for_build_editable"])
+@pytest.mark.parametrize("alias", [False, True], ids=["directory", "symlink"])
+def test_prepare_metadata_rejects_ancestor_directory(tmp_path: Path, hook: str, alias: bool) -> None:
+    # The old cleanup can remove the whole ancestor, so keep it inside tmp_path.
+    ancestor: Final[Path] = tmp_path / "sandbox"
+    root: Final[Path] = ancestor / "project"
+    root.mkdir(parents=True)
+    source: Final[Path] = root / "build_tester.py"
+    source.write_text("source content\n")
+    unrelated: Final[Path] = ancestor / "unrelated.txt"
+    unrelated.write_text("keep me")
+    metadata_directory: Final[Path] = tmp_path / "alias" if alias else ancestor
+    if alias:
+        metadata_directory.symlink_to(ancestor, target_is_directory=True)
+    frontend: Final[SubprocessFrontend] = SubprocessFrontend(root, (root,), "build_tester", None, ())
+
+    with pytest.raises(RuntimeError, match="the metadata directory can't contain the project root"):
+        getattr(frontend, hook)(metadata_directory)
+
+    assert source.read_text() == "source content\n"
+    assert unrelated.read_text() == "keep me"
+
+
+@pytest.mark.parametrize("hook", ["prepare_metadata_for_build_wheel", "prepare_metadata_for_build_editable"])
+def test_prepare_metadata_allows_sibling_directory(tmp_path: Path, hook: str) -> None:
+    root: Final[Path] = tmp_path / "project"
+    root.mkdir()
+    source: Final[Path] = root / "build_tester.py"
+    source.write_text("")
+    metadata_directory: Final[Path] = tmp_path / "project-metadata"
+    metadata_directory.mkdir()
+    (metadata_directory / "stale.txt").write_text("remove me")
+    frontend: Final[SubprocessFrontend] = SubprocessFrontend(root, (root,), "build_tester", None, ())
+
+    assert getattr(frontend, hook)(metadata_directory) is None
+
+    assert source.is_file()
+    assert list(metadata_directory.iterdir()) == []
+
+
 def test_no_wheel_prepare_metadata_for_build_wheel(local_builder: Callable[[str], Path]) -> None:
     txt = "def build_wheel(wheel_directory, config_settings=None, metadata_directory=None): return 'out'"
     tmp_path = local_builder(txt)