android-notify 1.60.0__py3-none-any.whl → 1.60.1__py3-none-any.whl

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

@@ -1,486 +0,0 @@
-# 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, Sequence
-from functools import partial
-from typing import NoReturn, TextIO
-
-import build
-
-from . import ProjectBuilder, _ctx
-from . import env as _env
-from ._exceptions import BuildBackendException, BuildException, FailedProcessError
-from ._types import ConfigSettings, Distribution, StrPath
-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))
-
-
-_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 origin is None:
-        (first, *rest) = message.splitlines()
-        _cprint('{bold}{}{reset}', _fill(first, initial_indent='* '))
-        for line in rest:
-            print(_fill(line, initial_indent='  '))
-
-    elif origin[0] == 'subprocess':
-        initial_indent = '> ' if origin[1] == 'cmd' else '< '
-        file = sys.stderr if origin[1] == 'stderr' else None
-        for line in message.splitlines():
-            _cprint('{dim}{}{reset}', _fill(line, initial_indent=initial_indent), file=file)
-
-
-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(_log)
-    _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)
-    raise SystemExit(code)
-
-
-def _format_dep_chain(dep_chain: Sequence[str]) -> str:
-    return ' -> '.join(dep.partition(';')[0].strip() for dep in dep_chain)
-
-
-def _build_in_isolated_env(
-    srcdir: StrPath,
-    outdir: StrPath,
-    distribution: Distribution,
-    config_settings: ConfigSettings | None,
-    installer: _env.Installer,
-) -> str:
-    with DefaultIsolatedEnv(installer=installer) as env:
-        builder = ProjectBuilder.from_isolated_env(env, srcdir)
-        # 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 or {}))
-        return builder.build(distribution, outdir, config_settings or {})
-
-
-def _build_in_current_env(
-    srcdir: StrPath,
-    outdir: StrPath,
-    distribution: Distribution,
-    config_settings: ConfigSettings | None,
-    skip_dependency_check: bool = False,
-) -> str:
-    builder = ProjectBuilder(srcdir)
-
-    if not skip_dependency_check:
-        missing = builder.check_dependencies(distribution, config_settings or {})
-        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}')
-
-    return builder.build(distribution, outdir, config_settings or {})
-
-
-def _build(
-    isolation: bool,
-    srcdir: StrPath,
-    outdir: StrPath,
-    distribution: Distribution,
-    config_settings: ConfigSettings | None,
-    skip_dependency_check: bool,
-    installer: _env.Installer,
-) -> str:
-    if isolation:
-        return _build_in_isolated_env(srcdir, outdir, distribution, config_settings, installer)
-    else:
-        return _build_in_current_env(srcdir, outdir, distribution, config_settings, skip_dependency_check)
-
-
-@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)
-        _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',
-) -> Sequence[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',
-) -> Sequence[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 main_parser() -> argparse.ArgumentParser:
-    """
-    Construct the main parser.
-    """
-    formatter_class = partial(argparse.RawDescriptionHelpFormatter, width=min(_max_terminal_width, 127))
-    # Workaround for 3.14.0 beta 1, can remove once beta 2 is out
-    if sys.version_info >= (3, 14):
-        formatter_class = partial(formatter_class, color=True)
-
-    make_parser = partial(
-        argparse.ArgumentParser,
-        description=textwrap.indent(
-            textwrap.dedent(
-                """
-                A simple, correct Python build frontend.
-
-                By default, a source distribution (sdist) is built from {srcdir}
-                and a binary distribution (wheel) is built from the sdist.
-                This is recommended as it will ensure the sdist can be used
-                to build wheels.
-
-                Pass -s/--sdist and/or -w/--wheel to build a specific distribution.
-                If you do this, the default behavior will be disabled, and all
-                artifacts will be built from {srcdir} (even if you combine
-                -w/--wheel with -s/--sdist, the wheel will be built from {srcdir}).
-                """
-            ).strip(),
-            '    ',
-        ),
-        # 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, color=True)
-
-    parser = make_parser()
-    parser.add_argument(
-        'srcdir',
-        type=str,
-        nargs='?',
-        default=os.getcwd(),
-        help='source directory (defaults to current directory)',
-    )
-    parser.add_argument(
-        '--version',
-        '-V',
-        action='version',
-        version=f'build {build.__version__} ({",".join(build.__path__)})',
-    )
-    parser.add_argument(
-        '--verbose',
-        '-v',
-        dest='verbosity',
-        action='count',
-        default=0,
-        help='increase verbosity',
-    )
-    parser.add_argument(
-        '--sdist',
-        '-s',
-        dest='distributions',
-        action='append_const',
-        const='sdist',
-        help='build a source distribution (disables the default behavior)',
-    )
-    parser.add_argument(
-        '--wheel',
-        '-w',
-        dest='distributions',
-        action='append_const',
-        const='wheel',
-        help='build a wheel (disables the default behavior)',
-    )
-    parser.add_argument(
-        '--outdir',
-        '-o',
-        type=str,
-        help=f'output directory (defaults to {{srcdir}}{os.sep}dist)',
-        metavar='PATH',
-    )
-    parser.add_argument(
-        '--skip-dependency-check',
-        '-x',
-        action='store_true',
-        help='do not check that build dependencies are installed',
-    )
-    env_group = parser.add_mutually_exclusive_group()
-    env_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',
-    )
-    env_group.add_argument(
-        '--installer',
-        choices=_env.INSTALLERS,
-        help='Python package installer to use (defaults to pip)',
-    )
-    config_group = parser.add_mutually_exclusive_group()
-    config_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 character; use ``--config-setting=--my-setting -C--my-other-setting``',
-        metavar='KEY[=VALUE]',
-    )
-    config_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',
-    )
-
-    return parser
-
-
-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 = {}
-
-    # 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:
-        for arg in args.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)
-
-    # outdir is relative to srcdir only if omitted.
-    outdir = os.path.join(args.srcdir, 'dist') if args.outdir is None else args.outdir
-
-    distributions: list[Distribution] = args.distributions
-    if distributions:
-        build_call = build_package
-    else:
-        build_call = build_package_via_sdist
-        distributions = ['wheel']
-
-    with _handle_build_error():
-        built = build_call(
-            args.srcdir,
-            outdir,
-            distributions,
-            config_settings,
-            not args.no_isolation,
-            args.skip_dependency_check,
-            args.installer,
-        )
-        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',
-]