def __call__(self,
parser: argparse.ArgumentParser,
namespace: argparse.Namespace,
values: typing.Any,
option_string: typing.Optional[str] = None) -> None:
from nunavut.version import __version__
parser._print_message(__version__, sys.stdout)
parser.exit()
def __call__(self,
parser: argparse.ArgumentParser,
namespace: argparse.Namespace,
values: Union[str, Sequence[Any], None],
option_string: Optional[str] = None) -> NoReturn:
formatter = parser._get_formatter()
formatter.add_text(self.version)
parser._print_message(formatter.format_help(), self.stdout)
parser.exit()
def parse_arguments(parser: ArgumentParser,
settings_from_yaml: Optional[Dict[str, Any]] = None,
fail_on_unknown_args: bool = False,
args: List[str] = None) -> ParserResult:
"""
Parses a list of commandline arguments with a given parser, and adds additional information read
from YAML files. Returns results broken down into a full arguments dictionary, a dictionary of arguments
that were set to non-default values, and unknown arguments.
:param parser: The parser to use
:param settings_from_yaml: A dictionary of settings read from a YAML config file.
:param fail_on_unknown_args: If True, raise an exception if the parser encounters an argument that it does not
recognize. If False, unrecognized arguments will be ignored, and added to the "unknown" field of the parser result.
:param args: Arguments to parse. If not given, use those in sys.argv
:return: The parsed arguments, and overrides
"""
if args is None:
args = sys.argv[1:]
# The following code is a slightly modified version of what happens in parser.parse_known_args. This had to be
# copied here because otherwise we would not be able to achieve the priority order that we desire.
namespace = _create_default_namespace(parser)
known_settings_from_yaml = dict()
unknown_settings_from_yaml = dict()
if settings_from_yaml:
for key, setting_from_yaml in settings_from_yaml.items():
if hasattr(namespace, key):
known_settings_from_yaml[key] = setting_from_yaml
setattr(namespace, key, setting_from_yaml)
else:
unknown_settings_from_yaml[key] = setting_from_yaml
if len(unknown_settings_from_yaml) > 0 and fail_on_unknown_args:
raise ValueError(
f'Unknown settings from YAML: {unknown_settings_from_yaml}')
try:
namespace, unknown = parser._parse_known_args(args, namespace)
if hasattr(namespace, argparse._UNRECOGNIZED_ARGS_ATTR):
unknown.extend(getattr(namespace,
argparse._UNRECOGNIZED_ARGS_ATTR))
delattr(namespace, argparse._UNRECOGNIZED_ARGS_ATTR)
except ArgumentError:
parser.print_usage(sys.stderr)
err = sys.exc_info()[1]
parser._print_message(str(err), sys.stderr)
raise
# Parse the arguments a second time, without supplying defaults, to see which arguments actually differ
# from defaults.
namespace_without_defaults, _ = parser._parse_known_args(args, Namespace())
parsed_args = vars(namespace).copy()
overrides = vars(namespace_without_defaults).copy()
if len(unknown) > 0 and fail_on_unknown_args:
raise ValueError(f'Unknown arguments: {unknown}')
return ParserResult(args=parsed_args,
unknown=unknown,
overrides=overrides,
known_settings_from_yaml=known_settings_from_yaml,
unknown_settings_from_yaml=unknown_settings_from_yaml)
def _print_message(self, message, file=None): # pylint: disable=redefined-outer-name,useless-suppression
return ArgumentParser._print_message(self, message, self.buf)
