Typer, build great CLIs. Easy to code. Based on Python type hints.
Project description
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 will love using and developers will love 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 a
typer
command/program that you can use to run scripts, automatically converting them to CLIs, even if they don't use Typer internally.
FastAPI of CLIs
Typer is FastAPI's little sibling, it's the FastAPI of CLIs.
Installation
Create and activate a virtual environment and then install Typer:
$ pip install typer
---> 100%
Successfully installed typer rich shellingham
Example
The absolute minimum
- Create a file
main.py
with:
def main(name: str):
print(f"Hello {name}")
This script doesn't even use Typer internally. But you can use the typer
command to run it as a CLI application.
Run it
Run your application with the typer
command:
// Run your application
$ typer main.py run
// You get a nice error, you are missing NAME
Usage: typer [PATH_OR_MODULE] run [OPTIONS] NAME
Try 'typer [PATH_OR_MODULE] run --help' for help.
╭─ Error ───────────────────────────────────────────╮
│ Missing argument 'NAME'. │
╰───────────────────────────────────────────────────╯
// You get a --help for free
$ typer main.py run --help
Usage: typer [PATH_OR_MODULE] run [OPTIONS] NAME
Run 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 Camila
Hello 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 the typer
command.
Use Typer in your code
Now let's start using Typer in your own code, update main.py
with:
import typer
def main(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 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 TEXT [default: None] [required] |
╰───────────────────────────────────────────────────╯
╭─ Options ─────────────────────────────────────────╮
│ --help Show this message and exit. │
╰───────────────────────────────────────────────────╯
// Now pass the NAME argument
$ python main.py Camila
Hello Camila
// It works! 🎉
Note: you can also call this same script with the typer
command, but you don't need to.
Example upgrade
This was the simplest example possible.
Now let's see one a bit more complex.
An example with two subcommands
Modify the file main.py
.
Create a typer.Typer()
app, and create two subcommands with their parameters.
import typer
app = typer.Typer()
@app.command()
def hello(name: str):
print(f"Hello {name}")
@app.command()
def goodbye(name: str, formal: bool = False):
if formal:
print(f"Goodbye Ms. {name}. Have a good day.")
else:
print(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.
- The previous
- Add two subcommands with
@app.command()
. - Execute the
app()
itself, as if it was a function (instead oftyper.run
).
Run the upgraded example
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 the hello
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 the goodbye
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 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 (CLI arguments and CLI 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.
For example, for an int
:
total: int
or for a bool
flag:
force: bool
And similarly for files, paths, enums (choices), etc. And there are tools to create groups of subcommands, add metadata, extra validation, etc.
You get: great editor support, including completion and type checks everywhere.
Your users get: automatic --help
, auto-completion in their terminal (Bash, Zsh, Fish, PowerShell) when they install your package or when using the typer
command.
For a more complete example including more features, see the Tutorial - User Guide.
Dependencies
Typer stands on the shoulders of a giant. Its only internal required dependency is Click.
By default it also comes with extra standard dependencies:
rich
: to show nicely formatted errors automatically.shellingham
: to automatically detect the current shell when installing completion.- With
shellingham
you 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
typer-slim
If you don't want the extra standard optional dependencies, install typer-slim
instead.
When you install with:
pip install typer
...it includes the same code and dependencies as:
pip install "typer-slim[standard]"
The standard
extra dependencies are rich
and shellingham
.
Note: The typer
command is only included in the typer
package.
License
This project is licensed under the terms of the MIT license.
Project details
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distribution
Built Distribution
Hashes for typer_slim-0.12.5-py3-none-any.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 9a994f721b828783dbf144e17461b1c720bb4598e0d5eff7c1b3f08ee58cb062 |
|
MD5 | 9eac6753b76a2ddb75f6a6d8a2ecb00b |
|
BLAKE2b-256 | 98d4ced1f8074819b43804a0a5015f33bae422330e8d38b1992be91fa947190c |