Invoke callback without command for autocompletion

[alexrosenfeld10]

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

use_cache_option = typer.Option(True, "--cache/--no-cache", help="Use internal caching")

@app.callback(invoke_without_command=True)
def set_cache_option(use_cache: bool = use_cache_option):
    set_option("cache", use_cache) # this is just a function that sets a value in a map, very similar to the "state" example here: https://typer.tiangolo.com/tutorial/commands/callback/)

## later on, I have this:

filter_option = typer.Option(None, help="Filter by stuff", autocompletion=complete_filter)

## where complete_filter relies on the "cache" option being set, I get it via 
_global_options = {}
def get_option(option_name: str):
    return _global_options[option_name]

Description

Calling get_option raises KeyError: 'cache' when I tab complete on my_cli --filter thing[TAB] because the callback hasn't run, therefore the _global_options dictionary is empty. I would expect it to have "cache": True because the default parameter for the use_cache_option is True.

The impact here is the user gets an error. The obvious fix is, just populate the _global_options map with initial default values. However, that's not ideal, because it means users can't disable caching for tab completion. For example, I'd expect this to tab complete without hitting the cache: my_cli --no-cache --filter thing[TAB].

Operating System

macOS

Operating System Details

No response

Typer Version

0.12.3

Python Version

3.12.3

Additional Context

No response

[WJCFerguson]

If I understand right, I have a simillar issue.

I want my completion to depend on global options I pass via callback() global args. In my case, I'm allowing setting --hostname via callback(), and then my completion wants to go to that host and find out what to offer for a command's arguments' completions.

#!/usr/bin/env python
"""Test script to illustrate issue"""

from typing import Annotated

import typer

app = typer.Typer()

HOSTNAME = "localhost"


def _completions():
    if HOSTNAME == "localhost":
        return ["local_1", "local_2", "local_3"]
    else:
        return ["remote_1", "remote_2", "remote_3"]  # in reality would fetch


@app.callback(invoke_without_command=True)  # this arg doesn't help (isn't relevant?)
def common_args(hostname: str = "localhost"):
    global HOSTNAME
    HOSTNAME = hostname


@app.command()
def cmd(thing: Annotated[str, typer.Argument(autocompletion=_completions)]):
    assert thing in _completions()
    print(f"Getting {thing} from {HOSTNAME}")


if __name__ == "__main__":
    app()

$ ./typer_test.py cmd [TAB]
local_1  local_2  local_3  

$ ./typer_test.py cmd local_1
Getting local_1 from localhost

$ ./typer_test.py --hostname host1 cmd local_1
╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮
│ /home/foo/tmp/py/ionq/./typer_test.py:28 in cmd                                                 │
│                                                                                                  │
│   25                                                                                             │
│   26 @app.command()                                                                              │
│   27 def cmd(thing: Annotated[str, typer.Argument(autocompletion=_completions)]):                │
│ ❱ 28 │   assert thing in _completions()                                                          │
│   29 │   print(f"Getting {thing} from {HOSTNAME}")                                               │
│   30                                                                                             │
│   31                                                                                             │
│                                                                                                  │
│ ╭───── locals ──────╮                                                                            │
│ │ thing = 'local_1' │                                                                            │
│ ╰───────────────────╯                                                                            │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
AssertionError

$ ./typer_test.py --hostname host1 cmd remote_1
Getting remote_1 from host

$ ./typer_test.py --hostname host1 cmd [TAB]
local_1  local_2  local_3  

$ ./typer_test.py --hostname host1 cmd local_