@uns-kit/cli 0.0.50 → 0.0.53

package/templates/python/venv/lib/python3.12/site-packages/setuptools/_distutils/core.py

@@ -1,289 +0,0 @@
-"""distutils.core
-
-The only module that needs to be imported to use the Distutils; provides
-the 'setup' function (which is to be called from the setup script).  Also
-indirectly provides the Distribution and Command classes, although they are
-really defined in distutils.dist and distutils.cmd.
-"""
-
-from __future__ import annotations
-
-import os
-import sys
-import tokenize
-from collections.abc import Iterable
-
-from .cmd import Command
-from .debug import DEBUG
-
-# Mainly import these so setup scripts can "from distutils.core import" them.
-from .dist import Distribution
-from .errors import (
-    CCompilerError,
-    DistutilsArgError,
-    DistutilsError,
-    DistutilsSetupError,
-)
-from .extension import Extension
-
-__all__ = ['Distribution', 'Command', 'Extension', 'setup']
-
-# This is a barebones help message generated displayed when the user
-# runs the setup script with no arguments at all.  More useful help
-# is generated with various --help options: global help, list commands,
-# and per-command help.
-USAGE = """\
-usage: %(script)s [global_opts] cmd1 [cmd1_opts] [cmd2 [cmd2_opts] ...]
-   or: %(script)s --help [cmd1 cmd2 ...]
-   or: %(script)s --help-commands
-   or: %(script)s cmd --help
-"""
-
-
-def gen_usage(script_name):
-    script = os.path.basename(script_name)
-    return USAGE % locals()
-
-
-# Some mild magic to control the behaviour of 'setup()' from 'run_setup()'.
-_setup_stop_after = None
-_setup_distribution = None
-
-# Legal keyword arguments for the setup() function
-setup_keywords = (
-    'distclass',
-    'script_name',
-    'script_args',
-    'options',
-    'name',
-    'version',
-    'author',
-    'author_email',
-    'maintainer',
-    'maintainer_email',
-    'url',
-    'license',
-    'description',
-    'long_description',
-    'keywords',
-    'platforms',
-    'classifiers',
-    'download_url',
-    'requires',
-    'provides',
-    'obsoletes',
-)
-
-# Legal keyword arguments for the Extension constructor
-extension_keywords = (
-    'name',
-    'sources',
-    'include_dirs',
-    'define_macros',
-    'undef_macros',
-    'library_dirs',
-    'libraries',
-    'runtime_library_dirs',
-    'extra_objects',
-    'extra_compile_args',
-    'extra_link_args',
-    'swig_opts',
-    'export_symbols',
-    'depends',
-    'language',
-)
-
-
-def setup(**attrs):  # noqa: C901
-    """The gateway to the Distutils: do everything your setup script needs
-    to do, in a highly flexible and user-driven way.  Briefly: create a
-    Distribution instance; find and parse config files; parse the command
-    line; run each Distutils command found there, customized by the options
-    supplied to 'setup()' (as keyword arguments), in config files, and on
-    the command line.
-
-    The Distribution instance might be an instance of a class supplied via
-    the 'distclass' keyword argument to 'setup'; if no such class is
-    supplied, then the Distribution class (in dist.py) is instantiated.
-    All other arguments to 'setup' (except for 'cmdclass') are used to set
-    attributes of the Distribution instance.
-
-    The 'cmdclass' argument, if supplied, is a dictionary mapping command
-    names to command classes.  Each command encountered on the command line
-    will be turned into a command class, which is in turn instantiated; any
-    class found in 'cmdclass' is used in place of the default, which is
-    (for command 'foo_bar') class 'foo_bar' in module
-    'distutils.command.foo_bar'.  The command class must provide a
-    'user_options' attribute which is a list of option specifiers for
-    'distutils.fancy_getopt'.  Any command-line options between the current
-    and the next command are used to set attributes of the current command
-    object.
-
-    When the entire command-line has been successfully parsed, calls the
-    'run()' method on each command object in turn.  This method will be
-    driven entirely by the Distribution object (which each command object
-    has a reference to, thanks to its constructor), and the
-    command-specific options that became attributes of each command
-    object.
-    """
-
-    global _setup_stop_after, _setup_distribution
-
-    # Determine the distribution class -- either caller-supplied or
-    # our Distribution (see below).
-    klass = attrs.get('distclass')
-    if klass:
-        attrs.pop('distclass')
-    else:
-        klass = Distribution
-
-    if 'script_name' not in attrs:
-        attrs['script_name'] = os.path.basename(sys.argv[0])
-    if 'script_args' not in attrs:
-        attrs['script_args'] = sys.argv[1:]
-
-    # Create the Distribution instance, using the remaining arguments
-    # (ie. everything except distclass) to initialize it
-    try:
-        _setup_distribution = dist = klass(attrs)
-    except DistutilsSetupError as msg:
-        if 'name' not in attrs:
-            raise SystemExit(f"error in setup command: {msg}")
-        else:
-            raise SystemExit("error in {} setup command: {}".format(attrs['name'], msg))
-
-    if _setup_stop_after == "init":
-        return dist
-
-    # Find and parse the config file(s): they will override options from
-    # the setup script, but be overridden by the command line.
-    dist.parse_config_files()
-
-    if DEBUG:
-        print("options (after parsing config files):")
-        dist.dump_option_dicts()
-
-    if _setup_stop_after == "config":
-        return dist
-
-    # Parse the command line and override config files; any
-    # command-line errors are the end user's fault, so turn them into
-    # SystemExit to suppress tracebacks.
-    try:
-        ok = dist.parse_command_line()
-    except DistutilsArgError as msg:
-        raise SystemExit(gen_usage(dist.script_name) + f"\nerror: {msg}")
-
-    if DEBUG:
-        print("options (after parsing command line):")
-        dist.dump_option_dicts()
-
-    if _setup_stop_after == "commandline":
-        return dist
-
-    # And finally, run all the commands found on the command line.
-    if ok:
-        return run_commands(dist)
-
-    return dist
-
-
-# setup ()
-
-
-def run_commands(dist):
-    """Given a Distribution object run all the commands,
-    raising ``SystemExit`` errors in the case of failure.
-
-    This function assumes that either ``sys.argv`` or ``dist.script_args``
-    is already set accordingly.
-    """
-    try:
-        dist.run_commands()
-    except KeyboardInterrupt:
-        raise SystemExit("interrupted")
-    except OSError as exc:
-        if DEBUG:
-            sys.stderr.write(f"error: {exc}\n")
-            raise
-        else:
-            raise SystemExit(f"error: {exc}")
-
-    except (DistutilsError, CCompilerError) as msg:
-        if DEBUG:
-            raise
-        else:
-            raise SystemExit("error: " + str(msg))
-
-    return dist
-
-
-def run_setup(script_name, script_args: Iterable[str] | None = None, stop_after="run"):
-    """Run a setup script in a somewhat controlled environment, and
-    return the Distribution instance that drives things.  This is useful
-    if you need to find out the distribution meta-data (passed as
-    keyword args from 'script' to 'setup()', or the contents of the
-    config files or command-line.
-
-    'script_name' is a file that will be read and run with 'exec()';
-    'sys.argv[0]' will be replaced with 'script' for the duration of the
-    call.  'script_args' is a list of strings; if supplied,
-    'sys.argv[1:]' will be replaced by 'script_args' for the duration of
-    the call.
-
-    'stop_after' tells 'setup()' when to stop processing; possible
-    values:
-      init
-        stop after the Distribution instance has been created and
-        populated with the keyword arguments to 'setup()'
-      config
-        stop after config files have been parsed (and their data
-        stored in the Distribution instance)
-      commandline
-        stop after the command-line ('sys.argv[1:]' or 'script_args')
-        have been parsed (and the data stored in the Distribution)
-      run [default]
-        stop after all commands have been run (the same as if 'setup()'
-        had been called in the usual way
-
-    Returns the Distribution instance, which provides all information
-    used to drive the Distutils.
-    """
-    if stop_after not in ('init', 'config', 'commandline', 'run'):
-        raise ValueError(f"invalid value for 'stop_after': {stop_after!r}")
-
-    global _setup_stop_after, _setup_distribution
-    _setup_stop_after = stop_after
-
-    save_argv = sys.argv.copy()
-    g = {'__file__': script_name, '__name__': '__main__'}
-    try:
-        try:
-            sys.argv[0] = script_name
-            if script_args is not None:
-                sys.argv[1:] = script_args
-            # tokenize.open supports automatic encoding detection
-            with tokenize.open(script_name) as f:
-                code = f.read().replace(r'\r\n', r'\n')
-                exec(code, g)
-        finally:
-            sys.argv = save_argv
-            _setup_stop_after = None
-    except SystemExit:
-        # Hmm, should we do something if exiting with a non-zero code
-        # (ie. error)?
-        pass
-
-    if _setup_distribution is None:
-        raise RuntimeError(
-            "'distutils.core.setup()' was never called -- "
-            f"perhaps '{script_name}' is not a Distutils setup script?"
-        )
-
-    # I wonder if the setup script's namespace -- g and l -- would be of
-    # any interest to callers?
-    # print "_setup_distribution:", _setup_distribution
-    return _setup_distribution
-
-
-# run_setup ()

package/templates/python/venv/lib/python3.12/site-packages/setuptools/_distutils/cygwinccompiler.py

@@ -1,31 +0,0 @@
-from .compilers.C import cygwin
-from .compilers.C.cygwin import (
-    CONFIG_H_NOTOK,
-    CONFIG_H_OK,
-    CONFIG_H_UNCERTAIN,
-    check_config_h,
-    get_msvcr,
-    is_cygwincc,
-)
-
-__all__ = [
-    'CONFIG_H_NOTOK',
-    'CONFIG_H_OK',
-    'CONFIG_H_UNCERTAIN',
-    'CygwinCCompiler',
-    'Mingw32CCompiler',
-    'check_config_h',
-    'get_msvcr',
-    'is_cygwincc',
-]
-
-
-CygwinCCompiler = cygwin.Compiler
-Mingw32CCompiler = cygwin.MinGW32Compiler
-
-
-get_versions = None
-"""
-A stand-in for the previous get_versions() function to prevent failures
-when monkeypatched. See pypa/setuptools#2969.
-"""

package/templates/python/venv/lib/python3.12/site-packages/setuptools/_distutils/debug.py

@@ -1,5 +0,0 @@
-import os
-
-# If DISTUTILS_DEBUG is anything other than the empty string, we run in
-# debug mode.
-DEBUG = os.environ.get('DISTUTILS_DEBUG')

package/templates/python/venv/lib/python3.12/site-packages/setuptools/_distutils/dep_util.py

@@ -1,14 +0,0 @@
-import warnings
-
-from . import _modified
-
-
-def __getattr__(name):
-    if name not in ['newer', 'newer_group', 'newer_pairwise']:
-        raise AttributeError(name)
-    warnings.warn(
-        "dep_util is Deprecated. Use functions from setuptools instead.",
-        DeprecationWarning,
-        stacklevel=2,
-    )
-    return getattr(_modified, name)

package/templates/python/venv/lib/python3.12/site-packages/setuptools/_distutils/dir_util.py

@@ -1,244 +0,0 @@
-"""distutils.dir_util
-
-Utility functions for manipulating directories and directory trees."""
-
-import functools
-import itertools
-import os
-import pathlib
-
-from . import file_util
-from ._log import log
-from .errors import DistutilsFileError, DistutilsInternalError
-
-
-class SkipRepeatAbsolutePaths(set):
-    """
-    Cache for mkpath.
-
-    In addition to cheapening redundant calls, eliminates redundant
-    "creating /foo/bar/baz" messages in dry-run mode.
-    """
-
-    def __init__(self):
-        SkipRepeatAbsolutePaths.instance = self
-
-    @classmethod
-    def clear(cls):
-        super(cls, cls.instance).clear()
-
-    def wrap(self, func):
-        @functools.wraps(func)
-        def wrapper(path, *args, **kwargs):
-            if path.absolute() in self:
-                return
-            result = func(path, *args, **kwargs)
-            self.add(path.absolute())
-            return result
-
-        return wrapper
-
-
-# Python 3.8 compatibility
-wrapper = SkipRepeatAbsolutePaths().wrap
-
-
-@functools.singledispatch
-@wrapper
-def mkpath(name: pathlib.Path, mode=0o777, verbose=True, dry_run=False) -> None:
-    """Create a directory and any missing ancestor directories.
-
-    If the directory already exists (or if 'name' is the empty string, which
-    means the current directory, which of course exists), then do nothing.
-    Raise DistutilsFileError if unable to create some directory along the way
-    (eg. some sub-path exists, but is a file rather than a directory).
-    If 'verbose' is true, log the directory created.
-    """
-    if verbose and not name.is_dir():
-        log.info("creating %s", name)
-
-    try:
-        dry_run or name.mkdir(mode=mode, parents=True, exist_ok=True)
-    except OSError as exc:
-        raise DistutilsFileError(f"could not create '{name}': {exc.args[-1]}")
-
-
-@mkpath.register
-def _(name: str, *args, **kwargs):
-    return mkpath(pathlib.Path(name), *args, **kwargs)
-
-
-@mkpath.register
-def _(name: None, *args, **kwargs):
-    """
-    Detect a common bug -- name is None.
-    """
-    raise DistutilsInternalError(f"mkpath: 'name' must be a string (got {name!r})")
-
-
-def create_tree(base_dir, files, mode=0o777, verbose=True, dry_run=False):
-    """Create all the empty directories under 'base_dir' needed to put 'files'
-    there.
-
-    'base_dir' is just the name of a directory which doesn't necessarily
-    exist yet; 'files' is a list of filenames to be interpreted relative to
-    'base_dir'.  'base_dir' + the directory portion of every file in 'files'
-    will be created if it doesn't already exist.  'mode', 'verbose' and
-    'dry_run' flags are as for 'mkpath()'.
-    """
-    # First get the list of directories to create
-    need_dir = set(os.path.join(base_dir, os.path.dirname(file)) for file in files)
-
-    # Now create them
-    for dir in sorted(need_dir):
-        mkpath(dir, mode, verbose=verbose, dry_run=dry_run)
-
-
-def copy_tree(
-    src,
-    dst,
-    preserve_mode=True,
-    preserve_times=True,
-    preserve_symlinks=False,
-    update=False,
-    verbose=True,
-    dry_run=False,
-):
-    """Copy an entire directory tree 'src' to a new location 'dst'.
-
-    Both 'src' and 'dst' must be directory names.  If 'src' is not a
-    directory, raise DistutilsFileError.  If 'dst' does not exist, it is
-    created with 'mkpath()'.  The end result of the copy is that every
-    file in 'src' is copied to 'dst', and directories under 'src' are
-    recursively copied to 'dst'.  Return the list of files that were
-    copied or might have been copied, using their output name.  The
-    return value is unaffected by 'update' or 'dry_run': it is simply
-    the list of all files under 'src', with the names changed to be
-    under 'dst'.
-
-    'preserve_mode' and 'preserve_times' are the same as for
-    'copy_file'; note that they only apply to regular files, not to
-    directories.  If 'preserve_symlinks' is true, symlinks will be
-    copied as symlinks (on platforms that support them!); otherwise
-    (the default), the destination of the symlink will be copied.
-    'update' and 'verbose' are the same as for 'copy_file'.
-    """
-    if not dry_run and not os.path.isdir(src):
-        raise DistutilsFileError(f"cannot copy tree '{src}': not a directory")
-    try:
-        names = os.listdir(src)
-    except OSError as e:
-        if dry_run:
-            names = []
-        else:
-            raise DistutilsFileError(f"error listing files in '{src}': {e.strerror}")
-
-    if not dry_run:
-        mkpath(dst, verbose=verbose)
-
-    copy_one = functools.partial(
-        _copy_one,
-        src=src,
-        dst=dst,
-        preserve_symlinks=preserve_symlinks,
-        verbose=verbose,
-        dry_run=dry_run,
-        preserve_mode=preserve_mode,
-        preserve_times=preserve_times,
-        update=update,
-    )
-    return list(itertools.chain.from_iterable(map(copy_one, names)))
-
-
-def _copy_one(
-    name,
-    *,
-    src,
-    dst,
-    preserve_symlinks,
-    verbose,
-    dry_run,
-    preserve_mode,
-    preserve_times,
-    update,
-):
-    src_name = os.path.join(src, name)
-    dst_name = os.path.join(dst, name)
-
-    if name.startswith('.nfs'):
-        # skip NFS rename files
-        return
-
-    if preserve_symlinks and os.path.islink(src_name):
-        link_dest = os.readlink(src_name)
-        if verbose >= 1:
-            log.info("linking %s -> %s", dst_name, link_dest)
-        if not dry_run:
-            os.symlink(link_dest, dst_name)
-        yield dst_name
-
-    elif os.path.isdir(src_name):
-        yield from copy_tree(
-            src_name,
-            dst_name,
-            preserve_mode,
-            preserve_times,
-            preserve_symlinks,
-            update,
-            verbose=verbose,
-            dry_run=dry_run,
-        )
-    else:
-        file_util.copy_file(
-            src_name,
-            dst_name,
-            preserve_mode,
-            preserve_times,
-            update,
-            verbose=verbose,
-            dry_run=dry_run,
-        )
-        yield dst_name
-
-
-def _build_cmdtuple(path, cmdtuples):
-    """Helper for remove_tree()."""
-    for f in os.listdir(path):
-        real_f = os.path.join(path, f)
-        if os.path.isdir(real_f) and not os.path.islink(real_f):
-            _build_cmdtuple(real_f, cmdtuples)
-        else:
-            cmdtuples.append((os.remove, real_f))
-    cmdtuples.append((os.rmdir, path))
-
-
-def remove_tree(directory, verbose=True, dry_run=False):
-    """Recursively remove an entire directory tree.
-
-    Any errors are ignored (apart from being reported to stdout if 'verbose'
-    is true).
-    """
-    if verbose >= 1:
-        log.info("removing '%s' (and everything under it)", directory)
-    if dry_run:
-        return
-    cmdtuples = []
-    _build_cmdtuple(directory, cmdtuples)
-    for cmd in cmdtuples:
-        try:
-            cmd[0](cmd[1])
-            # Clear the cache
-            SkipRepeatAbsolutePaths.clear()
-        except OSError as exc:
-            log.warning("error removing %s: %s", directory, exc)
-
-
-def ensure_relative(path):
-    """Take the full path 'path', and make it a relative path.
-
-    This is useful to make 'path' the second argument to os.path.join().
-    """
-    drive, path = os.path.splitdrive(path)
-    if path[0:1] == os.sep:
-        path = drive + path[1:]
-    return path