Typer

Typer is a modern, fast, and easy-to-use Python library for building beautiful command-line interface (CLI) applications. It leverages Python type hints to automatically generate powerful and user-friendly CLIs, significantly reducing boilerplate code and improving readability. Created by Sebastián Ramírez, the same developer behind FastAPI, Typer shares a similar philosophy of using standard Python features (like type hints) to provide a superior developer experience.

At its core, Typer is built on top of the robust Click library, inheriting all of Click's powerful features such as argument parsing, options, subcommands, help generation, and more. However, Typer distinguishes itself by integrating deeply with Python's type hinting system. This means that instead of defining arguments and options using decorators or special functions, you simply declare them as function parameters with type annotations (e.g., `name: str`, `age: int = 30`). Typer then intelligently infers how to parse these inputs from the command line, validate them, and generate comprehensive help messages.

Key features and benefits of Typer include:
- Intuitive Argument & Option Definition: Arguments and options are defined using standard Python function parameters with type hints, making the code more readable and self-documenting.
- Automatic Type Conversion & Validation: Typer automatically converts command-line string inputs to the specified Python types (e.g., `int`, `float`, `bool`, `Path`, `datetime`) and provides validation.
- Rich Help Messages: Automatically generates detailed and user-friendly help messages based on function signatures and docstrings.
- Shell Autocompletion: Supports powerful shell autocompletion for bash, zsh, and fish, enhancing user experience.
- Dependency Injection: While not as explicit as in FastAPI, the function-based approach inherently supports a form of dependency injection through its parameter handling.
- Extensible: Being built on Click, it's fully compatible with Click's extensive ecosystem and advanced features.
- Rich Output: Integrates well with libraries like `rich` for beautiful terminal output, progress bars, and more.

Typer simplifies the process of creating sophisticated CLIs, allowing developers to focus more on the application's logic and less on the mechanics of command-line parsing.

import typer
from typing import Optional

 Create a Typer application instance
app = typer.Typer()

@app.command()
def hello(
    name: str = typer.Argument("World", help="The name to greet."),
    formal: bool = typer.Option(False, "--formal", "-f", help="Say hello formally."),
    age: Optional[int] = typer.Option(None, help="Your age (optional)."),
):
    """
    Say hello to someone with optional formality and age.
    """
    greeting = "Hello"
    if formal:
        greeting = "Greetings"

    message = f"{greeting}, {name}!"
    if age is not None:
        message += f" You are {age} years old."

    print(message)

@app.command()
def goodbye(
    name: str = typer.Argument("user", help="The name to bid farewell."),
    farewell_message: str = typer.Option("See you!", "--message", "-m", help="Custom farewell message."),
):
    """
    Bid farewell to someone with a custom message.
    """
    print(f"{farewell_message}, {name}!")

 To run the application, save this code as, for example, 'main.py'.
 Then, from your terminal, you can run commands like:

   python main.py hello --help
   python main.py hello --name Alice
   python main.py hello Bob --formal --age 30
   python main.py goodbye --name Charlie --message "Adieu"

if __name__ == "__main__":
    app()