oppapī
Ergonomic option parser on top of dataclasses, inspired by structopt.
Usage
from typing import Optional
from oppapi import from_args, oppapi
@oppapi
class Opt:
"""
Option parser using oppapi
"""
host: str
""" This will be positional argument of type `str` """
port: Optional[int] = 8000
""" Optional argument will be option argument """
opt = from_args(Opt)
print(opt)
The code above generates such option parser that
- Generates parser description from class's docstring
- Generates argument description from field's docstring
- A field will be a positional argument
- An optional field will be an optional argument
See the parser help message:
$ python simple.py -h
usage: simple.py [-h] [-p PORT] host
Option parser using oppapi
positional arguments:
host This will be positional argument of type `str`
optional arguments:
-h, --help show this help message and exit
-p PORT, --port PORT Optional argument will be option argument
Running the program deserializes the command line arguments into an object of the declared class.
$ python simple.py localhost -p 20000
Opt(host='localhost', port=20000)
Supported types
- Primitives (
int,float,str,bool) - Containers (
List,Tuple) typing.OptionalEnumandIntEnumdatetimedecimalipaddresspathlibuuid
short/long
oppapi generates flag names automatically, but you can specify arbitrary short/long names.
from typing import Optional
from oppapi import from_args, oppapi, field
@oppapi
class Opt:
host: Optional[str] = field(short="-n", long="--hostname")
enum
enum.Enum and enum.IntEnum will be an argument with choices parameter.
class Food(Enum):
A = "Apple"
B = "Beer"
C = "Chocolate"
class Price(IntEnum):
A = 10
B = 20
C = 30
@oppapi
class Opt:
food: Food
price: Optional[Price]
usage will be like this:
positional arguments:
{Apple,Beer,Chocolate}
optional arguments:
-h, --help show this help message and exit
-p {10,20,30}, --price {10,20,30}
oppapi converts the command line arguments back to Enum.
$ python choice.py Apple --price 20
Opt(food=<Food.A: 'Apple'>, price=<Price.B: 20>)
List/Tuple
List will be an arbitrary number of arguments (nargs="+"). Tuple will be a fixed number of arguments (nargs=NUM).
@oppapi
class Opt:
values: List[int]
opts: Optional[Tuple[int, str, float, bool]]
$ python nargs.py 1 2 3 --opts 10 foo 10.0 True
Opt(values=[1, 2, 3], opts=(10, 'foo', 10.0, True))
SubCommand
Union will be subcommands.
from typing import Optional, Union
from oppapi import from_args, oppapi
@oppapi
class Foo:
a: int
@oppapi
class Bar:
b: Optional[int]
@oppapi
class Opt:
cmd: str
sub: Union[Foo, Bar]
def main():
opt = from_args(Opt)
$ python subcommand.py -h
usage: subcommand.py [-h] cmd {foo,bar} ...
positional arguments:
cmd
{foo,bar}
optional arguments:
-h, --help show this help message and exit
Flatten
TODO
LICENSE
This project is licensed under the MIT license
1 Nov 2, 2021
1 Nov 3, 2021
31 Nov 23, 2022
1 Dec 13, 2021
1 Dec 15, 2021
1 Dec 17, 2021
101 Oct 30, 2022
1 Jul 15, 2022
55 Jul 29, 2021
1 Feb 07, 2022
13 Dec 19, 2022
6 Nov 19, 2021
34 Sep 29, 2022
4 Mar 12, 2022
1 Apr 08, 2022
7 Dec 21, 2022
2 Feb 18, 2022
1 May 10, 2022
1 Dec 15, 2021
2 Dec 19, 2021
10 Dec 02, 2022
4 Feb 10, 2022
2 Feb 04, 2022
5 Nov 30, 2022
0 Feb 13, 2022
4 May 21, 2022
10 Aug 19, 2022
4 Aug 07, 2021
21 Mar 08, 2022