This might be a more controversial change. 😄 I was looking at the new dataclass decorator overload that was implemented. It is a nice concept except that type hinting does not work with it. Since type hinting is the main benefit over normal argparse (In my opinion) I came up with this other approach.

Not sure how much approach conflicts with your vision of what you want but it seems to offer a similar experience as the dataclass approach while maintaining type hints.

This PR allows the user to override the type argument passed to add_argument. This is useful when a custom function needs to be used, but is not appropriate as a type. For example, from the argparse documentation:

def hyphenated(string):
    return '-'.join([word[:4] for word in string.casefold().split()])

parser = argparse.ArgumentParser()
_ = parser.add_argument('short_title', type=hyphenated)
parser.parse_args(['"The Tale of Two Cities"'])
Namespace(short_title='"the-tale-of-two-citi')

With this PR, one could define an argument like:

@dataclass
class Options:
    short_title: str = field(metadata=dict(type=hyphenated))

And thus the following will work correctly:

parser = argparse_dataclass.ArgumentParser(Options)
parser.parse_args(['--short-title', '"The Tale of Two Cities"'])

Which results in Options(short_title='"the-tale-of-two-citi')

Some more testing:

• tests/test_argumentparser.py has been updated so it has the same tests as tests/test_functional.py.
• in tests/test_functional.py, Fixed the name of the test class.

This is like the standard dataclass decorator but will also optionally (on by default) add a parse_args class method to the generated class. This would allow us to do shortcuts like:

@dataclass
class Parameters:
    x: int
    y: int

params = Parameters.parse_args()

Since I am in the happy position of building a school project and not being able to depend on click for command-line arguments, I decided to see if it was possible to combine dataclasses and argparse. Apparently your library (which I would have to rewrite anyway) doesn't make it possible to provide positional arguments. Would that be possible through another metadata flag?

The following class fails to parse:

@dataclass
class IndexOptsMinimal:
    index: Optional[int] = None

The following workaround is required:

@dataclass
class IndexOptsWorkaround:
    index: Optional[int] = field(metadata=dict(type=int), default=None)

Using optional arguments that are allowed to be None is such a common pattern that it deserves to supported implicitly.

I am not really sure about this change anymore.

Originally, I thought it would be helpful let a user know that they were about to do something that would break the parser, but realistically most people will understand that adding arguments after the parser has been created does not make sense.

I wanted to see what you thought before putting more time into it.

Sorry so many pull request in a short time. I have been taking a larger set of changes I had lying around and breaking them out by feature.

I only have one left. It is a documentation update. I am putting it off for last. 😄

• adding support for default values of True
• adding support to require a user to specify the value

Also, Adding Python 3.10 to the list of support Python versions and adding testing.

These are pretty small changes. They have no functional changes. This allow VSCode (and probably other IDEs) to detect the dataclass type that is being returned by parse_args().

--- BEFORE --

-- AFTER --

Hi,

I seem to be running into a couple of issues when using the decorator that was recently added in #9:

1. It does not work with optional keyword arguments:

from argparse_dataclass import dataclass

@dataclass(frozen=True)
class Opt:
    x: int = 42
    y: bool = False

Error: TypeError: cls must be a dataclass It seems that cls here is actually real_dataclass.wrap.

2. It does not behave like a regular dataclass:

from argparse_dataclass import dataclass

@dataclass
class Opt:
    x: int = 42
    y: bool = False

opt = Opt()
print(opt.x)

Error: AttributeError: 'Inner' object has no attribute 'x' Looks like Opt was "replaced" with Inner, which is defined in argparse_dataclass.dataclass.

This PR add support for setting the nargs argument passed to add_argument. An example usage of this is as follows:

from dataclasses import dataclass, field
from typing import List
from argparse_dataclass import ArgumentParser

@dataclass
class Options:
    values: List[int] = field(metadata=dict(type=int, nargs='*'))

parser = ArgumentParser(Options)
parser.parse_args('--values 1 2 3'.split())

This example results in Options(values=[1, 2, 3])

Note that this PR depends on #11 This is because when nargs is used, an appropriate field type would be a list. However, then ArgumentParser will parse each element as a list, which is likely an undesired behaviour. Therefore, when nargs is specified, it expects type to be explicitly specified as well.

I don't know if this is the right place to write, but I don't know where else write it, anyway.... Are you intending to publish the lib again on pypi? I found this library very useful and it could be worth!

Thanks in advance

Thank you for this library.

I would like to have an option that would allow to keep the underscores in the argument names instead of replacing them by minus signs. I can prepare a PR for that change if that is a feature you are happy to integrate.

from argparse_dataclass import dataclass
from argparse_dataclass import ArgumentParser

@dataclass
class SubOption:
    a: int = 1
    b: int = 2

@dataclass
class Options:
    x: int = 42
    y: bool = False
    sub: SubOption = None

parser = ArgumentParser(Options)
x = parser.parse_args(['--sub', '1'])
print(x)

for example, how can I parse args to get a value for sub?

example code: from dataclasses import dataclass, field from argparse_dataclass import ArgumentParser from argparse import ArgumentDefaultsHelpFormatter

@dataclass
class FineParams:
    batch_size: int = field(default=300) 

parser = ArgumentParser(GCPFineParams, formatter_class=ArgumentDefaultsHelpFormatter)
params: FineParams = parser.parse_args()

resulting non-defaults help printout.

diving into argparse code (argparse.py, ver 1.1, line 1861) shone that the ArgumentParser's _actions class members, batch_size action is stored as _StoreAction(option_strings=['--batch-size'], dest='batch_size', nargs=None, const=None, default=<dataclasses._MISSING_TYPE object at 0x7f8465889960>, type=<class 'int'>, choices=None, required=False, help=None, metavar=None)