+ """

+ Code for working with pyproject backends

+ """

+ 

+ from __future__ import annotations

+ 

+ import dataclasses

+ import os

+ import subprocess

+ import sys

+ from collections.abc import Callable, Mapping, Sequence

+ from pathlib import Path

+ from typing import TYPE_CHECKING, Any, Optional, Union

+ 

+ from pyproject_hooks import BuildBackendHookCaller as _BuildBackendHookCaller

+ 

+ if TYPE_CHECKING:

+     StrPath = Union[str, os.PathLike[str]]

+     # This should match the interface of pyproject_hooks.default_subprocess_runner

+     RunnerFuncT = Callable[

+         [Sequence[StrPath], StrPath, Optional[Mapping[str, str]]], None

+     ]

+ 

+ 

+ @dataclasses.dataclass

+ class BackendRequirement:

+     """

+     Represents a backend requirement and the reason it was added

+     """

+ 

+     name: str

+     reason: str | None = None

+ 

+ 

+ class BackendHookError(Exception):

+     """

+     Unhandled backend hook failure

+     """

+ 

+     def __init__(self, hook_name: str, returncode: int) -> None:

+         self.hook_name = hook_name

+         self.returncode = returncode

+         super().__init__(f"Failed to call {self.hook_name} hook")

+ 

+     def __repr__(self) -> str:

+         hook_name, returncode = self.hook_name, self.returncode

+         return f"BuildBackendHookCaller({hook_name=}, {returncode=})"

+ 

+ 

+ class BuildBackendHookCaller(_BuildBackendHookCaller):

+     """

+     pyproject_hooks.BuildBackendHookCaller subclass that wraps backend errors

+     """

+ 

+     def _call_hook(self, hook_name, kwargs):

+         try:

+             return super()._call_hook(hook_name, kwargs)

+         except subprocess.CalledProcessError as exc:

+             raise BackendHookError(hook_name, exc.returncode) from None

+ 

+ 

+ DEFAULT_BUILD_BACKEND = "setuptools.build_meta:__legacy__"

+ DEFAULT_BUILD_REQUIRES = (

+     BackendRequirement("setuptools >= 40.8", reason="default build backend"),

+     BackendRequirement("wheel", reason="default build backend"),

+ )

+ 

+ 

+ def stderr_subprocess_runner(

+     cmd: Sequence[StrPath], cwd: StrPath, extra_environ: Mapping[str, str] | None = None

+ ) -> None:

+     """

+     Alternative to pyproject_hooks.default_subprocess_runner that redirects all

+     stdout to stderr.

+     """

+     extra_environ = extra_environ or {}

+     subprocess.run(

+         cmd,

+         stdout=sys.stderr,

+         cwd=cwd,

+         env={**os.environ, **extra_environ},

+         check=True,

+     )

+ 

+ 

+ class _Sentinel:

+     pass

+ 

+ 

+ @dataclasses.dataclass

+ class BuildBackend:

+     """

+     Represents a build backend

+     """

+ 

+     name: str

+     requires: list[BackendRequirement]

+     path: list[str] | None = None

+     directory: Path = Path()

+     default_runner: RunnerFuncT | None = None

+ 

+     @classmethod

+     def from_pyproject_data(

+         cls,

+         data: dict[str, Any],

+         directory: Path = Path(),

+         default_runner: RunnerFuncT | None = None,

+     ) -> BuildBackend:

+         """

+         Create a BuildBackend object based on a parsed pyproject.toml dictionary

+         """

+         buildsystem_data: dict[str, Any] = data.get("build-system", {})

+ 

+         requires: list[BackendRequirement] = [

+             BackendRequirement(i, reason="build-system.requires")

+             for i in buildsystem_data.get("requires", [])

+         ]

+ 

+         backend_name: str | None = buildsystem_data.get("build-backend")

+ 

+         if not backend_name:

+             # https://www.python.org/dev/peps/pep-0517/:

+             # If the pyproject.toml file is absent, or the build-backend key is

+             # missing, the source tree is not using this specification, and tools

+             # should revert to the legacy behaviour of running setup.py

+             # (either directly, or by implicitly invoking the [following] backend).

+             # If setup.py is also not present program will mimick pip's behavior

+             # and end with an error.

+             if not (directory / "setup.py").exists():

+                 raise FileNotFoundError('"setup.py" not found for legacy project.')

+             backend_name = DEFAULT_BUILD_BACKEND

+ 

+             # Note: For projects without pyproject.toml, this was already echoed

+             # by the %pyproject_buildrequires macro, but this also handles cases

+             # with pyproject.toml without a specified build backend.

+             # If the default requirements change, also change them in the macro!

+             requires.extend(DEFAULT_BUILD_REQUIRES)

+ 

+         backend_path: list[str] = buildsystem_data.get("backend-path", [])

+         if isinstance(backend_path, str):

+             backend_path = [backend_path]

+ 

+         return cls(

+             name=backend_name,

+             requires=requires,

+             path=backend_path,

+             directory=directory,

+             default_runner=default_runner,

+         )

+ 

+     @classmethod

+     def from_directory(

+         cls, directory: Path = Path(), default_runner: RunnerFuncT | None = None

+     ) -> BuildBackend:

+         """

+         Create a BuildBackend object based on the pyproject.toml in `directory`.

+         """

+         if sys.version_info[:2] >= (3, 11):

+             import tomllib

+         else:

+             import tomli as tomllib

+ 

+         try:

+             f = (directory / "pyproject.toml").open("rb")

+         except FileNotFoundError:

+             pyproject_data = {}

+         else:

+             with f:

+                 pyproject_data = tomllib.load(f)

+         return cls.from_pyproject_data(

+             pyproject_data, directory, default_runner=default_runner

+         )

+ 

+     _DEFAULT_RUNNER = _Sentinel()

+ 

+     def get_caller(

+         self,

+         runner: RunnerFuncT | _Sentinel | None = _DEFAULT_RUNNER,

+     ) -> BuildBackendHookCaller:

+         """

+         Create a BuildBackendHookCaller object based on this BuildBackend

+         """

+         if runner is self._DEFAULT_RUNNER:

+             runner = self.default_runner

+ 

+         return BuildBackendHookCaller(self.directory, self.name, self.path, runner)

+ 

+ 

+ def parse_config_settings_args(config_settings):

+     """

+     Given a list of config `KEY=VALUE` formatted config settings,

+     return a dictionary that can be passed to PEP 517 hook functions.

+     """

+     if not config_settings:

+         return config_settings

+     new_config_settings = {}

+     for arg in config_settings:

+         key, _, value = arg.partition('=')

+         if key in new_config_settings:

+             if not isinstance(new_config_settings[key], list):

+                 # convert the existing value to a list

+                 new_config_settings[key] = [new_config_settings[key]]

+             new_config_settings[key].append(value)

+         else:

+             new_config_settings[key] = value

+     return new_config_settings

+ echo 'python%{python3_pkgversion}dist(pyproject-hooks)'

+   RPM_TOXENV="%{toxenv}" HOSTNAME="rpmbuild" %{__python3} -Bs %{_rpmconfigdir}/redhat/pyproject_buildrequires.py %{?!_python_no_extras_requires:--generate-extras} --python3_pkgversion %{python3_pkgversion} --wheeldir %{_pyproject_wheeldir} %{?**}

+ Version:        1.11.0

+ Source108:      _pyproject_hooks.py

+ BuildRequires:  python3dist(pyproject-hooks)

+ install -pm 644 _pyproject_hooks.py %{buildroot}%{_rpmconfigdir}/redhat/

+ %{_rpmconfigdir}/redhat/_pyproject_hooks.py

+ * Wed Dec 13 2023 Maxwell G <maxwell@gtmx.me> - 1.11.0-1

+ - Use pyproject_hooks to build wheel and call hooks

+ 

+ try:

+     from pyproject_hooks import HookMissing

+ except ImportError as e:

+     print_err('Import error:', e)

+     # already echoed by the %pyproject_buildrequires macro

+     sys.exit(0)

+ 

+ from _pyproject_hooks import (

+     BackendHookError,

+     BuildBackend,

+     parse_config_settings_args,

+     stderr_subprocess_runner,

+ )

+ 

+ def get_backend(requirements) -> BuildBackend:

+     backend = BuildBackend.from_directory(default_runner=stderr_subprocess_runner)

+     for require in backend.requires:

+         requirements.add(require.name, source=require.reason)

+     return backend

+ def generate_build_requirements(backend: BuildBackend, requirements):

+     caller = backend.get_caller()

+     new_reqs = caller.get_requires_for_build_wheel(requirements.config_settings)

+     requirements.extend(new_reqs, source='get_requires_for_build_wheel')

+     requirements.check(source='get_requires_for_build_wheel')

+ def generate_run_requirements_hook(backend: BuildBackend, requirements):

+     try:

+         dir_basename = backend.get_caller().prepare_metadata_for_build_wheel(

+             '.', requirements.config_settings, _allow_fallback=False

+         )

+     except HookMissing:

+         ) from None

+         os.makedirs(wheeldir, exist_ok=True)

+         try:

+             wheel = backend.get_caller().build_wheel(

+                 wheeldir, config_settings=requirements.config_settings

+             )

+             wheel = os.path.join(wheeldir, wheel)

+         except Exception as exc:

+             raise RuntimeError(

+                 'Failed to build the wheel for %pyproject_buildrequires -w.'

+             ) from exc

+     config_settings=None,

+         print(os.linesep.join(requirements.output_lines))

+     except BackendHookError as exc:

+         print_err(exc)

+         exit(exc.returncode)

+     build-backend = "foo.build"

+ import traceback

+ from pathlib import Path

+ from _pyproject_hooks import BuildBackend, BackendHookError, parse_config_settings_args

+ def build_wheel(*, wheeldir, config_settings=None):

+     wheeldir.mkdir(parents=True, exist_ok=True)

+     BuildBackend.from_directory().get_caller().build_wheel(wheeldir, config_settings)

+     parser.add_argument('wheeldir', help=argparse.SUPPRESS, type=Path)

+     try:

+         build_wheel(**vars(parse_args()))

+     except BackendHookError as exc:

+         print(exc, file=sys.stderr)

+         sys.exit(exc.returncode)

+     except Exception:

+         traceback.print_exc()

+         sys.exit(1)

+     else:

+         sys.exit(0)

+ import sys

+ from _pyproject_hooks import BackendHookError

+     # Mirror the way the actual code handles BackendHookError

+     except BackendHookError as e:

+         print(e, file=sys.stderr)

+         assert e.returncode == case['result']

+         dependencies, err = capfd.readouterr()

+ requires = ["flit-core"]

+ %pyproject_buildrequires -C abc=123 -C xyz=456 -C--option-with-dashes=1 -C--option-with-dashes=2 -w

+ %pyproject_wheel -C abc=123 -C xyz=456 -C--option-with-dashes=1 -C--option-with-dashes=2