3 """Command-line parsing library
5 This module is an optparse-inspired command-line parsing library that:
7 - handles both optional and positional arguments
8 - produces highly informative usage messages
9 - supports parsers that dispatch to sub-parsers
11 The following is a simple usage example that sums integers from the
12 command-line and writes the result to a file::
14 parser = argparse.ArgumentParser(
15 description='sum the integers at the command line')
17 'integers', metavar='int', nargs='+', type=int,
18 help='an integer to be summed')
20 '--log', default=sys.stdout, type=argparse.FileType('w'),
21 help='the file where the sum should be written')
22 args = parser.parse_args()
23 args.log.write('%s' % sum(args.integers))
26 The module contains the following public classes:
28 - ArgumentParser -- The main entry point for command-line parsing. As the
29 example above shows, the add_argument() method is used to populate
30 the parser with actions for optional and positional arguments. Then
31 the parse_args() method is invoked to convert the args at the
32 command-line into an object with attributes.
34 - ArgumentError -- The exception raised by ArgumentParser objects when
35 there are errors with the parser's actions. Errors raised while
36 parsing the command-line are caught by ArgumentParser and emitted
37 as command-line messages.
39 - FileType -- A factory for defining types of files to be created. As the
40 example above shows, instances of FileType are typically passed as
41 the type= argument of add_argument() calls.
43 - Action -- The base class for parser actions. Typically actions are
44 selected by passing strings like 'store_true' or 'append_const' to
45 the action= argument of add_argument(). However, for greater
46 customization of ArgumentParser actions, subclasses of Action may
47 be defined and passed as the action= argument.
49 - HelpFormatter, RawDescriptionHelpFormatter, RawTextHelpFormatter,
50 ArgumentDefaultsHelpFormatter -- Formatter classes which
51 may be passed as the formatter_class= argument to the
52 ArgumentParser constructor. HelpFormatter is the default,
53 RawDescriptionHelpFormatter and RawTextHelpFormatter tell the parser
54 not to change the formatting for help text, and
55 ArgumentDefaultsHelpFormatter adds information about argument defaults
58 All other classes in this module are considered implementation details.
59 (Also note that HelpFormatter and RawDescriptionHelpFormatter are only
60 considered public as object names -- the API of the formatter objects is
61 still considered an implementation detail.)
71 'ArgumentDefaultsHelpFormatter',
72 'RawDescriptionHelpFormatter',
73 'RawTextHelpFormatter',
85 import collections
as _collections
90 import textwrap
as _textwrap
92 from gettext
import gettext
as _
96 return hasattr(obj,
'__call__')
or hasattr(obj,
'__bases__')
99 SUPPRESS =
'==SUPPRESS=='
106 _UNRECOGNIZED_ARGS_ATTR =
'_unrecognized_args'
113 """Abstract base class that provides __repr__.
115 The __repr__ method returns a string in the format::
116 ClassName(attr=name, attr=name, ...)
117 The attributes are determined either by a class-level attribute,
118 '_kwarg_names', or by inspecting the instance __dict__.
122 type_name = type(self).__name__
125 arg_strings.append(repr(arg))
127 arg_strings.append(
'%s=%r' % (name, value))
128 return '%s(%s)' % (type_name,
', '.
join(arg_strings))
131 return sorted(self.__dict__.items())
138 if getattr(namespace, name,
None)
is None:
139 setattr(namespace, name, value)
140 return getattr(namespace, name)
148 """Formatter for generating usage messages and argument help strings.
150 Only the name of this class is considered a public API. All the methods
151 provided by the class are considered an implementation detail.
157 max_help_position=24,
163 width = int(_os.environ[
'COLUMNS'])
164 except (KeyError, ValueError):
197 def __init__(self, formatter, parent, heading=None):
205 if self.
parent is not None:
206 self.formatter._indent()
207 join = self.formatter._join_parts
208 for func, args
in self.
items:
210 item_help =
join([func(*args)
for func, args
in self.
items])
211 if self.
parent is not None:
212 self.formatter._dedent()
220 current_indent = self.formatter._current_indent
221 heading =
'%*s%s:\n' % (current_indent,
'', self.
heading)
226 return join([
'\n', heading, item_help,
'\n'])
229 self._current_section.items.append((func, args))
245 if text
is not SUPPRESS
and text
is not None:
248 def add_usage(self, usage, actions, groups, prefix=None):
249 if usage
is not SUPPRESS:
250 args = usage, actions, groups, prefix
254 if action.help
is not SUPPRESS:
258 invocations = [get_invocation(action)]
260 invocations.append(get_invocation(subaction))
263 invocation_length =
max([len(s)
for s
in invocations])
272 for action
in actions:
279 help = self._root_section.format_help()
281 help = self._long_break_matcher.sub(
'\n\n', help)
282 help = help.strip(
'\n') +
'\n'
287 for part
in part_strings
288 if part
and part
is not SUPPRESS])
292 prefix = _(
'usage: ')
295 if usage
is not None:
299 elif usage
is None and not actions:
300 usage =
'%(prog)s' %
dict(prog=self.
_prog)
304 prog =
'%(prog)s' %
dict(prog=self.
_prog)
309 for action
in actions:
310 if action.option_strings:
311 optionals.append(action)
313 positionals.append(action)
317 action_usage =
format(optionals + positionals, groups)
318 usage =
' '.
join([s
for s
in [prog, action_usage]
if s])
322 if len(prefix) + len(usage) > text_width:
325 part_regexp =
r'\(.*?\)+|\[.*?\]+|\S+'
326 opt_usage =
format(optionals, groups)
327 pos_usage =
format(positionals, groups)
328 opt_parts = _re.findall(part_regexp, opt_usage)
329 pos_parts = _re.findall(part_regexp, pos_usage)
330 assert ' '.
join(opt_parts) == opt_usage
331 assert ' '.
join(pos_parts) == pos_usage
334 def get_lines(parts, indent, prefix=None):
337 if prefix
is not None:
338 line_len = len(prefix) - 1
340 line_len = len(indent) - 1
342 if line_len + 1 + len(part) > text_width:
343 lines.append(indent +
' '.
join(line))
345 line_len = len(indent) - 1
347 line_len += len(part) + 1
349 lines.append(indent +
' '.
join(line))
350 if prefix
is not None:
351 lines[0] = lines[0][len(indent):]
355 if len(prefix) + len(prog) <= 0.75 * text_width:
356 indent =
' ' * (len(prefix) + len(prog) + 1)
358 lines = get_lines([prog] + opt_parts, indent, prefix)
359 lines.extend(get_lines(pos_parts, indent))
361 lines = get_lines([prog] + pos_parts, indent, prefix)
367 indent =
' ' * len(prefix)
368 parts = opt_parts + pos_parts
369 lines = get_lines(parts, indent)
372 lines.extend(get_lines(opt_parts, indent))
373 lines.extend(get_lines(pos_parts, indent))
374 lines = [prog] + lines
377 usage =
'\n'.
join(lines)
380 return '%s%s\n\n' % (prefix, usage)
384 group_actions =
set()
388 start = actions.index(group._group_actions[0])
392 end = start + len(group._group_actions)
393 if actions[start:end] == group._group_actions:
394 for action
in group._group_actions:
395 group_actions.add(action)
396 if not group.required:
398 inserts[start] +=
' ['
404 inserts[start] +=
' ('
408 for i
in range(start + 1, end):
413 for i, action
in enumerate(actions):
417 if action.help
is SUPPRESS:
419 if inserts.get(i) ==
'|':
421 elif inserts.get(i + 1) ==
'|':
425 elif not action.option_strings:
429 if action
in group_actions:
430 if part[0] ==
'[' and part[-1] ==
']':
438 option_string = action.option_strings[0]
442 if action.nargs == 0:
443 part =
'%s' % option_string
448 default = action.dest.upper()
450 part =
'%s %s' % (option_string, args_string)
453 if not action.required
and action
not in group_actions:
460 for i
in sorted(inserts, reverse=
True):
461 parts[i:i] = [inserts[i]]
464 text =
' '.
join([item
for item
in parts
if item
is not None])
469 text = _re.sub(
r'(%s) ' % open,
r'\1', text)
470 text = _re.sub(
r' (%s)' % close,
r'\1', text)
471 text = _re.sub(
r'%s *%s' % (open, close),
r'', text)
472 text = _re.sub(
r'\(([^|]*)\)',
r'\1', text)
479 if '%(prog)' in text:
483 return self.
_fill_text(text, text_width, indent) +
'\n\n'
489 help_width = self.
_width - help_position
496 action_header =
'%*s%s\n' % tup
499 elif len(action_header) <= action_width:
501 action_header =
'%*s%-*s ' % tup
507 action_header =
'%*s%s\n' % tup
508 indent_first = help_position
511 parts = [action_header]
517 parts.append(
'%*s%s\n' % (indent_first,
'', help_lines[0]))
518 for line
in help_lines[1:]:
519 parts.append(
'%*s%s\n' % (help_position,
'', line))
522 elif not action_header.endswith(
'\n'):
533 if not action.option_strings:
542 if action.nargs == 0:
543 parts.extend(action.option_strings)
548 default = action.dest.upper()
550 for option_string
in action.option_strings:
551 parts.append(
'%s %s' % (option_string, args_string))
553 return ', '.
join(parts)
556 if action.metavar
is not None:
557 result = action.metavar
558 elif action.choices
is not None:
559 choice_strs = [str(choice)
for choice
in action.choices]
560 result =
'{%s}' %
','.
join(choice_strs)
562 result = default_metavar
565 if isinstance(result, tuple):
568 return (result, ) * tuple_size
573 if action.nargs
is None:
574 result =
'%s' % get_metavar(1)
575 elif action.nargs == OPTIONAL:
576 result =
'[%s]' % get_metavar(1)
577 elif action.nargs == ZERO_OR_MORE:
578 result =
'[%s [%s ...]]' % get_metavar(2)
579 elif action.nargs == ONE_OR_MORE:
580 result =
'%s [%s ...]' % get_metavar(2)
581 elif action.nargs == REMAINDER:
583 elif action.nargs == PARSER:
584 result =
'%s ...' % get_metavar(1)
586 formats = [
'%s' for _
in range(action.nargs)]
587 result =
' '.
join(formats) % get_metavar(action.nargs)
591 params =
dict(vars(action), prog=self.
_prog)
592 for name
in list(params):
593 if params[name]
is SUPPRESS:
595 for name
in list(params):
596 if hasattr(params[name],
'__name__'):
597 params[name] = params[name].__name__
598 if params.get(
'choices')
is not None:
599 choices_str =
', '.
join([str(c)
for c
in params[
'choices']])
600 params[
'choices'] = choices_str
605 get_subactions = action._get_subactions
606 except AttributeError:
610 for subaction
in get_subactions():
615 text = self._whitespace_matcher.sub(
' ', text).
strip()
616 return _textwrap.wrap(text, width)
619 text = self._whitespace_matcher.sub(
' ', text).
strip()
620 return _textwrap.fill(text, width, initial_indent=indent,
621 subsequent_indent=indent)
628 """Help message formatter which retains any formatting in descriptions.
630 Only the name of this class is considered a public API. All the methods
631 provided by the class are considered an implementation detail.
635 return ''.
join([indent + line
for line
in text.splitlines(
True)])
639 """Help message formatter which retains formatting of all help text.
641 Only the name of this class is considered a public API. All the methods
642 provided by the class are considered an implementation detail.
646 return text.splitlines()
650 """Help message formatter which adds default values to argument help.
652 Only the name of this class is considered a public API. All the methods
653 provided by the class are considered an implementation detail.
658 if '%(default)' not in action.help:
659 if action.default
is not SUPPRESS:
660 defaulting_nargs = [OPTIONAL, ZERO_OR_MORE]
661 if action.option_strings
or action.nargs
in defaulting_nargs:
662 help +=
' (default: %(default)s)'
673 elif argument.option_strings:
674 return '/'.
join(argument.option_strings)
675 elif argument.metavar
not in (
None, SUPPRESS):
676 return argument.metavar
677 elif argument.dest
not in (
None, SUPPRESS):
684 """An error from creating or using an argument (optional or positional).
686 The string value of this exception is the message, augmented with
687 information about the argument that caused it.
696 format =
'%(message)s'
698 format =
'argument %(argument_name)s: %(message)s'
704 """An error from trying to convert a command line string to a type."""
713 """Information about how to convert command line strings to Python objects.
715 Action objects are used by an ArgumentParser to represent the information
716 needed to parse a single argument from one or more strings from the
717 command line. The keyword arguments to the Action constructor are also
718 all attributes of Action instances.
722 - option_strings -- A list of command-line option strings which
723 should be associated with this action.
725 - dest -- The name of the attribute to hold the created object(s)
727 - nargs -- The number of command-line arguments that should be
728 consumed. By default, one argument will be consumed and a single
729 value will be produced. Other values include:
730 - N (an integer) consumes N arguments (and produces a list)
731 - '?' consumes zero or one arguments
732 - '*' consumes zero or more arguments (and produces a list)
733 - '+' consumes one or more arguments (and produces a list)
734 Note that the difference between the default and nargs=1 is that
735 with the default, a single value will be produced, while with
736 nargs=1, a list containing a single value will be produced.
738 - const -- The value to be produced if the option is specified and the
739 option uses an action that takes no values.
741 - default -- The value to be produced if the option is not specified.
743 - type -- The type which the command-line arguments should be converted
744 to, should be one of 'string', 'int', 'float', 'complex' or a
745 callable object that accepts a single string argument. If None,
748 - choices -- A container of values that should be allowed. If not None,
749 after a command-line argument has been converted to the appropriate
750 type, an exception will be raised if it is not a member of this
753 - required -- True if the action must always be specified at the
754 command line. This is only meaningful for optional command-line
757 - help -- The help string describing the argument.
759 - metavar -- The name to be used for the option's argument with the
760 help string. If None, the 'dest' value will be used as the name.
797 return [(name, getattr(self, name))
for name
in names]
799 def __call__(self, parser, namespace, values, option_string=None):
800 raise NotImplementedError(_(
'.__call__() not defined'))
817 raise ValueError(
'nargs for store actions must be > 0; if you '
818 'have nothing to store, actions such as store '
819 'true or store const may be more appropriate')
820 if const
is not None and nargs != OPTIONAL:
821 raise ValueError(
'nargs must be %r to supply const' % OPTIONAL)
823 option_strings=option_strings,
834 def __call__(self, parser, namespace, values, option_string=None):
835 setattr(namespace, self.
dest, values)
848 super(_StoreConstAction, self).
__init__(
849 option_strings=option_strings,
857 def __call__(self, parser, namespace, values, option_string=None):
858 setattr(namespace, self.
dest, self.
const)
869 super(_StoreTrueAction, self).
__init__(
870 option_strings=option_strings,
886 super(_StoreFalseAction, self).
__init__(
887 option_strings=option_strings,
909 raise ValueError(
'nargs for append actions must be > 0; if arg '
910 'strings are not supplying the value to append, '
911 'the append const action may be more appropriate')
912 if const
is not None and nargs != OPTIONAL:
913 raise ValueError(
'nargs must be %r to supply const' % OPTIONAL)
914 super(_AppendAction, self).
__init__(
915 option_strings=option_strings,
926 def __call__(self, parser, namespace, values, option_string=None):
929 setattr(namespace, self.
dest, items)
942 super(_AppendConstAction, self).
__init__(
943 option_strings=option_strings,
952 def __call__(self, parser, namespace, values, option_string=None):
954 items.append(self.
const)
955 setattr(namespace, self.
dest, items)
967 option_strings=option_strings,
974 def __call__(self, parser, namespace, values, option_string=None):
976 setattr(namespace, self.
dest, new_count)
987 option_strings=option_strings,
993 def __call__(self, parser, namespace, values, option_string=None):
1005 help=
"show program's version number and exit"):
1006 super(_VersionAction, self).
__init__(
1007 option_strings=option_strings,
1014 def __call__(self, parser, namespace, values, option_string=None):
1017 version = parser.version
1018 formatter = parser._get_formatter()
1019 formatter.add_text(version)
1020 parser.exit(message=formatter.format_help())
1029 sup.__init__(option_strings=[], dest=name, help=help)
1044 super(_SubParsersAction, self).
__init__(
1045 option_strings=option_strings,
1054 if kwargs.get(
'prog')
is None:
1058 if 'help' in kwargs:
1059 help = kwargs.pop(
'help')
1061 self._choices_actions.append(choice_action)
1071 def __call__(self, parser, namespace, values, option_string=None):
1072 parser_name = values[0]
1073 arg_strings = values[1:]
1076 if self.
dest is not SUPPRESS:
1077 setattr(namespace, self.
dest, parser_name)
1084 msg = _(
'unknown parser %r (choices: %s)') % tup
1090 namespace, arg_strings = parser.parse_known_args(arg_strings, namespace)
1092 vars(namespace).setdefault(_UNRECOGNIZED_ARGS_ATTR, [])
1093 getattr(namespace, _UNRECOGNIZED_ARGS_ATTR).extend(arg_strings)
1101 """Factory for creating file object types
1103 Instances of FileType are typically passed as type= arguments to the
1104 ArgumentParser add_argument() method.
1107 - mode -- A string indicating how the file is to be opened. Accepts the
1108 same values as the builtin open() function.
1109 - bufsize -- The file's desired buffer size. Accepts the same values as
1110 the builtin open() function.
1120 if 'r' in self._mode:
1122 elif 'w' in self.
_mode:
1125 msg = _(
'argument "-" with mode %r') % self.
_mode
1126 raise ValueError(msg)
1131 except IOError
as e:
1132 message = _(
"can't open '%s': %s")
1137 args_str =
', '.
join(repr(arg)
for arg
in args
if arg != -1)
1138 return '%s(%s)' % (type(self).__name__, args_str)
1145 """Simple object for storing attributes.
1147 Implements equality by attribute names and values, and provides a simple
1148 string representation.
1153 setattr(self, name, kwargs[name])
1158 return vars(self) == vars(other)
1161 return not (self == other)
1164 return key
in self.__dict__
1174 super(_ActionsContainer, self).
__init__()
1185 self.
register(
'action',
None, _StoreAction)
1186 self.
register(
'action',
'store', _StoreAction)
1187 self.
register(
'action',
'store_const', _StoreConstAction)
1188 self.
register(
'action',
'store_true', _StoreTrueAction)
1189 self.
register(
'action',
'store_false', _StoreFalseAction)
1190 self.
register(
'action',
'append', _AppendAction)
1191 self.
register(
'action',
'append_const', _AppendConstAction)
1192 self.
register(
'action',
'count', _CountAction)
1193 self.
register(
'action',
'help', _HelpAction)
1194 self.
register(
'action',
'version', _VersionAction)
1195 self.
register(
'action',
'parsers', _SubParsersAction)
1222 registry = self._registries.setdefault(registry_name, {})
1223 registry[value] = object
1232 self._defaults.update(kwargs)
1237 if action.dest
in kwargs:
1238 action.default = kwargs[action.dest]
1242 if action.dest == dest
and action.default
is not None:
1243 return action.default
1244 return self._defaults.get(dest,
None)
1252 add_argument(dest, ..., name=value, ...)
1253 add_argument(option_string, option_string, ..., name=value, ...)
1260 if not args
or len(args) == 1
and args[0][0]
not in chars:
1261 if args
and 'dest' in kwargs:
1262 raise ValueError(
'dest supplied twice for positional argument')
1270 if 'default' not in kwargs:
1271 dest = kwargs[
'dest']
1273 kwargs[
'default'] = self.
_defaults[dest]
1280 raise ValueError(
'unknown action "%s"' % (action_class,))
1281 action = action_class(**kwargs)
1284 type_func = self.
_registry_get(
'type', action.type, action.type)
1286 raise ValueError(
'%r is not callable' % (type_func,))
1289 if hasattr(self,
"_get_formatter"):
1291 self._get_formatter()._format_args(action,
None)
1293 raise ValueError(
"length of metavar tuple does not match nargs")
1299 self._action_groups.append(group)
1304 self._mutually_exclusive_groups.append(group)
1312 self._actions.append(action)
1313 action.container = self
1316 for option_string
in action.option_strings:
1320 for option_string
in action.option_strings:
1321 if self._negative_number_matcher.match(option_string):
1323 self._has_negative_number_optionals.append(
True)
1329 self._actions.remove(action)
1333 title_group_map = {}
1335 if group.title
in title_group_map:
1336 msg = _(
'cannot merge actions - two groups are named %r')
1337 raise ValueError(msg % (group.title))
1338 title_group_map[group.title] = group
1342 for group
in container._action_groups:
1346 if group.title
not in title_group_map:
1349 description=group.description,
1350 conflict_handler=group.conflict_handler)
1353 for action
in group._group_actions:
1354 group_map[action] = title_group_map[group.title]
1359 for group
in container._mutually_exclusive_groups:
1361 required=group.required)
1364 for action
in group._group_actions:
1365 group_map[action] = mutex_group
1368 for action
in container._actions:
1373 if 'required' in kwargs:
1374 msg = _(
"'required' is an invalid argument for positionals")
1375 raise TypeError(msg)
1379 if kwargs.get(
'nargs')
not in [OPTIONAL, ZERO_OR_MORE]:
1380 kwargs[
'required'] =
True
1381 if kwargs.get(
'nargs') == ZERO_OR_MORE
and 'default' not in kwargs:
1382 kwargs[
'required'] =
True
1385 return dict(kwargs, dest=dest, option_strings=[])
1390 long_option_strings = []
1391 for option_string
in args:
1394 msg = _(
'invalid option string %r: '
1395 'must start with a character %r')
1397 raise ValueError(msg % tup)
1400 option_strings.append(option_string)
1402 if len(option_string) > 1:
1404 long_option_strings.append(option_string)
1407 dest = kwargs.pop(
'dest',
None)
1409 if long_option_strings:
1410 dest_option_string = long_option_strings[0]
1412 dest_option_string = option_strings[0]
1415 msg = _(
'dest= is required for options like %r')
1416 raise ValueError(msg % option_string)
1417 dest = dest.replace(
'-',
'_')
1420 return dict(kwargs, dest=dest, option_strings=option_strings)
1423 action = kwargs.pop(
'action', default)
1430 return getattr(self, handler_func_name)
1431 except AttributeError:
1432 msg = _(
'invalid conflict_resolution value: %r')
1438 confl_optionals = []
1439 for option_string
in action.option_strings:
1442 confl_optionals.append((option_string, confl_optional))
1450 message = _(
'conflicting option string(s): %s')
1451 conflict_string =
', '.
join([option_string
1452 for option_string, action
1453 in conflicting_actions])
1459 for option_string, action
in conflicting_actions:
1462 action.option_strings.remove(option_string)
1463 self._option_string_actions.pop(option_string,
None)
1467 if not action.option_strings:
1468 action.container._remove_action(action)
1473 def __init__(self, container, title=None, description=None, **kwargs):
1475 update = kwargs.setdefault
1476 update(
'conflict_handler', container.conflict_handler)
1477 update(
'prefix_chars', container.prefix_chars)
1478 update(
'argument_default', container.argument_default)
1479 super_init = super(_ArgumentGroup, self).__init__
1480 super_init(description=description, **kwargs)
1492 container._has_negative_number_optionals
1496 action = super(_ArgumentGroup, self).
_add_action(action)
1497 self._group_actions.append(action)
1502 self._group_actions.remove(action)
1508 super(_MutuallyExclusiveGroup, self).
__init__(container)
1514 msg = _(
'mutually exclusive arguments must be optional')
1515 raise ValueError(msg)
1516 action = self._container._add_action(action)
1517 self._group_actions.append(action)
1521 self._container._remove_action(action)
1522 self._group_actions.remove(action)
1526 """Object for parsing command line strings into Python objects.
1529 - prog -- The name of the program (default: sys.argv[0])
1530 - usage -- A usage message (default: auto-generated from arguments)
1531 - description -- A description of what the program does
1532 - epilog -- Text following the argument descriptions
1533 - parents -- Parsers whose arguments should be copied into this one
1534 - formatter_class -- HelpFormatter class for printing help messages
1535 - prefix_chars -- Characters that prefix optional arguments
1536 - fromfile_prefix_chars -- Characters that prefix files containing
1537 additional arguments
1538 - argument_default -- The default value for all arguments
1539 - conflict_handler -- String indicating how to handle conflicts
1540 - add_help -- Add a -h/-help option
1550 formatter_class=HelpFormatter,
1552 fromfile_prefix_chars=
None,
1553 argument_default=
None,
1554 conflict_handler=
'error',
1557 if version
is not None:
1560 """The "version" argument to ArgumentParser is deprecated. """
1562 """"add_argument(..., action='version', version="N", ...)" """
1563 """instead""", DeprecationWarning)
1565 superinit = super(ArgumentParser, self).__init__
1566 superinit(description=description,
1567 prefix_chars=prefix_chars,
1568 argument_default=argument_default,
1569 conflict_handler=conflict_handler)
1573 prog = _os.path.basename(_sys.argv[0])
1589 def identity(string):
1591 self.
register(
'type',
None, identity)
1595 default_prefix =
'-' if '-' in prefix_chars
else prefix_chars[0]
1598 default_prefix+
'h', default_prefix*2+
'help',
1599 action=
'help', default=SUPPRESS,
1600 help=_(
'show this help message and exit'))
1603 default_prefix+
'v', default_prefix*2+
'version',
1604 action=
'version', default=SUPPRESS,
1606 help=_(
"show program's version number and exit"))
1609 for parent
in parents:
1612 defaults = parent._defaults
1613 except AttributeError:
1616 self._defaults.update(defaults)
1631 return [(name, getattr(self, name))
for name
in names]
1638 self.
error(_(
'cannot have multiple subparser arguments'))
1641 kwargs.setdefault(
'parser_class', type(self))
1643 if 'title' in kwargs
or 'description' in kwargs:
1644 title = _(kwargs.pop(
'title',
'subcommands'))
1645 description = _(kwargs.pop(
'description',
None))
1652 if kwargs.get(
'prog')
is None:
1656 formatter.add_usage(self.
usage, positionals, groups,
'')
1657 kwargs[
'prog'] = formatter.format_help().
strip()
1661 action = parsers_class(option_strings=[], **kwargs)
1662 self._subparsers._add_action(action)
1668 if action.option_strings:
1669 self._optionals._add_action(action)
1671 self._positionals._add_action(action)
1677 if action.option_strings]
1682 if not action.option_strings]
1690 msg = _(
'unrecognized arguments: %s')
1697 args = _sys.argv[1:]
1700 if namespace
is None:
1705 if action.dest
is not SUPPRESS:
1706 if not hasattr(namespace, action.dest):
1707 if action.default
is not SUPPRESS:
1708 default = action.default
1709 if isinstance(action.default, basestring):
1711 setattr(namespace, action.dest, default)
1715 if not hasattr(namespace, dest):
1716 setattr(namespace, dest, self.
_defaults[dest])
1721 if hasattr(namespace, _UNRECOGNIZED_ARGS_ATTR):
1722 args.extend(getattr(namespace, _UNRECOGNIZED_ARGS_ATTR))
1723 delattr(namespace, _UNRECOGNIZED_ARGS_ATTR)
1724 return namespace, args
1725 except ArgumentError:
1726 err = _sys.exc_info()[1]
1727 self.
error(str(err))
1736 action_conflicts = {}
1738 group_actions = mutex_group._group_actions
1739 for i, mutex_action
in enumerate(mutex_group._group_actions):
1740 conflicts = action_conflicts.setdefault(mutex_action, [])
1741 conflicts.extend(group_actions[:i])
1742 conflicts.extend(group_actions[i + 1:])
1747 option_string_indices = {}
1748 arg_string_pattern_parts = []
1749 arg_strings_iter = iter(arg_strings)
1750 for i, arg_string
in enumerate(arg_strings_iter):
1753 if arg_string ==
'--':
1754 arg_string_pattern_parts.append(
'-')
1755 for arg_string
in arg_strings_iter:
1756 arg_string_pattern_parts.append(
'A')
1762 if option_tuple
is None:
1765 option_string_indices[i] = option_tuple
1767 arg_string_pattern_parts.append(pattern)
1770 arg_strings_pattern =
''.
join(arg_string_pattern_parts)
1773 seen_actions =
set()
1774 seen_non_default_actions =
set()
1776 def take_action(action, argument_strings, option_string=None):
1777 seen_actions.add(action)
1778 argument_values = self.
_get_values(action, argument_strings)
1783 if argument_values
is not action.default:
1784 seen_non_default_actions.add(action)
1785 for conflict_action
in action_conflicts.get(action, []):
1786 if conflict_action
in seen_non_default_actions:
1787 msg = _(
'not allowed with argument %s')
1793 if argument_values
is not SUPPRESS:
1794 action(self, namespace, argument_values, option_string)
1797 def consume_optional(start_index):
1800 option_tuple = option_string_indices[start_index]
1801 action, option_string, explicit_arg = option_tuple
1811 extras.append(arg_strings[start_index])
1812 return start_index + 1
1816 if explicit_arg
is not None:
1817 arg_count = match_argument(action,
'A')
1823 if arg_count == 0
and option_string[1]
not in chars:
1824 action_tuples.append((action, [], option_string))
1825 char = option_string[0]
1826 option_string = char + explicit_arg[0]
1827 new_explicit_arg = explicit_arg[1:]
or None
1829 if option_string
in optionals_map:
1830 action = optionals_map[option_string]
1831 explicit_arg = new_explicit_arg
1833 msg = _(
'ignored explicit argument %r')
1838 elif arg_count == 1:
1839 stop = start_index + 1
1840 args = [explicit_arg]
1841 action_tuples.append((action, args, option_string))
1847 msg = _(
'ignored explicit argument %r')
1854 start = start_index + 1
1855 selected_patterns = arg_strings_pattern[start:]
1856 arg_count = match_argument(action, selected_patterns)
1857 stop = start + arg_count
1858 args = arg_strings[start:stop]
1859 action_tuples.append((action, args, option_string))
1864 assert action_tuples
1865 for action, args, option_string
in action_tuples:
1866 take_action(action, args, option_string)
1874 def consume_positionals(start_index):
1877 selected_pattern = arg_strings_pattern[start_index:]
1878 arg_counts = match_partial(positionals, selected_pattern)
1882 for action, arg_count
in zip(positionals, arg_counts):
1883 args = arg_strings[start_index: start_index + arg_count]
1884 start_index += arg_count
1885 take_action(action, args)
1889 positionals[:] = positionals[len(arg_counts):]
1896 if option_string_indices:
1897 max_option_string_index =
max(option_string_indices)
1899 max_option_string_index = -1
1900 while start_index <= max_option_string_index:
1903 next_option_string_index =
min([
1905 for index
in option_string_indices
1906 if index >= start_index])
1907 if start_index != next_option_string_index:
1908 positionals_end_index = consume_positionals(start_index)
1912 if positionals_end_index > start_index:
1913 start_index = positionals_end_index
1916 start_index = positionals_end_index
1920 if start_index
not in option_string_indices:
1921 strings = arg_strings[start_index:next_option_string_index]
1922 extras.extend(strings)
1923 start_index = next_option_string_index
1926 start_index = consume_optional(start_index)
1929 stop_index = consume_positionals(start_index)
1932 extras.extend(arg_strings[stop_index:])
1937 self.
error(_(
'too few arguments'))
1942 if action
not in seen_actions:
1944 self.
error(_(
'argument %s is required') % name)
1949 for action
in group._group_actions:
1950 if action
in seen_non_default_actions:
1956 for action
in group._group_actions
1957 if action.help
is not SUPPRESS]
1958 msg = _(
'one of the arguments %s is required')
1962 return namespace, extras
1966 new_arg_strings = []
1967 for arg_string
in arg_strings:
1971 new_arg_strings.append(arg_string)
1976 args_file = open(arg_string[1:])
1979 for arg_line
in args_file.read().splitlines():
1981 arg_strings.append(arg)
1983 new_arg_strings.extend(arg_strings)
1987 err = _sys.exc_info()[1]
1988 self.
error(str(err))
1991 return new_arg_strings
1999 match = _re.match(nargs_pattern, arg_strings_pattern)
2004 None: _(
'expected one argument'),
2005 OPTIONAL: _(
'expected at most one argument'),
2006 ONE_OR_MORE: _(
'expected at least one argument'),
2008 default = _(
'expected %s argument(s)') % action.nargs
2009 msg = nargs_errors.get(action.nargs, default)
2013 return len(match.group(1))
2019 for i
in range(len(actions), 0, -1):
2020 actions_slice = actions[:i]
2022 for action
in actions_slice])
2023 match = _re.match(pattern, arg_strings_pattern)
2024 if match
is not None:
2025 result.extend([len(string)
for string
in match.groups()])
2043 return action, arg_string,
None
2046 if len(arg_string) == 1:
2050 if '=' in arg_string:
2051 option_string, explicit_arg = arg_string.split(
'=', 1)
2054 return action, option_string, explicit_arg
2061 if len(option_tuples) > 1:
2062 options =
', '.
join([option_string
2063 for action, option_string, explicit_arg
in option_tuples])
2064 tup = arg_string, options
2065 self.
error(_(
'ambiguous option: %s could match %s') % tup)
2069 elif len(option_tuples) == 1:
2070 option_tuple, = option_tuples
2076 if self._negative_number_matcher.match(arg_string):
2081 if ' ' in arg_string:
2086 return None, arg_string,
None
2094 if option_string[0]
in chars
and option_string[1]
in chars:
2095 if '=' in option_string:
2096 option_prefix, explicit_arg = option_string.split(
'=', 1)
2098 option_prefix = option_string
2101 if option_string.startswith(option_prefix):
2103 tup = action, option_string, explicit_arg
2109 elif option_string[0]
in chars
and option_string[1]
not in chars:
2110 option_prefix = option_string
2112 short_option_prefix = option_string[:2]
2113 short_explicit_arg = option_string[2:]
2116 if option_string == short_option_prefix:
2118 tup = action, option_string, short_explicit_arg
2120 elif option_string.startswith(option_prefix):
2122 tup = action, option_string, explicit_arg
2127 self.
error(_(
'unexpected option string: %s') % option_string)
2135 nargs = action.nargs
2139 nargs_pattern =
'(-*A-*)'
2142 elif nargs == OPTIONAL:
2143 nargs_pattern =
'(-*A?-*)'
2146 elif nargs == ZERO_OR_MORE:
2147 nargs_pattern =
'(-*[A-]*)'
2150 elif nargs == ONE_OR_MORE:
2151 nargs_pattern =
'(-*A[A-]*)'
2154 elif nargs == REMAINDER:
2155 nargs_pattern =
'([-AO]*)'
2158 elif nargs == PARSER:
2159 nargs_pattern =
'(-*A[-AO]*)'
2163 nargs_pattern =
'(-*%s-*)' %
'-*'.
join(
'A' * nargs)
2166 if action.option_strings:
2167 nargs_pattern = nargs_pattern.replace(
'-*',
'')
2168 nargs_pattern = nargs_pattern.replace(
'-',
'')
2171 return nargs_pattern
2178 if action.nargs
not in [PARSER, REMAINDER]:
2179 arg_strings = [s
for s
in arg_strings
if s !=
'--']
2182 if not arg_strings
and action.nargs == OPTIONAL:
2183 if action.option_strings:
2184 value = action.const
2186 value = action.default
2187 if isinstance(value, basestring):
2193 elif (
not arg_strings
and action.nargs == ZERO_OR_MORE
and
2194 not action.option_strings):
2195 if action.default
is not None:
2196 value = action.default
2202 elif len(arg_strings) == 1
and action.nargs
in [
None, OPTIONAL]:
2203 arg_string, = arg_strings
2208 elif action.nargs == REMAINDER:
2209 value = [self.
_get_value(action, v)
for v
in arg_strings]
2212 elif action.nargs == PARSER:
2213 value = [self.
_get_value(action, v)
for v
in arg_strings]
2218 value = [self.
_get_value(action, v)
for v
in arg_strings]
2226 type_func = self.
_registry_get(
'type', action.type, action.type)
2228 msg = _(
'%r is not callable')
2233 result = type_func(arg_string)
2236 except ArgumentTypeError:
2237 name = getattr(action.type,
'__name__', repr(action.type))
2238 msg = str(_sys.exc_info()[1])
2242 except (TypeError, ValueError):
2243 name = getattr(action.type,
'__name__', repr(action.type))
2244 msg = _(
'invalid %s value: %r')
2252 if action.choices
is not None and value
not in action.choices:
2253 tup = value,
', '.
join(
map(repr, action.choices))
2254 msg = _(
'invalid choice: %r (choose from %s)') % tup
2264 return formatter.format_help()
2278 formatter.start_section(action_group.title)
2279 formatter.add_text(action_group.description)
2280 formatter.add_arguments(action_group._group_actions)
2281 formatter.end_section()
2284 formatter.add_text(self.
epilog)
2287 return formatter.format_help()
2292 'The format_version method is deprecated -- the "version" '
2293 'argument to ArgumentParser is no longer supported.',
2296 formatter.add_text(self.
version)
2297 return formatter.format_help()
2318 'The print_version method is deprecated -- the "version" '
2319 'argument to ArgumentParser is no longer supported.',
2332 def exit(self, status=0, message=None):
2338 """error(message: string)
2340 Prints a usage message incorporating the message to stderr and
2343 If you override this in a subclass, it should not return -- it
2344 should either exit or raise an exception.
2347 self.
exit(2, _(
'%s: error: %s\n') % (self.
prog, message))
def _handle_conflict_resolve
def add_mutually_exclusive_group
def _get_positional_actions
def _match_arguments_partial
string format
Some error handling for the usage.
_mutually_exclusive_groups
def _get_positional_kwargs
def _read_args_from_files
def convert_arg_line_to_args
const T & max(const T &a, const T &b)
def _add_container_actions
def _get_optional_actions
static std::string join(char **cmd)
_has_negative_number_optionals
def _handle_conflict_error
T get(const Candidate &c)
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger list("!*","!HLTx*"if it matches 2 triggers or more) will accept the event if all the matching triggers are FAIL.It will reject the event if any of the triggers are PASS or EXCEPTION(this matches the behavior of"!*"before the partial wildcard feature was incorporated).Triggers which are in the READY state are completely ignored.(READY should never be returned since the trigger paths have been run
void set(const std::string &name, int value)
set the flag, with a run-time name