Merge pull request #924 from python-cmd2/wrapper_kwargs

Command function wrappers now pass kwargs through to wrapped function

2 files changed, 43 insertions, 16 deletions

diff --git a/cmd2/cmd2.py b/cmd2/cmd2.py
index 98969d10..34f53044 100644
--- a/cmd2/cmd2.py
+++ b/cmd2/cmd2.py
@@ -3169,17 +3169,16 @@ class Cmd(cmd.Cmd):
     py_parser.add_argument('command', nargs=argparse.OPTIONAL, help="command to run")
     py_parser.add_argument('remainder', nargs=argparse.REMAINDER, help="remainder of command")
 
-    # This is a hidden flag for telling do_py to run a pyscript. It is intended only to be used by run_pyscript
-    # after it sets up sys.argv for the script being run. When this flag is present, it takes precedence over all
-    # other arguments.
-    py_parser.add_argument('--pyscript', help=argparse.SUPPRESS)
-
     # Preserve quotes since we are passing these strings to Python
     @with_argparser(py_parser, preserve_quotes=True)
-    def do_py(self, args: argparse.Namespace) -> Optional[bool]:
+    def do_py(self, args: argparse.Namespace, *, pyscript: Optional[str] = None) -> Optional[bool]:
         """
         Enter an interactive Python shell
 
+        :param args: Namespace of args on the command line
+        :param pyscript: optional path to a pyscript file to run. This is intended only to be used by run_pyscript
+                         after it sets up sys.argv for the script. If populated, this takes precedence over all
+                         other arguments. (Defaults to None)
         :return: True if running of commands should stop
         """
         def py_quit():
@@ -3211,9 +3210,9 @@ class Cmd(cmd.Cmd):
                 localvars['self'] = self
 
             # Handle case where we were called by run_pyscript
-            if args.pyscript:
+            if pyscript is not None:
                 # Read the script file
-                expanded_filename = os.path.expanduser(utils.strip_quotes(args.pyscript))
+                expanded_filename = os.path.expanduser(pyscript)
 
                 try:
                     with open(expanded_filename) as f:
@@ -3320,7 +3319,7 @@ class Cmd(cmd.Cmd):
             sys.argv = [args.script_path] + args.script_arguments
 
             # noinspection PyTypeChecker
-            py_return = self.do_py('--pyscript {}'.format(utils.quote_string(args.script_path)))
+            py_return = self.do_py('', pyscript=args.script_path)
 
         finally:
             # Restore command line arguments to original state
diff --git a/cmd2/decorators.py b/cmd2/decorators.py
index deac4701..dc196032 100644
--- a/cmd2/decorators.py
+++ b/cmd2/decorators.py
@@ -1,7 +1,7 @@
 # coding=utf-8
 """Decorators for ``cmd2`` commands"""
 import argparse
-from typing import Callable, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Union
 
 from . import constants
 from .exceptions import Cmd2ArgparseError
@@ -53,12 +53,20 @@ def with_argument_list(*args: List[Callable], preserve_quotes: bool = False) ->
 
     def arg_decorator(func: Callable):
         @functools.wraps(func)
-        def cmd_wrapper(cmd2_app, statement: Union[Statement, str]):
+        def cmd_wrapper(cmd2_app, statement: Union[Statement, str], **kwargs: Dict[str, Any]) -> Optional[bool]:
+            """
+            Command function wrapper which translates command line into an argument list and calls actual command function
+
+            :param cmd2_app: CLI instance passed as self parameter to command function
+            :param statement: command line string or already generated Statement
+            :param kwargs: any keyword arguments being passed to command function
+            :return: return value of command function
+            """
             _, parsed_arglist = cmd2_app.statement_parser.get_command_arg_list(command_name,
                                                                                statement,
                                                                                preserve_quotes)
 
-            return func(cmd2_app, parsed_arglist)
+            return func(cmd2_app, parsed_arglist, **kwargs)
 
         command_name = func.__name__[len(constants.COMMAND_FUNC_PREFIX):]
         cmd_wrapper.__doc__ = func.__doc__
@@ -132,7 +140,17 @@ def with_argparser_and_unknown_args(parser: argparse.ArgumentParser, *,
 
     def arg_decorator(func: Callable):
         @functools.wraps(func)
-        def cmd_wrapper(cmd2_app, statement: Union[Statement, str]):
+        def cmd_wrapper(cmd2_app, statement: Union[Statement, str], **kwargs: Dict[str, Any]) -> Optional[bool]:
+            """
+            Command function wrapper which translates command line into argparse Namespace and calls actual
+            command function
+
+            :param cmd2_app: CLI instance passed as self parameter to command function
+            :param statement: command line string or already generated Statement
+            :param kwargs: any keyword arguments being passed to command function
+            :return: return value of command function
+            :raises: Cmd2ArgparseError if argparse has error parsing command line
+            """
             statement, parsed_arglist = cmd2_app.statement_parser.get_command_arg_list(command_name,
                                                                                        statement,
                                                                                        preserve_quotes)
@@ -148,7 +166,7 @@ def with_argparser_and_unknown_args(parser: argparse.ArgumentParser, *,
                 raise Cmd2ArgparseError
             else:
                 setattr(args, '__statement__', statement)
-                return func(cmd2_app, args, unknown)
+                return func(cmd2_app, args, unknown, **kwargs)
 
         # argparser defaults the program name to sys.argv[0], but we want it to be the name of our command
         command_name = func.__name__[len(constants.COMMAND_FUNC_PREFIX):]
@@ -204,7 +222,17 @@ def with_argparser(parser: argparse.ArgumentParser, *,
 
     def arg_decorator(func: Callable):
         @functools.wraps(func)
-        def cmd_wrapper(cmd2_app, statement: Union[Statement, str]):
+        def cmd_wrapper(cmd2_app, statement: Union[Statement, str], **kwargs: Dict[str, Any]) -> Optional[bool]:
+            """
+            Command function wrapper which translates command line into argparse Namespace and calls actual
+            command function
+
+            :param cmd2_app: CLI instance passed as self parameter to command function
+            :param statement: command line string or already generated Statement
+            :param kwargs: any keyword arguments being passed to command function
+            :return: return value of command function
+            :raises: Cmd2ArgparseError if argparse has error parsing command line
+            """
             statement, parsed_arglist = cmd2_app.statement_parser.get_command_arg_list(command_name,
                                                                                        statement,
                                                                                        preserve_quotes)
@@ -220,7 +248,7 @@ def with_argparser(parser: argparse.ArgumentParser, *,
                 raise Cmd2ArgparseError
             else:
                 setattr(args, '__statement__', statement)
-                return func(cmd2_app, args)
+                return func(cmd2_app, args, **kwargs)
 
         # argparser defaults the program name to sys.argv[0], but we want it to be the name of our command
         command_name = func.__name__[len(constants.COMMAND_FUNC_PREFIX):]