Repository files navigation

Typer, build great CLIs. Easy to code. Based on Python type hints.

Documentation:https://typer.tiangolo.com

Source Code:https://github.com/fastapi/typer

Typer is a library for building CLI applications that users willlove using and developers willlove creating. Based on Python type hints.

It's also a command line tool to run scripts, automatically converting them to CLI applications.

The key features are:

• Intuitive to write: Great editor support. Completion everywhere. Less time debugging. Designed to be easy to use and learn. Less time reading docs.
• Easy to use: It's easy to use for the final users. Automatic help, and automatic completion for all shells.
• Short: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs.
• Start simple: The simplest example adds only 2 lines of code to your app:1 import, 1 function call.
• Grow large: Grow in complexity as much as you want, create arbitrarily complex trees of commands and groups of subcommands, with options and arguments.
• Run scripts: Typer includes atyper command/program that you can use to run scripts, automatically converting them to CLIs, even if they don't use Typer internally.

Help us define Typer's future by filling theTyper developer survey. ✨

Typer isFastAPI's little sibling, it's the FastAPI of CLIs.

Create and activate avirtual environment and then installTyper:

$pip install typer---> 100%Successfully installed typer rich shellingham

• Create a filemain.py with:

defmain(name:str):print(f"Hello{name}")

This script doesn't even use Typer internally. But you can use thetyper command to run it as a CLI application.

Run your application with thetyper command:

// Run your application$typer main.py run// You get a nice error, you are missing NAMEUsage: typer [PATH_OR_MODULE] run [OPTIONS] NAMETry 'typer [PATH_OR_MODULE] run --help' for help.╭─ Error ───────────────────────────────────────────╮│ Missing argument 'NAME'.                          │╰───────────────────────────────────────────────────╯// You get a --help for free$typer main.py run --helpUsage: typer [PATH_OR_MODULE] run [OPTIONS] NAMERun the provided Typer app.╭─ Arguments ───────────────────────────────────────╮│ *    name      TEXT  [default: None] [required]   |╰───────────────────────────────────────────────────╯╭─ Options ─────────────────────────────────────────╮│ --help          Show this message and exit.       │╰───────────────────────────────────────────────────╯// Now pass the NAME argument$typer main.py run CamilaHello Camila// It works! 🎉

This is the simplest use case, not even using Typer internally, but it can already be quite useful for simple scripts.

Note: auto-completion works when you create a Python package and run it with--install-completion or when you use thetyper command.

Now let's start using Typer in your own code, updatemain.py with:

importtyperdefmain(name:str):print(f"Hello{name}")if__name__=="__main__":typer.run(main)

Now you could run it with Python directly:

// Run your application$python main.py// You get a nice error, you are missing NAMEUsage: main.py [OPTIONS] NAMETry 'main.py --help' for help.╭─ Error ───────────────────────────────────────────╮│ Missing argument 'NAME'.                          │╰───────────────────────────────────────────────────╯// You get a --help for free$python main.py --helpUsage: main.py [OPTIONS] NAME╭─ Arguments ───────────────────────────────────────╮│ *    name      TEXT  [default: None] [required]   |╰───────────────────────────────────────────────────╯╭─ Options ─────────────────────────────────────────╮│ --help          Show this message and exit.       │╰───────────────────────────────────────────────────╯// Now pass the NAME argument$python main.py CamilaHello Camila// It works! 🎉

Note: you can also call this same script with thetyper command, but you don't need to.

This was the simplest example possible.

Now let's see one a bit more complex.

Modify the filemain.py.

Create atyper.Typer() app, and create two subcommands with their parameters.

importtyperapp=typer.Typer()@app.command()defhello(name:str):print(f"Hello{name}")@app.command()defgoodbye(name:str,formal:bool=False):ifformal:print(f"Goodbye Ms.{name}. Have a good day.")else:print(f"Bye{name}!")if__name__=="__main__":app()

And that will:

• Explicitly create atyper.Typer app.
  • The previoustyper.run actually creates one implicitly for you.
• Add two subcommands with@app.command().
• Execute theapp() itself, as if it was a function (instead oftyper.run).

Check the new help:

$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 ────────────────────────────────────────╮│ goodbye                                           ││ hello                                             │╰───────────────────────────────────────────────────╯// When you create a package you get ✨ auto-completion ✨ for free, installed with --install-completion// You have 2 subcommands (the 2 functions): goodbye and hello

Now check the help for thehello command:

$python main.py hello --help Usage: main.py hello [OPTIONS] NAME╭─ Arguments ───────────────────────────────────────╮│ *    name      TEXT  [default: None] [required]   │╰───────────────────────────────────────────────────╯╭─ Options ─────────────────────────────────────────╮│ --help          Show this message and exit.       │╰───────────────────────────────────────────────────╯

And now check the help for thegoodbye command:

$python main.py goodbye --help Usage: main.py goodbye [OPTIONS] NAME╭─ Arguments ───────────────────────────────────────╮│ *    name      TEXT  [default: None] [required]   │╰───────────────────────────────────────────────────╯╭─ Options ─────────────────────────────────────────╮│ --formal    --no-formal      [default: no-formal] ││ --help                       Show this message    ││                              and exit.            │╰───────────────────────────────────────────────────╯// Automatic --formal and --no-formal for the bool option 🎉

Now you can try out the new command line application:

// Use it with the hello command$python main.py hello CamilaHello Camila// And with the goodbye command$python main.py goodbye CamilaBye Camila!// And with --formal$python main.py goodbye --formal CamilaGoodbye Ms. Camila. Have a good day.

Note: If your app only has one command, by default the command name isomitted in usage:python main.py Camila. However, when there are multiple commands, you mustexplicitly include the command name:python main.py hello Camila. SeeOne or Multiple Commands for more details.

In summary, you declareonce the types of parameters (CLI arguments andCLI options) as function parameters.

You do that with standard modern Python types.

You don't have to learn a new syntax, the methods or classes of a specific library, etc.

Just standardPython.

For example, for anint:

total:int

or for abool flag:

force:bool

And similarly forfiles,paths,enums (choices), etc. And there are tools to creategroups of subcommands, add metadata, extravalidation, etc.

You get: great editor support, includingcompletion andtype checks everywhere.

Your users get: automatic--help,auto-completion in their terminal (Bash, Zsh, Fish, PowerShell) when they install your package or when using thetyper command.

For a more complete example including more features, see theTutorial - User Guide.

Typer stands on the shoulders of giants. It has three required dependencies:

• Click: a popular tool for building CLIs in Python. Typer is based on it.
• rich: to show nicely formatted errors automatically.
• shellingham: to automatically detect the current shell when installing completion.

There used to be a slimmed-down version of Typer calledtyper-slim, which didn't include the dependenciesrich andshellingham, nor thetyper command.

However, since version 0.22.0, we have stopped supporting this, andtyper-slim now simply installs (all of) Typer.

If you want to disable Rich globally, you can set an environmental variableTYPER_USE_RICH toFalse or0.

This project is licensed under the terms of the MIT license.