Typer, build great CLIs. Easy to code. Based on Python type hints.
---
**Documentation**: https://typer.tiangolo.com
**Source Code**: https://github.com/tiangolo/typer
---
Typer is library to build CLI applications that users will love using and developers will love creating. Based on Python 3.6+ type hints.
**Typer** is FastAPI's little sibling. And it's intended to be the FastAPI of CLIs.
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 commands, and (optional) 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 sub-commands, with options and arguments.
## Requirements
Python 3.6+
Typer stands on the shoulders of a giant. Its only internal dependency is Click.
## Installation
```console
$ pip install typer
---> 100%
Successfully installed typer
```
## Example
### The absolute minimum
* Create a file `main.py` with:
```Python
import typer
def main(name: str):
typer.echo(f"Hello {name}")
if __name__ == "__main__":
typer.run(main)
```
### Run it
Run your application:
```console
// 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
Options:
--help Show this message and exit.
// Now pass the NAME argument
$ python main.py Camila
Hello Camila
// It works! 🎉
```
## Example upgrade
This was the simplest example possible.
Now let's see one a bit more complex.
### An example with two sub-commands
Modify the file `main.py`.
Create a `typer.Typer()` app, and create two sub-commands with their parameters.
```Python hl_lines="3 6 11 20"
import typer
app = typer.Typer()
@app.command()
def hello(name: str):
typer.echo(f"Hello {name}")
@app.command()
def goodbye(name: str, formal: bool = False):
if formal:
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.Typer` app.
* The previous `typer.run` actually creates one implicitly for you.
* Add two sub-commands with `@app.command()`.
* Execute the `app()` itself, as if it was a function (instead of `typer.run`).
### Run the upgraded example
```console
// Check the --help
$ python main.py --help
Usage: main.py [OPTIONS] COMMAND [ARGS]...
Options:
--help Show this message and exit.
Commands:
goodbye
hello
// You have 2 sub-commands (the 2 functions): goodbye and hello
// Now get the --help for hello
$ python main.py hello --help
Usage: main.py hello [OPTIONS] NAME
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
Options:
--formal / --no-formal
--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.
```
### Recap
In summary, you declare **once** the types of parameters (*arguments* and *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 standard **Python 3.6+**.
For example, for an `int`:
```Python
total: int
```
or for a `bool` flag:
```Python
force: bool
```
And similarly for **files**, **paths**, **enums** (choices), etc. And there are tools to create **groups of sub-commands**, add metadata, extra **validation**, etc.
**You get**: great editor support, including **completion** and **type checks** everywhere.
**Your users get**: automatic **`--help`**, (optional) **autocompletion** in their terminal (Bash, Zsh, Fish, PowerShell).
For a more complete example including more features, see the Tutorial - User Guide.
## Optional Dependencies
Typer uses Click internally. 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.
* Then you can use any tool you want to output your terminal's colors in all the systems, including the integrated `typer.style()` and `typer.secho()` (provided by Click).
* Or any other tool, e.g. wasabi, blessings.
* click-completion: and Typer will automatically configure it to provide completion for all the shells, including installation commands.
You can install `typer` with `colorama` and `click-completion` with `pip install typer[all]`.
## Other tools and plug-ins
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 at click-contrib that you can explore.
* tabulate: to automatically display tabular data nicely. Independent of Click or typer.
* etc... you can re-use many of the great available tools for building CLIs.
## License
This project is licensed under the terms of the MIT license.