add typing annotations

1 files changed, 46 insertions, 26 deletions

diff --git a/src/click/formatting.py b/src/click/formatting.py
index 72e25c9..1e59fc2 100644
--- a/src/click/formatting.py
+++ b/src/click/formatting.py
@@ -9,23 +9,30 @@ from .parser import split_opt
 FORCED_WIDTH: t.Optional[int] = None
 
 
-def measure_table(rows):
-    widths = {}
+def measure_table(rows: t.Iterable[t.Tuple[str, str]]) -> t.Tuple[int, ...]:
+    widths: t.Dict[int, int] = {}
+
     for row in rows:
         for idx, col in enumerate(row):
             widths[idx] = max(widths.get(idx, 0), term_len(col))
+
     return tuple(y for x, y in sorted(widths.items()))
 
 
-def iter_rows(rows, col_count):
+def iter_rows(
+    rows: t.Iterable[t.Tuple[str, str]], col_count: int
+) -> t.Iterator[t.Tuple[str, ...]]:
     for row in rows:
-        row = tuple(row)
         yield row + ("",) * (col_count - len(row))
 
 
 def wrap_text(
-    text, width=78, initial_indent="", subsequent_indent="", preserve_paragraphs=False
-):
+    text: str,
+    width: int = 78,
+    initial_indent: str = "",
+    subsequent_indent: str = "",
+    preserve_paragraphs: bool = False,
+) -> str:
     """A helper function that intelligently wraps text.  By default, it
     assumes that it operates on a single paragraph of text but if the
     `preserve_paragraphs` parameter is provided it will intelligently
@@ -56,11 +63,11 @@ def wrap_text(
     if not preserve_paragraphs:
         return wrapper.fill(text)
 
-    p = []
-    buf = []
+    p: t.List[t.Tuple[int, bool, str]] = []
+    buf: t.List[str] = []
     indent = None
 
-    def _flush_par():
+    def _flush_par() -> None:
         if not buf:
             return
         if buf[0].strip() == "\b":
@@ -104,7 +111,12 @@ class HelpFormatter:
                   width clamped to a maximum of 78.
     """
 
-    def __init__(self, indent_increment=2, width=None, max_width=None):
+    def __init__(
+        self,
+        indent_increment: int = 2,
+        width: t.Optional[int] = None,
+        max_width: t.Optional[int] = None,
+    ) -> None:
         import shutil
 
         self.indent_increment = indent_increment
@@ -116,21 +128,23 @@ class HelpFormatter:
                 width = max(min(shutil.get_terminal_size().columns, max_width) - 2, 50)
         self.width = width
         self.current_indent = 0
-        self.buffer = []
+        self.buffer: t.List[str] = []
 
-    def write(self, string):
+    def write(self, string: str) -> None:
         """Writes a unicode string into the internal buffer."""
         self.buffer.append(string)
 
-    def indent(self):
+    def indent(self) -> None:
         """Increases the indentation."""
         self.current_indent += self.indent_increment
 
-    def dedent(self):
+    def dedent(self) -> None:
         """Decreases the indentation."""
         self.current_indent -= self.indent_increment
 
-    def write_usage(self, prog, args="", prefix=None):
+    def write_usage(
+        self, prog: str, args: str = "", prefix: t.Optional[str] = None
+    ) -> None:
         """Writes a usage line into the buffer.
 
         :param prog: the program name.
@@ -168,16 +182,16 @@ class HelpFormatter:
 
         self.write("\n")
 
-    def write_heading(self, heading):
+    def write_heading(self, heading: str) -> None:
         """Writes a heading into the buffer."""
         self.write(f"{'':>{self.current_indent}}{heading}:\n")
 
-    def write_paragraph(self):
+    def write_paragraph(self) -> None:
         """Writes a paragraph into the buffer."""
         if self.buffer:
             self.write("\n")
 
-    def write_text(self, text):
+    def write_text(self, text: str) -> None:
         """Writes re-indented text into the buffer.  This rewraps and
         preserves paragraphs.
         """
@@ -194,7 +208,12 @@ class HelpFormatter:
         )
         self.write("\n")
 
-    def write_dl(self, rows, col_max=30, col_spacing=2):
+    def write_dl(
+        self,
+        rows: t.Sequence[t.Tuple[str, str]],
+        col_max: int = 30,
+        col_spacing: int = 2,
+    ) -> None:
         """Writes a definition list into the buffer.  This is how options
         and commands are usually formatted.
 
@@ -234,7 +253,7 @@ class HelpFormatter:
                 self.write("\n")
 
     @contextmanager
-    def section(self, name):
+    def section(self, name: str) -> t.Iterator[None]:
         """Helpful context manager that writes a paragraph, a heading,
         and the indents.
 
@@ -249,7 +268,7 @@ class HelpFormatter:
             self.dedent()
 
     @contextmanager
-    def indentation(self):
+    def indentation(self) -> t.Iterator[None]:
         """A context manager that increases the indentation."""
         self.indent()
         try:
@@ -257,12 +276,12 @@ class HelpFormatter:
         finally:
             self.dedent()
 
-    def getvalue(self):
+    def getvalue(self) -> str:
         """Returns the buffer contents."""
         return "".join(self.buffer)
 
 
-def join_options(options):
+def join_options(options: t.Sequence[str]) -> t.Tuple[str, bool]:
     """Given a list of option strings this joins them in the most appropriate
     way and returns them in the form ``(formatted_string,
     any_prefix_is_slash)`` where the second item in the tuple is a flag that
@@ -270,13 +289,14 @@ def join_options(options):
     """
     rv = []
     any_prefix_is_slash = False
+
     for opt in options:
         prefix = split_opt(opt)[0]
+
         if prefix == "/":
             any_prefix_is_slash = True
+
         rv.append((len(prefix), opt))
 
     rv.sort(key=lambda x: x[0])
-
-    rv = ", ".join(x[1] for x in rv)
-    return rv, any_prefix_is_slash
+    return ", ".join(x[1] for x in rv), any_prefix_is_slash