nargs='?' equivalent

[noamgot]

First Check

• I added a very descriptive title here.
• I used the GitHub search to find a similar question and didn't find it.
• I searched the Typer documentation, with the integrated search.
• I already searched in Google "How to X in Typer" and didn't find any information.
• I already read and followed all the tutorials in the docs and didn't find an answer.
• I already checked if it is not related to Typer but to Click.

Commit to Help

• I commit to help with one of those options 👆

Example Code

parser = argparse.ArgumentParser()
parser.add_argument('--foo', nargs='?', const='c', default='d')
parser.add_argument('bar', nargs='?', default='d')
parser.parse_args(['XX', '--foo', 'YY'])
Namespace(bar='XX', foo='YY')
parser.parse_args(['XX', '--foo'])
Namespace(bar='XX', foo='c')
parser.parse_args([])
Namespace(bar='d', foo='d')

Description

I'm looking for an equivalent to python's argparse nargs='?' option, where:

One argument will be consumed from the command line if possible, and produced as a single item. If no command-line argument is present, the value from default will be produced. Note that for optional arguments, there is an additional case - the option string is present but not followed by a command-line argument. In this case the value from const will be produced. Some examples to illustrate this:

(from python's argparse docs)

The attached code is an example of the desired behavior when using argparse. The main feature that I'm looking is defining some constant value (or behavior) when a "bare" flag is provided, e.g:

python app.py --foo

in this case, I want foo to contain some value, but still allowing the user to provide their own value:

python app.py --foo some_user_provided_value

I hope that it makes sense...
I wasn't able to find a way to implement this using typer, would appreciate any help. thanks!

Operating System

Linux

Operating System Details

No response

Typer Version

0.15.1

Python Version

3.10.14

Additional Context

No response

[peterjc]

I had a similar usecase where I am calling a typer app from a snakemake workflow, and sometimes the argument was missing in which case I wanted to use the app's default. I could workaround this, e.g. sending an empty string like python app.py --foo '' but that is just a workaround.

[MaxFreedomPollard]

Worth splitting your argparse example into its two cases, because Typer handles them very differently.

The positional bar (nargs='?' with a default) is native. An argument with a default is optional:

import typer
app = typer.Typer()

@app.command()
def main(bar: str = typer.Argument("d")):
    typer.echo(f"bar={bar!r}")

(no args)  -> bar='d'
XX         -> bar='XX'

The --foo case (bare --foo gives a const, --foo X gives X) is the hard one. That's Click's "optional value" feature, and the copy of Click that current Typer bundles has dropped the parser support for it, so there's no single-option way to get it on recent Typer. Bare --foo just errors with "requires an argument." (Same underlying limitation as #608.)

The clean workaround that reproduces the behavior is two parameters: a bool flag plus a value option.

from typing import Optional
import typer
app = typer.Typer()
CONST = "c"

@app.command()
def main(
    bar: str = typer.Argument("d"),
    foo: bool = typer.Option(False, "--foo"),
    foo_value: Optional[str] = typer.Option(None, "--foo-value"),
):
    resolved = foo_value if foo_value is not None else (CONST if foo else "d")
    typer.echo(f"bar={bar!r} foo={resolved!r}")

(nothing)         -> bar='d'  foo='d'
XX --foo          -> bar='XX' foo='c'
XX --foo-value YY -> bar='XX' foo='YY'

If you genuinely need the single-flag --foo / --foo YY UX, drop that one command down to raw Click (which still supports is_flag=False, flag_value=... in click<9) and keep Typer for the rest of the app.

Tested on Typer 0.26.8, Python 3.11.