# Author: Steven J. Bethard <[email protected]>.

# New maintainer as of 29 August 2019: Raymond Hettinger <[email protected]>

"""Command-line parsing library

This module is an optparse-inspired command-line parsing library that:

- handles both optional and positional arguments

- produces highly informative usage messages

- supports parsers that dispatch to sub-parsers

The following is a simple usage example that sums integers from the

command-line and writes the result to a file::

parser = argparse.ArgumentParser(

description='sum the integers at the command line')

parser.add_argument(

'integers', metavar='int', nargs='+', type=int,

help='an integer to be summed')

parser.add_argument(

'--log', default=sys.stdout, type=argparse.FileType('w'),

help='the file where the sum should be written')

args = parser.parse_args()

args.log.write('%s' % sum(args.integers))

args.log.close()

The module contains the following public classes:

- ArgumentParser -- The main entry point for command-line parsing. As the

example above shows, the add_argument() method is used to populate

the parser with actions for optional and positional arguments. Then

the parse_args() method is invoked to convert the args at the

command-line into an object with attributes.

- ArgumentError -- The exception raised by ArgumentParser objects when

there are errors with the parser's actions. Errors raised while

parsing the command-line are caught by ArgumentParser and emitted

as command-line messages.

- FileType -- A factory for defining types of files to be created. As the

example above shows, instances of FileType are typically passed as

the type= argument of add_argument() calls.

- Action -- The base class for parser actions. Typically actions are

selected by passing strings like 'store_true' or 'append_const' to

the action= argument of add_argument(). However, for greater

customization of ArgumentParser actions, subclasses of Action may

be defined and passed as the action= argument.

- HelpFormatter, RawDescriptionHelpFormatter, RawTextHelpFormatter,

ArgumentDefaultsHelpFormatter -- Formatter classes which

may be passed as the formatter_class= argument to the

ArgumentParser constructor. HelpFormatter is the default,

RawDescriptionHelpFormatter and RawTextHelpFormatter tell the parser

not to change the formatting for help text, and

ArgumentDefaultsHelpFormatter adds information about argument defaults

to the help.

All other classes in this module are considered implementation details.

(Also note that HelpFormatter and RawDescriptionHelpFormatter are only

considered public as object names -- the API of the formatter objects is

still considered an implementation detail.)

"""

__version__ = '1.1'

__all__ = [

'ArgumentParser',

'ArgumentError',

'ArgumentTypeError',

'BooleanOptionalAction',

'FileType',

'HelpFormatter',

'ArgumentDefaultsHelpFormatter',

'RawDescriptionHelpFormatter',

'RawTextHelpFormatter',

'MetavarTypeHelpFormatter',

'Namespace',

'Action',

'ONE_OR_MORE',

'OPTIONAL',

'PARSER',

'REMAINDER',

'SUPPRESS',

'ZERO_OR_MORE',

]

import os as _os

import re as _re

import sys as _sys

from gettext import gettext as _, ngettext

SUPPRESS = '==SUPPRESS=='

OPTIONAL = '?'

ZERO_OR_MORE = '*'

ONE_OR_MORE = '+'

PARSER = 'A...'

REMAINDER = '...'

_UNRECOGNIZED_ARGS_ATTR = '_unrecognized_args'

# =============================

# Utility functions and classes

# =============================

class _AttributeHolder(object):

"""Abstract base class that provides __repr__.

The __repr__ method returns a string in the format::

ClassName(attr=name, attr=name, ...)

The attributes are determined either by a class-level attribute,

'_kwarg_names', or by inspecting the instance __dict__.

"""

def __repr__(self):

type_name = type(self).__name__

arg_strings = []

star_args = {}

for arg in self._get_args():

arg_strings.append(repr(arg))

for name, value in self._get_kwargs():

if name.isidentifier():

arg_strings.append('%s=%r' % (name, value))

else:

star_args[name] = value

if star_args:

arg_strings.append('**%s' % repr(star_args))

return '%s(%s)' % (type_name, ', '.join(arg_strings))

def _get_kwargs(self):

return list(self.__dict__.items())

def _get_args(self):

return []

def _copy_items(items):

if items is None:

return []

# The copy module is used only in the 'append' and 'append_const'

# actions, and it is needed only when the default value isn't a list.

# Delay its import for speeding up the common case.

if type(items) is list:

return items[:]

import copy

return copy.copy(items)

# ===============

# Formatting Help

# ===============

class HelpFormatter(object):

"""Formatter for generating usage messages and argument help strings.

Only the name of this class is considered a public API. All the methods

provided by the class are considered an implementation detail.

"""

def __init__(self,

prog,

indent_increment=2,

max_help_position=24,

width=None):

# default setting for width

if width is None:

import shutil

width = shutil.get_terminal_size().columns

width -= 2

self._prog = prog

self._indent_increment = indent_increment

self._max_help_position = min(max_help_position,

max(width - 20, indent_increment * 2))

self._width = width

self._current_indent = 0

self._level = 0

self._action_max_length = 0

self._root_section = self._Section(self, None)

self._current_section = self._root_section

self._whitespace_matcher = _re.compile(r'\s+', _re.ASCII)

self._long_break_matcher = _re.compile(r'\n\n\n+')

# ===============================

# Section and indentation methods

# ===============================

def _indent(self):

self._current_indent += self._indent_increment

self._level += 1

def _dedent(self):

self._current_indent -= self._indent_increment

assert self._current_indent >= 0, 'Indent decreased below 0.'

self._level -= 1

class _Section(object):

def __init__(self, formatter, parent, heading=None):

self.formatter = formatter

self.parent = parent

self.heading = heading

self.items = []

def format_help(self):

# format the indented section

if self.parent is not None:

self.formatter._indent()

join = self.formatter._join_parts

item_help = join([func(*args) for func, args in self.items])

if self.parent is not None:

self.formatter._dedent()

# return nothing if the section was empty

if not item_help:

return ''

# add the heading if the section was non-empty

if self.heading is not SUPPRESS and self.heading is not None:

current_indent = self.formatter._current_indent

heading_text = _('%(heading)s:') % dict(heading=self.heading)

heading = '%*s%s\n' % (current_indent, '', heading_text)

else:

heading = ''

# join the section-initial newline, the heading and the help

return join(['\n', heading, item_help, '\n'])

def _add_item(self, func, args):

self._current_section.items.append((func, args))

# ========================

# Message building methods

# ========================

def start_section(self, heading):

self._indent()

section = self._Section(self, self._current_section, heading)

self._add_item(section.format_help, [])

self._current_section = section

def end_section(self):

self._current_section = self._current_section.parent

self._dedent()

def add_text(self, text):

if text is not SUPPRESS and text is not None:

self._add_item(self._format_text, [text])

def add_usage(self, usage, actions, groups, prefix=None):

if usage is not SUPPRESS:

args = usage, actions, groups, prefix

self._add_item(self._format_usage, args)

def add_argument(self, action):

if action.help is not SUPPRESS:

# find all invocations

get_invocation = self._format_action_invocation

invocation_lengths = [len(get_invocation(action)) + self._current_indent]

for subaction in self._iter_indented_subactions(action):

invocation_lengths.append(len(get_invocation(subaction)) + self._current_indent)

# update the maximum item length

action_length = max(invocation_lengths)

self._action_max_length = max(self._action_max_length,

action_length)

# add the item to the list

self._add_item(self._format_action, [action])

def add_arguments(self, actions):

for action in actions:

self.add_argument(action)

# =======================

# Help-formatting methods

# =======================

def format_help(self):

help = self._root_section.format_help()

if help:

help = self._long_break_matcher.sub('\n\n', help)

help = help.strip('\n') + '\n'

return help

def _join_parts(self, part_strings):

return ''.join([part

for part in part_strings

if part and part is not SUPPRESS])

def _format_usage(self, usage, actions, groups, prefix):

if prefix is None:

prefix = _('usage: ')

# if usage is specified, use that

if usage is not None:

usage = usage % dict(prog=self._prog)

# if no optionals or positionals are available, usage is just prog

elif usage is None and not actions:

usage = '%(prog)s' % dict(prog=self._prog)

# if optionals and positionals are available, calculate usage

elif usage is None:

prog = '%(prog)s' % dict(prog=self._prog)

# split optionals from positionals

optionals = []

positionals = []

for action in actions:

if action.option_strings:

optionals.append(action)

else:

positionals.append(action)

# build full usage string

format = self._format_actions_usage

action_usage = format(optionals + positionals, groups)

usage = ' '.join([s for s in [prog, action_usage] if s])

# wrap the usage parts if it's too long

text_width = self._width - self._current_indent

if len(prefix) + len(usage) > text_width:

# break usage into wrappable parts

opt_parts = self._get_actions_usage_parts(optionals, groups)

pos_parts = self._get_actions_usage_parts(positionals, groups)

# helper for wrapping lines

def get_lines(parts, indent, prefix=None):

lines = []

line = []

indent_length = len(indent)

if prefix is not None:

line_len = len(prefix) - 1

else:

line_len = indent_length - 1

for part in parts:

if line_len + 1 + len(part) > text_width and line:

lines.append(indent + ' '.join(line))

line = []

line_len = indent_length - 1

line.append(part)

line_len += len(part) + 1

if line:

lines.append(indent + ' '.join(line))

if prefix is not None:

lines[0] = lines[0][indent_length:]

return lines

# if prog is short, follow it with optionals or positionals

if len(prefix) + len(prog) <= 0.75 * text_width:

indent = ' ' * (len(prefix) + len(prog) + 1)

if opt_parts:

lines = get_lines([prog] + opt_parts, indent, prefix)

lines.extend(get_lines(pos_parts, indent))

elif pos_parts:

lines = get_lines([prog] + pos_parts, indent, prefix)

else:

lines = [prog]

# if prog is long, put it on its own line

else:

indent = ' ' * len(prefix)

parts = opt_parts + pos_parts

lines = get_lines(parts, indent)

if len(lines) > 1:

lines = []

lines.extend(get_lines(opt_parts, indent))

lines.extend(get_lines(pos_parts, indent))

lines = [prog] + lines

# join lines into usage

usage = '\n'.join(lines)

# prefix with 'usage:'

return '%s%s\n\n' % (prefix, usage)

def _format_actions_usage(self, actions, groups):

return ' '.join(self._get_actions_usage_parts(actions, groups))

def _get_actions_usage_parts(self, actions, groups):

# find group indices and identify actions in groups

group_actions = set()

inserts = {}

for group in groups:

if not group._group_actions:

raise ValueError(f'empty group {group}')

if all(action.help is SUPPRESS for action in group._group_actions):

continue

try:

start = actions.index(group._group_actions[0])

except ValueError:

continue

else:

end = start + len(group._group_actions)

if actions[start:end] == group._group_actions:

group_actions.update(group._group_actions)

inserts[start, end] = group

# collect all actions format strings

parts = []

for action in actions:

# suppressed arguments are marked with None

if action.help is SUPPRESS:

part = None

# produce all arg strings

elif not action.option_strings:

default = self._get_default_metavar_for_positional(action)

part = self._format_args(action, default)

# if it's in a group, strip the outer []

if action in group_actions:

if part[0] == '[' and part[-1] == ']':

part = part[1:-1]

# produce the first way to invoke the option in brackets

else:

option_string = action.option_strings[0]

# if the Optional doesn't take a value, format is:

# -s or --long

if action.nargs == 0:

part = action.format_usage()

# if the Optional takes a value, format is:

# -s ARGS or --long ARGS

else:

default = self._get_default_metavar_for_optional(action)

args_string = self._format_args(action, default)

part = '%s %s' % (option_string, args_string)

# make it look optional if it's not required or in a group

if not action.required and action not in group_actions:

part = '[%s]' % part

# add the action string to the list

parts.append(part)

# group mutually exclusive actions

inserted_separators_indices = set()

for start, end in sorted(inserts, reverse=True):

group = inserts[start, end]

group_parts = [item for item in parts[start:end] if item is not None]

group_size = len(group_parts)

if group.required:

open, close = "()" if group_size > 1 else ("", "")

else:

open, close = "[]"

group_parts[0] = open + group_parts[0]

group_parts[-1] = group_parts[-1] + close

for i, part in enumerate(group_parts[:-1], start=start):

# insert a separator if not already done in a nested group

if i not in inserted_separators_indices:

parts[i] = part + ' |'

inserted_separators_indices.add(i)

parts[start + group_size - 1] = group_parts[-1]

for i in range(start + group_size, end):

parts[i] = None

# return the usage parts

return [item for item in parts if item is not None]

def _format_text(self, text):

if '%(prog)' in text:

text = text % dict(prog=self._prog)

text_width = max(self._width - self._current_indent, 11)

indent = ' ' * self._current_indent

return self._fill_text(text, text_width, indent) + '\n\n'

def _format_action(self, action):

# determine the required width and the entry label

help_position = min(self._action_max_length + 2,

self._max_help_position)

help_width = max(self._width - help_position, 11)

action_width = help_position - self._current_indent - 2

action_header = self._format_action_invocation(action)

# no help; start on same line and add a final newline

if not action.help:

tup = self._current_indent, '', action_header

action_header = '%*s%s\n' % tup

# short action name; start on the same line and pad two spaces

elif len(action_header) <= action_width:

tup = self._current_indent, '', action_width, action_header

action_header = '%*s%-*s ' % tup

indent_first = 0

# long action name; start on the next line

else:

tup = self._current_indent, '', action_header

action_header = '%*s%s\n' % tup

indent_first = help_position

# collect the pieces of the action help

parts = [action_header]

# if there was help for the action, add lines of help text

if action.help and action.help.strip():

help_text = self._expand_help(action)

if help_text:

help_lines = self._split_lines(help_text, help_width)

parts.append('%*s%s\n' % (indent_first, '', help_lines[0]))

for line in help_lines[1:]:

parts.append('%*s%s\n' % (help_position, '', line))

# or add a newline if the description doesn't end with one

elif not action_header.endswith('\n'):

parts.append('\n')

# if there are any sub-actions, add their help as well

for subaction in self._iter_indented_subactions(action):

parts.append(self._format_action(subaction))

# return a single string

return self._join_parts(parts)

def _format_action_invocation(self, action):

if not action.option_strings:

default = self._get_default_metavar_for_positional(action)

return ' '.join(self._metavar_formatter(action, default)(1))

else:

# if the Optional doesn't take a value, format is:

# -s, --long

if action.nargs == 0:

return ', '.join(action.option_strings)

# if the Optional takes a value, format is:

# -s, --long ARGS

else:

default = self._get_default_metavar_for_optional(action)

args_string = self._format_args(action, default)

return ', '.join(action.option_strings) + ' ' + args_string

def _metavar_formatter(self, action, default_metavar):

if action.metavar is not None:

result = action.metavar

elif action.choices is not None:

choice_strs = [str(choice) for choice in action.choices]

result = '{%s}' % ','.join(choice_strs)

else:

result = default_metavar

def format(tuple_size):

if isinstance(result, tuple):

return result

else:

return (result, ) * tuple_size

return format

def _format_args(self, action, default_metavar):

get_metavar = self._metavar_formatter(action, default_metavar)

if action.nargs is None:

result = '%s' % get_metavar(1)

elif action.nargs == OPTIONAL:

result = '[%s]' % get_metavar(1)

elif action.nargs == ZERO_OR_MORE:

metavar = get_metavar(1)

if len(metavar) == 2:

result = '[%s [%s ...]]' % metavar

else:

result = '[%s ...]' % metavar

elif action.nargs == ONE_OR_MORE:

result = '%s [%s ...]' % get_metavar(2)

elif action.nargs == REMAINDER:

result = '...'

elif action.nargs == PARSER:

result = '%s ...' % get_metavar(1)

elif action.nargs == SUPPRESS:

result = ''

else:

try:

formats = ['%s' for _ in range(action.nargs)]

except TypeError:

raise ValueError("invalid nargs value") from None

result = ' '.join(formats) % get_metavar(action.nargs)

return result

def _expand_help(self, action):

params = dict(vars(action), prog=self._prog)

for name in list(params):

if params[name] is SUPPRESS:

del params[name]

for name in list(params):

if hasattr(params[name], '__name__'):

params[name] = params[name].__name__

if params.get('choices') is not None:

choices_str = ', '.join([str(c) for c in params['choices']])

params['choices'] = choices_str

return self._get_help_string(action) % params

def _iter_indented_subactions(self, action):

try:

get_subactions = action._get_subactions

except AttributeError:

pass

else:

self._indent()

yield from get_subactions()

self._dedent()

def _split_lines(self, text, width):

text = self._whitespace_matcher.sub(' ', text).strip()

# The textwrap module is used only for formatting help.

# Delay its import for speeding up the common usage of argparse.

import textwrap

return textwrap.wrap(text, width)

def _fill_text(self, text, width, indent):

text = self._whitespace_matcher.sub(' ', text).strip()

import textwrap

return textwrap.fill(text, width,

initial_indent=indent,

subsequent_indent=indent)

def _get_help_string(self, action):

return action.help

def _get_default_metavar_for_optional(self, action):

return action.dest.upper()

def _get_default_metavar_for_positional(self, action):

return action.dest

class RawDescriptionHelpFormatter(HelpFormatter):

"""Help message formatter which retains any formatting in descriptions.

Only the name of this class is considered a public API. All the methods

provided by the class are considered an implementation detail.

"""

def _fill_text(self, text, width, indent):

return ''.join(indent + line for line in text.splitlines(keepends=True))

class RawTextHelpFormatter(RawDescriptionHelpFormatter):

"""Help message formatter which retains formatting of all help text.

Only the name of this class is considered a public API. All the methods

provided by the class are considered an implementation detail.

"""

def _split_lines(self, text, width):

return text.splitlines()

class ArgumentDefaultsHelpFormatter(HelpFormatter):

"""Help message formatter which adds default values to argument help.

Only the name of this class is considered a public API. All the methods

provided by the class are considered an implementation detail.

"""

def _get_help_string(self, action):

help = action.help

if help is None:

help = ''

if '%(default)' not in help:

if action.default is not SUPPRESS:

defaulting_nargs = [OPTIONAL, ZERO_OR_MORE]

if action.option_strings or action.nargs in defaulting_nargs:

help += _(' (default: %(default)s)')

return help

class MetavarTypeHelpFormatter(HelpFormatter):

"""Help message formatter which uses the argument 'type' as the default

metavar value (instead of the argument 'dest')

Only the name of this class is considered a public API. All the methods

provided by the class are considered an implementation detail.

"""

def _get_default_metavar_for_optional(self, action):

return action.type.__name__

def _get_default_metavar_for_positional(self, action):

return action.type.__name__

# =====================

# Options and Arguments

# =====================

def _get_action_name(argument):

if argument is None:

return None

elif argument.option_strings:

return '/'.join(argument.option_strings)

elif argument.metavar not in (None, SUPPRESS):

metavar = argument.metavar

if not isinstance(metavar, tuple):

return metavar

if argument.nargs == ZERO_OR_MORE and len(metavar) == 2:

return '%s[, %s]' % metavar

elif argument.nargs == ONE_OR_MORE:

return '%s[, %s]' % metavar

else:

return ', '.join(metavar)

elif argument.dest not in (None, SUPPRESS):

return argument.dest

elif argument.choices:

return '{' + ','.join(argument.choices) + '}'

else:

return None

class ArgumentError(Exception):

"""An error from creating or using an argument (optional or positional).

The string value of this exception is the message, augmented with

information about the argument that caused it.

"""

def __init__(self, argument, message):

self.argument_name = _get_action_name(argument)

self.message = message

def __str__(self):

if self.argument_name is None:

format = '%(message)s'

else:

format = _('argument %(argument_name)s: %(message)s')

return format % dict(message=self.message,

argument_name=self.argument_name)

class ArgumentTypeError(Exception):

"""An error from trying to convert a command line string to a type."""

pass

# ==============

# Action classes

# ==============

class Action(_AttributeHolder):

"""Information about how to convert command line strings to Python objects.

Action objects are used by an ArgumentParser to represent the information

needed to parse a single argument from one or more strings from the

command line. The keyword arguments to the Action constructor are also

all attributes of Action instances.

Keyword Arguments:

- option_strings -- A list of command-line option strings which

should be associated with this action.

- dest -- The name of the attribute to hold the created object(s)

- nargs -- The number of command-line arguments that should be

consumed. By default, one argument will be consumed and a single

value will be produced. Other values include:

- N (an integer) consumes N arguments (and produces a list)

- '?' consumes zero or one arguments

- '*' consumes zero or more arguments (and produces a list)

- '+' consumes one or more arguments (and produces a list)

Note that the difference between the default and nargs=1 is that

with the default, a single value will be produced, while with

nargs=1, a list containing a single value will be produced.

- const -- The value to be produced if the option is specified and the

option uses an action that takes no values.

- default -- The value to be produced if the option is not specified.

- type -- A callable that accepts a single string argument, and

returns the converted value. The standard Python types str, int,

float, and complex are useful examples of such callables. If None,

str is used.

- choices -- A container of values that should be allowed. If not None,

after a command-line argument has been converted to the appropriate

type, an exception will be raised if it is not a member of this

collection.

- required -- True if the action must always be specified at the

command line. This is only meaningful for optional command-line

arguments.

- help -- The help string describing the argument.

- metavar -- The name to be used for the option's argument with the

help string. If None, the 'dest' value will be used as the name.

"""

def __init__(self,

option_strings,

dest,

nargs=None,

const=None,

default=None,

type=None,

choices=None,

required=False,

help=None,

metavar=None,

deprecated=False):

self.option_strings = option_strings

self.dest = dest

self.nargs = nargs

self.const = const

self.default = default

self.type = type

self.choices = choices

self.required = required

self.help = help

self.metavar = metavar

self.deprecated = deprecated

def _get_kwargs(self):

names = [

'option_strings',

'dest',

'nargs',

'const',

'default',

'type',

'choices',

'required',

'help',

'metavar',

'deprecated',

]

return [(name, getattr(self, name)) for name in names]

def format_usage(self):

return self.option_strings[0]

def __call__(self, parser, namespace, values, option_string=None):

raise NotImplementedError(_('.__call__() not defined'))

# FIXME: remove together with `BooleanOptionalAction` deprecated arguments.

_deprecated_default = object()

class BooleanOptionalAction(Action):

def __init__(self,

option_strings,

dest,

default=None,

type=_deprecated_default,

choices=_deprecated_default,

required=False,

help=None,

metavar=_deprecated_default,

deprecated=False):

_option_strings = []

for option_string in option_strings:

_option_strings.append(option_string)

if option_string.startswith('--'):

option_string = '--no-' + option_string[2:]

_option_strings.append(option_string)

# We need `_deprecated` special value to ban explicit arguments that

# match default value. Like:

# parser.add_argument('-f', action=BooleanOptionalAction, type=int)

for field_name in ('type', 'choices', 'metavar'):

if locals()[field_name] is not _deprecated_default:

import warnings

warnings._deprecated(

field_name,

"{name!r} is deprecated as of Python 3.12 and will be "

"removed in Python {remove}.",

remove=(3, 14))

if type is _deprecated_default:

type = None

if choices is _deprecated_default:

choices = None

if metavar is _deprecated_default:

metavar = None

super().__init__(

option_strings=_option_strings,

dest=dest,

nargs=0,

default=default,

type=type,

choices=choices,

required=required,

help=help,

metavar=metavar,

deprecated=deprecated)

def __call__(self, parser, namespace, values, option_string=None):

if option_string in self.option_strings:

setattr(namespace, self.dest, not option_string.startswith('--no-'))

def format_usage(self):

return ' | '.join(self.option_strings)

class _StoreAction(Action):

def __init__(self,

option_strings,

dest,

nargs=None,

const=None,

default=None,

type=None,

choices=None,

required=False,

help=None,

metavar=None,

deprecated=False):

if nargs == 0:

raise ValueError('nargs for store actions must be != 0; if you '

'have nothing to store, actions such as store '

'true or store const may be more appropriate')

if const is not None and nargs != OPTIONAL:

raise ValueError('nargs must be %r to supply const' % OPTIONAL)

super(_StoreAction, self).__init__(

option_strings=option_strings,

dest=dest,

nargs=nargs,

const=const,

default=default,

type=type,

choices=choices,

required=required,

help=help,

metavar=metavar,

deprecated=deprecated)

def __call__(self, parser, namespace, values, option_string=None):

setattr(namespace, self.dest, values)

class _StoreConstAction(Action):

def __init__(self,

option_strings,

dest,

const=None,

default=None,

required=False,

help=None,

metavar=None,

deprecated=False):

super(_StoreConstAction, self).__init__(

option_strings=option_strings,

dest=dest,

nargs=0,

const=const,

default=default,

required=required,

help=help,

deprecated=deprecated)

def __call__(self, parser, namespace, values, option_string=None):

setattr(namespace, self.dest, self.const)

class _StoreTrueAction(_StoreConstAction):

def __init__(self,

option_strings,

dest,

default=False,

required=False,

help=None,

deprecated=False):

super(_StoreTrueAction, self).__init__(

option_strings=option_strings,

dest=dest,

const=True,

deprecated=deprecated,

required=required,

help=help,

default=default)

class _StoreFalseAction(_StoreConstAction):

def __init__(self,

option_strings,

dest,

default=True,

required=False,

help=None,