You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
157 lines
5.9 KiB
157 lines
5.9 KiB
from contextlib import contextmanager
|
|
import os
|
|
from os.path import dirname, abspath, join as pjoin
|
|
import shutil
|
|
from subprocess import check_call
|
|
import sys
|
|
from tempfile import mkdtemp
|
|
|
|
from . import compat
|
|
|
|
_in_proc_script = pjoin(dirname(abspath(__file__)), '_in_process.py')
|
|
|
|
@contextmanager
|
|
def tempdir():
|
|
td = mkdtemp()
|
|
try:
|
|
yield td
|
|
finally:
|
|
shutil.rmtree(td)
|
|
|
|
class BackendUnavailable(Exception):
|
|
"""Will be raised if the backend cannot be imported in the hook process."""
|
|
|
|
class UnsupportedOperation(Exception):
|
|
"""May be raised by build_sdist if the backend indicates that it can't."""
|
|
|
|
def default_subprocess_runner(cmd, cwd=None, extra_environ=None):
|
|
"""The default method of calling the wrapper subprocess."""
|
|
env = os.environ.copy()
|
|
if extra_environ:
|
|
env.update(extra_environ)
|
|
|
|
check_call(cmd, cwd=cwd, env=env)
|
|
|
|
class Pep517HookCaller(object):
|
|
"""A wrapper around a source directory to be built with a PEP 517 backend.
|
|
|
|
source_dir : The path to the source directory, containing pyproject.toml.
|
|
backend : The build backend spec, as per PEP 517, from pyproject.toml.
|
|
"""
|
|
def __init__(self, source_dir, build_backend):
|
|
self.source_dir = abspath(source_dir)
|
|
self.build_backend = build_backend
|
|
self._subprocess_runner = default_subprocess_runner
|
|
|
|
# TODO: Is this over-engineered? Maybe frontends only need to
|
|
# set this when creating the wrapper, not on every call.
|
|
@contextmanager
|
|
def subprocess_runner(self, runner):
|
|
prev = self._subprocess_runner
|
|
self._subprocess_runner = runner
|
|
yield
|
|
self._subprocess_runner = prev
|
|
|
|
def get_requires_for_build_wheel(self, config_settings=None):
|
|
"""Identify packages required for building a wheel
|
|
|
|
Returns a list of dependency specifications, e.g.:
|
|
["wheel >= 0.25", "setuptools"]
|
|
|
|
This does not include requirements specified in pyproject.toml.
|
|
It returns the result of calling the equivalently named hook in a
|
|
subprocess.
|
|
"""
|
|
return self._call_hook('get_requires_for_build_wheel', {
|
|
'config_settings': config_settings
|
|
})
|
|
|
|
def prepare_metadata_for_build_wheel(self, metadata_directory, config_settings=None):
|
|
"""Prepare a *.dist-info folder with metadata for this project.
|
|
|
|
Returns the name of the newly created folder.
|
|
|
|
If the build backend defines a hook with this name, it will be called
|
|
in a subprocess. If not, the backend will be asked to build a wheel,
|
|
and the dist-info extracted from that.
|
|
"""
|
|
return self._call_hook('prepare_metadata_for_build_wheel', {
|
|
'metadata_directory': abspath(metadata_directory),
|
|
'config_settings': config_settings,
|
|
})
|
|
|
|
def build_wheel(self, wheel_directory, config_settings=None, metadata_directory=None):
|
|
"""Build a wheel from this project.
|
|
|
|
Returns the name of the newly created file.
|
|
|
|
In general, this will call the 'build_wheel' hook in the backend.
|
|
However, if that was previously called by
|
|
'prepare_metadata_for_build_wheel', and the same metadata_directory is
|
|
used, the previously built wheel will be copied to wheel_directory.
|
|
"""
|
|
if metadata_directory is not None:
|
|
metadata_directory = abspath(metadata_directory)
|
|
return self._call_hook('build_wheel', {
|
|
'wheel_directory': abspath(wheel_directory),
|
|
'config_settings': config_settings,
|
|
'metadata_directory': metadata_directory,
|
|
})
|
|
|
|
def get_requires_for_build_sdist(self, config_settings=None):
|
|
"""Identify packages required for building a wheel
|
|
|
|
Returns a list of dependency specifications, e.g.:
|
|
["setuptools >= 26"]
|
|
|
|
This does not include requirements specified in pyproject.toml.
|
|
It returns the result of calling the equivalently named hook in a
|
|
subprocess.
|
|
"""
|
|
return self._call_hook('get_requires_for_build_sdist', {
|
|
'config_settings': config_settings
|
|
})
|
|
|
|
def build_sdist(self, sdist_directory, config_settings=None):
|
|
"""Build an sdist from this project.
|
|
|
|
Returns the name of the newly created file.
|
|
|
|
This calls the 'build_sdist' backend hook in a subprocess.
|
|
"""
|
|
return self._call_hook('build_sdist', {
|
|
'sdist_directory': abspath(sdist_directory),
|
|
'config_settings': config_settings,
|
|
})
|
|
|
|
|
|
def _call_hook(self, hook_name, kwargs):
|
|
# On Python 2, pytoml returns Unicode values (which is correct) but the
|
|
# environment passed to check_call needs to contain string values. We
|
|
# convert here by encoding using ASCII (the backend can only contain
|
|
# letters, digits and _, . and : characters, and will be used as a
|
|
# Python identifier, so non-ASCII content is wrong on Python 2 in
|
|
# any case).
|
|
if sys.version_info[0] == 2:
|
|
build_backend = self.build_backend.encode('ASCII')
|
|
else:
|
|
build_backend = self.build_backend
|
|
|
|
with tempdir() as td:
|
|
compat.write_json({'kwargs': kwargs}, pjoin(td, 'input.json'),
|
|
indent=2)
|
|
|
|
# Run the hook in a subprocess
|
|
self._subprocess_runner(
|
|
[sys.executable, _in_proc_script, hook_name, td],
|
|
cwd=self.source_dir,
|
|
extra_environ={'PEP517_BUILD_BACKEND': build_backend}
|
|
)
|
|
|
|
data = compat.read_json(pjoin(td, 'output.json'))
|
|
if data.get('unsupported'):
|
|
raise UnsupportedOperation
|
|
if data.get('no_backend'):
|
|
raise BackendUnavailable
|
|
return data['return_val']
|
|
|