Move many type comments to annotations

Use the tool com2ann to automatically convert most type comments to type
annotations. Some type comments continue to exist where any work beyond
the automatic conversion was required (for example, additional
formatting or circular references).

For additional information on the com2ann tool, see:
https://github.com/ilevkivskyi/com2ann

Author: jdufresne

news/fb85e56c-2761-4d08-b0c2-8c1130841508.trivial.rst

@@ -123,8 +123,7 @@ def docs(session: nox.Session) -> None:
     session.install("-e", ".")
     session.install("-r", REQUIREMENTS["docs"])
 
-    def get_sphinx_build_command(kind):
-        # type: (str) -> List[str]
+    def get_sphinx_build_command(kind: str) -> List[str]:
         # Having the conf.py in the docs/html is weird but needed because we
         # can not use a different configuration directory vs source directory
         # on RTD currently. So, we'll pass "-c docs/html" here.
@@ -180,8 +179,7 @@ def vendoring(session: nox.Session) -> None:
         session.run("vendoring", "sync", ".", "-v")
         return
 
-    def pinned_requirements(path):
-        # type: (Path) -> Iterator[Tuple[str, str]]
+    def pinned_requirements(path: Path) -> Iterator[Tuple[str, str]]:
         for line in path.read_text().splitlines(keepends=False):
             one, sep, two = line.partition("==")
             if not sep:

noxfile.py

@@ -1,8 +1,7 @@
 from typing import List, Optional
 
 
-def main(args=None):
-    # type: (Optional[List[str]]) -> int
+def main(args: Optional[List[str]] = None) -> int:
     """This is preserved for old console scripts that may still be referencing
     it.
 

src/pip/_internal/main.py

@@ -8,16 +8,14 @@
 from pip._internal.exceptions import InstallationError
 
 
-def _is_list_of_str(obj):
-    # type: (Any) -> bool
+def _is_list_of_str(obj: Any) -> bool:
     return (
         isinstance(obj, list) and
         all(isinstance(item, str) for item in obj)
     )
 
 
-def make_pyproject_path(unpacked_source_directory):
-    # type: (str) -> str
+def make_pyproject_path(unpacked_source_directory: str) -> str:
     return os.path.join(unpacked_source_directory, 'pyproject.toml')
 
 
@@ -27,12 +25,11 @@ def make_pyproject_path(unpacked_source_directory):
 
 
 def load_pyproject_toml(
-    use_pep517,  # type: Optional[bool]
-    pyproject_toml,  # type: str
-    setup_py,  # type: str
-    req_name  # type: str
-):
-    # type: (...) -> Optional[BuildSystemDetails]
+    use_pep517: Optional[bool],
+    pyproject_toml: str,
+    setup_py: str,
+    req_name: str
+) -> Optional[BuildSystemDetails]:
     """Load the pyproject.toml file.
 
     Parameters:
@@ -163,7 +160,7 @@ def load_pyproject_toml(
 
     backend = build_system.get("build-backend")
     backend_path = build_system.get("backend-path", [])
-    check = []  # type: List[str]
+    check: List[str] = []
     if backend is None:
         # If the user didn't specify a backend, we assume they want to use
         # the setuptools backend. But we can't be sure they have included

src/pip/_internal/pyproject.py

@@ -23,17 +23,15 @@
 logger = logging.getLogger(__name__)
 
 
-def _get_statefile_name(key):
-    # type: (str) -> str
+def _get_statefile_name(key: str) -> str:
     key_bytes = key.encode()
     name = hashlib.sha224(key_bytes).hexdigest()
     return name
 
 
 class SelfCheckState:
-    def __init__(self, cache_dir):
-        # type: (str) -> None
-        self.state = {}  # type: Dict[str, Any]
+    def __init__(self, cache_dir: str) -> None:
+        self.state: Dict[str, Any] = {}
         self.statefile_path = None
 
         # Try to load the existing state
@@ -50,12 +48,10 @@ def __init__(self, cache_dir):
                 pass
 
     @property
-    def key(self):
-        # type: () -> str
+    def key(self) -> str:
         return sys.prefix
 
-    def save(self, pypi_version, current_time):
-        # type: (str, datetime.datetime) -> None
+    def save(self, pypi_version: str, current_time: datetime.datetime) -> None:
         # If we do not have a path to cache in, don't bother saving.
         if not self.statefile_path:
             return
@@ -90,8 +86,7 @@ def save(self, pypi_version, current_time):
             pass
 
 
-def was_installed_by_pip(pkg):
-    # type: (str) -> bool
+def was_installed_by_pip(pkg: str) -> bool:
     """Checks whether pkg was installed by pip
 
     This is used not to display the upgrade message when pip is in fact
@@ -101,8 +96,7 @@ def was_installed_by_pip(pkg):
     return dist is not None and "pip" == dist.installer
 
 
-def pip_self_version_check(session, options):
-    # type: (PipSession, optparse.Values) -> None
+def pip_self_version_check(session: PipSession, options: optparse.Values) -> None:
     """Check for an update for pip.
 
     Limit the frequency of checks to once per week. State is stored either in

src/pip/_internal/self_outdated_check.py

@@ -6,21 +6,20 @@
 from pip._internal.utils.misc import splitext
 
 WHEEL_EXTENSION = ".whl"
-BZ2_EXTENSIONS = (".tar.bz2", ".tbz")  # type: Tuple[str, ...]
-XZ_EXTENSIONS = (
+BZ2_EXTENSIONS: Tuple[str, ...] = (".tar.bz2", ".tbz")
+XZ_EXTENSIONS: Tuple[str, ...] = (
     ".tar.xz",
     ".txz",
     ".tlz",
     ".tar.lz",
     ".tar.lzma",
-)  # type: Tuple[str, ...]
-ZIP_EXTENSIONS = (".zip", WHEEL_EXTENSION)  # type: Tuple[str, ...]
-TAR_EXTENSIONS = (".tar.gz", ".tgz", ".tar")  # type: Tuple[str, ...]
+)
+ZIP_EXTENSIONS: Tuple[str, ...] = (".zip", WHEEL_EXTENSION)
+TAR_EXTENSIONS: Tuple[str, ...] = (".tar.gz", ".tgz", ".tar")
 ARCHIVE_EXTENSIONS = ZIP_EXTENSIONS + BZ2_EXTENSIONS + TAR_EXTENSIONS + XZ_EXTENSIONS
 
 
-def is_archive_file(name):
-    # type: (str) -> bool
+def is_archive_file(name: str) -> bool:
     """Return True if `name` is a considered as an archive file."""
     ext = splitext(name)[1].lower()
     if ext in ARCHIVE_EXTENSIONS:

src/pip/_internal/utils/filetypes.py

@@ -6,14 +6,12 @@
 from typing import Optional, Tuple
 
 
-def glibc_version_string():
-    # type: () -> Optional[str]
+def glibc_version_string() -> Optional[str]:
     "Returns glibc version string, or None if not using glibc."
     return glibc_version_string_confstr() or glibc_version_string_ctypes()
 
 
-def glibc_version_string_confstr():
-    # type: () -> Optional[str]
+def glibc_version_string_confstr() -> Optional[str]:
     "Primary implementation of glibc_version_string using os.confstr."
     # os.confstr is quite a bit faster than ctypes.DLL. It's also less likely
     # to be broken or missing. This strategy is used in the standard library
@@ -30,8 +28,7 @@ def glibc_version_string_confstr():
     return version
 
 
-def glibc_version_string_ctypes():
-    # type: () -> Optional[str]
+def glibc_version_string_ctypes() -> Optional[str]:
     "Fallback implementation of glibc_version_string using ctypes."
 
     try:
@@ -78,8 +75,7 @@ def glibc_version_string_ctypes():
 # versions that was generated by pip 8.1.2 and earlier is useless and
 # misleading. Solution: instead of using platform, use our code that actually
 # works.
-def libc_ver():
-    # type: () -> Tuple[str, str]
+def libc_ver() -> Tuple[str, str]:
     """Try to determine the glibc version
 
     Returns a tuple of strings (lib, version) which default to empty strings

src/pip/_internal/utils/glibc.py

@@ -10,8 +10,7 @@
 import sys
 
 
-def inject_securetransport():
-    # type: () -> None
+def inject_securetransport() -> None:
     # Only relevant on macOS
     if sys.platform != "darwin":
         return

src/pip/_internal/utils/inject_securetransport.py

@@ -43,8 +43,9 @@ class BrokenStdoutLoggingError(Exception):
     # In Windows, a broken pipe can show up as EINVAL rather than EPIPE:
     # https://bugs.python.org/issue19612
     # https://bugs.python.org/issue30418
-    def _is_broken_pipe_error(exc_class, exc):
-        # type: (Type[BaseException], BaseException) -> bool
+    def _is_broken_pipe_error(
+        exc_class: Type[BaseException], exc: BaseException
+    ) -> bool:
         """See the docstring for non-Windows below."""
         return (exc_class is BrokenPipeError) or (
             isinstance(exc, OSError) and exc.errno in (errno.EINVAL, errno.EPIPE)
@@ -53,8 +54,9 @@ def _is_broken_pipe_error(exc_class, exc):
 
 else:
     # Then we are in the non-Windows case.
-    def _is_broken_pipe_error(exc_class, exc):
-        # type: (Type[BaseException], BaseException) -> bool
+    def _is_broken_pipe_error(
+        exc_class: Type[BaseException], exc: BaseException
+    ) -> bool:
         """
         Return whether an exception is a broken pipe error.
 
@@ -66,8 +68,7 @@ def _is_broken_pipe_error(exc_class, exc):
 
 
 @contextlib.contextmanager
-def indent_log(num=2):
-    # type: (int) -> Iterator[None]
+def indent_log(num: int = 2) -> Iterator[None]:
     """
     A context manager which will cause the log output to be indented for any
     log messages emitted inside it.
@@ -81,8 +82,7 @@ def indent_log(num=2):
         _log_state.indentation -= num
 
 
-def get_indentation():
-    # type: () -> int
+def get_indentation() -> int:
     return getattr(_log_state, "indentation", 0)
 
 
@@ -91,11 +91,10 @@ class IndentingFormatter(logging.Formatter):
 
     def __init__(
         self,
-        *args,  # type: Any
-        add_timestamp=False,  # type: bool
-        **kwargs,  # type: Any
-    ):
-        # type: (...) -> None
+        *args: Any,
+        add_timestamp: bool = False,
+        **kwargs: Any,
+    ) -> None:
         """
         A logging.Formatter that obeys the indent_log() context manager.
 
@@ -105,8 +104,7 @@ def __init__(
         self.add_timestamp = add_timestamp
         super().__init__(*args, **kwargs)
 
-    def get_message_start(self, formatted, levelno):
-        # type: (str, int) -> str
+    def get_message_start(self, formatted: str, levelno: int) -> str:
         """
         Return the start of the formatted log message (not counting the
         prefix to add to each line).
@@ -122,8 +120,7 @@ def get_message_start(self, formatted, levelno):
 
         return "ERROR: "
 
-    def format(self, record):
-        # type: (logging.LogRecord) -> str
+    def format(self, record: logging.LogRecord) -> str:
         """
         Calls the standard formatter, but will indent all of the log message
         lines by our current indentation level.
@@ -140,10 +137,8 @@ def format(self, record):
         return formatted
 
 
-def _color_wrap(*colors):
-    # type: (*str) -> Callable[[str], str]
-    def wrapped(inp):
-        # type: (str) -> str
+def _color_wrap(*colors: str) -> Callable[[str], str]:
+    def wrapped(inp: str) -> str:
         return "".join(list(colors) + [inp, colorama.Style.RESET_ALL])
 
     return wrapped
@@ -161,16 +156,14 @@ class ColorizedStreamHandler(logging.StreamHandler):
     else:
         COLORS = []
 
-    def __init__(self, stream=None, no_color=None):
-        # type: (Optional[TextIO], bool) -> None
+    def __init__(self, stream: Optional[TextIO] = None, no_color: bool = None) -> None:
         super().__init__(stream)
         self._no_color = no_color
 
         if WINDOWS and colorama:
             self.stream = colorama.AnsiToWin32(self.stream)
 
-    def _using_stdout(self):
-        # type: () -> bool
+    def _using_stdout(self) -> bool:
         """
         Return whether the handler is using sys.stdout.
         """
@@ -181,8 +174,7 @@ def _using_stdout(self):
 
         return self.stream is sys.stdout
 
-    def should_color(self):
-        # type: () -> bool
+    def should_color(self) -> bool:
         # Don't colorize things if we do not have colorama or if told not to
         if not colorama or self._no_color:
             return False
@@ -204,8 +196,7 @@ def should_color(self):
         # If anything else we should not color it
         return False
 
-    def format(self, record):
-        # type: (logging.LogRecord) -> str
+    def format(self, record: logging.LogRecord) -> str:
         msg = super().format(record)
 
         if self.should_color():
@@ -217,8 +208,7 @@ def format(self, record):
         return msg
 
     # The logging module says handleError() can be customized.
-    def handleError(self, record):
-        # type: (logging.LogRecord) -> None
+    def handleError(self, record: logging.LogRecord) -> None:
         exc_class, exc = sys.exc_info()[:2]
         # If a broken pipe occurred while calling write() or flush() on the
         # stdout stream in logging's Handler.emit(), then raise our special
@@ -236,19 +226,16 @@ def handleError(self, record):
 
 
 class BetterRotatingFileHandler(logging.handlers.RotatingFileHandler):
-    def _open(self):
-        # type: () -> IO[Any]
+    def _open(self) -> IO[Any]:
         ensure_dir(os.path.dirname(self.baseFilename))
         return super()._open()
 
 
 class MaxLevelFilter(Filter):
-    def __init__(self, level):
-        # type: (int) -> None
+    def __init__(self, level: int) -> None:
         self.level = level
 
-    def filter(self, record):
-        # type: (logging.LogRecord) -> bool
+    def filter(self, record: logging.LogRecord) -> bool:
         return record.levelno < self.level
 
 
@@ -258,15 +245,13 @@ class ExcludeLoggerFilter(Filter):
     A logging Filter that excludes records from a logger (or its children).
     """
 
-    def filter(self, record):
-        # type: (logging.LogRecord) -> bool
+    def filter(self, record: logging.LogRecord) -> bool:
         # The base Filter class allows only records from a logger (or its
         # children).
         return not super().filter(record)
 
 
-def setup_logging(verbosity, no_color, user_log_file):
-    # type: (int, bool, Optional[str]) -> int
+def setup_logging(verbosity: int, no_color: bool, user_log_file: Optional[str]) -> int:
     """Configures and sets up all of the logging
 
     Returns the requested logging level, as its integer value.