@scrypted/server 0.0.141 → 0.0.142

package/.venv/lib/python3.9/site-packages/pip/_internal/utils/subprocess.py

@@ -1,289 +0,0 @@
-import logging
-import os
-import shlex
-import subprocess
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Iterable,
-    List,
-    Mapping,
-    Optional,
-    Union,
-)
-
-from pip._internal.cli.spinners import SpinnerInterface, open_spinner
-from pip._internal.exceptions import InstallationSubprocessError
-from pip._internal.utils.logging import VERBOSE, subprocess_logger
-from pip._internal.utils.misc import HiddenText
-
-if TYPE_CHECKING:
-    # Literal was introduced in Python 3.8.
-    #
-    # TODO: Remove `if TYPE_CHECKING` when dropping support for Python 3.7.
-    from typing import Literal
-
-CommandArgs = List[Union[str, HiddenText]]
-
-
-LOG_DIVIDER = "----------------------------------------"
-
-
-def make_command(*args: Union[str, HiddenText, CommandArgs]) -> CommandArgs:
-    """
-    Create a CommandArgs object.
-    """
-    command_args: CommandArgs = []
-    for arg in args:
-        # Check for list instead of CommandArgs since CommandArgs is
-        # only known during type-checking.
-        if isinstance(arg, list):
-            command_args.extend(arg)
-        else:
-            # Otherwise, arg is str or HiddenText.
-            command_args.append(arg)
-
-    return command_args
-
-
-def format_command_args(args: Union[List[str], CommandArgs]) -> str:
-    """
-    Format command arguments for display.
-    """
-    # For HiddenText arguments, display the redacted form by calling str().
-    # Also, we don't apply str() to arguments that aren't HiddenText since
-    # this can trigger a UnicodeDecodeError in Python 2 if the argument
-    # has type unicode and includes a non-ascii character.  (The type
-    # checker doesn't ensure the annotations are correct in all cases.)
-    return " ".join(
-        shlex.quote(str(arg)) if isinstance(arg, HiddenText) else shlex.quote(arg)
-        for arg in args
-    )
-
-
-def reveal_command_args(args: Union[List[str], CommandArgs]) -> List[str]:
-    """
-    Return the arguments in their raw, unredacted form.
-    """
-    return [arg.secret if isinstance(arg, HiddenText) else arg for arg in args]
-
-
-def make_subprocess_output_error(
-    cmd_args: Union[List[str], CommandArgs],
-    cwd: Optional[str],
-    lines: List[str],
-    exit_status: int,
-) -> str:
-    """
-    Create and return the error message to use to log a subprocess error
-    with command output.
-
-    :param lines: A list of lines, each ending with a newline.
-    """
-    command = format_command_args(cmd_args)
-
-    # We know the joined output value ends in a newline.
-    output = "".join(lines)
-    msg = (
-        # Use a unicode string to avoid "UnicodeEncodeError: 'ascii'
-        # codec can't encode character ..." in Python 2 when a format
-        # argument (e.g. `output`) has a non-ascii character.
-        "Command errored out with exit status {exit_status}:\n"
-        " command: {command_display}\n"
-        "     cwd: {cwd_display}\n"
-        "Complete output ({line_count} lines):\n{output}{divider}"
-    ).format(
-        exit_status=exit_status,
-        command_display=command,
-        cwd_display=cwd,
-        line_count=len(lines),
-        output=output,
-        divider=LOG_DIVIDER,
-    )
-    return msg
-
-
-def call_subprocess(
-    cmd: Union[List[str], CommandArgs],
-    show_stdout: bool = False,
-    cwd: Optional[str] = None,
-    on_returncode: 'Literal["raise", "warn", "ignore"]' = "raise",
-    extra_ok_returncodes: Optional[Iterable[int]] = None,
-    command_desc: Optional[str] = None,
-    extra_environ: Optional[Mapping[str, Any]] = None,
-    unset_environ: Optional[Iterable[str]] = None,
-    spinner: Optional[SpinnerInterface] = None,
-    log_failed_cmd: Optional[bool] = True,
-    stdout_only: Optional[bool] = False,
-) -> str:
-    """
-    Args:
-      show_stdout: if true, use INFO to log the subprocess's stderr and
-        stdout streams.  Otherwise, use DEBUG.  Defaults to False.
-      extra_ok_returncodes: an iterable of integer return codes that are
-        acceptable, in addition to 0. Defaults to None, which means [].
-      unset_environ: an iterable of environment variable names to unset
-        prior to calling subprocess.Popen().
-      log_failed_cmd: if false, failed commands are not logged, only raised.
-      stdout_only: if true, return only stdout, else return both. When true,
-        logging of both stdout and stderr occurs when the subprocess has
-        terminated, else logging occurs as subprocess output is produced.
-    """
-    if extra_ok_returncodes is None:
-        extra_ok_returncodes = []
-    if unset_environ is None:
-        unset_environ = []
-    # Most places in pip use show_stdout=False. What this means is--
-    #
-    # - We connect the child's output (combined stderr and stdout) to a
-    #   single pipe, which we read.
-    # - We log this output to stderr at DEBUG level as it is received.
-    # - If DEBUG logging isn't enabled (e.g. if --verbose logging wasn't
-    #   requested), then we show a spinner so the user can still see the
-    #   subprocess is in progress.
-    # - If the subprocess exits with an error, we log the output to stderr
-    #   at ERROR level if it hasn't already been displayed to the console
-    #   (e.g. if --verbose logging wasn't enabled).  This way we don't log
-    #   the output to the console twice.
-    #
-    # If show_stdout=True, then the above is still done, but with DEBUG
-    # replaced by INFO.
-    if show_stdout:
-        # Then log the subprocess output at INFO level.
-        log_subprocess = subprocess_logger.info
-        used_level = logging.INFO
-    else:
-        # Then log the subprocess output using VERBOSE.  This also ensures
-        # it will be logged to the log file (aka user_log), if enabled.
-        log_subprocess = subprocess_logger.verbose
-        used_level = VERBOSE
-
-    # Whether the subprocess will be visible in the console.
-    showing_subprocess = subprocess_logger.getEffectiveLevel() <= used_level
-
-    # Only use the spinner if we're not showing the subprocess output
-    # and we have a spinner.
-    use_spinner = not showing_subprocess and spinner is not None
-
-    if command_desc is None:
-        command_desc = format_command_args(cmd)
-
-    log_subprocess("Running command %s", command_desc)
-    env = os.environ.copy()
-    if extra_environ:
-        env.update(extra_environ)
-    for name in unset_environ:
-        env.pop(name, None)
-    try:
-        proc = subprocess.Popen(
-            # Convert HiddenText objects to the underlying str.
-            reveal_command_args(cmd),
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT if not stdout_only else subprocess.PIPE,
-            cwd=cwd,
-            env=env,
-            errors="backslashreplace",
-        )
-    except Exception as exc:
-        if log_failed_cmd:
-            subprocess_logger.critical(
-                "Error %s while executing command %s",
-                exc,
-                command_desc,
-            )
-        raise
-    all_output = []
-    if not stdout_only:
-        assert proc.stdout
-        assert proc.stdin
-        proc.stdin.close()
-        # In this mode, stdout and stderr are in the same pipe.
-        while True:
-            line: str = proc.stdout.readline()
-            if not line:
-                break
-            line = line.rstrip()
-            all_output.append(line + "\n")
-
-            # Show the line immediately.
-            log_subprocess(line)
-            # Update the spinner.
-            if use_spinner:
-                assert spinner
-                spinner.spin()
-        try:
-            proc.wait()
-        finally:
-            if proc.stdout:
-                proc.stdout.close()
-        output = "".join(all_output)
-    else:
-        # In this mode, stdout and stderr are in different pipes.
-        # We must use communicate() which is the only safe way to read both.
-        out, err = proc.communicate()
-        # log line by line to preserve pip log indenting
-        for out_line in out.splitlines():
-            log_subprocess(out_line)
-        all_output.append(out)
-        for err_line in err.splitlines():
-            log_subprocess(err_line)
-        all_output.append(err)
-        output = out
-
-    proc_had_error = proc.returncode and proc.returncode not in extra_ok_returncodes
-    if use_spinner:
-        assert spinner
-        if proc_had_error:
-            spinner.finish("error")
-        else:
-            spinner.finish("done")
-    if proc_had_error:
-        if on_returncode == "raise":
-            if not showing_subprocess and log_failed_cmd:
-                # Then the subprocess streams haven't been logged to the
-                # console yet.
-                msg = make_subprocess_output_error(
-                    cmd_args=cmd,
-                    cwd=cwd,
-                    lines=all_output,
-                    exit_status=proc.returncode,
-                )
-                subprocess_logger.error(msg)
-            raise InstallationSubprocessError(proc.returncode, command_desc)
-        elif on_returncode == "warn":
-            subprocess_logger.warning(
-                'Command "%s" had error code %s in %s',
-                command_desc,
-                proc.returncode,
-                cwd,
-            )
-        elif on_returncode == "ignore":
-            pass
-        else:
-            raise ValueError(f"Invalid value: on_returncode={on_returncode!r}")
-    return output
-
-
-def runner_with_spinner_message(message: str) -> Callable[..., None]:
-    """Provide a subprocess_runner that shows a spinner message.
-
-    Intended for use with for pep517's Pep517HookCaller. Thus, the runner has
-    an API that matches what's expected by Pep517HookCaller.subprocess_runner.
-    """
-
-    def runner(
-        cmd: List[str],
-        cwd: Optional[str] = None,
-        extra_environ: Optional[Mapping[str, Any]] = None,
-    ) -> None:
-        with open_spinner(message) as spinner:
-            call_subprocess(
-                cmd,
-                cwd=cwd,
-                extra_environ=extra_environ,
-                spinner=spinner,
-            )
-
-    return runner

package/.venv/lib/python3.9/site-packages/pip/_internal/utils/temp_dir.py

@@ -1,246 +0,0 @@
-import errno
-import itertools
-import logging
-import os.path
-import tempfile
-from contextlib import ExitStack, contextmanager
-from typing import Any, Dict, Iterator, Optional, TypeVar, Union
-
-from pip._internal.utils.misc import enum, rmtree
-
-logger = logging.getLogger(__name__)
-
-_T = TypeVar("_T", bound="TempDirectory")
-
-
-# Kinds of temporary directories. Only needed for ones that are
-# globally-managed.
-tempdir_kinds = enum(
-    BUILD_ENV="build-env",
-    EPHEM_WHEEL_CACHE="ephem-wheel-cache",
-    REQ_BUILD="req-build",
-)
-
-
-_tempdir_manager: Optional[ExitStack] = None
-
-
-@contextmanager
-def global_tempdir_manager() -> Iterator[None]:
-    global _tempdir_manager
-    with ExitStack() as stack:
-        old_tempdir_manager, _tempdir_manager = _tempdir_manager, stack
-        try:
-            yield
-        finally:
-            _tempdir_manager = old_tempdir_manager
-
-
-class TempDirectoryTypeRegistry:
-    """Manages temp directory behavior"""
-
-    def __init__(self) -> None:
-        self._should_delete: Dict[str, bool] = {}
-
-    def set_delete(self, kind: str, value: bool) -> None:
-        """Indicate whether a TempDirectory of the given kind should be
-        auto-deleted.
-        """
-        self._should_delete[kind] = value
-
-    def get_delete(self, kind: str) -> bool:
-        """Get configured auto-delete flag for a given TempDirectory type,
-        default True.
-        """
-        return self._should_delete.get(kind, True)
-
-
-_tempdir_registry: Optional[TempDirectoryTypeRegistry] = None
-
-
-@contextmanager
-def tempdir_registry() -> Iterator[TempDirectoryTypeRegistry]:
-    """Provides a scoped global tempdir registry that can be used to dictate
-    whether directories should be deleted.
-    """
-    global _tempdir_registry
-    old_tempdir_registry = _tempdir_registry
-    _tempdir_registry = TempDirectoryTypeRegistry()
-    try:
-        yield _tempdir_registry
-    finally:
-        _tempdir_registry = old_tempdir_registry
-
-
-class _Default:
-    pass
-
-
-_default = _Default()
-
-
-class TempDirectory:
-    """Helper class that owns and cleans up a temporary directory.
-
-    This class can be used as a context manager or as an OO representation of a
-    temporary directory.
-
-    Attributes:
-        path
-            Location to the created temporary directory
-        delete
-            Whether the directory should be deleted when exiting
-            (when used as a contextmanager)
-
-    Methods:
-        cleanup()
-            Deletes the temporary directory
-
-    When used as a context manager, if the delete attribute is True, on
-    exiting the context the temporary directory is deleted.
-    """
-
-    def __init__(
-        self,
-        path: Optional[str] = None,
-        delete: Union[bool, None, _Default] = _default,
-        kind: str = "temp",
-        globally_managed: bool = False,
-    ):
-        super().__init__()
-
-        if delete is _default:
-            if path is not None:
-                # If we were given an explicit directory, resolve delete option
-                # now.
-                delete = False
-            else:
-                # Otherwise, we wait until cleanup and see what
-                # tempdir_registry says.
-                delete = None
-
-        # The only time we specify path is in for editables where it
-        # is the value of the --src option.
-        if path is None:
-            path = self._create(kind)
-
-        self._path = path
-        self._deleted = False
-        self.delete = delete
-        self.kind = kind
-
-        if globally_managed:
-            assert _tempdir_manager is not None
-            _tempdir_manager.enter_context(self)
-
-    @property
-    def path(self) -> str:
-        assert not self._deleted, f"Attempted to access deleted path: {self._path}"
-        return self._path
-
-    def __repr__(self) -> str:
-        return f"<{self.__class__.__name__} {self.path!r}>"
-
-    def __enter__(self: _T) -> _T:
-        return self
-
-    def __exit__(self, exc: Any, value: Any, tb: Any) -> None:
-        if self.delete is not None:
-            delete = self.delete
-        elif _tempdir_registry:
-            delete = _tempdir_registry.get_delete(self.kind)
-        else:
-            delete = True
-
-        if delete:
-            self.cleanup()
-
-    def _create(self, kind: str) -> str:
-        """Create a temporary directory and store its path in self.path"""
-        # We realpath here because some systems have their default tmpdir
-        # symlinked to another directory.  This tends to confuse build
-        # scripts, so we canonicalize the path by traversing potential
-        # symlinks here.
-        path = os.path.realpath(tempfile.mkdtemp(prefix=f"pip-{kind}-"))
-        logger.debug("Created temporary directory: %s", path)
-        return path
-
-    def cleanup(self) -> None:
-        """Remove the temporary directory created and reset state"""
-        self._deleted = True
-        if not os.path.exists(self._path):
-            return
-        rmtree(self._path)
-
-
-class AdjacentTempDirectory(TempDirectory):
-    """Helper class that creates a temporary directory adjacent to a real one.
-
-    Attributes:
-        original
-            The original directory to create a temp directory for.
-        path
-            After calling create() or entering, contains the full
-            path to the temporary directory.
-        delete
-            Whether the directory should be deleted when exiting
-            (when used as a contextmanager)
-
-    """
-
-    # The characters that may be used to name the temp directory
-    # We always prepend a ~ and then rotate through these until
-    # a usable name is found.
-    # pkg_resources raises a different error for .dist-info folder
-    # with leading '-' and invalid metadata
-    LEADING_CHARS = "-~.=%0123456789"
-
-    def __init__(self, original: str, delete: Optional[bool] = None) -> None:
-        self.original = original.rstrip("/\\")
-        super().__init__(delete=delete)
-
-    @classmethod
-    def _generate_names(cls, name: str) -> Iterator[str]:
-        """Generates a series of temporary names.
-
-        The algorithm replaces the leading characters in the name
-        with ones that are valid filesystem characters, but are not
-        valid package names (for both Python and pip definitions of
-        package).
-        """
-        for i in range(1, len(name)):
-            for candidate in itertools.combinations_with_replacement(
-                cls.LEADING_CHARS, i - 1
-            ):
-                new_name = "~" + "".join(candidate) + name[i:]
-                if new_name != name:
-                    yield new_name
-
-        # If we make it this far, we will have to make a longer name
-        for i in range(len(cls.LEADING_CHARS)):
-            for candidate in itertools.combinations_with_replacement(
-                cls.LEADING_CHARS, i
-            ):
-                new_name = "~" + "".join(candidate) + name
-                if new_name != name:
-                    yield new_name
-
-    def _create(self, kind: str) -> str:
-        root, name = os.path.split(self.original)
-        for candidate in self._generate_names(name):
-            path = os.path.join(root, candidate)
-            try:
-                os.mkdir(path)
-            except OSError as ex:
-                # Continue if the name exists already
-                if ex.errno != errno.EEXIST:
-                    raise
-            else:
-                path = os.path.realpath(path)
-                break
-        else:
-            # Final fallback on the default behavior.
-            path = os.path.realpath(tempfile.mkdtemp(prefix=f"pip-{kind}-"))
-
-        logger.debug("Created temporary directory: %s", path)
-        return path