Typer, build great CLIs. Easy to code. Based on Python type hints.
Documentation:https://typer.tiangolo
Source Code:https://github /tiangolo/typer
Typer is a library for building CLI applications that users willlove usingand developers willlove creating.Based on Python 3.6+ type hints.
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.
TyperisFastAPI's little sibling.
And it's intended to be the FastAPI of CLIs.
Python 3.6+
Typerstands on the shoulders of a giant. Its only internal dependency isClick.
$pip install typer
---> 100%
Successfully installed typer- Create a file
main.pywith:
importtyper
defmain(name:str):
typer.echo(f "Hello{name}")
if__name__=="__main__":
typer.run(main)Run your application:
// Run your application
$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 free
$Python main.py --help
Usage: main.py [OPTIONS] NAME
Arguments:
NAME [required]
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.
// When you create a package you get ✨ auto-completion ✨ for free, installed with --install-completion
// Now pass the NAME argument
$Python main.py Camila
Hello Camila
// It works! 🎉Note:auto-completion works when you create a Python package and run it with--install-completionor when you useTyper CLI.
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.
importtyper
app=typer.Typer()
@app.command()
defhello(name:str):
typer.echo(f "Hello{name}")
@app.command()
defgoodbye(name:str,formal:bool=False):
ifformal:
typer.echo(f "Goodbye Ms.{name}.Have a good day. ")
else:
typer.echo(f "Bye{name}!")
if__name__=="__main__":
app()And that will:
- Explicitly create a
typer.Typerapp.- The previous
typer.runactually creates one implicitly for you.
- The previous
- Add two subcommands with
@app mand(). - Execute the
app()itself, as if it was a function (instead oftyper.run).
// Check the --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
// You have 2 subcommands (the 2 functions): goodbye and hello
// Now get the --help for hello
$Python main.py hello --help
Usage: main.py hello [OPTIONS] NAME
Arguments:
NAME [required]
Options:
--help Show this message and exit.
// And now get the --help for goodbye
$Python main.py goodbye --help
Usage: main.py goodbye [OPTIONS] NAME
Arguments:
NAME [required]
Options:
--formal / --no-formal [default: False]
--help Show this message and exit.
// Automatic --formal and --no-formal for the bool option 🎉
// And if you use it with the hello command
$Python main.py hello Camila
Hello Camila
// And with the goodbye command
$Python main.py goodbye Camila
Bye Camila!
// And with --formal
$Python main.py goodbye --formal Camila
Goodbye Ms. Camila. Have a good day.In summary, you declareoncethe types of parameters (CLI argumentsandCLI 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 3.6+.
For example, for anint:
total:intor for aboolflag:
force:boolAnd similarly forfiles,paths,enums(choices), etc. And there are tools to creategroups of subcommands,add metadata, extravalidation,etc.
You get:great editor support, includingcompletionandtype checkseverywhere.
Your users get:automatic--help,auto-completionin their terminal (Bash, Zsh, Fish, PowerShell) when they install your package or when usingTyper CLI.
For a more complete example including more features, see theTutorial - User Guide.
Typer usesClickinternally. That's the only dependency.
But you can also install extras:
colorama:and Click will automatically use it to make sure your terminal's colors always work correctly, even in Windows.shellingham:and Typer will automatically detect the current shell when installing completion.- With
shellinghamyou can just use--install-completion. - Without
shellingham,you have to pass the name of the shell to install completion for, e.g.--install-completion bash.
- With
You can installtyperwithcoloramaandshellinghamwithpip install typer[all].
Click has many plug-ins available that you can use. And there are many tools that help with command line applications that you can use as well, even if they are not related to Typer or Click.
For example:
click-spinner:to show the user that you are loading data. A Click plug-in.- There are several other Click plug-ins atclick-contribthat you can explore.
tabulate:to automatically display tabular data nicely. Independent of Click or Typer.tqdm:a fast, extensible progress bar, alternative to Typer's owntyper.progressbar().- etc... you can re-use many of the great available tools for building CLIs.
This project is licensed under the terms of the MIT license.