prompteval-core 0.1.0__py3-none-any.whl

venv/Lib/site-packages/build/__main__.py

@@ -0,0 +1,588 @@
+# SPDX-License-Identifier: MIT
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import contextvars
+import json
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import tempfile
+import textwrap
+import traceback
+import warnings
+
+from collections.abc import Iterator, Mapping, Sequence
+from functools import partial
+from typing import Any, NoReturn, TextIO
+
+import pyproject_hooks
+
+import build
+
+from . import ProjectBuilder, _ctx
+from . import env as _env
+from ._exceptions import BuildBackendException, BuildException, FailedProcessError
+from ._types import ConfigSettings, Distribution, StrPath, SubprocessRunner
+from .env import DefaultIsolatedEnv
+
+
+_COLORS = {
+    'red': '\33[91m',
+    'green': '\33[92m',
+    'yellow': '\33[93m',
+    'bold': '\33[1m',
+    'dim': '\33[2m',
+    'underline': '\33[4m',
+    'reset': '\33[0m',
+}
+_NO_COLORS = dict.fromkeys(_COLORS, '')
+
+
+_styles = contextvars.ContextVar('_styles', default=_COLORS)
+
+
+def _init_colors() -> None:
+    if 'NO_COLOR' in os.environ:
+        if 'FORCE_COLOR' in os.environ:
+            warnings.warn('Both NO_COLOR and FORCE_COLOR environment variables are set, disabling color', stacklevel=2)
+        _styles.set(_NO_COLORS)
+    elif 'FORCE_COLOR' in os.environ or sys.stdout.isatty():
+        return
+    _styles.set(_NO_COLORS)
+
+
+def _cprint(fmt: str = '', msg: str = '', file: TextIO | None = None) -> None:
+    print(fmt.format(msg, **_styles.get()), file=file, flush=True)
+
+
+def _showwarning(
+    message: Warning | str,
+    category: type[Warning],
+    filename: str,
+    lineno: int,
+    file: TextIO | None = None,
+    line: str | None = None,
+) -> None:  # pragma: no cover
+    _cprint('{yellow}WARNING{reset} {}', str(message), file)
+
+
+def _make_logger() -> _ctx.Logger:
+    max_terminal_width = shutil.get_terminal_size().columns - 2
+    if max_terminal_width <= 0:  # pragma: no cover
+        max_terminal_width = 78
+
+    fill = partial(textwrap.fill, subsequent_indent='  ', width=max_terminal_width)
+
+    def log(message: str, *, origin: tuple[str, ...] | None = None) -> None:
+        if _ctx.verbosity >= -1:
+            if origin is None:
+                (first, *rest) = message.splitlines()
+                _cprint('{bold}{}{reset}', fill(first, initial_indent='* '), file=sys.stderr)
+                for line in rest:
+                    print(fill(line, initial_indent='  '), file=sys.stderr)
+
+            elif origin[0] == 'subprocess':
+                initial_indent = '> ' if origin[1] == 'cmd' else '< '
+                for line in message.splitlines():
+                    _cprint('{dim}{}{reset}', fill(line, initial_indent=initial_indent), file=sys.stderr)
+
+    return log
+
+
+def _setup_cli(*, verbosity: int) -> None:
+    warnings.showwarning = _showwarning
+
+    if platform.system() == 'Windows':
+        try:
+            import colorama
+
+            colorama.init()
+        except ModuleNotFoundError:
+            pass
+
+    _init_colors()
+
+    _ctx.LOGGER.set(_make_logger())
+    _ctx.VERBOSITY.set(verbosity)
+
+
+def _error(msg: str, code: int = 1) -> NoReturn:  # pragma: no cover
+    """
+    Print an error message and exit. Will color the output when writing to a TTY.
+
+    :param msg: Error message
+    :param code: Error code
+    """
+    _cprint('{red}ERROR{reset} {}', msg, file=sys.stderr)
+    raise SystemExit(code)
+
+
+def _format_dep_chain(dep_chain: Sequence[str]) -> str:
+    return ' -> '.join(dep.partition(';')[0].strip() for dep in dep_chain)
+
+
+@contextlib.contextmanager
+def _bootstrap_build_env(
+    isolation: bool,
+    srcdir: StrPath,
+    distribution: Distribution,
+    config_settings: ConfigSettings | None,
+    skip_dependency_check: bool,
+    installer: _env.Installer,
+    runner: SubprocessRunner | None = None,
+) -> Iterator[ProjectBuilder]:
+    if isolation:
+        with DefaultIsolatedEnv(installer=installer) as env:
+            make_builder = partial(ProjectBuilder.from_isolated_env, env, srcdir)
+            if runner:
+                make_builder = partial(make_builder, runner=runner)
+            builder = make_builder()
+
+            # first install the build dependencies
+            env.install(builder.build_system_requires)
+            # then get the extra required dependencies from the backend (which was installed in the call above :P)
+            env.install(builder.get_requires_for_build(distribution, config_settings))
+
+            yield builder
+
+    else:
+        make_builder = partial(ProjectBuilder, srcdir)
+        if runner:
+            make_builder = partial(make_builder, runner=runner)
+        builder = make_builder()
+
+        if not skip_dependency_check:
+            missing = builder.check_dependencies(distribution, config_settings)
+            if missing:
+                dependencies = ''.join(
+                    '\n\t' + dep for deps in missing for dep in (deps[0], _format_dep_chain(deps[1:])) if dep
+                )
+                _cprint()
+                _error(f'Missing dependencies:{dependencies}')
+
+        yield builder
+
+
+def _build(
+    isolation: bool,
+    srcdir: StrPath,
+    outdir: StrPath,
+    distribution: Distribution,
+    config_settings: ConfigSettings | None,
+    skip_dependency_check: bool,
+    installer: _env.Installer,
+) -> str:
+    with _bootstrap_build_env(
+        isolation,
+        srcdir,
+        distribution,
+        config_settings,
+        skip_dependency_check,
+        installer,
+        pyproject_hooks.quiet_subprocess_runner if _ctx.verbosity < 0 else None,
+    ) as builder:
+        return builder.build(distribution, outdir, config_settings)
+
+
+@contextlib.contextmanager
+def _handle_build_error() -> Iterator[None]:
+    try:
+        yield
+    except (BuildException, FailedProcessError) as e:
+        _error(str(e))
+    except BuildBackendException as e:
+        if isinstance(e.exception, subprocess.CalledProcessError):
+            _cprint()
+            _error(str(e))
+
+        if e.exc_info:
+            tb_lines = traceback.format_exception(
+                e.exc_info[0],
+                e.exc_info[1],
+                e.exc_info[2],
+                limit=-1,
+            )
+            tb = ''.join(tb_lines)
+        else:  # pragma: no cover
+            tb = traceback.format_exc(-1)  # type: ignore[unreachable]
+        _cprint('\n{dim}{}{reset}\n', tb.strip('\n'))
+        _error(str(e))
+    except Exception as e:  # pragma: no cover
+        tb = traceback.format_exc().strip('\n')
+        _cprint('\n{dim}{}{reset}\n', tb)
+        _error(str(e))
+
+
+def _natural_language_list(elements: Sequence[str]) -> str:
+    if len(elements) == 0:
+        msg = 'no elements'
+        raise IndexError(msg)
+    elif len(elements) == 1:
+        return elements[0]
+    else:
+        return '{} and {}'.format(
+            ', '.join(elements[:-1]),
+            elements[-1],
+        )
+
+
+def build_package(
+    srcdir: StrPath,
+    outdir: StrPath,
+    distributions: Sequence[Distribution],
+    config_settings: ConfigSettings | None = None,
+    isolation: bool = True,
+    skip_dependency_check: bool = False,
+    installer: _env.Installer = 'pip',
+) -> list[str]:
+    """
+    Run the build process.
+
+    :param srcdir: Source directory
+    :param outdir: Output directory
+    :param distribution: Distribution to build (sdist or wheel)
+    :param config_settings: Configuration settings to be passed to the backend
+    :param isolation: Isolate the build in a separate environment
+    :param skip_dependency_check: Do not perform the dependency check
+    """
+    built: list[str] = []
+    for distribution in distributions:
+        out = _build(isolation, srcdir, outdir, distribution, config_settings, skip_dependency_check, installer)
+        built.append(os.path.basename(out))
+    return built
+
+
+def build_package_via_sdist(
+    srcdir: StrPath,
+    outdir: StrPath,
+    distributions: Sequence[Distribution],
+    config_settings: ConfigSettings | None = None,
+    isolation: bool = True,
+    skip_dependency_check: bool = False,
+    installer: _env.Installer = 'pip',
+) -> list[str]:
+    """
+    Build a sdist and then the specified distributions from it.
+
+    :param srcdir: Source directory
+    :param outdir: Output directory
+    :param distribution: Distribution to build (only wheel)
+    :param config_settings: Configuration settings to be passed to the backend
+    :param isolation: Isolate the build in a separate environment
+    :param skip_dependency_check: Do not perform the dependency check
+    """
+    from ._compat import tarfile
+
+    if 'sdist' in distributions:
+        msg = 'Only binary distributions are allowed but sdist was specified'
+        raise ValueError(msg)
+
+    sdist = _build(isolation, srcdir, outdir, 'sdist', config_settings, skip_dependency_check, installer)
+
+    sdist_name = os.path.basename(sdist)
+    sdist_out = tempfile.mkdtemp(prefix='build-via-sdist-')
+    built: list[str] = []
+    if distributions:
+        # extract sdist
+        with tarfile.TarFile.open(sdist) as t:
+            t.extractall(sdist_out)
+            try:
+                _ctx.log(f'Building {_natural_language_list(distributions)} from sdist')
+                srcdir = os.path.join(sdist_out, sdist_name[: -len('.tar.gz')])
+                for distribution in distributions:
+                    out = _build(isolation, srcdir, outdir, distribution, config_settings, skip_dependency_check, installer)
+                    built.append(os.path.basename(out))
+            finally:
+                shutil.rmtree(sdist_out, ignore_errors=True)
+    return [sdist_name, *built]
+
+
+def _build_metadata(
+    srcdir: StrPath,
+    outdir: StrPath,
+    distributions: Sequence[Distribution],
+    config_settings: ConfigSettings | None = None,
+    isolation: bool = True,
+    skip_dependency_check: bool = False,
+    installer: _env.Installer = 'pip',
+) -> list[str]:
+    import packaging.metadata
+
+    def run_subprocess(cmd: Sequence[StrPath], cwd: str | None = None, extra_environ: Mapping[str, str] | None = None) -> None:
+        env = os.environ.copy()
+        if extra_environ:
+            env.update(extra_environ)
+        _ctx.run_subprocess(cmd, cwd, env)
+
+    with (
+        _bootstrap_build_env(
+            isolation, srcdir, 'wheel', config_settings, skip_dependency_check, installer, runner=run_subprocess
+        ) as builder,
+        tempfile.TemporaryDirectory() as tempdir,
+        open(
+            os.path.join(builder.metadata_path(tempdir), 'METADATA'),
+            'rb',
+        ) as metadata_file,
+    ):
+        valid_metadata, _ = packaging.metadata.parse_email(metadata_file.read())
+    print(
+        json.dumps(valid_metadata, ensure_ascii=False, indent=2),
+    )
+
+    return []
+
+
+def main_parser() -> argparse.ArgumentParser:
+    """
+    Construct the main parser.
+    """
+
+    class NegativeCountAction(argparse.Action):
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            dest: str,
+            default: Any = None,
+            help: str | None = None,
+        ) -> None:
+            super().__init__(
+                option_strings=option_strings,
+                dest=dest,
+                nargs=0,
+                default=default,
+                help=help,
+            )
+
+        def __call__(
+            self,
+            parser: argparse.ArgumentParser,
+            namespace: object,
+            values: str | Sequence[Any] | None,
+            option_string: str | None = None,
+        ) -> None:
+            setattr(namespace, self.dest, getattr(namespace, self.dest, 0) - 1)
+
+    formatter_class = argparse.RawDescriptionHelpFormatter
+
+    make_parser = partial(
+        argparse.ArgumentParser,
+        add_help=False,
+        description="""\
+    A simple, correct Python build frontend.
+
+    By default, a source distribution (sdist) is built from the project root
+    and a binary distribution (wheel) is built from the sdist.
+    If this is undesirable, you can pass `--sdist` and/or `--wheel`
+    to build distributions independently of each other.
+    """.rstrip(),
+        # Prevent argparse from taking up the entire width of the terminal window
+        # which impedes readability. Also keep the description formatted.
+        formatter_class=formatter_class,
+    )
+    if sys.version_info >= (3, 14):
+        make_parser = partial(make_parser, suggest_on_error=True)
+
+    parser = make_parser()
+    parser.add_argument(
+        'srcdir',
+        type=str,
+        nargs='?',
+        default=os.getcwd(),
+        help='source directory (defaults to the current working directory)',
+    )
+
+    global_group = parser.add_argument_group('global options')
+    global_group.add_argument(
+        '-h',
+        '--help',
+        action='help',
+        default=argparse.SUPPRESS,
+        help='show this help message and exit',
+    )
+    global_group.add_argument(
+        '--version',
+        '-V',
+        action='version',
+        version=f'build {build.__version__} ({",".join(build.__path__)})',
+    )
+    verbosity_exclusive_group = global_group.add_mutually_exclusive_group()
+    verbosity_exclusive_group.add_argument(
+        '--quiet',
+        '-q',
+        dest='verbosity',
+        action=NegativeCountAction,
+        default=0,
+        help='reduce verbosity',
+    )
+    verbosity_exclusive_group.add_argument(
+        '--verbose',
+        '-v',
+        dest='verbosity',
+        action='count',
+        default=0,
+        help='increase verbosity',
+    )
+
+    build_group = parser.add_argument_group('build options')
+    build_group.add_argument(
+        '--outdir',
+        '-o',
+        type=str,
+        help=f'output directory (defaults to {{srcdir}}{os.sep}dist).  Cannot be used together with ``--metadata``',
+        metavar='PATH',
+    )
+    build_group.add_argument(
+        '--sdist',
+        '-s',
+        dest='distributions',
+        action='append_const',
+        const='sdist',
+        help='build a source distribution (disables the default behavior)',
+    )
+    build_group.add_argument(
+        '--wheel',
+        '-w',
+        dest='distributions',
+        action='append_const',
+        const='wheel',
+        help='build a wheel (disables the default behavior)',
+    )
+    build_group.add_argument(
+        '--metadata',
+        action='store_true',
+        help="print out a wheel's metadata in JSON format. Cannot be used in conjunction with ``--sdist`` or ``--wheel``",
+    )
+    config_exclusive_group = build_group.add_mutually_exclusive_group()
+    config_exclusive_group.add_argument(
+        '--config-setting',
+        '-C',
+        dest='config_settings',
+        action='append',
+        help='settings to pass to the backend.  Multiple settings can be provided. '
+        'Settings beginning with a hyphen will erroneously be interpreted as options to build if separated '
+        'by a space; use ``--config-setting=--my-setting -C--my-other-setting`` instead',
+        metavar='KEY[=VALUE]',
+    )
+    config_exclusive_group.add_argument(
+        '--config-json',
+        dest='config_json',
+        help='settings to pass to the backend as a JSON object. '
+        'This is an alternative to ``--config-setting`` that allows complex nested structures. '
+        'Cannot be used together with ``--config-setting``',
+        metavar='JSON_STRING',
+    )
+
+    install_group = parser.add_argument_group('installation options')
+    env_exclusive_group = install_group.add_mutually_exclusive_group()
+    env_exclusive_group.add_argument(
+        '--installer',
+        choices=_env.INSTALLERS,
+        help='Python package installer to use (defaults to pip)',
+    )
+    env_exclusive_group.add_argument(
+        '--no-isolation',
+        '-n',
+        action='store_true',
+        help='disable building the project in an isolated virtual environment. '
+        'Build dependencies must be installed separately when this option is used',
+    )
+    install_group.add_argument(
+        '--skip-dependency-check',
+        '-x',
+        action='store_true',
+        help='do not check that build dependencies are installed',
+    )
+
+    return parser
+
+
+def _parse_config_settings(raw_config_settings: list[str]) -> dict[str, Any]:
+    config_settings = dict[str, Any]()
+
+    for arg in raw_config_settings:
+        setting, _, value = arg.partition('=')
+        if setting not in config_settings:
+            config_settings[setting] = value
+        else:
+            if not isinstance(config_settings[setting], list):
+                config_settings[setting] = [config_settings[setting]]
+
+            config_settings[setting].append(value)
+
+    return config_settings
+
+
+def main(cli_args: Sequence[str], prog: str | None = None) -> None:
+    """
+    Parse the CLI arguments and invoke the build process.
+
+    :param cli_args: CLI arguments
+    :param prog: Program name to show in help text
+    """
+    parser = main_parser()
+    if prog:
+        parser.prog = prog
+    args = parser.parse_args(cli_args)
+
+    _setup_cli(verbosity=args.verbosity)
+
+    config_settings = dict[str, Any]()
+
+    # Handle --config-json
+    if args.config_json:
+        try:
+            config_settings = json.loads(args.config_json)
+            if not isinstance(config_settings, dict):
+                _error('--config-json must contain a JSON object (dict), not a list or primitive value')
+        except json.JSONDecodeError as e:
+            _error(f'Invalid JSON in --config-json: {e}')
+
+    # Handle --config-setting (original logic)
+    elif args.config_settings:
+        config_settings = _parse_config_settings(args.config_settings)
+
+    # outdir is relative to srcdir only if omitted.
+    outdir = os.path.join(args.srcdir, 'dist') if args.outdir is None else args.outdir
+
+    if args.metadata and args.distributions:
+        parser.error('--metadata: not allowed with --sdist or --wheel')
+    elif args.metadata:
+        build = partial(_build_metadata, distributions=['wheel'])
+    elif args.distributions:
+        build = partial(build_package, distributions=args.distributions)
+    else:
+        build = partial(build_package_via_sdist, distributions=['wheel'])
+
+    with _handle_build_error():
+        built = build(
+            args.srcdir,
+            outdir,
+            config_settings=config_settings,
+            isolation=not args.no_isolation,
+            skip_dependency_check=args.skip_dependency_check,
+            installer=args.installer,
+        )
+        if _ctx.verbosity >= -1 and built:
+            artifact_list = _natural_language_list(
+                ['{underline}{}{reset}{bold}{green}'.format(artifact, **_styles.get()) for artifact in built]
+            )
+            _cprint('{bold}{green}Successfully built {}{reset}', artifact_list)
+
+
+def entrypoint() -> None:
+    main(sys.argv[1:])
+
+
+if __name__ == '__main__':  # pragma: no cover
+    main(sys.argv[1:], 'python -m build')
+
+
+__all__ = [
+    'main',
+    'main_parser',
+]