Macros are not calling autocomplete functions but aliases do

[Sripadvallabh]

Is there a possible way for macros to call autocomplete functions in case their placeholder arguments are given to the macro??

Basically i have a situation as follows:

macro create x1 words {1} {2} full

alias create xd x1 d

When i invoke the command 'xd new_word <TAB>' is there a way to expect the autocompletion list as in "words d new_word <TAB>" ?????

But if i just have an alias it autocompletes the next word in sequence.

[tleonhardt]

@kmvanbrunt This question is up your alley ...

[kmvanbrunt]

Because macros do not resolve until after hitting Enter, tab completion will only complete paths while typing a macro.

When I wrote this feature 6 years ago, I remember having a lot of trouble solving how to implement tab completing macros in the way you are asking. It gets complicated since arguments can be used in any order in a resolved macro. A later argument could determine what to tab complete in an earlier argument.

Here is an extreme example:
macro create my_macro help {2} {1}

Running my_macro create alias resolves to help alias create

Therefore I couldn't tab complete the first argument without first knowing what the second argument was.

Additionally, an argument number can be repeated in a macro:
macro create ft file_taxes -p {1} -q {2} -r {1}

Lastly macros can resolve into other macros and aliases. So there is a lot of state to keep track of.

[kmvanbrunt]

As you already know, aliases autocomplete as if you typed their actual value. This behavior cannot be changed.

Changing macros to autocomplete something other than paths requires you to override cmd2.Cmd.perform_completion() just to change one line of code.

# Check if a macro was entered
if command in self.macros:
    completer_func = self.path_complete

Note: We are removing macros from cmd2 3.0, so I don't recommend getting used to them.

[Sripadvallabh]

Thanks for your reply.

Maybe i will change that line of code to reflect my app currently.

May i know why are you removing macros? Isn't it not useful & powerful??

[kmvanbrunt]

We are removing them because cmd2 provides better options like aliases and argparse-based commands which offer far more customization for tab completing arguments. Macros offer no advantage over these options.

Are you using argparse-based commands? They will make it simple for you to tab complete the dictionary values.

Otherwise if you are using regular commands, you can implement Cmd.completedefault() to tab complete your dictionary values for commands that have no completer.

https://docs.python.org/3/library/cmd.html#cmd.Cmd.completedefault

Something like this:

def completedefault(self, text, line, begidx, endidx):
    return self.basic_complete(text, line, begidx, endidx, <dictionary values>)

[Sripadvallabh]

Yes i understand your point.

In our case one of the major motivations to use our application is to minimize much of the lengthy underlying commands users need to type all the time. Our app shell in turn calls another application that takes commands whose lengths are > 30 characters.

There are only a few variations between the commands; as an example an argument of (0, 1, 2 or 3) at the start of the command will print different outputs. Hence we try to utilize macros to supply that argument at the start but is not available via aliases. Argparse based options are not applicable since our commands do not use such options because only the underlying app does(a C-based shell).

As an example,

(cmd2-shell) command1 <sub_command1 <XYZ> <NUM_ARG> <XYZ> <OTHER_ARG>>

where sub_command1 is a command in the underlying C shell.

So for this type of command, we create a macro saying macro create mr command1 sub_command1 <XYZ> {1} <XYZ> along with an alias saying alias create mr0 0 for 0 num arg & alias create mr1 1 for 1 num arg & so on upto 4. Btw, this is the predominant use-case via our shell for more than 100 users at least.

All in all, i expect you guys to atleast retain backward compatibility with macros for my sake. Or you can provide me a way ; maybe pip install an older version & keep it running. We can have further conversations via meet also if you would want to see the use-case in live.

Thanks for going through this long message

[kmvanbrunt]

You're the first person I've heard from that uses macros. What an interesting use case.

I originally wrote macros for a particular user and they never ended up using them. I've never used them either, so it's encouraging to know the feature didn't go to waste.

Give me some time to consider your issue. There may be a way to solve it without macros and get tab completion.

If we keep macros, they would have to be improved. The lack of proper tab completion has always bothered me.

[tleonhardt]

@Sripadvallabh Absolutely, cmd2 empowers you to easily have custom auto-completion. Please see our basic_completion.py example which should show you how to accomplish what you want.

[Sripadvallabh]

Yes Todd. However my use-case is slightly complicated as mentioned in the above reply thread.

[tleonhardt]

Macros are a feature we wish we hadn't created because there are so many nasty edge cases. We plan to remove them in the 3.0 release.

[Sripadvallabh]

I understand your concerns.

But can we atleast have a plugin for this to ensure this stays as extended and can ensure backward compatibility?

Trust me, I really need this one, a lot of users benefit from this. I can share more details of the use cases and benefits in mail as well.

[tleonhardt]

@Sripadvallabh We can investigate if macros are something that can be supported via a plugin. That is a potentially good idea.

I'd appreciate it if you could share details of your use case. That could help us understand the benefits. My email is <first_name>.<last_name>@gmail.com and my full name is in my GitHub profile.

[Sripadvallabh]

Sure thanks todd. Will send a mail across consisting of the detailed use case and implementation. Just give me a day or two.

I can help contribute towards the plugin as well if you guys are busy as it is something that I would benefit from a lot.

[tleonhardt]

We'd very much appreciate your help contributing towards a plugin for this and we'd be happy to collaborate with you on that. I look forward to your email - no rush.

[tleonhardt]

@Sripadvallabh
We are now leaning towards leaving Macros in. However they are a pain to work with and maintain. We probably wont' be improving them any.

If you want to submit a PR to improve them somehow to fix any perceived shortcomings, we'd be happy to entertain that.

[Sripadvallabh]

Thanks a lot for this. I understand there are some nasty side effects from using macros, hence i appreciate your courage leaving them in 3.0 which you guys have tried best to improve.

Let me check the macro implementation and try to see if we can improve the code. Although I am still a beginner, still I will try my best alongside chatgpt :) to check them out.

Really appreciate your commitment to improving cmd2. Thanks a lot! It's a wonderful module to work with