[Feature request] Use optional argument and options in combination with argument passthrough (optional argument with multiple but undefined number of values at the end of the command)

[AleixMT]

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

from __future__ import annotations

import logging
import os
from typing import List, Optional
from pathlib import Path
import typer
from rich.console import Console

from .config.loader import load_settings
from .config.schema import Settings
from .core.logging import setup_logging
from .shared_options import (
    EnvironmentOpt, EntrypointOpt, DebugOpt, PortOpt,
    DryRunOpt, VerboseOpt, QuietOpt, DockerScreenOpt,
)

console = Console()
app = typer.Typer(help="tot – BMDE CLI", no_args_is_help=True)
log = logging.getLogger("tot.cli")



@app.command("build")
def build_command(
        ctx: typer.Context,

        d: Optional[Path] = typer.Option(
            None,
            exists=True,
            file_okay=False,
            dir_okay=True,
            readable=True,
            resolve_path=True,
            help="Path to the project directory. If omitted, the current directory is used."
        ),
        passthrough: Optional[List[str]] = typer.Option(
            None,
            help="Arguments after '--' are passed directly to the backend entrypoint.",
            show_default=False,
        ),
        shell: bool = typer.Option(False, "-s", "--shell", is_flag=True,
                                   help="Open backend shell (docker only)"),

      
):
  print("d " + str(d))
  print("passthrough " + str())
  print("shell " + str())

Description

Create a typer script so that there is an optional positional argument in combination with other named arguments and an argument passwthough, so that the last thing in the CLI command will sometimes be -- arg1 arg2 arg3 ...

The command usage and its expected output in all different scenarios is the following:

../../venv/bin/python -m tot build . -- clean # (d: ., pasthrough: clean, shell: false) 

../../venv/bin/python -m tot build -- clean # (d: cwd, pasthrough: clean, shell: false) 

../../venv/bin/python -m tot build # (d: cwd, pasthrough: , shell: false)

../../venv/bin/python -m tot build -s -- clean # (d: cwd, pasthrough: clean, shell: true) 

../../venv/bin/python -m tot build -s . -- clean install# (d: ., pasthrough: clean install, shell: true) 

I would like to know how to do this with Typer or at least understand how can I do this without it but still using it to manage the rest of my argument. I could not find anything related to this in the documentation.

Operating System

Linux

Operating System Details

Ubuntu 20.04

Typer Version

0.20.0

Python Version

3.11.9

Additional Context

No response

[AleixMT]

First thing to say is that I was not in the right page of the docs. The full docs are here.

So, after reading them I have achieved the optional argument for the d parameter using the documentations for creating an optional argument

The relevant part of the code that has changed is this:

@app.command("build")
def build_command(
        ctx: typer.Context,

        directory: Annotated[Path, typer.Argument(
                                                 exists=True,
                                                 file_okay=False,
                                                 dir_okay=True,
                                                 readable=True,
                                                 resolve_path=True,
                                                 help="Path to the project directory. If omitted, the current directory is used.")] = os.getcwd(),

Now I can provide or not the d parameter as the first positional parameter, but this is optional as I wanted.

The rest of option arguments (now shown in the code) still work as expected (this is a normal use case, the other ones are not).

The problem now is that for achieving the argument passthrough I need an optional argument that accepts multiple values with undefined number of values. It can be only at the end of command and only once in a command to avoid complications. I can't use argument with multiple values because typer confuses it with the value for the d parameter. I need an option in order to explictly say where the passthrough arguments start (I proposed --, but I'd be happy using another string, such as --passthrough)

So, I think that this means that you can't do this with typer currently, because as the documentation says

You can set the number of values and types to anything you want, but it has to be a fixed number of values.

I think that we could implement this, I have seen argument passthrough in many commands such as gnome-terminal:

07:27 $ gnome-terminal --help                                                                                                      
Uso:                                                                                                                               
  gnome-terminal [OPCIÓN…] [-- COMANDO …]                                                                                                           

or docker run:

07:28 $ docker run --help
Usage:  docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

Although it is true that is the previous command docker run IMAGE is not an optional argument, it is mandatory.

As a workaround you can relax the spec for d and use it as optional argument, so that you need to explicitly say -d for setting it, but you can use the rest of unbindind parameters for the passthrough as optional argument with multiple values.

You can also say that passthrough only accepts one value, and this value is the string containing all args, so it needs to be split, but in this case you will not handle correctly spaces for the shell.

I can raise a PR but since it seems a non-trivial feature that can clash with other features I am requesting some help / guidelines for implementing it.

Thank you.

[AleixMT]

Final version of the code looks like this:

@app.command("build")
def build_command(
        ctx: typer.Context,
        params: Annotated[
            List[str], typer.Argument(
                                      help="Arguments are passed directly to the backend entrypoint.")] = (),
        directory: Annotated[Path, typer.Option(os.getcwd(), "-d", "--directory",
                                                 exists=True,
                                                 file_okay=False,
                                                 dir_okay=True,
                                                 readable=True,
                                                 resolve_path=True,
                                                 help="Path to the project directory. If omitted, the current directory is used.")] = os.getcwd(),

(I changed d for directory).

Now I can do:

../../venv/bin/python -m tot build -d . clean # (d: ., pasthrough: clean, shell: false) 

../../venv/bin/python -m tot build clean # (d: cwd, pasthrough: clean, shell: false) 

../../venv/bin/python -m tot build # (d: cwd, pasthrough: , shell: false)

../../venv/bin/python -m tot build -s clean # (d: cwd, pasthrough: clean, shell: true) 

../../venv/bin/python -m tot build -s -d . clean install# (d: ., pasthrough: clean install, shell: true)