[FEATURE] Load command line options from config file

[timothybrooks]

Hello! I love Typer and have started to use it for my deep learning training.

One addition that would be really helpful for deep learning CLIs is the ability to load command line arguments and options from configuration files. This is particularly useful to help manage CLIs with lots of arguments and options, especially when certain sets of inputs are common. Sacred configs have this ability, as do WandB configs:

Here is a demo of how this could work with Typer:

Parameters specified in resnet.yml will automatically fill in args/options of the same names:

train.py --config resnet.yml

When multiple configs are provided, the latter will override the former should there be conflicts.

run.py --config resnet.yml small_test.yml

If args/options are also specified directly, those override anything provided in the config.

run.py --config resnet.yml small_test.yml --num_layers 4

An alternative to consider is just making each config its own boolean option. This has the following downsides:

• Requires adding more flags, even if they only modify other args/options. This does not scale well.
• Ambiguous overriding if multiple configs are provided or if args/options are also added directly.

With argparser, people will sometimes use the following pattern to achieve something similar. By changing the defaults and re-parsing rather than directly changing the args, this allows args/options defined directly on the command line to still override the new defaults. However, this too does not scale well, and there is no clear way to change defaults with Typer.

args, _ = parser.parse_known_args()
        if opt.small_test:
            parser.set_defaults(batch_size=1, num_layers=2, multiscale=False, ...)
args = parser.parse()

I believe the addition of loading args from config files would make Typer fantastic for deep learning research, making it much easier to scale and compose different configurations, and clarifying which parameters override others.

This unfortunately isn't something I know how to implement, but I would be happy to discuss or clarify this further if you agree that it would be a good addition.

Thanks!

[tiangolo]

I'm glad you're liking Typer!

So, this would actually fall in the scope of each specific CLI tool, how to handle it, etc.

But you can easily build something like that.

You could install:

$ pip install pyyaml

Then let's say you have a file dl.py:

import typer
import yaml
from pathlib import Path


def main(config: Path = None, num_layers: int = None):
    config_data = {}
    if config:
        config_data = yaml.load(config.read_text(), Loader=yaml.Loader)
    if num_layers:
        config_data["num_layers"] = num_layers
    typer.echo(f"DL config: {config_data}")

And let's say you also have a config.yml file:

version: "2.4"
num_layers: 5

And let's imagine you are using Typer CLI to get autocompletion for it.

You could use it like:

$ typer ./dl.py run

DL config: {}

$ typer ./dl.py run --config ./config.yml

DL config: {'version': '2.4', 'num_layers': 5}

$ typer ./dl.py run --config ./config.yml --num-layers 2

DL config: {'version': '2.4', 'num_layers': 2}

(I just tried all that) 🎁

[pakozm]

I think this feature will be very useful. @tiangolo many thanks for this awesome library. But the proposed solution is not convincing to me. Ideally you would like to have just a reverse of what is proposed. IMHO, someone will expect that config file integration will let you use the function arguments directly instead of using the new config dictionary which may be overridden by the given function arguments. Even more, no default values can be given to function arguments because None is used in the proposal to decide whether or not override the cofnig dictionary.

Is it possible to put a wrapper over the main function, so such wrapper will look for config file option, and if found it, it will call main with the values given there?

I was thinking in some kind of "partialization" of the main function, but I'm not sure how typer will react. Something like this (no real code):

import functools
import typer
import yaml
from pathlib import Path


def main(num_layers: int = None):
    typer.echo(f"DL num layers: {num_layers}")

def config_wrapper(main, *args):
    if config options are in command line:
        config = load yaml from given config path
        return functools.partial(main, **config)
    return main

typer.run(config_wrapper(main, '-c', '--config'))

Will something like this work? How far is typer of accepting something like this? Is it just something dumb what I'm proposing?

[tiangolo]

@pakozm I'm pretty sure that should work as Typer doesn't modify the original function. I think the original signature is also kept in the wrapped function, but I actually wouldn't be certain.

It's an interesting experiment for sure 😄 🧪 🥽

[github-actions]

Assuming the original issue was solved, it will be automatically closed now. But feel free to add more comments or create new issues.

[malarinv]

I am looking for something like https://pypi.org/project/ConfigArgParse/ but that integrates with typer

[malarinv]

hmm. hydra seems to handle them better https://hydra.cc/docs/tutorial/config_file

[maxb2]

UPDATE: I made a package for the solution below: maxb2/typer-config.

I found a simple solution to this inspired by phha/click_config_file.
In short, the config option is set with is_eager so that it's callback is called before the rest.
The callback then sets the default_map in the underlying click context based on the config file.
You can still set args and options to override the config file.

# typer_config.py
import typer
import yaml

app = typer.Typer( )

def conf_callback(ctx: typer.Context, param: typer.CallbackParam, value: str):
    if value:
        typer.echo(f"Loading config file: {value}")
        try: 
            with open(value, 'r') as f:    # Load config file
                conf = yaml.safe_load(f)
            ctx.default_map = ctx.default_map or {}   # Initialize the default map
            ctx.default_map.update(conf)   # Merge the config dict into default_map
        except Exception as ex:
            raise typer.BadParameter(str(ex))
    return value

@app.command()
def main(
    arg1: str,
    config: str = typer.Option("", callback=conf_callback, is_eager=True),
    opt1: str = typer.Option(...),
    opt2: str = typer.Option("hello"),
):
    typer.echo(f"{opt1} {opt2} {arg1}")


if __name__ == "__main__":
    app()

With a config file:

# config.yaml
arg1: stuff
opt1: things
opt2: nothing

And invoked with python:

$ python typer_config.py --config config.yml
things nothing stuff

$ python typer_config.py --config config.yml others
things nothing others

$ python typer_config.py --config config.yml --opt1 people
people nothing stuff