morel-theme-pack 0.1.31 → 0.1.321

data/assets/env/lib/python3.10/site-packages/pip/_vendor/pep517/in_process/_in_process.py

@@ -1,351 +0,0 @@
-"""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()

data/assets/env/lib/python3.10/site-packages/pip/_vendor/pep517/meta.py

@@ -1,93 +0,0 @@
-"""Build metadata for a project using PEP 517 hooks.
-"""
-import argparse
-import functools
-import logging
-import os
-import shutil
-import tempfile
-
-try:
-    import importlib.metadata as imp_meta
-except ImportError:
-    import importlib_metadata as imp_meta
-
-try:
-    from zipfile import Path
-except ImportError:
-    from zipp import Path
-
-from .build import compat_system, load_system, validate_system
-from .dirtools import dir_to_zipfile
-from .envbuild import BuildEnvironment
-from .wrappers import Pep517HookCaller, quiet_subprocess_runner
-
-log = logging.getLogger(__name__)
-
-
-def _prep_meta(hooks, env, dest):
-    reqs = hooks.get_requires_for_build_wheel({})
-    log.info('Got build requires: %s', reqs)
-
-    env.pip_install(reqs)
-    log.info('Installed dynamic build dependencies')
-
-    with tempfile.TemporaryDirectory() as td:
-        log.info('Trying to build metadata in %s', td)
-        filename = hooks.prepare_metadata_for_build_wheel(td, {})
-        source = os.path.join(td, filename)
-        shutil.move(source, os.path.join(dest, os.path.basename(filename)))
-
-
-def build(source_dir='.', dest=None, system=None):
-    system = system or load_system(source_dir)
-    dest = os.path.join(source_dir, dest or 'dist')
-    os.makedirs(dest, exist_ok=True)
-    validate_system(system)
-    hooks = Pep517HookCaller(
-        source_dir, system['build-backend'], system.get('backend-path')
-    )
-
-    with hooks.subprocess_runner(quiet_subprocess_runner):
-        with BuildEnvironment() as env:
-            env.pip_install(system['requires'])
-            _prep_meta(hooks, env, dest)
-
-
-def build_as_zip(builder=build):
-    with tempfile.TemporaryDirectory() as out_dir:
-        builder(dest=out_dir)
-        return dir_to_zipfile(out_dir)
-
-
-def load(root):
-    """
-    Given a source directory (root) of a package,
-    return an importlib.metadata.Distribution object
-    with metadata build from that package.
-    """
-    root = os.path.expanduser(root)
-    system = compat_system(root)
-    builder = functools.partial(build, source_dir=root, system=system)
-    path = Path(build_as_zip(builder))
-    return imp_meta.PathDistribution(path)
-
-
-parser = argparse.ArgumentParser()
-parser.add_argument(
-    'source_dir',
-    help="A directory containing pyproject.toml",
-)
-parser.add_argument(
-    '--out-dir', '-o',
-    help="Destination in which to save the builds relative to source dir",
-)
-
-
-def main():
-    args = parser.parse_args()
-    build(args.source_dir, args.out_dir)
-
-
-if __name__ == '__main__':
-    main()