| """This is invoked in a subprocess to call the build backend hooks. |
| |
| It expects: |
| - Command line args: hook_name, control_dir |
| - Environment variables: |
| PEP517_BUILD_BACKEND=entry.point:spec |
| PEP517_BACKEND_PATH=paths (separated with os.pathsep) |
| - control_dir/input.json: |
| - {"kwargs": {...}} |
| |
| Results: |
| - control_dir/output.json |
| - {"return_val": ...} |
| """ |
| import json |
| import os |
| import os.path |
| import re |
| import shutil |
| import sys |
| import traceback |
| from glob import glob |
| from importlib import import_module |
| from os.path import join as pjoin |
| |
| # This file is run as a script, and `import wrappers` is not zip-safe, so we |
| # include write_json() and read_json() from wrappers.py. |
| |
| |
| def write_json(obj, path, **kwargs): |
| with open(path, 'w', encoding='utf-8') as f: |
| json.dump(obj, f, **kwargs) |
| |
| |
| def read_json(path): |
| with open(path, encoding='utf-8') as f: |
| return json.load(f) |
| |
| |
| class BackendUnavailable(Exception): |
| """Raised if we cannot import the backend""" |
| def __init__(self, traceback): |
| self.traceback = traceback |
| |
| |
| class BackendInvalid(Exception): |
| """Raised if the backend is invalid""" |
| def __init__(self, message): |
| self.message = message |
| |
| |
| class HookMissing(Exception): |
| """Raised if a hook is missing and we are not executing the fallback""" |
| def __init__(self, hook_name=None): |
| super().__init__(hook_name) |
| self.hook_name = hook_name |
| |
| |
| def contained_in(filename, directory): |
| """Test if a file is located within the given directory.""" |
| filename = os.path.normcase(os.path.abspath(filename)) |
| directory = os.path.normcase(os.path.abspath(directory)) |
| return os.path.commonprefix([filename, directory]) == directory |
| |
| |
| def _build_backend(): |
| """Find and load the build backend""" |
| # Add in-tree backend directories to the front of sys.path. |
| backend_path = os.environ.get('PEP517_BACKEND_PATH') |
| if backend_path: |
| extra_pathitems = backend_path.split(os.pathsep) |
| sys.path[:0] = extra_pathitems |
| |
| ep = os.environ['PEP517_BUILD_BACKEND'] |
| mod_path, _, obj_path = ep.partition(':') |
| try: |
| obj = import_module(mod_path) |
| except ImportError: |
| raise BackendUnavailable(traceback.format_exc()) |
| |
| if backend_path: |
| if not any( |
| contained_in(obj.__file__, path) |
| for path in extra_pathitems |
| ): |
| raise BackendInvalid("Backend was not loaded from backend-path") |
| |
| if obj_path: |
| for path_part in obj_path.split('.'): |
| obj = getattr(obj, path_part) |
| return obj |
| |
| |
| def _supported_features(): |
| """Return the list of options features supported by the backend. |
| |
| Returns a list of strings. |
| The only possible value is 'build_editable'. |
| """ |
| backend = _build_backend() |
| features = [] |
| if hasattr(backend, "build_editable"): |
| features.append("build_editable") |
| return features |
| |
| |
| def get_requires_for_build_wheel(config_settings): |
| """Invoke the optional get_requires_for_build_wheel hook |
| |
| Returns [] if the hook is not defined. |
| """ |
| backend = _build_backend() |
| try: |
| hook = backend.get_requires_for_build_wheel |
| except AttributeError: |
| return [] |
| else: |
| return hook(config_settings) |
| |
| |
| def get_requires_for_build_editable(config_settings): |
| """Invoke the optional get_requires_for_build_editable hook |
| |
| Returns [] if the hook is not defined. |
| """ |
| backend = _build_backend() |
| try: |
| hook = backend.get_requires_for_build_editable |
| except AttributeError: |
| return [] |
| else: |
| return hook(config_settings) |
| |
| |
| def prepare_metadata_for_build_wheel( |
| metadata_directory, config_settings, _allow_fallback): |
| """Invoke optional prepare_metadata_for_build_wheel |
| |
| Implements a fallback by building a wheel if the hook isn't defined, |
| unless _allow_fallback is False in which case HookMissing is raised. |
| """ |
| backend = _build_backend() |
| try: |
| hook = backend.prepare_metadata_for_build_wheel |
| except AttributeError: |
| if not _allow_fallback: |
| raise HookMissing() |
| whl_basename = backend.build_wheel(metadata_directory, config_settings) |
| return _get_wheel_metadata_from_wheel(whl_basename, metadata_directory, |
| config_settings) |
| else: |
| return hook(metadata_directory, config_settings) |
| |
| |
| def prepare_metadata_for_build_editable( |
| metadata_directory, config_settings, _allow_fallback): |
| """Invoke optional prepare_metadata_for_build_editable |
| |
| Implements a fallback by building an editable wheel if the hook isn't |
| defined, unless _allow_fallback is False in which case HookMissing is |
| raised. |
| """ |
| backend = _build_backend() |
| try: |
| hook = backend.prepare_metadata_for_build_editable |
| except AttributeError: |
| if not _allow_fallback: |
| raise HookMissing() |
| try: |
| build_hook = backend.build_editable |
| except AttributeError: |
| raise HookMissing(hook_name='build_editable') |
| else: |
| whl_basename = build_hook(metadata_directory, config_settings) |
| return _get_wheel_metadata_from_wheel(whl_basename, |
| metadata_directory, |
| config_settings) |
| else: |
| return hook(metadata_directory, config_settings) |
| |
| |
| WHEEL_BUILT_MARKER = 'PEP517_ALREADY_BUILT_WHEEL' |
| |
| |
| def _dist_info_files(whl_zip): |
| """Identify the .dist-info folder inside a wheel ZipFile.""" |
| res = [] |
| for path in whl_zip.namelist(): |
| m = re.match(r'[^/\\]+-[^/\\]+\.dist-info/', path) |
| if m: |
| res.append(path) |
| if res: |
| return res |
| raise Exception("No .dist-info folder found in wheel") |
| |
| |
| def _get_wheel_metadata_from_wheel( |
| whl_basename, metadata_directory, config_settings): |
| """Extract the metadata from a wheel. |
| |
| Fallback for when the build backend does not |
| define the 'get_wheel_metadata' hook. |
| """ |
| from zipfile import ZipFile |
| with open(os.path.join(metadata_directory, WHEEL_BUILT_MARKER), 'wb'): |
| pass # Touch marker file |
| |
| whl_file = os.path.join(metadata_directory, whl_basename) |
| with ZipFile(whl_file) as zipf: |
| dist_info = _dist_info_files(zipf) |
| zipf.extractall(path=metadata_directory, members=dist_info) |
| return dist_info[0].split('/')[0] |
| |
| |
| def _find_already_built_wheel(metadata_directory): |
| """Check for a wheel already built during the get_wheel_metadata hook. |
| """ |
| if not metadata_directory: |
| return None |
| metadata_parent = os.path.dirname(metadata_directory) |
| if not os.path.isfile(pjoin(metadata_parent, WHEEL_BUILT_MARKER)): |
| return None |
| |
| whl_files = glob(os.path.join(metadata_parent, '*.whl')) |
| if not whl_files: |
| print('Found wheel built marker, but no .whl files') |
| return None |
| if len(whl_files) > 1: |
| print('Found multiple .whl files; unspecified behaviour. ' |
| 'Will call build_wheel.') |
| return None |
| |
| # Exactly one .whl file |
| return whl_files[0] |
| |
| |
| def build_wheel(wheel_directory, config_settings, metadata_directory=None): |
| """Invoke the mandatory build_wheel hook. |
| |
| If a wheel was already built in the |
| prepare_metadata_for_build_wheel fallback, this |
| will copy it rather than rebuilding the wheel. |
| """ |
| prebuilt_whl = _find_already_built_wheel(metadata_directory) |
| if prebuilt_whl: |
| shutil.copy2(prebuilt_whl, wheel_directory) |
| return os.path.basename(prebuilt_whl) |
| |
| return _build_backend().build_wheel(wheel_directory, config_settings, |
| metadata_directory) |
| |
| |
| def build_editable(wheel_directory, config_settings, metadata_directory=None): |
| """Invoke the optional build_editable hook. |
| |
| If a wheel was already built in the |
| prepare_metadata_for_build_editable fallback, this |
| will copy it rather than rebuilding the wheel. |
| """ |
| backend = _build_backend() |
| try: |
| hook = backend.build_editable |
| except AttributeError: |
| raise HookMissing() |
| else: |
| prebuilt_whl = _find_already_built_wheel(metadata_directory) |
| if prebuilt_whl: |
| shutil.copy2(prebuilt_whl, wheel_directory) |
| return os.path.basename(prebuilt_whl) |
| |
| return hook(wheel_directory, config_settings, metadata_directory) |
| |
| |
| def get_requires_for_build_sdist(config_settings): |
| """Invoke the optional get_requires_for_build_wheel hook |
| |
| Returns [] if the hook is not defined. |
| """ |
| backend = _build_backend() |
| try: |
| hook = backend.get_requires_for_build_sdist |
| except AttributeError: |
| return [] |
| else: |
| return hook(config_settings) |
| |
| |
| class _DummyException(Exception): |
| """Nothing should ever raise this exception""" |
| |
| |
| class GotUnsupportedOperation(Exception): |
| """For internal use when backend raises UnsupportedOperation""" |
| def __init__(self, traceback): |
| self.traceback = traceback |
| |
| |
| def build_sdist(sdist_directory, config_settings): |
| """Invoke the mandatory build_sdist hook.""" |
| backend = _build_backend() |
| try: |
| return backend.build_sdist(sdist_directory, config_settings) |
| except getattr(backend, 'UnsupportedOperation', _DummyException): |
| raise GotUnsupportedOperation(traceback.format_exc()) |
| |
| |
| HOOK_NAMES = { |
| 'get_requires_for_build_wheel', |
| 'prepare_metadata_for_build_wheel', |
| 'build_wheel', |
| 'get_requires_for_build_editable', |
| 'prepare_metadata_for_build_editable', |
| 'build_editable', |
| 'get_requires_for_build_sdist', |
| 'build_sdist', |
| '_supported_features', |
| } |
| |
| |
| def main(): |
| if len(sys.argv) < 3: |
| sys.exit("Needs args: hook_name, control_dir") |
| hook_name = sys.argv[1] |
| control_dir = sys.argv[2] |
| if hook_name not in HOOK_NAMES: |
| sys.exit("Unknown hook: %s" % hook_name) |
| hook = globals()[hook_name] |
| |
| hook_input = read_json(pjoin(control_dir, 'input.json')) |
| |
| json_out = {'unsupported': False, 'return_val': None} |
| try: |
| json_out['return_val'] = hook(**hook_input['kwargs']) |
| except BackendUnavailable as e: |
| json_out['no_backend'] = True |
| json_out['traceback'] = e.traceback |
| except BackendInvalid as e: |
| json_out['backend_invalid'] = True |
| json_out['backend_error'] = e.message |
| except GotUnsupportedOperation as e: |
| json_out['unsupported'] = True |
| json_out['traceback'] = e.traceback |
| except HookMissing as e: |
| json_out['hook_missing'] = True |
| json_out['missing_hook_name'] = e.hook_name or hook_name |
| |
| write_json(json_out, pjoin(control_dir, 'output.json'), indent=2) |
| |
| |
| if __name__ == '__main__': |
| main() |
