Missing option in typer.Option to tell typer to ignore the parsing of a certain argument

[doronz88]

Example Code

Description

The click module has options such as hidden, which tell it not to show the parameter to the user, but I could not find any way to tell typer to ignore a specific parameter.

In my use case, I use the cls=MyOwnTyperClass which always adds specific optionals. You can see this as an example:

https://github.com/doronz88/pymobiledevice3/blob/cef614ac0042641ffe8bd59df65001ebb5d94549/pymobiledevice3/cli/developer.py#L103

However, I failed to figure out a way in which I can accomplish this skip, and it does not seem like typer is designed to ignore such cases. Probably the best case would be implementing inside get_click_type() function so have such an option. What do you think?

This is an example API I think is best for the use case:

Annotated[MyClass, typer.Option(None, ignore=True)]

Or perhaps simply respect click's hidden=True option.

Typer Version

0.19.1

Python Version

3.13

Additional Context

No response

[YuriiMotov]

hidden=True parameter in Click hides the option from help message. It still can be used, but just doesn't appear in help.
And, it works in Typer as well:

import typer
from typing_extensions import Annotated


def main(
    name: str,
    lastname: Annotated[str, typer.Argument(hidden=True)] = "",
):
    print(f"Hello {name} {lastname}")


if __name__ == "__main__":
    typer.run(main)

$ typer main.py run --help
                                                                                                                            
 Usage: typer [PATH_OR_MODULE] run [OPTIONS] NAME [LASTNAME]                                                                
                                                                                                                            
 Run the provided Typer app.                                                                                                
                                                                                                                            
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ *    name      TEXT  [required]                                                                                          │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                                                              │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

$ typer main.py run Yurii
Hello Yurii 

$ typer main.py run Yurii Motov
Hello Yurii Motov

---

If your intention is to forbid passing this argument via command line, you can achieve this with the callback:

import typer
from typing_extensions import Annotated

def enforce_default(ctx: typer.Context, param: typer.CallbackParam, value: str):
    return param.default


def main(
    name: str,
    lastname: Annotated[
        str,
        typer.Argument(hidden=True, callback=enforce_default)
    ] = "<default>",
):
    print(f"Hello {name} {lastname}")


if __name__ == "__main__":
    typer.run(main)

$ typer main.py run Yurii
Hello Yurii <default>

$ typer main.py run Yurii Motov
Hello Yurii <default>

---

With complex types you will also need to specify parser and use default_factory instead of default:

import inspect
import typer
from typing_extensions import Annotated

def enforce_default(ctx: typer.Context, param: typer.CallbackParam, value: str):
    if inspect.isfunction(param.default):
        return param.default()
    return param.default


class MyClass:
    def __init__(self, a: str):
        self.a = a

def main(
    name: str,
    param: Annotated[
        MyClass,
        typer.Argument(
            hidden=True,
            callback=enforce_default,
            default_factory=lambda: MyClass(a="default_value"),
            parser=lambda x: None
        ),
    ],
):
    print(f"Hello {name}")
    print(param)


if __name__ == "__main__":
    typer.run(main)

[doronz88]

Just to clarify, I rely on click's ability to have my own costum callback inside the Command base class, so I make sure that the service_provider argument is always received before the actual execution - Meaning I would expect typer not to even see there was such a parameter in the first place:

def choose_service_provider(callback: Callable):
    def wrap_callback_calling(**kwargs: dict) -> None:
        service_provider = None
        lockdown_service_provider = kwargs.pop('lockdown_service_provider', None)
        rsd_service_provider_manually = kwargs.pop('rsd_service_provider_manually', None)
        rsd_service_provider_using_tunneld = kwargs.pop('rsd_service_provider_using_tunneld', None)
        if lockdown_service_provider is not None:
            service_provider = lockdown_service_provider
        if rsd_service_provider_manually is not None:
            service_provider = rsd_service_provider_manually
        if rsd_service_provider_using_tunneld is not None:
            service_provider = rsd_service_provider_using_tunneld
        callback(service_provider=service_provider, **kwargs)

    return wrap_callback_calling

class BaseServiceProviderCommand(BaseCommand):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.service_provider = None
        self.callback = choose_service_provider(self.callback)

[YuriiMotov]

Could you share a runnable minimal reproducible example?

[doronz88]

Sure, sorry for not making one in the first place:

Example for main-click.py:

from typing import Callable

import click


class MyServiceProvider:
    pass


def choose_service_provider(callback: Callable):
    def wrap_callback_calling(**kwargs: dict) -> None:
        callback(service_provider=MyServiceProvider, **kwargs)

    return wrap_callback_calling


class MyExtendedCommand(click.Command):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.callback = choose_service_provider(self.callback)


@click.group()
def cli() -> None:
    pass

@cli.command(cls=MyExtendedCommand)
def cli(service_provider: MyServiceProvider) -> None:
    pass


if __name__ == '__main__':
    cli()

You can run using:

python3 main-click.py --help

Now using typer (main-typer.py):

from typing import Callable

import typer.core


class MyServiceProvider:
    pass


def choose_service_provider(callback: Callable):
    def wrap_callback_calling(**kwargs: dict) -> None:
        callback(service_provider=MyServiceProvider, **kwargs)

    return wrap_callback_calling


class MyExtendedCommand(typer.core.TyperCommand):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.callback = choose_service_provider(self.callback)


cli = typer.Typer()


@cli.command(cls=MyExtendedCommand)
def cli(service_provider: MyServiceProvider) -> None:
    pass


if __name__ == '__main__':
    typer.run(cli)

As you can see in the example, the callback pops the first argument, so assuming typer and click are basically the same, this should also be able to be achieved. I tried using the hidden parameter as some kind of a workaround to bypass this.

[doronz88]

Since this seems to be by-design of typer, since unlike click it relies heavily on the callback signature and thus cannot be done the same way I use in click, the only option good option I can think of is adding a SkipParam annoation - telling typer to ignore it. I could check for it in get_params_convertors_ctx_param_name_from_function() and simply skip it the same way you already do for click.Context.

The only remaining question is if you are willing to accept a PR that will add this feature? If so, I'll happily submit one.

[doronz88]

Consider this example:

def get_params_convertors_ctx_param_name_from_function(
    callback: Optional[Callable[..., Any]],
) -> Tuple[List[Union[click.Argument, click.Option]], Dict[str, Any], Optional[str]]:
    params = []
    convertors = {}
    context_param_name = None
    if callback:
        parameters = get_params_from_function(callback)
        for param_name, param in parameters.items():
            if lenient_issubclass(param.annotation, type.SkipParam):  # <-- Skipping
                continue
            if lenient_issubclass(param.annotation, click.Context):
                context_param_name = param_name
                continue
            click_param, convertor = get_click_param(param)
            if convertor:
                convertors[param_name] = convertor
            params.append(click_param)
    return params, convertors, context_param_name