Now maintains a command->CommandSet mapping and passes the CommandSet

through to the ArgparseCompleter if one is registered.
For subcommands, the registered argparse instance for the subcommand is now tagged with the
CommandSet from which it originated.
If a CommandSet is detected, it's now passed in as 'self' for the
completion functions.
Fixes some issue found with removing a subcommand.
Adds additional tests.
Added a check to prevent removal of a CommandSet if it has commands with sub-commands
from another CommandSet bound to it.
Documentation improvements.
Standardized around using CommandSetRegistrationException during commandset install/uninstall related errors.
Added support for nested sub-command injection.

Author: anselor

cmd2/argparse_completer.py

@@ -23,6 +23,7 @@
     CompletionItem,
     generate_range_error,
 )
+from .command_definition import CommandSet
 from .table_creator import Column, SimpleTable
 from .utils import CompletionError, basic_complete
 
@@ -181,7 +182,8 @@ def __init__(self, parser: argparse.ArgumentParser, cmd2_app: cmd2.Cmd, *,
                 if isinstance(action, argparse._SubParsersAction):
                     self._subcommand_action = action
 
-    def complete_command(self, tokens: List[str], text: str, line: str, begidx: int, endidx: int) -> List[str]:
+    def complete_command(self, tokens: List[str], text: str, line: str, begidx: int, endidx: int, *,
+                         cmd_set: Optional[CommandSet] = None) -> List[str]:
         """
         Complete the command using the argparse metadata and provided argument dictionary
         :raises: CompletionError for various types of tab completion errors
@@ -358,7 +360,8 @@ def update_mutex_groups(arg_action: argparse.Action) -> None:
 
                                 completer = ArgparseCompleter(self._subcommand_action.choices[token], self._cmd2_app,
                                                               parent_tokens=parent_tokens)
-                                return completer.complete_command(tokens[token_index:], text, line, begidx, endidx)
+                                return completer.complete_command(tokens[token_index:], text, line, begidx, endidx,
+                                                                  cmd_set=cmd_set)
                             else:
                                 # Invalid subcommand entered, so no way to complete remaining tokens
                                 return []
@@ -403,7 +406,8 @@ 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_for_arg(flag_arg_state.action, text, line,
-                                                        begidx, endidx, consumed_arg_values)
+                                                        begidx, endidx, consumed_arg_values,
+                                                        cmd_set=cmd_set)
 
             # If we have results, then return them
             if completion_results:
@@ -423,7 +427,8 @@ def update_mutex_groups(arg_action: argparse.Action) -> None:
                 pos_arg_state = _ArgumentState(action)
 
             completion_results = self._complete_for_arg(pos_arg_state.action, text, line,
-                                                        begidx, endidx, consumed_arg_values)
+                                                        begidx, endidx, consumed_arg_values,
+                                                        cmd_set=cmd_set)
 
             # If we have results, then return them
             if completion_results:
@@ -543,7 +548,8 @@ def format_help(self, tokens: List[str]) -> str:
 
     def _complete_for_arg(self, arg_action: argparse.Action,
                           text: str, line: str, begidx: int, endidx: int,
-                          consumed_arg_values: Dict[str, List[str]]) -> List[str]:
+                          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
@@ -563,6 +569,12 @@ def _complete_for_arg(self, arg_action: argparse.Action,
         kwargs = {}
         if isinstance(arg_choices, ChoicesCallable):
             if arg_choices.is_method:
+                cmd_set = getattr(self._parser, constants.PARSER_ATTR_COMMANDSET, cmd_set)
+                if cmd_set is not None:
+                    if isinstance(cmd_set, CommandSet):
+                        # If command is part of a CommandSet, `self` should be the CommandSet and Cmd will be next
+                        if cmd_set is not None:
+                            args.append(cmd_set)
                 args.append(self._cmd2_app)
 
             # Check if arg_choices.to_call expects arg_tokens

cmd2/argparse_custom.py

@@ -60,18 +60,32 @@ def my_choices_function():
 
         parser.add_argument('-o', '--options', choices_function=my_choices_function)
 
-``choices_method`` - this is exactly like choices_function, but the function
-needs to be an instance method of a cmd2-based class. When ArgparseCompleter
-calls the method, it will pass the app instance as the self argument. This is
-good in cases where the list of choices being generated relies on state data of
-the cmd2-based app
-
-    Example::
+``choices_method`` - this is equivalent to choices_function, but the function
+needs to be an instance method of a cmd2.Cmd or cmd2.CommandSet subclass. When
+ArgparseCompleter calls the method, it well detect whether is is bound to a
+CommandSet or Cmd subclass.
+If bound to a cmd2.Cmd subclass, it will pass the app instance as the `self`
+argument. This is good in cases where the list of choices being generated
+relies on state data of the cmd2-based app.
+If bound to a cmd2.CommandSet subclass, it will pass the CommandSet instance
+as the `self` argument, and the app instance as the positional argument.
+
+    Example bound to cmd2.Cmd::
 
         def my_choices_method(self):
             ...
             return my_generated_list
 
+        parser.add_argument("arg", choices_method=my_choices_method)
+
+    Example bound to cmd2.CommandSEt::
+
+        def my_choices_method(self, app: cmd2.Cmd):
+            ...
+            return my_generated_list
+
+        parser.add_argument("arg", choices_method=my_choices_method)
+
 ``completer_function`` - pass a tab completion function that does custom
 completion. Since custom tab completion operations commonly need to modify
 cmd2's instance variables related to tab completion, it will be rare to need a
@@ -84,10 +98,16 @@ def my_completer_function(text, line, begidx, endidx):
             return completions
         parser.add_argument('-o', '--options', completer_function=my_completer_function)
 
-``completer_method`` - this is exactly like completer_function, but the
-function needs to be an instance method of a cmd2-based class. When
-ArgparseCompleter calls the method, it will pass the app instance as the self
-argument. cmd2 provides a few completer methods for convenience (e.g.,
+``completer_method`` - this is equivalent to completer_function, but the function
+needs to be an instance method of a cmd2.Cmd or cmd2.CommandSet subclass. When
+ArgparseCompleter calls the method, it well detect whether is is bound to a
+CommandSet or Cmd subclass.
+If bound to a cmd2.Cmd subclass, it will pass the app instance as the `self`
+argument. This is good in cases where the list of choices being generated
+relies on state data of the cmd2-based app.
+If bound to a cmd2.CommandSet subclass, it will pass the CommandSet instance
+as the `self` argument, and the app instance as the positional argument.
+cmd2 provides a few completer methods for convenience (e.g.,
 path_complete, delimiter_complete)
 
     Example::
@@ -560,6 +580,10 @@ class so cmd2 can remove subcommands from a parser.
     for name in to_remove:
         del self._name_parser_map[name]
 
+    if name in self.choices:
+        del self.choices[name]
+
+
 
 # noinspection PyProtectedMember
 setattr(argparse._SubParsersAction, 'remove_parser', _SubParsersAction_remove_parser)