The functions cmd2 adds to Namespaces (get_statement() and get_handler()) are now Cmd2AttributeWrapper objects.

This makes it easy to filter out which attributes in an argparse.Namespace were added by cmd2.

Author: kmvanbrunt

CHANGELOG.md

@@ -1,3 +1,11 @@
+## 1.3.6 (August 26, 2020)
+* Enhancements
+    * The functions cmd2 adds to Namespaces (`get_statement()` and `get_handler()`) are now 
+    `Cmd2AttributeWrapper` objects. This makes it easy to filter out which attributes in an
+    `argparse.Namespace` were added by `cmd2`.
+* Deprecations
+    * ``Namespace.__statement__`` will be removed in `cmd2` 2.0.0. Use `Namespace.get_statement()` going forward.
+
 ## 1.3.5 (August 25, 2020)
 * Bug Fixes
     * Fixed `RecursionError` when printing an `argparse.Namespace` caused by custom attribute cmd2 was adding

cmd2/__init__.py

@@ -16,7 +16,7 @@
     pass
 
 from .ansi import style, fg, bg
-from .argparse_custom import Cmd2ArgumentParser, CompletionItem, set_default_argument_parser
+from .argparse_custom import Cmd2ArgumentParser, Cmd2AttributeWrapper, CompletionItem, set_default_argument_parser
 
 # Check if user has defined a module that sets a custom value for argparse_custom.DEFAULT_ARGUMENT_PARSER
 import argparse

cmd2/argparse_custom.py

@@ -221,7 +221,7 @@ def my_completer_method(self, text, line, begidx, endidx, arg_tokens)
 import sys
 # noinspection PyUnresolvedReferences,PyProtectedMember
 from argparse import ONE_OR_MORE, ZERO_OR_MORE, ArgumentError, _
-from typing import Callable, Optional, Tuple, Type, Union
+from typing import Any, Callable, Optional, Tuple, Type, Union
 
 from . import ansi, constants
 
@@ -904,6 +904,18 @@ def _print_message(self, message, file=None):
             ansi.style_aware_write(file, message)
 
 
+class Cmd2AttributeWrapper:
+    """
+    Wraps a cmd2-specific attribute added to an argparse Namespace. This class is
+    callable because the argparse decorator adds these as getter functions to Namespaces.
+    """
+    def __init__(self, attribute: Any):
+        self.__attribute = attribute
+
+    def __call__(self) -> Any:
+        return self.__attribute
+
+
 # The default ArgumentParser class for a cmd2 app
 DEFAULT_ARGUMENT_PARSER = Cmd2ArgumentParser
 

cmd2/decorators.py

@@ -4,6 +4,7 @@
 from typing import TYPE_CHECKING, Any, Callable, Dict, Iterable, List, Optional, Tuple, Union
 
 from . import constants
+from .argparse_custom import Cmd2AttributeWrapper
 from .exceptions import Cmd2ArgparseError
 from .parsing import Statement
 
@@ -186,10 +187,9 @@ def with_argparser_and_unknown_args(parser: argparse.ArgumentParser, *,
                         needs to be prepopulated with state data that affects parsing.
     :param preserve_quotes: if ``True``, then arguments passed to argparse maintain their quotes
     :return: function that gets passed argparse-parsed args in a ``Namespace`` and a list
-             of unknown argument strings. A member called ``__statement__`` is added to the
+             of unknown argument strings. A function called ``get_statement()`` is added to the
              ``Namespace`` to provide command functions access to the :class:`cmd2.Statement`
              object. This can be useful if the command function needs to know the command line.
-             ``__statement__`` can also be retrieved by calling ``get_statement()`` on the ``Namespace``.
 
     :Example:
 
@@ -223,12 +223,12 @@ def with_argparser(parser: argparse.ArgumentParser, *,
     :param ns_provider: An optional function that accepts a cmd2.Cmd object as an argument and returns an
                         argparse.Namespace. This is useful if the Namespace needs to be prepopulated with
                         state data that affects parsing.
-    :param preserve_quotes: if True, then arguments passed to argparse maintain their quotes
+    :param preserve_quotes: if ``True``, then arguments passed to argparse maintain their quotes
     :param with_unknown_args: if true, then capture unknown args
-    :return: function that gets passed the argparse-parsed args in a Namespace
-             A member called __statement__ is added to the Namespace to provide command functions access to the
-             Statement object. This can be useful if the command function needs to know the command line.
-             ``__statement__`` can also be retrieved by calling ``get_statement()`` on the ``Namespace``.
+    :return: function that gets passed argparse-parsed args in a ``Namespace``. A function called
+             ``get_statement()`` is added to the ``Namespace`` to provide command functions access to
+             the :class:`cmd2.Statement` object. This can be useful if the command function needs to know
+             the command line.
 
     :Example:
 
@@ -300,11 +300,16 @@ def cmd_wrapper(*args: Any, **kwargs: Dict[str, Any]) -> Optional[bool]:
             else:
                 # Add statement to Namespace and a getter function for it
                 setattr(ns, constants.NS_ATTR_STATEMENT, statement)
-                setattr(ns, 'get_statement', lambda: statement)
+                setattr(ns, 'get_statement', Cmd2AttributeWrapper(statement))
 
                 # Add getter function for subcmd handler, which can be None
-                subcmd_handler = getattr(ns, constants.NS_ATTR_SUBCMD_HANDLER, None)
-                setattr(ns, 'get_handler', lambda: subcmd_handler)
+                handler = getattr(ns, constants.NS_ATTR_SUBCMD_HANDLER, None)
+                setattr(ns, 'get_handler', Cmd2AttributeWrapper(handler))
+
+                # Remove the subcmd handler attribute from the Namespace
+                # since get_handler() is how a developer retrieves it.
+                if hasattr(ns, constants.NS_ATTR_SUBCMD_HANDLER):
+                    delattr(ns, constants.NS_ATTR_SUBCMD_HANDLER)
 
                 args_list = _arg_swap(args, statement, *new_args)
                 return func(*args_list, **kwargs)

docs/features/argument_processing.rst

@@ -13,8 +13,7 @@ handles the following for you:
 
 3. Passes the resulting ``argparse.Namespace`` object to your command function.
    The ``Namespace`` includes the ``Statement`` object that was created when
-   parsing the command line. It is stored in the ``__statement__`` attribute of
-   the ``Namespace`` and can also be retrieved by calling ``get_statement()``
+   parsing the command line. It can be retrieved by calling ``get_statement()``
    on the ``Namespace``.
 
 4. Adds the usage message from the argument parser to your command.

tests/test_argparse.py

@@ -289,7 +289,6 @@ def do_base(self, args):
         func = getattr(args, 'func')
         func(self, args)
 
-
     # Add a subcommand using as_subcommand_to decorator
     has_subcmd_parser = cmd2.Cmd2ArgumentParser(description="Tests as_subcmd_to decorator")
     has_subcmd_subparsers = has_subcmd_parser.add_subparsers(dest='subcommand', metavar='SUBCOMMAND')
@@ -306,7 +305,7 @@ def do_test_subcmd_decorator(self, args: argparse.Namespace):
     def subcmd_func(self, args: argparse.Namespace):
         # Make sure printing the Namespace works. The way we originally added get_hander()
         # to it resulted in a RecursionError when printing.
-        print(args)
+        self.poutput(args)
 
 @pytest.fixture
 def subcommand_app():