# 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',

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

args = parser.parse_args()

with (open(args.log, 'w') if args.log is not None

else contextlib.nullcontext(sys.stdout)) as log:

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

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. Deprecated since

Python 3.14.

- 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.)

"""

__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+')

def _set_color(self, color):

from _colorize import can_colorize, decolor, get_theme

if color and can_colorize():

self._theme = get_theme(force_color=True).argparse

self._decolor = decolor

else:

self._theme = get_theme(force_no_color=True).argparse

self._decolor = lambda text: text

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

# 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)

t = self.formatter._theme

heading = (

f'{" " * current_indent}'

f'{t.heading}{heading_text}{t.reset}\n'

)

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 = lambda x: self._decolor(self._format_action_invocation(x))

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):

t = self._theme

if prefix is None:

prefix = _('usage: ')

# if usage is specified, use that

if usage is not None:

usage = (

t.prog_extra

+ usage

% {"prog": f"{t.prog}{self._prog}{t.reset}{t.prog_extra}"}

+ t.reset

)

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

elif usage is None and not actions:

usage = f"{t.prog}{self._prog}{t.reset}"

# if optionals and positionals are available, calculate usage

elif usage is None:

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

parts, pos_start = self._get_actions_usage_parts(actions, groups)

# build full usage string

usage = ' '.join(filter(None, [prog, *parts]))

# wrap the usage parts if it's too long

text_width = self._width - self._current_indent

if len(prefix) + len(self._decolor(usage)) > text_width:

# break usage into wrappable parts

opt_parts = parts[:pos_start]

pos_parts = parts[pos_start:]

# 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:

part_len = len(self._decolor(part))

if line_len + 1 + part_len > text_width and line:

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

line = []

line_len = indent_length - 1

line.append(part)

line_len += part_len + 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

prog_len = len(self._decolor(prog))

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

indent = ' ' * (len(prefix) + prog_len + 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)

usage = usage.removeprefix(prog)

usage = f"{t.prog}{prog}{t.reset}{usage}"

# prefix with 'usage:'

return f'{t.usage}{prefix}{t.reset}{usage}\n\n'

def _is_long_option(self, string):

return len(string) > 2

def _get_actions_usage_parts(self, actions, groups):

"""Get usage parts with split index for optionals/positionals.

Returns (parts, pos_start) where pos_start is the index in parts

where positionals begin.

This preserves mutually exclusive group formatting across the

optionals/positionals boundary (gh-75949).

"""

actions = [action for action in actions if action.help is not SUPPRESS]

# group actions by mutually exclusive groups

action_groups = dict.fromkeys(actions)

for group in groups:

for action in group._group_actions:

if action in action_groups:

action_groups[action] = group

# positional arguments keep their position

positionals = []

for action in actions:

if not action.option_strings:

group = action_groups.pop(action)

if group:

group_actions = [

action2 for action2 in group._group_actions

if action2.option_strings and

action_groups.pop(action2, None)

] + [action]

positionals.append((group.required, group_actions))

else:

positionals.append((None, [action]))

# the remaining optional arguments are sorted by the position of

# the first option in the group

optionals = []

for action in actions:

if action.option_strings and action in action_groups:

group = action_groups.pop(action)

if group:

group_actions = [action] + [

action2 for action2 in group._group_actions

if action2.option_strings and

action_groups.pop(action2, None)

]

optionals.append((group.required, group_actions))

else:

optionals.append((None, [action]))

# collect all actions format strings

parts = []

t = self._theme

pos_start = None

for i, (required, group) in enumerate(optionals + positionals):

start = len(parts)

if i == len(optionals):

pos_start = start

in_group = len(group) > 1

for action in group:

# produce all arg strings

if 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 in_group:

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

part = part[1:-1]

part = t.summary_action + part + t.reset

# produce the first way to invoke the option in brackets

else:

option_string = action.option_strings[0]

if self._is_long_option(option_string):

option_color = t.summary_long_option

else:

option_color = t.summary_short_option

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

# -s or --long

if action.nargs == 0:

part = action.format_usage()

part = f"{option_color}{part}{t.reset}"

# 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 = (

f"{option_color}{option_string} "

f"{t.summary_label}{args_string}{t.reset}"

)

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

if not (action.required or required or in_group):

part = '[%s]' % part

# add the action string to the list

parts.append(part)

if in_group:

parts[start] = ('(' if required else '[') + parts[start]

for i in range(start, len(parts) - 1):

parts[i] += ' |'

parts[-1] += ')' if required else ']'

if pos_start is None:

pos_start = len(parts)

return parts, pos_start

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)

action_header_no_color = self._decolor(action_header)

# 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_no_color) <= action_width:

# calculate widths without color codes

action_header_color = action_header

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

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

# swap in the colored header

action_header = action_header.replace(

action_header_no_color, action_header_color

)

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):

t = self._theme

if not action.option_strings:

default = self._get_default_metavar_for_positional(action)

return (

t.action

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

+ t.reset

)

else:

def color_option_strings(strings):

parts = []

for s in strings:

if self._is_long_option(s):

parts.append(f"{t.long_option}{s}{t.reset}")

else:

parts.append(f"{t.short_option}{s}{t.reset}")

return parts

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

# -s, --long

if action.nargs == 0:

option_strings = color_option_strings(action.option_strings)

return ', '.join(option_strings)

# if the Optional takes a value, format is:

# -s, --long ARGS

else:

default = self._get_default_metavar_for_optional(action)

option_strings = color_option_strings(action.option_strings)

args_string = (

f"{t.label}{self._format_args(action, default)}{t.reset}"

)

return ', '.join(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:

result = '{%s}' % ','.join(map(str, action.choices))

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):

help_string = self._get_help_string(action)

if '%' not in help_string:

return help_string

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

for name in list(params):

value = params[name]

if value is SUPPRESS:

del params[name]

elif hasattr(value, '__name__'):

params[name] = value.__name__

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

params['choices'] = ', '.join(map(str, params['choices']))

return help_string % 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:

t = self._theme

default_str = _(" (default: %(default)s)")

prefix, suffix = default_str.split("%(default)s")

help += (

f" {t.default}{prefix.lstrip()}"

f"{t.default_value}%(default)s"

f"{t.default}{suffix}{t.reset}"

)

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 '{%s}' % ','.join(map(str, 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')

class BooleanOptionalAction(Action):

def __init__(self,

option_strings,

dest,

default=None,

required=False,

help=None,

deprecated=False):

_option_strings = []

neg_option_strings = []

for option_string in option_strings:

_option_strings.append(option_string)

if len(option_string) > 2 and option_string[0] == option_string[1]:

# two-dash long option: '--foo' -> '--no-foo'

if option_string.startswith('no-', 2):

raise ValueError(f'invalid option name {option_string!r} '

f'for BooleanOptionalAction')

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

_option_strings.append(option_string)

neg_option_strings.append(option_string)

elif len(option_string) > 2 and option_string[0] != option_string[1]:

# single-dash long option: '-foo' -> '-nofoo'

if option_string.startswith('no', 1):

raise ValueError(f'invalid option name {option_string!r} '

f'for BooleanOptionalAction')

option_string = option_string[:1] + 'no' + option_string[1:]

_option_strings.append(option_string)

neg_option_strings.append(option_string)

super().__init__(

option_strings=_option_strings,

dest=dest,

nargs=0,

default=default,

required=required,

help=help,

deprecated=deprecated)

self.neg_option_strings = neg_option_strings

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

if option_string in self.option_strings:

setattr(namespace, self.dest, option_string not in self.neg_option_strings)

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,