Typer

https://typer.tiangolo.com/
Admin
Typer is a library for building command-line interfaces (CLIs) in Python, leveraging type hints for...
Tokens:211,597
Snippets:1,751
Trust Score:9.1
Update:2 days ago
Show doc for...
Tokens:
Raw
### Run installed mycli command

Source: https://typer.tiangolo.com/tutorial/one-file-per-command

Execute the CLI using the installed `mycli` command. The example shows the `version` and `users add` commands with their expected outputs.

```bash
mycli version
mycli users add Camila
fast →mycli version  
My CLI Version 1.0  
  
mycli users add Camila  
Adding user: Camila  
  
restart ↻
```

--------------------------------

### Check context example with uv run commands

Source: https://typer.tiangolo.com/tutorial/commands/context

Run the example with create and delete subcommands to see the callback message and the command output.

```bash
uv run python main.py create Camila
uv run python main.py delete Camila

```

--------------------------------

### Run Typer example with uv

Source: https://typer.tiangolo.com/tutorial

Command to run any of the tutorial's example scripts after copying them to main.py. The output shows the magic happens here.

```bash
uv run python main.py

```

```text
✨ The magic happens here ✨

```

--------------------------------

### Running the label example

Source: https://typer.tiangolo.com/tutorial/progressbar

Command to run the label example and the expected output showing a progress bar with a label.

```bash
fast →python main.py█████ 13%

```

--------------------------------

### Run the progress bar example

Source: https://typer.tiangolo.com/tutorial/progressbar

Command to run the example script. The output shows the final message after the progress bar completes.

```bash
uv run python main.py
fast →uv run python main.py  
  
Processed 100 things.  
  
restart ↻

```

--------------------------------

### Install package with uv sync

Source: https://typer.tiangolo.com/tutorial/package

Installs the package and its dependencies into the uv-managed environment. Output shows the resolved packages and the installed rick-portal-gun version.

```bash
uv sync
```

```text
fast →uv sync  
Resolved 10 packages in 1ms  
      Built rick-portal-gun @ file:/home/rick-portal-gun  
Prepared 1 package in 18ms  
Uninstalled 1 package in 1ms  
Installed 1 package in 13ms  
 ~ rick-portal-gun==0.1.0 (from file:/home/rick-portal-gun)  
  
restart ↻
```

--------------------------------

### Install package from PyPI with uv tool install

Source: https://typer.tiangolo.com/tutorial/package

Install the package again using just the name so that uv pulls it from PyPI.

```bash
uv tool install rick-portal-gun
```

--------------------------------

### Run basic Typer example with uv and expected output

Source: https://typer.tiangolo.com/

Commands to run the basic example with uv, including running with --help and with an argument. The output shows the help text, an error when the name argument is missing, and the successful greeting.

```bash
uv run python main.py
uv run python main.py --help
uv run python main.py Camila
fast →💬 Run your applicationuv run python main.py  
💬 You get a nice error, you are missing 'name'Usage: main.py [OPTIONS] {name}  
Try 'main.py --help' for help.  
╭─ Error ───────────────────────────────────────────╮  
│ Missing argument 'name'.                          │  
╰───────────────────────────────────────────────────╯  
  
  
💬 You get a --help for freeuv run python main.py --help  
Usage: main.py [OPTIONS] {name}  
  
╭─ Arguments ───────────────────────────────────────╮  
│ *    name      <str>  [required]                  │  
╰───────────────────────────────────────────────────╯  
╭─ Options ─────────────────────────────────────────╮  
│ --help          Show this message and exit.       │  
╰───────────────────────────────────────────────────╯  
  
💬 Now pass the 'name' argumentuv run python main.py Camila  
Hello Camila  
  
💬 It works! 🎉  
restart ↻

```

--------------------------------

### Check tuple argument example with help, defaults, and errors

Source: https://typer.tiangolo.com/tutorial/multiple-values/arguments-with-multiple-values

Commands to run the tuple example and their outputs. Shows the help text, default behavior, error when an invalid number of arguments is passed, and successful execution with exactly three values.

```bash
uv run python main.py --help
uv run python main.py
uv run python main.py Draco Hagrid
uv run python main.py Draco Hagrid Dobby

```

```text
Usage: main.py [OPTIONS] [names]...  

Arguments:  
  names...  Select 3 characters to play with  [default: Harry, Hermione, Ron]  

Options:  
  --help                Show this message and exit.  

Hello Harry  
Hello Hermione  
Hello Ron  

Error: Argument 'names' takes 3 values  

Hello Draco  
Hello Hagrid  
Hello Dobby  

```

--------------------------------

### Test installed package with rick-portal-gun load

Source: https://typer.tiangolo.com/tutorial/package

Run the installed package to verify it works. The output shows 'Loading portal gun' and a success message.

```bash
rick-portal-gun load
```

--------------------------------

### Run the list argument example

Source: https://typer.tiangolo.com/tutorial/multiple-values/arguments-with-multiple-values

Command to run the list argument example with multiple file paths and a celebration string. The output shows the expected behavior.

```bash
uv run python main.py ./index.md ./first-steps.md woohoo!

```

--------------------------------

### Running the length example

Source: https://typer.tiangolo.com/tutorial/progressbar

Command to run the length example and the expected output showing 'Processed 100 user IDs.'

```bash
uv run python main.py
fast →uv run python main.py  
  
Processed 100 user IDs.  
  
restart ↻

```

--------------------------------

### Typer with context_settings for help options

Source: https://typer.tiangolo.com/reference/typer

Example for the context_settings parameter, passing configuration for the Click context.

```python
import typer

app = typer.Typer(context_settings={"help_option_names": ["-h", "--help"]})
```

--------------------------------

### Set help text

Source: https://typer.tiangolo.com/reference/typer

Example of setting the help text for the main Typer app.

```python
import typer

app = typer.Typer(help="Some help.")

```

--------------------------------

### Set context_settings for help options

Source: https://typer.tiangolo.com/reference/typer

Example of passing context_settings to customize help option names.

```python
import typer

app = typer.Typer(context_settings={"help_option_names": ["-h", "--help"]})

```

--------------------------------

### Create a Typer app

Source: https://typer.tiangolo.com/reference/typer

Basic example of creating a Typer application instance.

```python
import typer

app = typer.Typer()

```

--------------------------------

### Set short_help text

Source: https://typer.tiangolo.com/reference/typer

Example of setting a shortened help text for the app.

```python
import typer

app = typer.Typer(help="A lot of explanation about user management", short_help="user management")

```

--------------------------------

### Run main.py --help to show application help

Source: https://typer.tiangolo.com/

Shows the help output for the main application, listing available commands (hello and goodbye) and options like --install-completion and --show-completion. Use this to verify the CLI structure after upgrading.

```bash
uv run python main.py --help
```

```text
fast →uv run python main.py --help  
 Usage: main.py [OPTIONS] COMMAND [ARGS]...  
  
╭─ Options ─────────────────────────────────────────╮  
│ --install-completion          Install completion  │  
│                               for the current     │  
│                               shell.              │  
│ --show-completion             Show completion for │  
│                               the current shell,  │  
│                               to copy it or       │  
│                               customize the       │  
│                               installation.       │  
│ --help                        Show this message   │  
│                               and exit.           │  
╰───────────────────────────────────────────────────╯  
╭─ Commands ────────────────────────────────────────╮  
│ hello                                             │  
│ goodbye                                           │  
╰───────────────────────────────────────────────────╯  
  
💬 When you create a package you get ✨ auto-completion ✨ for free, installed with --install-completion  
💬 You have 2 subcommands (the 2 functions): hello and goodbye  
restart ↻
```

--------------------------------

### Run the CLI and view help output

Source: https://typer.tiangolo.com/tutorial/options/help

Command to run the example and the resulting help output showing the options --lastname and --formal with their help texts.

```bash
uv run python main.py --help
```

```text
Usage: main.py [OPTIONS] {name}  

  Say hi to 'name', optionally with a --lastname.  

  If --formal is used, say hi very formally.  

Arguments:  
  name  [required]  

Options:  
  --lastname <str>        Last name of person to greet.  
  --formal / --no-formal  Say hi formally.  [default: no-formal]  
  --help                  Show this message and exit.  

```

--------------------------------

### Example .zshrc completion configuration

Source: https://typer.tiangolo.com/contributing

Shows the content that may appear in the shell configuration file after installing completion.

```bash
fpath+=~/.zfunc; autoload -Uz compinit; compinit


zstyle ':completion:*' menu select
```

--------------------------------

### Run context configuration example with extra args

Source: https://typer.tiangolo.com/tutorial/commands/context

Run the command with extra CLI parameters to see them printed as a raw list of strings, including option names and values.

```bash
uv run python main.py --name Camila --city Berlin

```

--------------------------------

### Disable lazy file creation with Typer Option

Source: https://typer.tiangolo.com/reference/parameters

By default, a file is not created until you start writing to it. Set lazy=False to change this behavior. This example uses mode="a" and lazy=False.

```python
@app.command()
def main(config: Annotated[typer.FileText, typer.Option(mode="a", lazy=False)]):
    config.write("This is a single line\n")
    print("Config line written")
```

--------------------------------

### Run create --help and show output with panels

Source: https://typer.tiangolo.com/tutorial/commands/help

Shows the command to run the create command's help and the resulting output. The output displays the arguments and options grouped into panels: 'Arguments', 'Secondary Arguments', 'Options', and 'Additional Data'.

```bash
uv run python main.py create --help

```

```text
fast →uv run python main.py create --help  
** ****Usage: ****main.py create [OPTIONS] {username} [lastname]          **  
**                                                                     **  
 Create a new user. ✨  
  
╭─ Arguments ───────────────────────────────────────────────────────╮  
│ *    username      **<str>**  The username to create                  │  
│                          [required]                               │  
╰───────────────────────────────────────────────────────────────────╯  
╭─ Secondary Arguments ─────────────────────────────────────────────╮  
│   lastname      **lastname**  The last name of the new user           │  
╰───────────────────────────────────────────────────────────────────╯  
╭─ Options ─────────────────────────────────────────────────────────╮  
│ **--force**    **--no-force**      Force the creation of the user         │  
│                            [default: no-force]                    │  
│ **--help**                     Show this message and exit.            │  
╰───────────────────────────────────────────────────────────────────╯  
╭─ Additional Data ─────────────────────────────────────────────────╮  
│ **--age**                   **<int>   **  The age of the new user         │  
│ **--favorite-color**        **<str>   **  The favorite color of the new   │  
│                                  user                             │  
╰───────────────────────────────────────────────────────────────────╯  
  
restart ↻

```

--------------------------------

### Install wheel package with uv tool install

Source: https://typer.tiangolo.com/tutorial/package

Installs the built wheel as an isolated command-line tool. The command uses the full path to the wheel file. uv installs the tool in its own isolated environment to avoid conflicts.

```bash
uv tool install /home/rick/rick-portal-gun/dist/rick_portal_gun-0.1.0-py3-none-any.whl
```

--------------------------------

### Run and test the multiple-option CLI for users

Source: https://typer.tiangolo.com/tutorial/multiple-values/multiple-options

Commands to run the example and observe the output for no users, one user, and multiple users. The output shows the abort message when no users are provided.

```bash
uv run python main.py
uv run python main.py --user Camila
uv run python main.py --user Camila --user Rick --user Morty

```

```text
uv run python main.py  
No provided users (raw input = None)  
Aborted!  
  
💬 Now pass a user
uv run python main.py --user Camila  
Processing user: Camila  
  
💬 And now try with several users
uv run python main.py --user Camila --user Rick --user Morty  
Processing user: Camila  
Processing user: Rick  
Processing user: Morty  

```

--------------------------------

### Install Typer completion

Source: https://typer.tiangolo.com/contributing

Installs shell completion for Typer in the current shell.

```bash
typer --install-completion
```

--------------------------------

### Run one command with callback example

Source: https://typer.tiangolo.com/tutorial/commands/one-or-multiple

Commands to run the app with a callback. The help shows a single command 'create'.

```bash
uv run python main.py --help
uv run python main.py create

```

--------------------------------

### Start the zsh shell

Source: https://typer.tiangolo.com/contributing

Starts the zsh shell inside the container to test completion.

```bash
zsh
```

--------------------------------

### Run multiple commands example

Source: https://typer.tiangolo.com/tutorial/commands/one-or-multiple

Commands to run the multi-command app and its help output. The help shows both commands.

```bash
uv run python main.py --help
uv run python main.py create
uv run python main.py delete

```

--------------------------------

### Typer Option hide_input=True example

Source: https://typer.tiangolo.com/reference/parameters

Hides user input on the screen when prompting, for example for passwords.

```python
@app.command()
def login(
    name: str,
    password: Annotated[str, typer.Option(prompt=True, hide_input=True)],
):
    print(f"Hello {name}. Doing something very secure with password.")

```

--------------------------------

### Install shell completion with --install-completion

Source: https://typer.tiangolo.com/tutorial/package

Installs shell completion for the CLI. The output indicates that zsh completion was installed in /home/rick/.zshrc and will take effect after restarting the terminal. To remove completion, delete the added line in that file.

```bash
rick-portal-gun --install-completion
```

--------------------------------

### Help output for init command

Source: https://typer.tiangolo.com/tutorial/commands/help

Output of `uv run python main.py init --help` showing the command's docstring help and no options.

```text
Usage: main.py init [OPTIONS]

  Initialize the users database.

Options:
  --help  Show this message and exit.
```

--------------------------------

### Run the Typer application with commands and options

Source: https://typer.tiangolo.com/

Shows example invocations of the application with the hello and goodbye commands, including the --formal option, and their corresponding outputs. Use these commands to test the CLI application.

```bash
uv run python main.py hello Camila
uv run python main.py goodbye Camila
uv run python main.py goodbye --formal Camila
```

```text
fast →💬 Use it with the hello command  
uv run python main.py hello Camila  
Hello Camila  
  
💬 And with the goodbye command  
uv run python main.py goodbye Camila  
Bye Camila!  
  
💬 And with --formal  
uv run python main.py goodbye --formal Camila  
Goodbye Ms. Camila. Have a good day.  
  
restart ↻
```

--------------------------------

### Uninstall package with uv tool uninstall

Source: https://typer.tiangolo.com/tutorial/package

Uninstall the currently installed package to test installation from PyPI.

```bash
uv tool uninstall rick-portal-gun
```

--------------------------------

### Install Typer dependencies inside the container

Source: https://typer.tiangolo.com/contributing

Uses uv to install the project dependencies from requirements.txt inside the container.

```bash
uv pip install -r requirements.txt
```

--------------------------------

### Run the CLI with different parameter types

Source: https://typer.tiangolo.com/tutorial/parameter-types

Shows the commands to run the example: --help, a valid invocation with all types, and an invalid invocation that passes a float to an int option. The output demonstrates the help text, correct type conversion, and the error message for an invalid int.

```bash
uv run python main.py --help
uv run python main.py Camila --age 15 --height-meters 1.70 --female
uv run python main.py Camila --age 15.3

```

--------------------------------

### Run main --help and show output with command panels

Source: https://typer.tiangolo.com/tutorial/commands/help

Shows the command to run the main application's help and the resulting output. The output displays the commands grouped into panels: 'Commands' and 'Utils and Configs'.

```bash
uv run python main.py --help

```

```text
fast →uv run python main.py --help  
** ****Usage: ****main.py [OPTIONS] COMMAND [ARGS]...                   **  
**                                                                     **  
╭─ Options ─────────────────────────────────────────────────────────╮  
│ **--install-completion**          Install completion for the current  │  
│                               shell.                              │  
│ **--show-completion**             Show completion for the current     │  
│                               shell, to copy it or customize the  │  
│                               installation.                       │  
│ **--help**                        Show this message and exit.         │  
╰───────────────────────────────────────────────────────────────────╯  
╭─ Commands ────────────────────────────────────────────────────────╮  
│ **create          ** Create a new user. ✨                            │  
╰───────────────────────────────────────────────────────────────────╯  
╭─ Utils and Configs ───────────────────────────────────────────────╮  
│ **config         ** Configure the system. ⚙                          │  
╰───────────────────────────────────────────────────────────────────╯  
  
restart ↻

```

--------------------------------

### Example Typer app without Annotated

Source: https://typer.tiangolo.com/tutorial/options-autocompletion

A non-Annotated version of the example Typer app. Prefer the Annotated version if possible.

```python
import typer

app = typer.Typer()


@app.command()
def main(name: str = typer.Option("World", help="The name to say hi to.")):
    print(f"Hello {name}")


if __name__ == "__main__":
    app()

```

--------------------------------

### Create a new uv project with --package

Source: https://typer.tiangolo.com/tutorial/package

Initializes a new Python package project named rick-portal-gun using uv. The --package flag sets up a package structure. The output shows the project was initialized at /home/rick-portal-gun.

```bash
uv init --package rick-portal-gun
```

```text
Initialized project `rick-portal-gun` at `/home/rick-portal-gun`
```

--------------------------------

### Check help output for callback example

Source: https://typer.tiangolo.com/tutorial/subcommands/name-and-help

Run the main help and the users help to see the inferred help text. The output shows the help text 'Manage users in the app.' in the main help and as the description for the users command.

```bash
uv run python main.py --help
uv run python main.py users --help

```

--------------------------------

### Argument() source code with embedded examples

Source: https://typer.tiangolo.com/reference/parameters

Source code of the Argument() function in typer/params.py, including embedded examples for default, callback, and metavar parameters.

```python
def Argument(
    # Parameter
    default: Annotated[
        Any | None,
        Doc(
            """
            By default, CLI arguments are required. However, by giving them a default value they become [optional](https://typer.tiangolo.com/tutorial/arguments/optional):

            **Example**

            ```python
            @app.command()
            def main(name: str = typer.Argument("World")):
                print(f"Hello {name}!")
            ```

            Note that this usage is deprecated, and we recommend to use `Annotated` instead:
            ```python
            @app.command()
            def main(name: Annotated[str, typer.Argument()] = "World"):
                print(f"Hello {name}!")
            ```
            """
        ),
    ] = ...,
    *,
    callback: Annotated[
        Callable[..., Any] | None,
        Doc(
            """
            Add a callback to this CLI Argument, to execute additional logic with the value received from the terminal.
            See [the tutorial about callbacks](https://typer.tiangolo.com/tutorial/options/callback-and-context/) for more details.

            **Example**

            ```python
            def name_callback(value: str):
                if value != "Deadpool":
                    raise typer.BadParameter("Only Deadpool is allowed")
                return value

            @app.command()
            def main(name: Annotated[str, typer.Argument(callback=name_callback)]):
                print(f"Hello {name}")
            ```
            """
        ),
    ] = None,
    metavar: Annotated[
        str | None,
        Doc(
            """
            Customize the name displayed in the help text to represent this CLI Argument.
            By default, it will be the same name you declared, in uppercase.
            See [the tutorial about CLI Arguments with Help](https://typer.tiangolo.com/tutorial/arguments/help/#custom-help-name-metavar) for more details.

            **Example**

            ```python
            @app.command()
            def main(name: Annotated[str, typer.Argument(metavar="✨username✨")]):
                print(f"Hello {name}")
            ```
            """
        ),
    ] = None,
    expose_value: Annotated[
        bool,
        Doc(
            """
            **Note**: you probably shouldn't use this parameter, it is inherited from Click and supported for compatibility.

            ---

            """
        ),
    ] = True,

```

--------------------------------

### Install Typer with uv

Source: https://typer.tiangolo.com/

Adds Typer to the project using `uv add typer`. This installs both the library and the `typer` command in the project's virtual environment.

```bash
uv add typer
```

--------------------------------

### Run main.py hello --help to show hello command help

Source: https://typer.tiangolo.com/

Shows the help output for the hello subcommand, which requires a name argument. Use this to verify the command's usage and required arguments.

```bash
uv run python main.py hello --help
```

```text
fast →uv run python main.py hello --help  
 Usage: main.py hello [OPTIONS] {name}  
  
╭─ Arguments ───────────────────────────────────────╮  
│ *    name      <str>  [required]                  │  
╰───────────────────────────────────────────────────╯  
╭─ Options ─────────────────────────────────────────╮  
│ --help          Show this message and exit.       │  
╰───────────────────────────────────────────────────╯  
  
restart ↻
```

--------------------------------

### Run the app with uv

Source: https://typer.tiangolo.com/tutorial/testing

Command to run the example app with uv, passing name and city arguments.

```bash
uv run python main.py Camila --city Berlin

```

--------------------------------

### Example usage of typer.run

Source: https://typer.tiangolo.com/reference/run_launch

Example of using `typer.run` to convert a simple function into a CLI application. The function `main` takes a `name` argument and prints a greeting.

```python
import typer

def main(name: str):
    print(f"Hello {name}")

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

```

--------------------------------

### Run installed CLI command rick-portal-gun shoot

Source: https://typer.tiangolo.com/tutorial/package

Executes the installed CLI program. The output shows a success message 'It works 🎉Shooting portal gun'.

```bash
rick-portal-gun shoot
```

--------------------------------

### Run command and show --help output

Source: https://typer.tiangolo.com/tutorial/arguments/help

Shows the command to run the app and the resulting `--help` output, which includes the argument help text and marks the argument as required.

```bash
uv run python main.py --help
fast →uv run python main.py --help  
💬 Check the section with Arguments below 🚀Usage: main.py [OPTIONS] {name}  
  
Arguments:  
  name  The name of the user to greet  [required]  
  
Options:  
  --help                Show this message and exit.  
  
restart ↻

```

--------------------------------

### Install Typer with Rich support

Source: https://typer.tiangolo.com/release-notes

Install Typer with the optional Rich dependency using the 'all' extra. This is required to enable Rich integrations for help, errors, and tracebacks.

```bash
pip install "typer[all]"
```

--------------------------------

### Run command and help output with custom panels

Source: https://typer.tiangolo.com/tutorial/arguments/help

Run the application with --help to see the default 'Arguments' panel and the custom 'Secondary Arguments' panel. The output shows the help panels as described.

```bash
uv run python main.py --help
```

```text
fast →uv run python main.py --help  
** ****Usage: ****main.py [OPTIONS] {name} [lastname] [age]               **  
**                                                                     **  
 Say hi to 'name' very gently, like Dirk.  

╭─ Arguments ───────────────────────────────────────────────────────╮  
│ *    name      **str**  Who to greet [default: None] [required]       │  
╰───────────────────────────────────────────────────────────────────╯  
╭─ Secondary Arguments ─────────────────────────────────────────────╮  
│   lastname      **lastname**  The last name                           │  
│   age           **age     **  The user's age                          │  
╰───────────────────────────────────────────────────────────────────╯  
╭─ Options ─────────────────────────────────────────────────────────╮  
│ **--help**                        Show this message and exit.         │  
╰───────────────────────────────────────────────────────────────────╯  

restart ↻
```

--------------------------------

### Help output for create command

Source: https://typer.tiangolo.com/tutorial/commands/help

Output of `uv run python main.py create --help` showing the command's docstring help and required username argument.

```text
Usage: main.py create [OPTIONS] {username}

  Create a new user with username.

Arguments:
  username  [required]

Options:
  --help  Show this message and exit.
```

--------------------------------

### Zsh completion output example

Source: https://typer.tiangolo.com/tutorial/options-autocompletion

Example of what the completion looks like in Zsh when pressing TAB after --name. Shows the help text next to each completion item.

```shell
typer ./main.py run --name [TAB][TAB]
fast →typer ./main.py run --name [TAB][TAB]  
💬 We get the completion items with their help text 🎉Camila     -- The reader of books.  
Carlos     -- The writer of scripts.  
Sebastian  -- The type hints guy.  
  
restart ↻

```

--------------------------------

### Typer Option function source code with docstring examples

Source: https://typer.tiangolo.com/reference/parameters

Source code of the Option function in typer/params.py, including docstring examples for default, param_decls, and callback parameters.

```python
def Option(
    # Parameter
    default: Annotated[
        Any | None,
        Doc(
            """
            Usually, [CLI options](https://typer.tiangolo.com/tutorial/options/) are optional and have a default value, passed on like this:

            **Example**

            ```python
            @app.command()
            def main(network: str = typer.Option("CNN")):
                print(f"Training neural network of type: {network}")
            ```

            Note that this usage is deprecated, and we recommend to use `Annotated` instead:
            ```
            @app.command()
            def main(network: Annotated[str, typer.Option()] = "CNN"):
                print(f"Hello {name}!")
            ```

            You can also use `...` ([Ellipsis](https://docs.python.org/3/library/constants.html#Ellipsis)) as the "default" value to clarify that this is a required CLI option.
            """
        ),
    ] = ...,
    *param_decls: Annotated[
        str,
        Doc(
            """
            Positional argument that defines how users can call this option on the command line. This may be one or multiple aliases, all strings.
            If not defined, Typer will automatically use the function parameter as default name.
            See [the tutorial about CLI Option Names](https://typer.tiangolo.com/tutorial/options/name/) for more details.

            **Example**

            ```python
            @app.command()
            def main(user_name: Annotated[str, typer.Option("--user", "-u", "-x")]):
                print(f"Hello {user_name}")
            ```
            """
        ),
    ],
    callback: Annotated[
        Callable[..., Any] | None,
        Doc(
            """
            Add a callback to this CLI Option, to execute additional logic after its value was received from the terminal.
            See [the tutorial about callbacks](https://typer.tiangolo.com/tutorial/options/callback-and-context/) for more details.

            **Example**

            ```python
            def name_callback(value: str):
                if value != "Deadpool":
                    raise typer.BadParameter("Only Deadpool is allowed")
                return value

            @app.command()
            def main(name: Annotated[str, typer.Option(callback=name_callback)]):
                print(f"Hello {name}")
            ```
            """
        ),
    ] = None,
    metavar: Annotated[
        str | None,
        Doc(
            """
            Customize the name displayed in the [help text](https://typer.tiangolo.com/tutorial/options/help/) to represent this CLI option.
            Note that this doesn't influence the way the option must be called.

            **Example**


```

--------------------------------

### Install Typer AI agent skill with Library Skills

Source: https://typer.tiangolo.com/tutorial/install

Runs Library Skills via uvx to install the official Typer skill for AI coding agents. The skill is bundled with the package and stays aligned with the installed Typer version. Compatible with Codex, Claude Code, Cursor, GitHub Copilot, Gemini CLI, Pi, OpenCode, and most other coding agents.

```bash
uvx library-skills
```

--------------------------------

### Build and publish with uv

Source: https://typer.tiangolo.com/tutorial/package

Build and publish the package using `uv build` and `uv publish`. The output shows the uploaded files to PyPI.

```bash
uv build
uv publish
```

--------------------------------

### Get invoked subcommand name with typer.Context

Source: https://typer.tiangolo.com/tutorial/commands/context

Declare a callback parameter of type typer.Context and read ctx.invoked_subcommand to get the name of the subcommand being executed. The callback prints the subcommand name before the command runs.

```python
import typer

app = typer.Typer()


@app.command()
def create(username: str):
    print(f"Creating user: {username}")


@app.command()
def delete(username: str):
    print(f"Deleting user: {username}")


@app.callback()
def main(ctx: typer.Context):
    """
    Manage users in the awesome CLI app.
    """
    print(f"About to execute command: {ctx.invoked_subcommand}")


if __name__ == "__main__":
    app()

```

--------------------------------

### lookup_default

Source: https://typer.tiangolo.com/reference/context

Gets the default for a parameter from `default_map`.

```APIDOC
## lookup_default

### Description
Gets the default for a parameter from `default_map`.

### Method
lookup_default(name, call=True)

### Parameters
- **name** (str) - Required - The name of the parameter.
- **call** (bool) - Optional - If `True` and the default is callable, calls it and returns the result. Defaults to `True`.

### Returns
- The default value, or the result of calling the callable default if `call` is `True` and the default is callable. Returns `None` if no default is found.
```
Tokens:
Raw