Some mypy validation fixes

Author: anselor

cmd2/ansi.py

@@ -13,15 +13,16 @@
     Any,
     List,
     Union,
+    cast,
 )
 
-import colorama
+import colorama  # type: ignore [import]
 from colorama import (
     Back,
     Fore,
     Style,
 )
-from wcwidth import (
+from wcwidth import (  # type: ignore [import]
     wcswidth,
 )
 
@@ -86,14 +87,14 @@ def __add__(self, other: Any) -> str:
         Support building a color string when self is the left operand
         e.g. fg.blue + "hello"
         """
-        return str(self) + other
+        return cast(str, str(self) + other)
 
     def __radd__(self, other: Any) -> str:
         """
         Support building a color string when self is the right operand
         e.g. "hello" + fg.reset
         """
-        return other + str(self)
+        return cast(str, other + str(self))
 
     @classmethod
     def colors(cls) -> List[str]:
@@ -194,7 +195,7 @@ def style_aware_wcswidth(text: str) -> int:
              then this function returns -1. Replace tabs with spaces before calling this.
     """
     # Strip ANSI style sequences since they cause wcswidth to return -1
-    return wcswidth(strip_style(text))
+    return cast(int, wcswidth(strip_style(text)))
 
 
 def widest_line(text: str) -> int:
@@ -217,7 +218,7 @@ def widest_line(text: str) -> int:
     return max(lines_widths)
 
 
-def style_aware_write(fileobj: IO, msg: str) -> None:
+def style_aware_write(fileobj: IO[str], msg: str) -> None:
     """
     Write a string to a fileobject and strip its ANSI style sequences if required by allow_style setting
 
@@ -229,7 +230,7 @@ def style_aware_write(fileobj: IO, msg: str) -> None:
     fileobj.write(msg)
 
 
-def fg_lookup(fg_name: Union[str, fg]) -> str:
+def fg_lookup(fg_name: Union[str, fg]) -> Fore:
     """
     Look up ANSI escape codes based on foreground color name.
 
@@ -247,7 +248,7 @@ def fg_lookup(fg_name: Union[str, fg]) -> str:
     return ansi_escape
 
 
-def bg_lookup(bg_name: Union[str, bg]) -> str:
+def bg_lookup(bg_name: Union[str, bg]) -> Back:
     """
     Look up ANSI escape codes based on background color name.
 
@@ -321,7 +322,7 @@ def style(
         removals.append(UNDERLINE_DISABLE)
 
     # Combine the ANSI style sequences with the text
-    return "".join(additions) + text + "".join(removals)
+    return cast(str, "".join(additions) + text + "".join(removals))
 
 
 # Default styles for printing strings of various types.
@@ -400,4 +401,4 @@ def set_title_str(title: str) -> str:
     :param title: new title for the window
     :return: string to write to sys.stderr in order to set the window title to the desired test
     """
-    return colorama.ansi.set_title(title)
+    return cast(str, colorama.ansi.set_title(title))

cmd2/argparse_custom.py

@@ -198,16 +198,21 @@ def my_completer(self, text, line, begidx, endidx, arg_tokens)
     ONE_OR_MORE,
     ZERO_OR_MORE,
     ArgumentError,
-    _,
+)
+from gettext import (
+    gettext,
 )
 from typing import (
     Any,
     Callable,
+    Iterable,
+    List,
     NoReturn,
     Optional,
     Tuple,
     Type,
     Union,
+    cast,
 )
 
 from . import (
@@ -261,11 +266,11 @@ class CompletionItem(str):
     See header of this file for more information
     """
 
-    def __new__(cls, value: object, *args, **kwargs) -> str:
-        return super().__new__(cls, value)
+    def __new__(cls, value: object, *args: Any, **kwargs: Any) -> 'CompletionItem':
+        return cast(CompletionItem, super(CompletionItem, cls).__new__(cls, value))  # type: ignore [call-arg]
 
     # noinspection PyUnusedLocal
-    def __init__(self, value: object, desc: str = '', *args) -> None:
+    def __init__(self, value: object, desc: str = '', *args: Any) -> None:
         """
         CompletionItem Initializer
 
@@ -287,7 +292,11 @@ class ChoicesCallable:
     While argparse has the built-in choices attribute, it is limited to an iterable.
     """
 
-    def __init__(self, is_completer: bool, to_call: Callable):
+    def __init__(
+        self,
+        is_completer: bool,
+        to_call: Union[Callable[[], List[str]], Callable[[str, str, int, int], List[str]]],
+    ) -> None:
         """
         Initializer
         :param is_completer: True if to_call is a tab completion routine which expects
@@ -319,12 +328,12 @@ def _set_choices_callable(action: argparse.Action, choices_callable: ChoicesCall
     setattr(action, ATTR_CHOICES_CALLABLE, choices_callable)
 
 
-def set_choices_provider(action: argparse.Action, choices_provider: Callable) -> None:
+def set_choices_provider(action: argparse.Action, choices_provider: Callable[[], List[str]]) -> None:
     """Set choices_provider on an argparse action"""
     _set_choices_callable(action, ChoicesCallable(is_completer=False, to_call=choices_provider))
 
 
-def set_completer(action: argparse.Action, completer: Callable) -> None:
+def set_completer(action: argparse.Action, completer: Callable[[str, str, int, int], List[str]]) -> None:
     """Set completer on an argparse action"""
     _set_choices_callable(action, ChoicesCallable(is_completer=True, to_call=completer))
 
@@ -339,14 +348,14 @@ def set_completer(action: argparse.Action, completer: Callable) -> None:
 
 
 def _add_argument_wrapper(
-    self,
-    *args,
+    self: argparse._ActionsContainer,
+    *args: Any,
     nargs: Union[int, str, Tuple[int], Tuple[int, int], Tuple[int, float], None] = None,
-    choices_provider: Optional[Callable] = None,
-    completer: Optional[Callable] = None,
+    choices_provider: Optional[Callable[[], List[str]]] = None,
+    completer: Optional[Callable[[str, str, int, int], List[str]]] = None,
     suppress_tab_hint: bool = False,
     descriptive_header: Optional[str] = None,
-    **kwargs
+    **kwargs: Any
 ) -> argparse.Action:
     """
     Wrapper around _ActionsContainer.add_argument() which supports more settings used by cmd2
@@ -392,6 +401,7 @@ def _add_argument_wrapper(
     nargs_range = None
 
     if nargs is not None:
+        nargs_adjusted: Union[int, str, Tuple[int], Tuple[int, int], Tuple[int, float], None]
         # Check if nargs was given as a range
         if isinstance(nargs, tuple):
 
@@ -402,19 +412,19 @@ def _add_argument_wrapper(
             # Validate nargs tuple
             if (
                 len(nargs) != 2
-                or not isinstance(nargs[0], int)
-                or not (isinstance(nargs[1], int) or nargs[1] == constants.INFINITY)
+                or not isinstance(nargs[0], int)  # type: ignore[unreachable]
+                or not (isinstance(nargs[1], int) or nargs[1] == constants.INFINITY)  # type: ignore[misc]
             ):
                 raise ValueError('Ranged values for nargs must be a tuple of 1 or 2 integers')
-            if nargs[0] >= nargs[1]:
+            if nargs[0] >= nargs[1]:  # type: ignore[misc]
                 raise ValueError('Invalid nargs range. The first value must be less than the second')
             if nargs[0] < 0:
                 raise ValueError('Negative numbers are invalid for nargs range')
 
             # Save the nargs tuple as our range setting
             nargs_range = nargs
             range_min = nargs_range[0]
-            range_max = nargs_range[1]
+            range_max = nargs_range[1]  # type: ignore[misc]
 
             # Convert nargs into a format argparse recognizes
             if range_min == 0:
@@ -460,7 +470,7 @@ def _add_argument_wrapper(
 
 # Overwrite _ActionsContainer.add_argument with our wrapper
 # noinspection PyProtectedMember
-argparse._ActionsContainer.add_argument = _add_argument_wrapper
+setattr(argparse._ActionsContainer, 'add_argument', _add_argument_wrapper)
 
 ############################################################################################################
 # Patch ArgumentParser._get_nargs_pattern with our wrapper to nargs ranges
@@ -472,7 +482,7 @@ def _add_argument_wrapper(
 
 
 # noinspection PyProtectedMember
-def _get_nargs_pattern_wrapper(self, action) -> str:
+def _get_nargs_pattern_wrapper(self: argparse.ArgumentParser, action: argparse.Action) -> str:
     # Wrapper around ArgumentParser._get_nargs_pattern behavior to support nargs ranges
     nargs_range = getattr(action, ATTR_NARGS_RANGE, None)
     if nargs_range is not None:
@@ -494,7 +504,7 @@ def _get_nargs_pattern_wrapper(self, action) -> str:
 
 # Overwrite ArgumentParser._get_nargs_pattern with our wrapper
 # noinspection PyProtectedMember
-argparse.ArgumentParser._get_nargs_pattern = _get_nargs_pattern_wrapper
+setattr(argparse.ArgumentParser, '_get_nargs_pattern', _get_nargs_pattern_wrapper)
 
 
 ############################################################################################################
@@ -505,7 +515,7 @@ def _get_nargs_pattern_wrapper(self, action) -> str:
 
 
 # noinspection PyProtectedMember
-def _match_argument_wrapper(self, action, arg_strings_pattern) -> int:
+def _match_argument_wrapper(self: argparse.ArgumentParser, action: argparse.Action, arg_strings_pattern: str) -> int:
     # Wrapper around ArgumentParser._match_argument behavior to support nargs ranges
     nargs_pattern = self._get_nargs_pattern(action)
     match = re.match(nargs_pattern, arg_strings_pattern)
@@ -521,15 +531,15 @@ def _match_argument_wrapper(self, action, arg_strings_pattern) -> int:
 
 # Overwrite ArgumentParser._match_argument with our wrapper
 # noinspection PyProtectedMember
-argparse.ArgumentParser._match_argument = _match_argument_wrapper
+setattr(argparse.ArgumentParser, '_match_argument', _match_argument_wrapper)
 
 
 ############################################################################################################
 # Patch argparse._SubParsersAction to add remove_parser function
 ############################################################################################################
 
 # noinspection PyPep8Naming
-def _SubParsersAction_remove_parser(self, name: str):
+def _SubParsersAction_remove_parser(self: argparse._SubParsersAction, name: str) -> None:
     """
     Removes a sub-parser from a sub-parsers group
 
@@ -572,20 +582,26 @@ class so cmd2 can remove subcommands from a parser.
 class Cmd2HelpFormatter(argparse.RawTextHelpFormatter):
     """Custom help formatter to configure ordering of help text"""
 
-    def _format_usage(self, usage, actions, groups, prefix) -> str:
+    def _format_usage(
+        self,
+        usage: Optional[str],
+        actions: Iterable[argparse.Action],
+        groups: Iterable[argparse._ArgumentGroup],
+        prefix: Optional[str] = None,
+    ) -> str:
         if prefix is None:
-            prefix = _('Usage: ')
+            prefix = gettext('Usage: ')
 
         # if usage is specified, use that
         if usage is not None:
             usage %= dict(prog=self._prog)
 
         # if no optionals or positionals are available, usage is just prog
-        elif usage is None and not actions:
+        elif not actions:
             usage = '%(prog)s' % dict(prog=self._prog)
 
         # if optionals and positionals are available, calculate usage
-        elif usage is None:
+        else:
             prog = '%(prog)s' % dict(prog=self._prog)
 
             # split optionals from positionals
@@ -630,7 +646,7 @@ def _format_usage(self, usage, actions, groups, prefix) -> str:
 
                 # helper for wrapping lines
                 # noinspection PyMissingOrEmptyDocstring,PyShadowingNames
-                def get_lines(parts, indent, prefix=None):
+                def get_lines(parts: List[str], indent: str, prefix: Optional[str] = None):
                     lines = []
                     line = []
                     if prefix is not None:

cmd2/clipboard.py

@@ -2,7 +2,11 @@
 """
 This module provides basic ability to copy from and paste to the clipboard/pastebuffer.
 """
-import pyperclip
+from typing import (
+    cast,
+)
+
+import pyperclip  # type: ignore [import]
 
 # noinspection PyProtectedMember
 from pyperclip import (
@@ -26,7 +30,7 @@ def get_paste_buffer() -> str:
 
     :return: contents of the clipboard
     """
-    pb_str = pyperclip.paste()
+    pb_str = cast(str, pyperclip.paste())
     return pb_str
 
 

cmd2/exceptions.py

@@ -1,6 +1,9 @@
 # coding=utf-8
 """Custom exceptions for cmd2"""
 
+from typing import (
+    Any,
+)
 
 ############################################################################################################
 # The following exceptions are part of the public API
@@ -49,7 +52,7 @@ class CompletionError(Exception):
     - Tab completion hints
     """
 
-    def __init__(self, *args, apply_style: bool = True):
+    def __init__(self, *args: Any, apply_style: bool = True) -> None:
         """
         Initializer for CompletionError
         :param apply_style: If True, then ansi.style_error will be applied to the message text when printed.
@@ -68,7 +71,7 @@ class PassThroughException(Exception):
     This class is used to wrap an exception that should be raised instead of printed.
     """
 
-    def __init__(self, *args, wrapped_ex: BaseException):
+    def __init__(self, *args: Any, wrapped_ex: BaseException) -> None:
         """
         Initializer for PassThroughException
         :param wrapped_ex: the exception that will be raised

cmd2/plugin.py

@@ -3,33 +3,37 @@
 """Classes for the cmd2 plugin system"""
 import attr
 
+from .parsing import (
+    Statement,
+)
 
-@attr.s
+
+@attr.s(auto_attribs=True)
 class PostparsingData:
     """Data class containing information passed to postparsing hook methods"""
 
-    stop = attr.ib()
-    statement = attr.ib()
+    stop: bool
+    statement: Statement
 
 
-@attr.s
+@attr.s(auto_attribs=True)
 class PrecommandData:
     """Data class containing information passed to precommand hook methods"""
 
-    statement = attr.ib()
+    statement: Statement
 
 
-@attr.s
+@attr.s(auto_attribs=True)
 class PostcommandData:
     """Data class containing information passed to postcommand hook methods"""
 
-    stop = attr.ib()
-    statement = attr.ib()
+    stop: bool
+    statement: Statement
 
 
-@attr.s
+@attr.s(auto_attribs=True)
 class CommandFinalizationData:
     """Data class containing information passed to command finalization hook methods"""
 
-    stop = attr.ib()
-    statement = attr.ib()
+    stop: bool
+    statement: Statement