Is there a way to put global options and subcommand options in any place?

[chenzhiwei]

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

import typer
from dataclasses import dataclass

app = typer.Typer(add_completion=False)


@dataclass
class Common:
    username: str
    password: str
    host: str


@app.command()
def device_info(ctx: typer.Context,
                device: str = typer.Option(..., help='Device name')):
    """Get device info"""
    typer.echo(f'Login user {ctx.obj.username} to host {ctx.obj.host}')
    typer.echo(f'Retrieving {device} info')


@app.callback()
def common(ctx: typer.Context,
           username: str = typer.Option(..., envvar='APP_USERNAME', help='Username'),
           password: str = typer.Option(..., envvar='APP_PASSWORD', help='Password'),
           host: str = typer.Option(..., envvar='APP_HOST', help='Host')):
    """Common Entry Point"""
    ctx.obj = Common(username, password, host)


if __name__ == "__main__":
    app()

Description

In above code, the username, password and host are global options and can only place it after the main program.

Is there a way to put them after arguments or subcommands, like kubectl:

kubectl get pod -n kube-system
kubectl -n kube-system get pod
kubectl get -n kube-system pod

Operating System

Linux

Operating System Details

No response

Typer Version

0.15.1

Python Version

Python 3.13.1

Additional Context

No response

[katrinm86]

i would also be interested in this ... have you @chenzhiwei made any discoveries in that regard?

[chenzhiwei]

no

[ianpittwood]

I've banged my head on this for a while and came up with a partial solution that reuses the definitions for the flags and allows the flags to be used at the command level for every command they are injected into. Hopefully this will be helpful to others that are bothered by how global options must be included at the app level rather than the command level!

In theory, this could be combined with Typer's app-level callbacks to allow for using the flags at any level, but for my purposes I only cared about having the same flags available for each subcommand.

My partial solution revolves around creating a decorator that wraps the original command with the shared arguments/options, adds any logic to process those arguments/options, and then returns the command with a modified signature that includes the extra arguments/options. Here's an example for adding a --verbose flag to a command.

def with_verbosity_flag(fn):
    # Create a wrapper function to inject and process the --verbose flag.
    @functools.wraps(fn)
    def wrapper(
        *args,
        verbose: Annotated[Optional[bool], typer.Option("--verbose", "-v", help="Enable debug logging")] = False,
        **kwargs,
    ):
        log_level: str | int = logging.INFO
        if verbose:
            log_level = logging.DEBUG

        init_logging(log_level)

        # Return the call to the original command function.
        return fn(*args, **kwargs)

    # Update command function signature to include --verbose. This is what Typer looks at.
    sig = inspect.signature(wrapper)
    params = list(sig.parameters.values())
    params.extend(
        [
            inspect.Parameter(
                "verbose",
                inspect.Parameter.KEYWORD_ONLY,
                default=False,
                annotation=Annotated[Optional[bool], typer.Option("--verbose", "-v", help="Enable debug logging")],
            ),
        ]
    )
    sig = sig.replace(parameters=params)
    wrapper.__signature__ = sig

    # Return the wrapper function with the injected flag and logic and modified signature
    return wrapper


@app.command()
@with_verbosity_flag
def my_command(...):
    my_command_logic()

With the wrapper function, you can accept just about anything including the ctx: typer.Context object to share code around the Click context. Just make sure that no arguments/options are duplicated in the signature and that they appear in the correct order with positional arguments before keyword arguments.