ArgumentParser changes between 0.9.11 and 0.9.21

[dannypete]

Hello!

I'm trying to understand the differences in how ArgumentParsers are defined and used in this new form as I am trying to update a project.

My cmd2 app (using cmd2 0.9.11) uses the following structure:

def MyClass(cmd2.Cmd):
...

    parser = argparse_completer.ACArgumentParser()
    setattr(filter_create_sp.add_argument("my_arg"),
              argparse_completer.ACTION_ARG_CHOICES, ("_my_completer_function",))

    @cmd2.with_argparser(parser)
    def do_command(self, args):
        ...

where _my_completer_function is a method of the MyClass class.

My understanding is that the new format of this code is something along the lines of:

def MyClass(cmd2.Cmd):
...

    parser = cmd2.argparse_custom.Cmd2ArgumentParser()
    parser.add_argument("my_arg", choices_method=self._my_completer_function)

    @cmd2.with_argparser(parser)
    def do_command(self, args):
        ....

Unfortunately, I cannot work out how to pass/use self(or other reference to the instance of my cmd2 app) for the parser.add_argument("my_arg", choices_method=self._my_completer_function) line. I need the MyClass instance to be passed to my custom completer function. Am I missing something obvious?

Thanks in advance.

[kmvanbrunt]

@dannypete Thanks for using cmd2. For your application, just set choices_method to _my_completer_function. The tab completion class, AutoCompleter, will pass the instance of MyClass to _my_completer_function for you.

parser.add_argument("my_arg", choices_method=._my_completer_function)

We are currently in the process of updating our documentation, but this topic hasn't been added yet. In the meantime take a look at the header to argparse_custom.py. It covers all of our custom argparse features and provides examples.

[kmvanbrunt]

@dannypete Did that work for you?

[dannypete]

I'm afraid I'm still a little confused.

If I define my parsers inside my class, e.g.:

class MyClass(cmd2.Cmd):
    parser = argparse_custom.Cmd2ArgumentParser()
    parser.add_argument("my_arg", choices_method=MyClass._myarg_completer_function)
    ...
    def _myarg_completer_function(self, text, line, begidx, endidx):
        ...

I am causing an error in trying to resolve MyClass in choices_method=MyClass._myarg_completer_function.

If I try to define my parsers in the same python file but not within the class definition, I cannot reference either MyClass (when I put my parser definitions before my MyClass definition) or I cannot reference my parsers (when I put my parsers after my MyClass definition).

I feel like I am missing something really obvious, but I can't put my finger on what it is.

[kmvanbrunt]

@dannypete The class is still being defined at that point, so it can't be referenced by class name. The same principle is causing the error with your choices function. It needs to be defined before you refer to it.

This should work:

class MyClass(cmd2.Cmd):
    def _myarg_choices_function(self):
        return self.my_arg_choices

    parser = argparse_custom.Cmd2ArgumentParser()
    parser.add_argument("my_arg", choices_method=_myarg_choices_function)
    ...

[dannypete]

This resolves one issue, but now my decorators are confused. I accidentally left those out in my previous examples. E.g.

class MyClass(cmd2.Cmd):
    ...
    @cmd2.with_argparser(parser)
    def _myarg_choices_function(self):
        ...

    parser = ... 

[kmvanbrunt]

The with_argparser decorator is used on the command's do_xxx function.

[dannypete]

Ok, yeah I think the issue has been solved. It looks like the order of definitions is much more important now than before.

Changing my MyClass order of definitions to the following solved the issue.

class MyClass(cmd2.Cmd):
    [completer function definitions]

    [parser definitions]

    [do_x definitions with decorators]

Thank you so much for your help, Kevin!