Debug setting to print the args sent to do_xxx

[celephicus]

I'm liking cmd2, it does lots of work making things easy for me to concentrate on the code that actually does stuff.

I'm missing something that I've found useful: the ability to print the args namespace object that the do_xxx() functions use. I have been pasting the code in each command function, e.g:

def do_foo(self, args):
if self.debug_args:
self.poutput(f"Args: {str(data)}")
else:
......

Since the parsing is handled by decorators on the command function, not by the cmd2 framework, it looks like I need another decorator for the command function. But I've had no success writing one, can someone show me the way?

[kmvanbrunt]

@celephicus I'm glad you're finding cmd2 helpful.

When you say "namespace object", do you mean an argparse.Namespace? If so, that's what args.

If you mean the Statement object that we pass into undecorated do_xxx() functions, you can get that from the args namespace. We embed it as an attribute called cmd2_statement. It's a Cmd2AttributeWrapper object, so you use it this way.

import argparse
from cmd2 import Statement

def do_foo(self, args: argparse.Namespace) -> None:
    if self.debug_args:
        statement: Statement = args.cmd2_statement.get()
        self.poutput(f"Args: {statement}")

That code will print the arguments passed to the foo command. (e.g. foo arg1 arg2 would print Args: arg1 arg2).
If you want other data from the command line, check out the fields in the Statement class.

[celephicus]

Thank you for the prompt response. I've written a short example to illustrate my problem. It's not a show stopper at all, I'm just curious if it is possible as I don't like duplicated code. As my little language grows I will use several custom parsers and its handy to see their output when debugging.

In the example, if the debug_args setting is true, the action of the command is not run, it just dumps the contents of the args namespace less the cmd2_xxx members.

The args to which I refer are the args given to the do_foo & do_bar command functions, which are of type argparse.Namespace which are generated by the cmd2.with_argparser decorator.
It seems to me that I should be able to write a decorator for the commands funcs to add this functionality. I couldn't get one to work as I'm not good at decorators. I did look at the post parsing hook but it only gives me a Statement object which contains the args before they are parsed by the argument parser.

#!/usr/bin/env python3

import sys, cmd2

class SF_App(cmd2.Cmd):
	def __init__(self):
		super().__init__()

		# App setting for debugging the argument parsers. If true, the command does nothing just dumps its args.
		self.debug_args = False
		self.add_settable(
			cmd2.Settable('debug_args', bool, 'commands just dump their parsed args', self)
		)

	def dump_args_option(self, args):
		"Helper to dump args and not run command function depending on settings."
		if self.debug_args:
			self.poutput(f'Args: {", ".join([f"{k}={v}" for k,v in vars(args).items() if not k.startswith('cmd2')])}')
			return True
		return False

	foo_parser = cmd2.Cmd2ArgumentParser()
	foo_parser.add_argument("--foo-opt")
	@cmd2.with_argparser(foo_parser)
	def do_foo(self, args):
		if not self.dump_args_option(args):
			self.poutput("Do foo.")

	bar_parser = cmd2.Cmd2ArgumentParser()
	bar_parser.add_argument("--bar-opt")
	@cmd2.with_argparser(bar_parser)
	def do_bar(self, args):
		if not self.dump_args_option(args):
			self.poutput("Do bar.")

if __name__ == '__main__':
	sf_app = SF_App()
	sys.exit(sf_app.cmdloop())