argparse: Add support for custom argument types.

[agatti]

This PR adds support for optional custom argument type validation to argparse.ArgumentParser, allowing for shorter argument validation code for both simple builtins and complex types, as supported by CPython.

CPython also provides the argparse.FileType class to simplify argument file/directory handling, but that was not added to the MicroPython module. Its behaviour is rather easy to manually replicate if needed anyway.

This change increases the size of the argparse module by 306 bytes, and that's mostly due to the extra error handling and related text strings. Probably those new strings can be shortened, but given that this module isn't usually included in production code, the size increase shouldn't hurt too much I guess.

The unit tests unfortunately do not cover the case of a parameter failing validation, as the module will automatically issue a sys.exit call on error, after printing the relevant exception message. If there are cleaner ways to test that without hijacking sys.exit, let me know so I can update the tests accordingly.

[stinos]

assert "not callable" in str(e) would be CPython-compatible

[agatti]

Thanks, this should be sorted out now.

[stinos]

I'd suggest to make this as much CPython-compatible as possible. It has this particular behavior: https://docs.python.org/3/library/argparse.html#type

If the type keyword is used with the default keyword, the type converter is only applied if the default is a string.

So in CPython the resulting behavior is this:

parser.add_argument("-g", type=CustomArgType(1), default=1)
parser.add_argument("-i", type=CustomArgType(1), default="1")
args = parser.parse_args([])
assert args.g == 1
assert args.i == 2

[agatti]

I'd suggest to make this as much CPython-compatible as possible. It has this particular behavior: ...

Thanks for spotting that! I've made it more CPython-compatible, at the expense of an increased footprint by 100 more bytes. The case you mentioned should be handled, along with the exception handling limitations of the custom type parser (ie. let anything that's not ArgumentTypeError, TypeError, and ValueError through and catch the rest).

Right now the main differences between this and CPython should be the lack of type registration, and argparse.FileType not being present. This should cover most usages, I suppose.