Fixed black, isort, flake8, and doc8 issues

cmd2/argparse_completer.py

@@ -208,8 +208,9 @@ def __init__(
                 if isinstance(action, argparse._SubParsersAction):
                     self._subcommand_action = action
 
-    def complete(self, text: str, line: str, begidx: int, endidx: int, tokens: List[str], *,
-                 cmd_set: Optional[CommandSet] = None) -> List[str]:
+    def complete(
+        self, text: str, line: str, begidx: int, endidx: int, tokens: List[str], *, cmd_set: Optional[CommandSet] = None
+    ) -> List[str]:
         """
         Complete text using argparse metadata
 
@@ -391,10 +392,12 @@ def update_mutex_groups(arg_action: argparse.Action) -> None:
                                 if action.dest != argparse.SUPPRESS:
                                     parent_tokens[action.dest] = [token]
 
-                                completer = ArgparseCompleter(self._subcommand_action.choices[token], self._cmd2_app,
-                                                              parent_tokens=parent_tokens)
-                                return completer.complete(text, line, begidx, endidx, tokens[token_index + 1:],
-                                                          cmd_set=cmd_set)
+                                completer = ArgparseCompleter(
+                                    self._subcommand_action.choices[token], self._cmd2_app, parent_tokens=parent_tokens
+                                )
+                                return completer.complete(
+                                    text, line, begidx, endidx, tokens[token_index + 1 :], cmd_set=cmd_set
+                                )
                             else:
                                 # Invalid subcommand entered, so no way to complete remaining tokens
                                 return []
@@ -438,8 +441,9 @@ def update_mutex_groups(arg_action: argparse.Action) -> None:
 
         # Check if we are completing a flag's argument
         if flag_arg_state is not None:
-            completion_results = self._complete_arg(text, line, begidx, endidx, flag_arg_state, consumed_arg_values,
-                                                    cmd_set=cmd_set)
+            completion_results = self._complete_arg(
+                text, line, begidx, endidx, flag_arg_state, consumed_arg_values, cmd_set=cmd_set
+            )
 
             # If we have results, then return them
             if completion_results:
@@ -464,8 +468,9 @@ def update_mutex_groups(arg_action: argparse.Action) -> None:
                 action = remaining_positionals.popleft()
                 pos_arg_state = _ArgumentState(action)
 
-            completion_results = self._complete_arg(text, line, begidx, endidx, pos_arg_state, consumed_arg_values,
-                                                    cmd_set=cmd_set)
+            completion_results = self._complete_arg(
+                text, line, begidx, endidx, pos_arg_state, consumed_arg_values, cmd_set=cmd_set
+            )
 
             # If we have results, then return them
             if completion_results:
@@ -587,7 +592,7 @@ def complete_subcommand_help(self, text: str, line: str, begidx: int, endidx: in
             for token_index, token in enumerate(tokens):
                 if token in self._subcommand_action.choices:
                     completer = ArgparseCompleter(self._subcommand_action.choices[token], self._cmd2_app)
-                    return completer.complete_subcommand_help(text, line, begidx, endidx, tokens[token_index + 1:])
+                    return completer.complete_subcommand_help(text, line, begidx, endidx, tokens[token_index + 1 :])
                 elif token_index == len(tokens) - 1:
                     # Since this is the last token, we will attempt to complete it
                     return self._cmd2_app.basic_complete(text, line, begidx, endidx, self._subcommand_action.choices)
@@ -607,14 +612,22 @@ def format_help(self, tokens: List[str]) -> str:
             for token_index, token in enumerate(tokens):
                 if token in self._subcommand_action.choices:
                     completer = ArgparseCompleter(self._subcommand_action.choices[token], self._cmd2_app)
-                    return completer.format_help(tokens[token_index + 1:])
+                    return completer.format_help(tokens[token_index + 1 :])
                 else:
                     break
         return self._parser.format_help()
 
-    def _complete_arg(self, text: str, line: str, begidx: int, endidx: int,
-                      arg_state: _ArgumentState, consumed_arg_values: Dict[str, List[str]], *,
-                      cmd_set: Optional[CommandSet] = None) -> List[str]:
+    def _complete_arg(
+        self,
+        text: str,
+        line: str,
+        begidx: int,
+        endidx: int,
+        arg_state: _ArgumentState,
+        consumed_arg_values: Dict[str, List[str]],
+        *,
+        cmd_set: Optional[CommandSet] = None
+    ) -> List[str]:
         """
         Tab completion routine for an argparse argument
         :return: list of completions

cmd2/argparse_custom.py

@@ -285,6 +285,7 @@ class ChoicesCallable:
     Enables using a callable as the choices provider for an argparse argument.
     While argparse has the built-in choices attribute, it is limited to an iterable.
     """
+
     def __init__(self, is_completer: bool, to_call: Callable):
         """
         Initializer
@@ -305,12 +306,13 @@ def _set_choices_callable(action: argparse.Action, choices_callable: ChoicesCall
     """
     # Verify consistent use of parameters
     if action.choices is not None:
-        err_msg = ("None of the following parameters can be used alongside a choices parameter:\n"
-                   "choices_provider, completer")
+        err_msg = "None of the following parameters can be used alongside a choices parameter:\n" "choices_provider, completer"
         raise (TypeError(err_msg))
     elif action.nargs == 0:
-        err_msg = ("None of the following parameters can be used on an action that takes no arguments:\n"
-                   "choices_provider, completer")
+        err_msg = (
+            "None of the following parameters can be used on an action that takes no arguments:\n"
+            "choices_provider, completer"
+        )
         raise (TypeError(err_msg))
 
     setattr(action, ATTR_CHOICES_CALLABLE, choices_callable)
@@ -335,13 +337,16 @@ def set_completer(action: argparse.Action, completer: Callable) -> None:
 orig_actions_container_add_argument = argparse._ActionsContainer.add_argument
 
 
-def _add_argument_wrapper(self, *args,
-                          nargs: Union[int, str, Tuple[int], Tuple[int, int], None] = None,
-                          choices_provider: Optional[Callable] = None,
-                          completer: Optional[Callable] = None,
-                          suppress_tab_hint: bool = False,
-                          descriptive_header: Optional[str] = None,
-                          **kwargs) -> argparse.Action:
+def _add_argument_wrapper(
+    self,
+    *args,
+    nargs: Union[int, str, Tuple[int], Tuple[int, int], None] = None,
+    choices_provider: Optional[Callable] = None,
+    completer: Optional[Callable] = None,
+    suppress_tab_hint: bool = False,
+    descriptive_header: Optional[str] = None,
+    **kwargs
+) -> argparse.Action:
     """
     Wrapper around _ActionsContainer.add_argument() which supports more settings used by cmd2
 
@@ -379,8 +384,7 @@ def _add_argument_wrapper(self, *args,
     num_params_set = len(choices_callables) - choices_callables.count(None)
 
     if num_params_set > 1:
-        err_msg = ("Only one of the following parameters may be used at a time:\n"
-                   "choices_provider, completer")
+        err_msg = "Only one of the following parameters may be used at a time:\n" "choices_provider, completer"
         raise (ValueError(err_msg))
 
     # Pre-process special ranged nargs