Move UI helpers to cli subpackage (#6727)

src/pip/_internal/build_env.py

@@ -16,10 +16,10 @@ from sysconfig import get_paths
 from pip._vendor.pkg_resources import Requirement, VersionConflict, WorkingSet
 
 from pip import __file__ as pip_location
+from pip._internal.cli.spinners import open_spinner
 from pip._internal.utils.subprocess import call_subprocess
 from pip._internal.utils.temp_dir import TempDirectory, tempdir_kinds
 from pip._internal.utils.typing import MYPY_CHECK_RUNNING
-from pip._internal.utils.ui import open_spinner
 
 if MYPY_CHECK_RUNNING:
     from typing import Tuple, Set, Iterable, Optional, List

src/pip/_internal/cli/cmdoptions.py

@@ -21,6 +21,7 @@ from functools import partial
 from optparse import SUPPRESS_HELP, Option, OptionGroup
 from textwrap import dedent
 
+from pip._internal.cli.progress_bars import BAR_TYPES
 from pip._internal.exceptions import CommandError
 from pip._internal.locations import USER_CACHE_DIR, get_src_prefix
 from pip._internal.models.format_control import FormatControl
@@ -28,7 +29,6 @@ from pip._internal.models.index import PyPI
 from pip._internal.models.target_python import TargetPython
 from pip._internal.utils.hashes import STRONG_HASHES
 from pip._internal.utils.typing import MYPY_CHECK_RUNNING
-from pip._internal.utils.ui import BAR_TYPES
 
 if MYPY_CHECK_RUNNING:
     from typing import Any, Callable, Dict, Optional, Tuple

src/pip/_internal/cli/progress_bars.py

@@ -1,18 +1,10 @@
-# The following comment should be removed at some point in the future.
-# mypy: strict-optional=False
-# mypy: disallow-untyped-defs=False
+from __future__ import division
 
-from __future__ import absolute_import, division
-
-import contextlib
 import itertools
-import logging
 import sys
-import time
 from signal import SIGINT, default_int_handler, signal
 
 from pip._vendor import six
-from pip._vendor.progress import HIDE_CURSOR, SHOW_CURSOR
 from pip._vendor.progress.bar import Bar, FillingCirclesBar, IncrementalBar
 from pip._vendor.progress.spinner import Spinner
 
@@ -22,7 +14,7 @@ from pip._internal.utils.misc import format_size
 from pip._internal.utils.typing import MYPY_CHECK_RUNNING
 
 if MYPY_CHECK_RUNNING:
-    from typing import Any, Iterator, IO
+    from typing import Any, Dict, List
 
 try:
     from pip._vendor import colorama
@@ -31,10 +23,9 @@ try:
 except Exception:
     colorama = None
 
-logger = logging.getLogger(__name__)
-
 
 def _select_progress_class(preferred, fallback):
+    # type: (Bar, Bar) -> Bar
     encoding = getattr(preferred.file, "encoding", None)
 
     # If we don't know what encoding this file is in, then we'll just assume
@@ -83,10 +74,14 @@ class InterruptibleMixin(object):
     """
 
     def __init__(self, *args, **kwargs):
+        # type: (List[Any], Dict[Any, Any]) -> None
         """
         Save the original SIGINT handler for later.
         """
-        super(InterruptibleMixin, self).__init__(*args, **kwargs)
+        super(InterruptibleMixin, self).__init__(  # type: ignore
+            *args,
+            **kwargs
+        )
 
         self.original_handler = signal(SIGINT, self.handle_sigint)
 
@@ -99,16 +94,17 @@ class InterruptibleMixin(object):
             self.original_handler = default_int_handler
 
     def finish(self):
+        # type: () -> None
         """
         Restore the original SIGINT handler after finishing.
 
         This should happen regardless of whether the progress display finishes
         normally, or gets interrupted.
         """
-        super(InterruptibleMixin, self).finish()
+        super(InterruptibleMixin, self).finish()  # type: ignore
         signal(SIGINT, self.original_handler)
 
-    def handle_sigint(self, signum, frame):
+    def handle_sigint(self, signum, frame):  # type: ignore
         """
         Call self.finish() before delegating to the original SIGINT handler.
 
@@ -122,6 +118,7 @@ class InterruptibleMixin(object):
 class SilentBar(Bar):
 
     def update(self):
+        # type: () -> None
         pass
 
 
@@ -136,27 +133,36 @@ class BlueEmojiBar(IncrementalBar):
 class DownloadProgressMixin(object):
 
     def __init__(self, *args, **kwargs):
-        super(DownloadProgressMixin, self).__init__(*args, **kwargs)
-        self.message = (" " * (get_indentation() + 2)) + self.message
+        # type: (List[Any], Dict[Any, Any]) -> None
+        super(DownloadProgressMixin, self).__init__(  # type: ignore
+            *args,
+            **kwargs
+        )
+        self.message = (" " * (
+            get_indentation() + 2
+        )) + self.message  # type: str
 
     @property
     def downloaded(self):
-        return format_size(self.index)
+        # type: () -> str
+        return format_size(self.index)  # type: ignore
 
     @property
     def download_speed(self):
+        # type: () -> str
         # Avoid zero division errors...
-        if self.avg == 0.0:
+        if self.avg == 0.0:  # type: ignore
             return "..."
-        return format_size(1 / self.avg) + "/s"
+        return format_size(1 / self.avg) + "/s"  # type: ignore
 
     @property
     def pretty_eta(self):
-        if self.eta:
-            return "eta {}".format(self.eta_td)
+        # type: () -> str
+        if self.eta:  # type: ignore
+            return "eta {}".format(self.eta_td)  # type: ignore
         return ""
 
-    def iter(self, it):
+    def iter(self, it):  # type: ignore
         for x in it:
             yield x
             self.next(len(x))
@@ -166,6 +172,7 @@ class DownloadProgressMixin(object):
 class WindowsMixin(object):
 
     def __init__(self, *args, **kwargs):
+        # type: (List[Any], Dict[Any, Any]) -> None
         # The Windows terminal does not support the hide/show cursor ANSI codes
         # even with colorama. So we'll ensure that hide_cursor is False on
         # Windows.
@@ -173,15 +180,15 @@ class WindowsMixin(object):
         # is set in time. The base progress bar class writes the "hide cursor"
         # code to the terminal in its init, so if we don't set this soon
         # enough, we get a "hide" with no corresponding "show"...
-        if WINDOWS and self.hide_cursor:
+        if WINDOWS and self.hide_cursor:  # type: ignore
             self.hide_cursor = False
 
-        super(WindowsMixin, self).__init__(*args, **kwargs)
+        super(WindowsMixin, self).__init__(*args, **kwargs)  # type: ignore
 
         # Check if we are running on Windows and we have the colorama module,
         # if we do then wrap our file with it.
         if WINDOWS and colorama:
-            self.file = colorama.AnsiToWin32(self.file)
+            self.file = colorama.AnsiToWin32(self.file)  # type: ignore
             # The progress code expects to be able to call self.file.isatty()
             # but the colorama.AnsiToWin32() object doesn't have that, so we'll
             # add it.
@@ -233,12 +240,13 @@ class DownloadProgressSpinner(WindowsMixin, InterruptibleMixin,
     file = sys.stdout
     suffix = "%(downloaded)s %(download_speed)s"
 
-    def next_phase(self):
+    def next_phase(self):  # type: ignore
         if not hasattr(self, "_phaser"):
             self._phaser = itertools.cycle(self.phases)
         return next(self._phaser)
 
     def update(self):
+        # type: () -> None
         message = self.message % self
         phase = self.next_phase()
         suffix = self.suffix % self
@@ -262,167 +270,8 @@ BAR_TYPES = {
 }
 
 
-def DownloadProgressProvider(progress_bar, max=None):
+def DownloadProgressProvider(progress_bar, max=None):  # type: ignore
     if max is None or max == 0:
         return BAR_TYPES[progress_bar][1]().iter
     else:
         return BAR_TYPES[progress_bar][0](max=max).iter
-
-
-################################################################
-# Generic "something is happening" spinners
-#
-# We don't even try using progress.spinner.Spinner here because it's actually
-# simpler to reimplement from scratch than to coerce their code into doing
-# what we need.
-################################################################
-
-@contextlib.contextmanager
-def hidden_cursor(file):
-    # type: (IO[Any]) -> Iterator[None]
-    # The Windows terminal does not support the hide/show cursor ANSI codes,
-    # even via colorama. So don't even try.
-    if WINDOWS:
-        yield
-    # We don't want to clutter the output with control characters if we're
-    # writing to a file, or if the user is running with --quiet.
-    # See https://github.com/pypa/pip/issues/3418
-    elif not file.isatty() or logger.getEffectiveLevel() > logging.INFO:
-        yield
-    else:
-        file.write(HIDE_CURSOR)
-        try:
-            yield
-        finally:
-            file.write(SHOW_CURSOR)
-
-
-class RateLimiter(object):
-    def __init__(self, min_update_interval_seconds):
-        # type: (float) -> None
-        self._min_update_interval_seconds = min_update_interval_seconds
-        self._last_update = 0  # type: float
-
-    def ready(self):
-        # type: () -> bool
-        now = time.time()
-        delta = now - self._last_update
-        return delta >= self._min_update_interval_seconds
-
-    def reset(self):
-        # type: () -> None
-        self._last_update = time.time()
-
-
-class SpinnerInterface(object):
-    def spin(self):
-        # type: () -> None
-        raise NotImplementedError()
-
-    def finish(self, final_status):
-        # type: (str) -> None
-        raise NotImplementedError()
-
-
-class InteractiveSpinner(SpinnerInterface):
-    def __init__(self, message, file=None, spin_chars="-\\|/",
-                 # Empirically, 8 updates/second looks nice
-                 min_update_interval_seconds=0.125):
-        self._message = message
-        if file is None:
-            file = sys.stdout
-        self._file = file
-        self._rate_limiter = RateLimiter(min_update_interval_seconds)
-        self._finished = False
-
-        self._spin_cycle = itertools.cycle(spin_chars)
-
-        self._file.write(" " * get_indentation() + self._message + " ... ")
-        self._width = 0
-
-    def _write(self, status):
-        assert not self._finished
-        # Erase what we wrote before by backspacing to the beginning, writing
-        # spaces to overwrite the old text, and then backspacing again
-        backup = "\b" * self._width
-        self._file.write(backup + " " * self._width + backup)
-        # Now we have a blank slate to add our status
-        self._file.write(status)
-        self._width = len(status)
-        self._file.flush()
-        self._rate_limiter.reset()
-
-    def spin(self):
-        # type: () -> None
-        if self._finished:
-            return
-        if not self._rate_limiter.ready():
-            return
-        self._write(next(self._spin_cycle))
-
-    def finish(self, final_status):
-        # type: (str) -> None
-        if self._finished:
-            return
-        self._write(final_status)
-        self._file.write("\n")
-        self._file.flush()
-        self._finished = True
-
-
-# Used for dumb terminals, non-interactive installs (no tty), etc.
-# We still print updates occasionally (once every 60 seconds by default) to
-# act as a keep-alive for systems like Travis-CI that take lack-of-output as
-# an indication that a task has frozen.
-class NonInteractiveSpinner(SpinnerInterface):
-    def __init__(self, message, min_update_interval_seconds=60):
-        # type: (str, float) -> None
-        self._message = message
-        self._finished = False
-        self._rate_limiter = RateLimiter(min_update_interval_seconds)
-        self._update("started")
-
-    def _update(self, status):
-        assert not self._finished
-        self._rate_limiter.reset()
-        logger.info("%s: %s", self._message, status)
-
-    def spin(self):
-        # type: () -> None
-        if self._finished:
-            return
-        if not self._rate_limiter.ready():
-            return
-        self._update("still running...")
-
-    def finish(self, final_status):
-        # type: (str) -> None
-        if self._finished:
-            return
-        self._update("finished with status '{}'".format(final_status))
-        self._finished = True
-
-
-@contextlib.contextmanager
-def open_spinner(message):
-    # type: (str) -> Iterator[SpinnerInterface]
-    # Interactive spinner goes directly to sys.stdout rather than being routed
-    # through the logging system, but it acts like it has level INFO,
-    # i.e. it's only displayed if we're at level INFO or better.
-    # Non-interactive spinner goes through the logging system, so it is always
-    # in sync with logging configuration.
-    if sys.stdout.isatty() and logger.getEffectiveLevel() <= logging.INFO:
-        spinner = InteractiveSpinner(message)  # type: SpinnerInterface
-    else:
-        spinner = NonInteractiveSpinner(message)
-    try:
-        with hidden_cursor(sys.stdout):
-            yield spinner
-    except KeyboardInterrupt:
-        spinner.finish("canceled")
-        raise
-    except Exception:
-        spinner.finish("error")
-        raise
-    else:
-        spinner.finish("done")

src/pip/_internal/cli/spinners.py

@@ -0,0 +1,172 @@
+from __future__ import absolute_import, division
+
+import contextlib
+import itertools
+import logging
+import sys
+import time
+
+from pip._vendor.progress import HIDE_CURSOR, SHOW_CURSOR
+
+from pip._internal.utils.compat import WINDOWS
+from pip._internal.utils.logging import get_indentation
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+
+if MYPY_CHECK_RUNNING:
+    from typing import Iterator, IO
+
+logger = logging.getLogger(__name__)
+
+
+class SpinnerInterface(object):
+    def spin(self):
+        # type: () -> None
+        raise NotImplementedError()
+
+    def finish(self, final_status):
+        # type: (str) -> None
+        raise NotImplementedError()
+
+
+class InteractiveSpinner(SpinnerInterface):
+    def __init__(self, message, file=None, spin_chars="-\\|/",
+                 # Empirically, 8 updates/second looks nice
+                 min_update_interval_seconds=0.125):
+        # type: (str, IO[str], str, float) -> None
+        self._message = message
+        if file is None:
+            file = sys.stdout
+        self._file = file
+        self._rate_limiter = RateLimiter(min_update_interval_seconds)
+        self._finished = False
+
+        self._spin_cycle = itertools.cycle(spin_chars)
+
+        self._file.write(" " * get_indentation() + self._message + " ... ")
+        self._width = 0
+
+    def _write(self, status):
+        # type: (str) -> None
+        assert not self._finished
+        # Erase what we wrote before by backspacing to the beginning, writing
+        # spaces to overwrite the old text, and then backspacing again
+        backup = "\b" * self._width
+        self._file.write(backup + " " * self._width + backup)
+        # Now we have a blank slate to add our status
+        self._file.write(status)
+        self._width = len(status)
+        self._file.flush()
+        self._rate_limiter.reset()
+
+    def spin(self):
+        # type: () -> None
+        if self._finished:
+            return
+        if not self._rate_limiter.ready():
+            return
+        self._write(next(self._spin_cycle))
+
+    def finish(self, final_status):
+        # type: (str) -> None
+        if self._finished:
+            return
+        self._write(final_status)
+        self._file.write("\n")
+        self._file.flush()
+        self._finished = True
+
+
+# Used for dumb terminals, non-interactive installs (no tty), etc.
+# We still print updates occasionally (once every 60 seconds by default) to
+# act as a keep-alive for systems like Travis-CI that take lack-of-output as
+# an indication that a task has frozen.
+class NonInteractiveSpinner(SpinnerInterface):
+    def __init__(self, message, min_update_interval_seconds=60):
+        # type: (str, float) -> None
+        self._message = message
+        self._finished = False
+        self._rate_limiter = RateLimiter(min_update_interval_seconds)
+        self._update("started")
+
+    def _update(self, status):
+        # type: (str) -> None
+        assert not self._finished
+        self._rate_limiter.reset()
+        logger.info("%s: %s", self._message, status)
+
+    def spin(self):
+        # type: () -> None
+        if self._finished:
+            return
+        if not self._rate_limiter.ready():
+            return
+        self._update("still running...")
+
+    def finish(self, final_status):
+        # type: (str) -> None
+        if self._finished:
+            return
+        self._update("finished with status '%s'" % (final_status,))
+        self._finished = True
+
+
+class RateLimiter(object):
+    def __init__(self, min_update_interval_seconds):
+        # type: (float) -> None
+        self._min_update_interval_seconds = min_update_interval_seconds
+        self._last_update = 0  # type: float
+
+    def ready(self):
+        # type: () -> bool
+        now = time.time()
+        delta = now - self._last_update
+        return delta >= self._min_update_interval_seconds
+
+    def reset(self):
+        # type: () -> None
+        self._last_update = time.time()
+
+
+@contextlib.contextmanager
+def open_spinner(message):
+    # type: (str) -> Iterator[SpinnerInterface]
+    # Interactive spinner goes directly to sys.stdout rather than being routed
+    # through the logging system, but it acts like it has level INFO,
+    # i.e. it's only displayed if we're at level INFO or better.
+    # Non-interactive spinner goes through the logging system, so it is always
+    # in sync with logging configuration.
+    if sys.stdout.isatty() and logger.getEffectiveLevel() <= logging.INFO:
+        spinner = InteractiveSpinner(message)  # type: SpinnerInterface
+    else:
+        spinner = NonInteractiveSpinner(message)
+    try:
+        with hidden_cursor(sys.stdout):
+            yield spinner
+    except KeyboardInterrupt:
+        spinner.finish("canceled")
+        raise
+    except Exception:
+        spinner.finish("error")
+        raise
+    else:
+        spinner.finish("done")
+
+
+@contextlib.contextmanager
+def hidden_cursor(file):
+    # type: (IO[str]) -> Iterator[None]
+    # The Windows terminal does not support the hide/show cursor ANSI codes,
+    # even via colorama. So don't even try.
+    if WINDOWS:
+        yield
+    # We don't want to clutter the output with control characters if we're
+    # writing to a file, or if the user is running with --quiet.
+    # See https://github.com/pypa/pip/issues/3418
+    elif not file.isatty() or logger.getEffectiveLevel() > logging.INFO:
+        yield
+    else:
+        file.write(HIDE_CURSOR)
+        try:
+            yield
+        finally:
+            file.write(SHOW_CURSOR)

src/pip/_internal/network/download.py

@@ -8,6 +8,7 @@ import os
 from pip._vendor import requests
 from pip._vendor.requests.models import CONTENT_CHUNK_SIZE
 
+from pip._internal.cli.progress_bars import DownloadProgressProvider
 from pip._internal.models.index import PyPI
 from pip._internal.network.cache import is_from_cache
 from pip._internal.network.utils import response_chunks
@@ -17,7 +18,6 @@ from pip._internal.utils.misc import (
     splitext,
 )
 from pip._internal.utils.typing import MYPY_CHECK_RUNNING
-from pip._internal.utils.ui import DownloadProgressProvider
 
 if MYPY_CHECK_RUNNING:
     from typing import Iterable, Optional

src/pip/_internal/operations/build/wheel_legacy.py

@@ -1,6 +1,7 @@
 import logging
 import os.path
 
+from pip._internal.cli.spinners import open_spinner
 from pip._internal.utils.setuptools_build import (
     make_setuptools_bdist_wheel_args,
 )
@@ -10,7 +11,6 @@ from pip._internal.utils.subprocess import (
     format_command_args,
 )
 from pip._internal.utils.typing import MYPY_CHECK_RUNNING
-from pip._internal.utils.ui import open_spinner
 
 if MYPY_CHECK_RUNNING:
     from typing import List, Optional, Text

src/pip/_internal/utils/subprocess.py

@@ -9,18 +9,17 @@ import subprocess
 
 from pip._vendor.six.moves import shlex_quote
 
+from pip._internal.cli.spinners import SpinnerInterface, open_spinner
 from pip._internal.exceptions import InstallationError
 from pip._internal.utils.compat import console_to_str, str_to_display
 from pip._internal.utils.logging import subprocess_logger
 from pip._internal.utils.misc import HiddenText, path_to_display
 from pip._internal.utils.typing import MYPY_CHECK_RUNNING
-from pip._internal.utils.ui import open_spinner
 
 if MYPY_CHECK_RUNNING:
     from typing import (
         Any, Callable, Iterable, List, Mapping, Optional, Text, Union,
     )
-    from pip._internal.utils.ui import SpinnerInterface
 
     CommandArgs = List[Union[str, HiddenText]]
 

src/pip/_internal/vcs/versioncontrol.py

@@ -30,7 +30,7 @@ if MYPY_CHECK_RUNNING:
         Any, Dict, Iterable, Iterator, List, Mapping, Optional, Text, Tuple,
         Type, Union
     )
-    from pip._internal.utils.ui import SpinnerInterface
+    from pip._internal.cli.spinners import SpinnerInterface
     from pip._internal.utils.misc import HiddenText
     from pip._internal.utils.subprocess import CommandArgs
 

tests/unit/test_utils_subprocess.py

@@ -6,6 +6,7 @@ from textwrap import dedent
 
 import pytest
 
+from pip._internal.cli.spinners import SpinnerInterface
 from pip._internal.exceptions import InstallationError
 from pip._internal.utils.misc import hide_value
 from pip._internal.utils.subprocess import (
@@ -14,7 +15,6 @@ from pip._internal.utils.subprocess import (
     make_command,
     make_subprocess_output_error,
 )
-from pip._internal.utils.ui import SpinnerInterface
 
 
 @pytest.mark.parametrize('args, expected', [