access whole command list

[iancote]

Hello!

So I have a use case where I'm trying to build a cli configuration tool to eventually create a yaml file. I'd like to have the options the user enters autocomplete and eventually store in a dict I'm maintaining for dumping to said yaml. I was looking to use the arg_tokens feature like this:

Pass a dict of dicts structure like this or similar to a completer function:

subcommand_option1:
  field1:
    - a
    - b
    - c
  field2: 
    - c
    - d
  field3:
    field3_suboption1:
      - e
      - f
    field3_suboption2:
      - g
      - h

Then I'd like to return completion items to let them tab complete/ get description text for things to eventually get a line like
subcommand_option1 field2 c
that I can render back into yaml like:
subcommand_option1:
field2: c

I'm getting stuck in that I see the line in cmd2_statement.get(), but it's just a string so I can parse that, but I wonder if there's a better way to do all this? I feel like I'm recreating a wheel here.

Any help or suggestions appreciated.

[kmvanbrunt]

The get() method you're calling returns a cmd2.Statement object. It's a class that inherits from string and has other members added by cmd2. It is documented here. See if any of those members are what you're looking for.

I don't fully understand the problem you're trying to solve. Can you share a code snippet so I can help further?

[iancote]

Thanks for that pointer - it helped me get a bit further. Here's the code snippet I'm working on:

   set_description = "Set a value"
    set_parser = cmd2.Cmd2ArgumentParser(description=set_description)

    def set_parser_choices_provider(self, arg_tokens: Dict[str, List[str]]) -> List[str]:
        """ Traverse the device var tree to set values """
        rv = self._cmd.completer_dict['role_vars']
        if len(arg_tokens['config']) == 0:
            return rv.keys()
        tokens = arg_tokens['config']
        for position in tokens:
            if rv[position] is None:
                return []
            else:
                rv = rv[position]
        return rv.keys()

    set_parser.add_argument("config", nargs='*', choices_provider=set_parser_choices_provider)

    def do_set(self, args):
        """ Sets a value to a variable"""
        self._cmd.poutput("SET OUTPUT: {}".format(args))

The intent of what I'm going for is to string together a vetted series of tokens. The completer is getting a dict of dicts (self._cmd.completer_dict) that has a hierarchy of options. In this simplified case, the dict is
{'system': {'hostname': None, 'snmp_location': None},'interface': {'vlan': None, 'trunk': None, 'dhcp_trust': None}}

What I'm hoping for in this simple case is for the user to type "set " and get prompted with "system" or "interface". Then if they type in say, system - "set system " - they get prompted with "hostname" and "snmp_location".

In the end when they traverse the options and hit enter ("set system hostname foo") I'll use the do_set method to write that to a dict via the arg_list that gets returned. This will let me write the yaml I need for an ansible host_vars entry.

Hopefully this makes more sense. Thank you for taking a look.

[iancote]

Also, I should mention that this is in a CommandSet that is getting loaded, thus the "self._cmd.". I am still trying to figure out the self relationship between the command set and the actual cmd2.Cmd self object. From what I've seen, the original cmd2.Cmd self object seems to be in self._cmd inside the CommandSet object, so that's how I've been using it.

[anselor]

A couple thoughts come to mind here for different other directions you can explore.

First is you can create subcommands such that system and and interface are separate subcommands. Then each subcommand can separately define the next argument with just a simple argument list.

Second, we already have a built-in set command with the ability to define per-commandset settables. When you declare a settable you can specify the target object instance and attribute name to read/write values. You might be able to generate a bunch of settables based on the your config file.

[iancote]

Howdy! Thanks for the suggestions. In this case, I need to be able to take in a dict that is generated from data in an api call to generate the autocomplete tokens. I don't know what those are beforehand. I was going to use subcommands originally, but I didn't see a reasonable way to generate them dynamically. And also, I don't need the tokens to actually do anything - I'm not executing code based on the results of the token string, I'm converting it to a dict of dicts and eventually writing it out to yaml.

The folks I'm writing this for expect to use the term "set" for the purpose of the configuration bits - "set system hostname foo" - so I renamed the internal set command to accommodate this. I don't know if the built in arg_parse stuff for the internal set command is getting in the way, though.

[iancote]

AANND I'm just slow. Tonight after banging my head on this for days, I realized I missed actually using the "@cmd2.with_argparser" decorator to actually use my choices provider. That's why it was never completing anything. Once I realized that and corrected a logic bug and then accounted for the partials during tab complete, it works great.

Thanks all for the gentle advice and the pointers. I'm really enjoying learning all that cmd2 has to offer, and I couldn't do this project without it.