Typer

https://typer.tiangolo.com/

Simplest CLI

import typer


def main(name: str):
    print(f"Hello {name}")


if __name__ == "__main__":
    typer.run(main)

Hierarchical CLI (multiple entrypoints)

Please look through https://github.com/ezhang7423/language-control-diffusion/blob/main/src/lcd__main__.py

https://github.com/ezhang7423/language-control-diffusion/blob/main/src/lcd/__main__.py

import importlib.util
import os
from pathlib import Path

import typer
from loguru import logger

from lcd.utils.setup import abspath  # for monkeypatches

# Define the directory path containing the Python modules to import
apps_dir = abspath() / "apps"
app: typer.Typer = typer.Typer(name="lcd", no_args_is_help=True, pretty_exceptions_show_locals=False)


def main():
    """The master entrypoint to lcd.
    :param app: The app to run.
    :type app: str
    """
    command_kwargs = dict(
        context_settings={
            "allow_extra_args": True,
            "ignore_unknown_options": True,
        },
        # no_args_is_help=True
    )
    # Iterate over all files in the directory
    for filename in os.listdir(apps_dir):
        # Check if the file is a Python module
        if filename.endswith(".py"):
            # Construct the module name from the filename
            module_name = filename[:-3]
            # Import the module using importlib
            module_spec = importlib.util.spec_from_file_location(
                module_name, os.path.join(apps_dir, filename)
            )
            module = importlib.util.module_from_spec(module_spec)
            module_spec.loader.exec_module(module)
            # Add the module to the dictionary
            if hasattr(module, "_app_"):
                module_app = module._app_
                app.add_typer(
                    module_app,
                    name=module_name,
                    **command_kwargs
                    # add docs later by modulestring
                )

            else:
                try:
                    app.command(name=module_name, **command_kwargs)(module.main)
                except AttributeError as e:
                    logger.info(
                        f"{app} doesn't have a main function. Please check that {os.path.join(apps_dir, module_name)}.py defines main()"
                    )

    app()


if __name__ == "__main__":
    main()

Save Config Files

The following is all gratefully borrowed from https://maxb2.github.io/typer-config/1.2.1/examples/save_config/. Please attribute all credit to maxb2.

This example shows you how save the parameters of the invoked command to a configuration file using the @dump_config decorator which operates on Typer commands (requested in issue #25).

An example typer app:

from typing_extensions import Annotated

import typer
from typer_config.decorators import (
    dump_json_config,  # other formats available (1)
    use_json_config,
)


app = typer.Typer()


@app.command()
@use_json_config()  # before dump decorator (2)
@dump_json_config("./dumped.json")
def main(
    arg1: str,
    opt1: Annotated[str, typer.Option()],
    opt2: Annotated[str, typer.Option()] = "hello",
):
    typer.echo(f"{opt1} {opt2} {arg1}")


if __name__ == "__main__":
    app()

1. This package also provides @dump_yaml_config and @dump_toml_config for those file formats.

2. If you put @use_json_config before @dump_json_config, you will not capture the config parameter in your config dump. You probably want this behavior to avoid cascading config files.

And invoked with python:

$ python simple_app.py --opt1 foo --opt2 bar baz
foo bar baz

$ cat ./dumped.json
{"arg1": "baz", "opt1": "foo", "opt2": "bar"}