Breaking change: Removed cmd2 app as a required second parameter to

CommandSet command functions (do_, complete_, help_).
Renamed install_command_set and uninstall_command_set to
register_command_set and unregister_command_set.

Author: anselor

CHANGELOG.md

@@ -1,4 +1,9 @@
 ## 1.3.3 (TBD)
+* Breaking changes
+    * CommandSet command functions (do_, complete_, help_) will no longer have the cmd2 app
+      passed in as the first parameter after `self` since this is already a class member.
+    * Renamed `install_command_set()` and `uninstall_command_set()` to `register_command_set()` and 
+      `unregister_command_set()` for better name consistency.
 * Bug Fixes
     * Added explicit testing against python 3.5.2 for Ubuntu 16.04, and 3.5.3 for Debian 9
     * Added fallback definition of typing.Deque (taken from 3.5.4)

cmd2/argparse_completer.py

@@ -606,7 +606,8 @@ def _complete_for_arg(self, arg_action: argparse.Action,
                         # No cases matched, raise an error
                         raise CompletionError('Could not find CommandSet instance matching defining type for completer')
                     args.append(cmd_set)
-                args.append(self._cmd2_app)
+                else:
+                    args.append(self._cmd2_app)
 
             # Check if arg_choices.to_call expects arg_tokens
             to_call_params = inspect.signature(arg_choices.to_call).parameters

cmd2/argparse_custom.py

@@ -68,23 +68,16 @@ def my_choices_function():
 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.
+as the `self` argument.
 
-    Example bound to cmd2.Cmd::
+    Example::
 
         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/cmd2.py

@@ -45,7 +45,7 @@
 from . import ansi, constants, plugin, utils
 from .argparse_custom import DEFAULT_ARGUMENT_PARSER, CompletionItem
 from .clipboard import can_clip, get_paste_buffer, write_to_paste_buffer
-from .command_definition import CommandSet, _partial_passthru
+from .command_definition import CommandSet
 from .constants import COMMAND_FUNC_PREFIX, COMPLETER_FUNC_PREFIX, HELP_FUNC_PREFIX
 from .decorators import with_argparser, as_subcommand_to
 from .exceptions import (
@@ -186,7 +186,7 @@ def __init__(self, completekey: str = 'tab', stdin=None, stdout=None, *,
         :param auto_load_commands: If True, cmd2 will check for all subclasses of `CommandSet`
                                    that are currently loaded by Python and automatically
                                    instantiate and register all commands. If False, CommandSets
-                                   must be manually installed with `install_command_set`.
+                                   must be manually installed with `register_command_set`.
         """
         # If use_ipython is False, make sure the ipy command isn't available in this instance
         if not use_ipython:
@@ -264,7 +264,7 @@ def __init__(self, completekey: str = 'tab', stdin=None, stdout=None, *,
         self._cmd_to_command_sets = {}  # type: Dict[str, CommandSet]
         if command_sets:
             for command_set in command_sets:
-                self.install_command_set(command_set)
+                self.register_command_set(command_set)
 
         if auto_load_commands:
             self._autoload_commands()
@@ -452,11 +452,11 @@ def load_commandset_by_type(commandset_types: List[Type]) -> None:
                             or len(init_sig.parameters) != 1
                             or 'self' not in init_sig.parameters):
                         cmdset = cmdset_type()
-                        self.install_command_set(cmdset)
+                        self.register_command_set(cmdset)
 
         load_commandset_by_type(all_commandset_defs)
 
-    def install_command_set(self, cmdset: CommandSet) -> None:
+    def register_command_set(self, cmdset: CommandSet) -> None:
         """
         Installs a CommandSet, loading all commands defined in the CommandSet
 
@@ -476,23 +476,20 @@ def install_command_set(self, cmdset: CommandSet) -> None:
         try:
             for method_name, method in methods:
                 command = method_name[len(COMMAND_FUNC_PREFIX):]
-                command_wrapper = _partial_passthru(method, self)
 
-                self._install_command_function(command, command_wrapper, type(cmdset).__name__)
+                self._install_command_function(command, method, type(cmdset).__name__)
                 installed_attributes.append(method_name)
 
                 completer_func_name = COMPLETER_FUNC_PREFIX + command
                 cmd_completer = getattr(cmdset, completer_func_name, None)
                 if cmd_completer is not None:
-                    completer_wrapper = _partial_passthru(cmd_completer, self)
-                    self._install_completer_function(command, completer_wrapper)
+                    self._install_completer_function(command, cmd_completer)
                     installed_attributes.append(completer_func_name)
 
                 help_func_name = HELP_FUNC_PREFIX + command
                 cmd_help = getattr(cmdset, help_func_name, None)
                 if cmd_help is not None:
-                    help_wrapper = _partial_passthru(cmd_help, self)
-                    self._install_help_function(command, help_wrapper)
+                    self._install_help_function(command, cmd_help)
                     installed_attributes.append(help_func_name)
 
                 self._cmd_to_command_sets[command] = cmdset
@@ -508,7 +505,7 @@ def install_command_set(self, cmdset: CommandSet) -> None:
             if cmdset in self._cmd_to_command_sets.values():
                 self._cmd_to_command_sets = \
                     {key: val for key, val in self._cmd_to_command_sets.items() if val is not cmdset}
-            cmdset.on_unregister(self)
+            cmdset.on_unregister()
             raise
 
     def _install_command_function(self, command: str, command_wrapper: Callable, context=''):
@@ -549,7 +546,7 @@ def _install_help_function(self, cmd_name: str, cmd_help: Callable):
             raise CommandSetRegistrationError('Attribute already exists: {}'.format(help_func_name))
         setattr(self, help_func_name, cmd_help)
 
-    def uninstall_command_set(self, cmdset: CommandSet):
+    def unregister_command_set(self, cmdset: CommandSet):
         """
         Uninstalls a CommandSet and unloads all associated commands
         :param cmdset: CommandSet to uninstall
@@ -581,7 +578,7 @@ def uninstall_command_set(self, cmdset: CommandSet):
                 if hasattr(self, HELP_FUNC_PREFIX + cmd_name):
                     delattr(self, HELP_FUNC_PREFIX + cmd_name)
 
-            cmdset.on_unregister(self)
+            cmdset.on_unregister()
             self._installed_command_sets.remove(cmdset)
 
     def _check_uninstallable(self, cmdset: CommandSet):
@@ -656,11 +653,7 @@ def _register_subcommands(self, cmdset: Union[CommandSet, 'Cmd']) -> None:
                 raise CommandSetRegistrationError('Could not find argparser for command "{}" needed by subcommand: {}'
                                                   .format(command_name, str(method)))
 
-            if isinstance(cmdset, CommandSet):
-                command_handler = _partial_passthru(method, self)
-            else:
-                command_handler = method
-            subcmd_parser.set_defaults(cmd2_handler=command_handler)
+            subcmd_parser.set_defaults(cmd2_handler=method)
 
             def find_subcommand(action: argparse.ArgumentParser, subcmd_names: List[str]) -> argparse.ArgumentParser:
                 if not subcmd_names:

cmd2/command_definition.py

@@ -18,36 +18,6 @@
     pass
 
 
-def _partial_passthru(func: Callable, *args, **kwargs) -> functools.partial:
-    """
-    Constructs a partial function that passes arguments through to the wrapped function.
-    Must construct a new type every time so that each wrapped function's __doc__ can be copied correctly.
-
-    :param func: wrapped function
-    :param args: positional arguments
-    :param kwargs: keyword arguments
-    :return: partial function that exposes attributes of wrapped function
-    """
-    def __getattr__(self, item):
-        return getattr(self.func, item)
-
-    def __setattr__(self, key, value):
-        return setattr(self.func, key, value)
-
-    def __dir__(self) -> Iterable[str]:
-        return dir(self.func)
-
-    passthru_type = type('PassthruPartial' + func.__name__,
-                         (functools.partial,),
-                         {
-                             '__getattr__': __getattr__,
-                             '__setattr__': __setattr__,
-                             '__dir__': __dir__,
-                         })
-    passthru_type.__doc__ = func.__doc__
-    return passthru_type(func, *args, **kwargs)
-
-
 def with_default_category(category: str):
     """
     Decorator that applies a category to all ``do_*`` command methods in a class that do not already
@@ -78,8 +48,7 @@ class CommandSet(object):
 
     ``with_default_category`` can be used to apply a default category to all commands in the CommandSet.
 
-    ``do_``, ``help_``, and ``complete_`` functions differ only in that they're now required to accept
-    a reference to ``cmd2.Cmd`` as the first argument after self.
+    ``do_``, ``help_``, and ``complete_`` functions differ only in that self is the CommandSet instead of the cmd2 app
     """
 
     def __init__(self):
@@ -98,7 +67,7 @@ def on_register(self, cmd):
         else:
             raise CommandSetRegistrationError('This CommandSet has already been registered')
 
-    def on_unregister(self, cmd):
+    def on_unregister(self):
         """
         Called by ``cmd2.Cmd`` when a CommandSet is unregistered and removed.
 

cmd2/decorators.py

@@ -41,16 +41,18 @@ def cat_decorator(func):
 ##########################
 
 
-def _parse_positionals(args: Tuple) -> Tuple['cmd2.Cmd', Union[Statement, str]]:
+def _parse_positionals(args: Tuple) -> Tuple[Union['cmd2.Cmd', 'cmd2.CommandSet'], Union[Statement, str]]:
     """
     Helper function for cmd2 decorators to inspect the positional arguments until the cmd2.Cmd argument is found
     Assumes that we will find cmd2.Cmd followed by the command statement object or string.
     :arg args: The positional arguments to inspect
     :return: The cmd2.Cmd reference and the command line statement
     """
     for pos, arg in enumerate(args):
-        from cmd2 import Cmd
-        if isinstance(arg, Cmd) and len(args) > pos:
+        from cmd2 import Cmd, CommandSet
+        if (isinstance(arg, Cmd) or isinstance(arg, CommandSet)) and len(args) > pos:
+            if isinstance(arg, CommandSet):
+                arg = arg._cmd
             next_arg = args[pos + 1]
             if isinstance(next_arg, (Statement, str)):
                 return arg, args[pos + 1]
@@ -92,7 +94,7 @@ def with_argument_list(*args: List[Callable], preserve_quotes: bool = False) ->
     >>>     def do_echo(self, arglist):
     >>>         self.poutput(' '.join(arglist)
     """
-    import functools
+    import functools, cmd2
 
     def arg_decorator(func: Callable):
         @functools.wraps(func)
@@ -293,8 +295,8 @@ def cmd_wrapper(*args: Any, **kwargs: Dict[str, Any]) -> Optional[bool]:
             else:
                 setattr(ns, '__statement__', statement)
 
-                def get_handler(self: argparse.Namespace) -> Optional[Callable]:
-                    return getattr(self, constants.SUBCMD_HANDLER, None)
+                def get_handler(ns_self: argparse.Namespace) -> Optional[Callable]:
+                    return getattr(ns_self, constants.SUBCMD_HANDLER, None)
 
                 setattr(ns, 'get_handler', types.MethodType(get_handler, ns))