Simple, Elegant, Typed Argument Parsing

simple-parsing allows you to transform your ugly argparse scripts into beautifully structured, strongly typed little works of art. Using dataclasses, simple-parsing makes it easier to share and reuse command-line arguments - no more copy pasting!

Supports inheritance, nesting, easy serialization to json/yaml, automatic help strings from comments, and much more!

# examples/demo.py
from dataclasses import dataclass
from simple_parsing import ArgumentParser

parser = ArgumentParser()
parser.add_argument("--foo", type=int, default=123, help="foo help")

@dataclass
class Options:
    """ Help string for this group of command-line arguments """
    log_dir: str                # Help string for a required str argument    
    learning_rate: float = 1e-4 # Help string for a float argument

parser.add_arguments(Options, dest="options")

args = parser.parse_args()
print("foo:", args.foo)
print("options:", args.options)

$ python examples/demo.py --log_dir logs --foo 123
foo: 123
options: Options(log_dir='logs', learning_rate=0.0001)

$ python examples/demo.py --help
usage: demo.py [-h] [--foo int] --log_dir str [--learning_rate float]

optional arguments:
  -h, --help            show this help message and exit
  --foo int             foo help (default: 123)

Options ['options']:
   Help string for this group of command-line arguments 

  --log_dir str         Help string for a required str argument (default:
                        None)
  --learning_rate float
                        Help string for a float argument (default: 0.0001)

installation

pip install simple-parsing

Examples

API Documentation (Under construction)

Features

Automatic "--help" strings

As developers, we want to make it easy for people coming into our projects to understand how to run them. However, a user-friendly --help message is often hard to write and to maintain, especially as the number of arguments increases.

With simple-parsing, your arguments and their decriptions are defined in the same place, making your code easier to read, write, and maintain.

Modular, Reusable, Cleanly Grouped Arguments

(no more copy-pasting)

When you need to add a new group of command-line arguments similar to an existing one, instead of copy-pasting a block of argparse code and renaming variables, you can reuse your argument class, and let the ArgumentParser take care of adding relevant prefixes to the arguments for you:

parser.add_arguments(Options, dest="train")
parser.add_arguments(Options, dest="valid")
args = parser.parse_args()
train_options: Options = args.train
valid_options: Options = args.valid
print(train_options)
print(valid_options)

$ python examples/demo.py \
    --train.log_dir "training" \
    --valid.log_dir "validation"
Options(log_dir='training', learning_rate=0.0001)
Options(log_dir='validation', learning_rate=0.0001)

These prefixes can also be set explicitly, or not be used at all. For more info, take a look at the Prefixing Guide

Easy serialization:

Easily save/load configs to json or yaml!.
Inheritance!

You can easily customize an existing argument class by extending it and adding your own attributes, which helps promote code reuse accross projects. For more info, take a look at the inheritance example
Nesting!:

Dataclasses can be nested within dataclasses, as deep as you need!
Easier parsing of lists and tuples :

This is sometimes tricky to do with regular argparse, but simple-parsing makes it a lot easier by using the python's builtin type annotations to automatically convert the values to the right type for you. As an added feature, by using these type annotations, simple-parsing allows you to parse nested lists or tuples, as can be seen in this example
Enums support
(More to come!)

Examples:

Additional examples for all the features mentioned above can be found in the examples folder

License
- OSI Approved :: MIT License
Operating System
- OS Independent
Programming Language
- Python :: 3

Release files for simple-parsing 0.0.11.post16

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for simple-parsing 0.0.11.post16
File	Size	Uploaded
simple_parsing-0.0.11.post16.tar.gz	59.4 kB	Aug 4, 2020	Details

Built distribution (wheel)

Table of built distributions (wheels) for simple-parsing 0.0.11.post16
File	Interpreter	ABI	Platform	Reset
simple_parsing-0.0.11.post16-py3-none-any.whl 55.4 kB Aug 4, 2020	Python 3	none	any	Details

Total release size: 114.8 kB

Release files / simple_parsing-0.0.11.post16.tar.gz

Download URL	simple_parsing-0.0.11.post16.tar.gz
Size	59.4 kB
Tags	Source
SHA-256 checksum How to use checksums	`2ad8866af82148f7b9be3f3be8a221454877f6b732f769c482d429c2534fd3bc`
BLAKE2b-256 checksum How to use checksums	`a8655cf391294af9143033599f05b790420ab96fa1a504d7bd14877db45f7021`
Upload date	Aug 4, 2020
Uploaded using Trusted Publishing? What is trusted publishing?	No
Uploaded via	`twine/3.2.0 pkginfo/1.5.0.1 requests/2.24.0 setuptools/49.2.1 requests-toolbelt/0.9.1 tqdm/4.48.2 CPython/3.7.1`

Release files / simple_parsing-0.0.11.post16-py3-none-any.whl

Download URL	simple_parsing-0.0.11.post16-py3-none-any.whl
Size	55.4 kB
Tags	Python 3
SHA-256 checksum How to use checksums	`49fb8ec48d4c47e472aac841ed169314b1ca0af106a74755148d797c03983249`
BLAKE2b-256 checksum How to use checksums	`ad7da38881f0c1ad578836b7ffa65278f8d07650b317f7b9890c454d2220ed2a`
Upload date	Aug 4, 2020
Uploaded using Trusted Publishing? What is trusted publishing?	No
Uploaded via	`twine/3.2.0 pkginfo/1.5.0.1 requests/2.24.0 setuptools/49.2.1 requests-toolbelt/0.9.1 tqdm/4.48.2 CPython/3.7.1`