Merge pull request #10287 from jdufresne/com2ann

Move many type comments to annotations

Author: uranusjr

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.