Positional-only argument instead of typer.Argument

[flying-sheep]

Is your feature request related to a problem

Using positional-only arguments is already a way to signal “this argument has no name”.

It’s shorter and natural to use

The solution you would like

def main(arg: str, /, opt: int = 1): pass

would work like

def main(arg: str = typer.Argument(...), opt: int = 1): pass

Describe alternatives you've considered

Continue using typer.Argument

[sathoune]

Well, you can do something like that:

import typer

app = typer.Typer()

@app.command()
def main(
    arg: str, opt: int = 1
):
    print(arg)
    print(opt)


if __name__ == "__main__":
    app()

Arguments are required by default and Options are optional by default.
I am not sure if you missed/forgot about this part in the documentation or you want to achieve something different.
I believe one benefit could be is having arguments with default values and required options:

def main(arg: str, arg2: str = 2, /, opt: int, opt2: int = 1, ): pass

This however is invalid Python syntax, because you cannot have non-default parameters after default parameters, here: non-default opt after default arg2.

An obvious drawback is also that positional only arguments are a feature in Python 3.8 so that would require some more complex logic in the Typer code to handle different versions.

I understand that the non-default == typer.Argument and default == typer.Option is something that you have to keep in mind and positional/keyword only arguments could signal it more explicitly but is there anything else that I am missing?

[flying-sheep]

This would probably be useful, no?

def main(arg: str, arg2: int = 2, /, opt: int = 1): pass

Required options are rarely a good idea.

[flying-sheep]

Regarding Python 3.8: It would of course be possible to still use typer.Argument for older Python versions. And for the required option you brought up, once could do this:

def main(arg: str, arg2: str = 2, /, opt: int = typer.Option(...), opt2: int = 1): pass

The combination of optional argument and required option is bad CLI design, so making that awkward isn’t a bad tradeoff.

[ivantodorovich]

Hello,

I'm also interested by this proposal.

I find the current way to define default values for arguments (and making them optional) require too much boilerplate for something that's already in the language with the positional-only method arguments.

I'm happy to make a PR implementing this. Is this something maintainers would accept?

[YuriiMotov]

I think this will not simplify things a lot since:

• It's already possible to use just arg: str to declare required argument. This feature will only simplify this for non-required arguments
• In a lot of cases you will still need to use Argument() to specify help message and other parameters
• This syntax is not commonly used and might be confusing for some programmers

At the same time it brings additional maintenance burden.
So, I think we shouldn't implement this.

See also more broad similar idea: #331

[flying-sheep]

Maintenance burden, really? I’m a maintainer, and a better user-facing API is always worth adding like 2 new tests for me.

But since cyclopts exists, I’m no longer as invested in Typer anyway.