tomlparse

tomlparse is a Python library and command-line tool that allows you to use TOML configuration files in conjunction with the argparse module. It provides a simple and convenient way to handle your python projects, leveraging the strengths of both TOML and argparse.

📝 Table of Contents

1. Installation
2. Usage
   1. Basic Example
   2. Extended Example
3. Contributing

💻 How to install

You can install the library using pip

pip install tomlparse

🔍 How to use

Using tomlparse is straightforward and requires only a few extra steps compared to using argparse alone.

🐍 Basic Example

You first define your configuration options in a TOML file. TOML files are highly flexible and include a lot of native types. Have look here for an extensive list. TOML files usually come in the following form:

# This is a very basic TOML file
foo = 10
bar = "hello"

At the core of this module is the TOML ArgumentParser, a simple wrapper of the original argparse module. To use the TOML arguments for our project, we we would create an ArgumentParser as usual:

import tomlparse
parser = tomlparse.ArgumentParser()
parser.add_argument("--foo", type=int, default=0)
parser.add_argument("--bar", type=str, default="")
parser.parse_args()

This is just a simple example with two arguments. But for larger projects with many hyperparameters, the number of arguments can quickly grow, and the TOML file provides an easy way to collect and store different hyperparameter configurations. Every TOML ArgumentParser has a toml argument defined that we can pass using the following command-line syntax:

python experiment.py --toml "example.toml"

This will replace the default values from the ArgumentParser with the TOML values.

🐍 Extended Example

TOML files have the ability to separate arguments into different sections (called tables), which are represented by nested dictionaries:

# This is a TOML File

# Parameters without a prededing [] are not part of a table (called root-table)
foo = 10
bar = "hello"

# These arguments are part of the table [general]
[general]
foo = 20

# These arguments are part of the table [root]
[root]
bar = "hey"

If we would load this TOML file as usual this would return a dict {"foo": 10, "bar": "hello", "general": {"foo": 20}, "root" : {"bar": "hey"}}. Note that foo and bar are overloaded and defined twice. To specify the values we wish to take each TOML ArgumentParser has two arguments defined:

1. table
2. root-table

We can use these directly from the command-line:

python experiment.py --toml "example.toml" --table "general"

Here the root-table is not defined. In this case the arguments at the top of the file without a table are taken and parsing would return the following dict {"foo": 20, "bar": "hello"}. Note that table arguments override arguments from the root-table.

We can also specify the root-table:

python experiment.py --toml "example.toml" --table "general" --root-table "root"

which would return the following dict {"foo: 20", "bar": "hey"} and override the arguments from the top of the TOML file.

In general, we have the following hierarchy of arguments:

1. Arguments passed through the command line are selected over TOML arguments, even if both are passed
2. Arguments from the TOML file are preferred over the default arguments
3. Arguments from the TOML with a section override the arguments without a section

This means that we can also override arguments in the TOML file from the command-line:

python experiment.py --toml "example.toml" --table "general" --foo 100

🌸 Contributing

Please have a look at the contribution guidlines in Contributing.rst.

Repository initiated with fpgmaas/cookiecutter-poetry.