Cmd2ArgumentParser pass reference to state object for consumption by choices_provider functions

[gjvc]

How do I pass an object to a Cmd2ArgumentParser() constructor so that it or one of its subparsers may refer to it, for example, via the use of a "choices_provider=" argument to a parser argument? I am using the @cmd2.with_argparser decorator.

[anselor]

You should be passing a fully constructed Cmd2ArgumentParser to the with_argparser decorator so you should be able to construct it whatever parameters you like.

[gjvc]

Hello @anselor -- thank you for your explanation, but I'm afraid I don't follow. Let me try to explain as concisely as possible what I am seeking to do and you can laugh or sigh as appropriate.

I have an InteractiveShell class, which contains Model and Settings instances, thus:

class InteractiveShell( cmd2.cmd ):
    def __init__( self, *args, **kwargs ):
        super().__init__( *args, **kwargs )
        self._settings = Settings()
        self._model = Model()


    @cmd2.with_argparser( settings_argparser, ns_provider=ns_provider )
    def do_settings( self, args: argparse.Namespace ):
        do_settings( args )

do_settings is a free function

def do_settings( args: argparse.Namespace ):
    log.info( f'{args=}' )

Also, ns_provider is a free function, and I can't pass self._settings or self._model to it at all.

How and when should I construct settings_argparser so as to have access to the same self._settings object?

Right now I have

settings_argparser = cmd2.Cmd2ArgumentParser( add_help=False )
settings_subparsers = settings_argparser.add_subparsers( dest='action' )

list_parser = settings_subparsers.add_parser( 'list' )
list_parser.add_argument( 'what', choices={ 'packages', 'systems' } )

list_parser = settings_subparsers.add_parser( 'load' )

...but what I really want to do is pass a property on an instance of Model into list_parser.add_argument(), so that the completion can be driven by the contents of Model.

Am I doing this completely wrongly?

[anselor]

Ah, so what we have here is an order of operations issue with how I originally implemented the argparse registration.

The cmd2.with_argparser() command decorators are executed during module load as the class definition is executed. The model instance doesn't exist until much later when you're instantiating the class. It is, therefore, impossible to pass anything on the cmd2 instance to the argparser or the decorator.

Pull Request #1278 may interest you as it is adds the ability to provide a factory function that is called when the cmd2 instance is created and therefore allows for future access to instance-specific attributes.

In the near-term there is a work-around you can do. You can define a method on your cmd2.Cmd subclass and methods can access instance attributes. You can then pass the class method as either a choices_provider or a completer depending on what you need to do.

Using choices_provider you just return all possible values that can be completed and Cmd2 will handle matching it based on string prefix matching. This makes sense when the number of choices is on the smaller side.

If you want to have custom completion behavior you can write a completer function that parses the line input and returns only the values that match. This makes more sense if you're querying something potentially very large (like querying information in a large database table) and you can use the characters the user has typed to filter the results from the database query.

class InteractiveShell( cmd2.Cmd ):
    def __init__( self, *args, **kwargs ):
        super().__init__( *args, **kwargs )
        self._settings = Settings()
        self._model = Model()

    def _my_arg_choices(self) -> List[str]:
        return self._model.arg_choices
    
    def _my_arg_completer(self, text: str, line: str, begidx: int, endidx: int) -> List[str]:
        return [item for item in self._model.arg_choices if item.startswith(text)]
        
    settings_argparser = cmd2.Cmd2ArgumentParser( add_help=False )
    settings_subparsers = settings_argparser.add_subparsers( dest='action' )
    
    list_parser = settings_subparsers.add_parser( 'list' )
    list_parser.add_argument( 'what', choices_provider=_my_arg_choices)
    
    load_parser = settings_subparsers.add_parser( 'load' )
    load_parser.add_argument('what', completer=_my_arg_completer)

    @cmd2.with_argparser( settings_argparser, ns_provider=ns_provider )
    def do_settings( self, args: argparse.Namespace ):
        do_settings( args )

[DM1122]

Hello, how are you accessing self._model.arg_choices in _my_arg_choices() without passing self into _my_arg_choices?

For context, I'm looking for a similar workaround to enable Cmd2ArgumentParser to print the argparse usage errors to poutput

[anselor]

There were some typeos when I wrote that out. I've updated the answer in include the self parameter for the class method _my_arg_choinces().