# Author: Steven J. Bethard <steven.bethard@gmail.com>.

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

    'Namespace',

    'Action',

    'FileType',

    'HelpFormatter',

    'RawDescriptionHelpFormatter',

    'RawTextHelpFormatter',

    'ArgumentDefaultsHelpFormatter',

]

import copy as _copy

import os as _os

import re as _re

import sys as _sys

import textwrap as _textwrap

from gettext import gettext as _

def _callable(obj):

    return hasattr(obj, '__call__') or hasattr(obj, '__bases__')

SUPPRESS = '==SUPPRESS=='

OPTIONAL = '?'

ZERO_OR_MORE = '*'

ONE_OR_MORE = '+'

PARSER = 'A...'

REMAINDER = '...'

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

# 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 = []

        for arg in self._get_args():

            arg_strings.append(repr(arg))

        for name, value in self._get_kwargs():

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

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

    def _get_kwargs(self):

        return sorted(self.__dict__.items())

    def _get_args(self):

        return []

def _ensure_value(namespace, name, value):

    if getattr(namespace, name, None) is None:

        setattr(namespace, name, value)

    return getattr(namespace, name)

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

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

            try:

                width = int(_os.environ['COLUMNS'])

            except (KeyError, ValueError):

                width = 80

            width -= 2

        self._prog = prog

        self._indent_increment = indent_increment

        self._max_help_position = max_help_position

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

        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

            for func, args in self.items:

                func(*args)

            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 = '%*s%s:\n' % (current_indent, '', self.heading)

            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

            invocations = [get_invocation(action)]

            for subaction in self._iter_indented_subactions(action):

                invocations.append(get_invocation(subaction))

            # update the maximum item length

            invocation_length = max([len(s) for s in invocations])

            action_length = invocation_length + self._current_indent

            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

                part_regexp = r'\(.*?\)+|\[.*?\]+|\S+'

                opt_usage = format(optionals, groups)

                pos_usage = format(positionals, groups)

                opt_parts = _re.findall(part_regexp, opt_usage)

                pos_parts = _re.findall(part_regexp, pos_usage)

                assert ' '.join(opt_parts) == opt_usage

                assert ' '.join(pos_parts) == pos_usage

                # helper for wrapping lines

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

                    lines = []

                    line = []

                    if prefix is not None:

                        line_len = len(prefix) - 1

                    else:

                        line_len = len(indent) - 1

                    for part in parts:

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

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

                            line = []

                            line_len = len(indent) - 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][len(indent):]

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

        # find group indices and identify actions in groups

        group_actions = set()

        inserts = {}

        for group in groups:

            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:

                    for action in group._group_actions:

                        group_actions.add(action)

                    if not group.required:

                        inserts[start] = '['

                        inserts[end] = ']'

                    else:

                        inserts[start] = '('

                        inserts[end] = ')'

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

                        inserts[i] = '|'

        # collect all actions format strings

        parts = []

        for i, action in enumerate(actions):

            # suppressed arguments are marked with None

            # remove | separators for suppressed arguments

            if action.help is SUPPRESS:

                parts.append(None)

                if inserts.get(i) == '|':

                    inserts.pop(i)

                elif inserts.get(i + 1) == '|':

                    inserts.pop(i + 1)

            # produce all arg strings

            elif not action.option_strings:

                part = self._format_args(action, action.dest)

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

                if action in group_actions:

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

                        part = part[1:-1]

                # add the action string to the list

                parts.append(part)

            # 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 = '%s' % option_string

                # if the Optional takes a value, format is:

                #    -s ARGS or --long ARGS

                else:

                    default = action.dest.upper()

                    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)

        # insert things at the necessary indices

        for i in sorted(inserts, reverse=True):

            parts[i:i] = [inserts[i]]

        # join all the action items with spaces

        text = ' '.join([item for item in parts if item is not None])

        # clean up separators for mutually exclusive groups

        open = r'[\[(]'

        close = r'[\])]'

        text = _re.sub(r'(%s) ' % open, r'\1', text)

        text = _re.sub(r' (%s)' % close, r'\1', text)

        text = _re.sub(r'%s *%s' % (open, close), r'', text)

        text = _re.sub(r'\(([^|]*)\)', r'\1', text)

        text = text.strip()

        # return the text

        return text

    def _format_text(self, text):

        if '%(prog)' in text:

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

        text_width = self._width - self._current_indent

        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 = self._width - help_position

        action_width = help_position - self._current_indent - 2

        action_header = self._format_action_invocation(action)

        # ho nelp; 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:

            help_text = self._expand_help(action)

            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:

            metavar, = self._metavar_formatter(action, action.dest)(1)

            return metavar

        else:

            parts = []

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

            #    -s, --long

            if action.nargs == 0:

                parts.extend(action.option_strings)

            # if the Optional takes a value, format is:

            #    -s ARGS, --long ARGS

            else:

                default = action.dest.upper()

                args_string = self._format_args(action, default)

                for option_string in action.option_strings:

                    parts.append('%s %s' % (option_string, args_string))

            return ', '.join(parts)

    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:

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

        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)

        else:

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

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

            for subaction in get_subactions():

                yield subaction

            self._dedent()

    def _split_lines(self, text, width):

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

        return _textwrap.wrap(text, width)

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

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

        return _textwrap.fill(text, width, initial_indent=indent,

                                           subsequent_indent=indent)

    def _get_help_string(self, action):

        return action.help

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(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 '%(default)' not in action.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

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

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

        return argument.metavar

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

        return argument.dest

    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 -- The type which the command-line arguments should be converted

            to, should be one of 'string', 'int', 'float', 'complex' or a

            callable object that accepts a single string argument. If None,

            'string' is assumed.

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

        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

    def _get_kwargs(self):

        names = [

            'option_strings',

            'dest',

            'nargs',

            'const',

            'default',

            'type',

            'choices',

            'help',

            'metavar',

        ]

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

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

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

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

        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)

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

        setattr(namespace, self.dest, values)

class _StoreConstAction(Action):

    def __init__(self,

                 option_strings,

                 dest,

                 const,

                 default=None,

                 required=False,

                 help=None,

                 metavar=None):

        super(_StoreConstAction, self).__init__(

            option_strings=option_strings,

            dest=dest,

            nargs=0,

            const=const,

            default=default,

            required=required,

            help=help)

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

        super(_StoreTrueAction, self).__init__(

            option_strings=option_strings,

            dest=dest,

            const=True,

            default=default,

            required=required,

            help=help)

class _StoreFalseAction(_StoreConstAction):

    def __init__(self,

                 option_strings,

                 dest,

                 default=True,

                 required=False,

                 help=None):

        super(_StoreFalseAction, self).__init__(

            option_strings=option_strings,

            dest=dest,

            const=False,

            default=default,

            required=required,

            help=help)

class _AppendAction(Action):

    def __init__(self,

                 option_strings,

                 dest,

                 nargs=None,

                 const=None,

                 default=None,

                 type=None,

                 choices=None,

                 required=False,

                 help=None,

                 metavar=None):

        if nargs == 0:

            raise ValueError('nargs for append actions must be > 0; if arg '

                             'strings are not supplying the value to append, '

                             'the append const action may be more appropriate')

        if const is not None and nargs != OPTIONAL:

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

        super(_AppendAction, self).__init__(

            option_strings=option_strings,

            dest=dest,

            nargs=nargs,

            const=const,

            default=default,

            type=type,

            choices=choices,

            required=required,

            help=help,

            metavar=metavar)

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

        items = _copy.copy(_ensure_value(namespace, self.dest, []))

        items.append(values)

        setattr(namespace, self.dest, items)

class _AppendConstAction(Action):

    def __init__(self,

                 option_strings,

                 dest,

                 const,

                 default=None,

                 required=False,

                 help=None,

                 metavar=None):

        super(_AppendConstAction, self).__init__(

            option_strings=option_strings,

            dest=dest,

            nargs=0,

            const=const,

            default=default,

            required=required,

            help=help,

            metavar=metavar)

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

        items = _copy.copy(_ensure_value(namespace, self.dest, []))

        items.append(self.const)

        setattr(namespace, self.dest, items)

class _CountAction(Action):

    def __init__(self,

                 option_strings,

                 dest,

                 default=None,

                 required=False,

                 help=None):

        super(_CountAction, self).__init__(

            option_strings=option_strings,

            dest=dest,

            nargs=0,

            default=default,

            required=required,

            help=help)

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

        new_count = _ensure_value(namespace, self.dest, 0) + 1

        setattr(namespace, self.dest, new_count)

class _HelpAction(Action):

    def __init__(self,

                 option_strings,

                 dest=SUPPRESS,

                 default=SUPPRESS,

                 help=None):

        super(_HelpAction, self).__init__(

            option_strings=option_strings,

            dest=dest,

            default=default,

            nargs=0,

            help=help)

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

        parser.print_help()

        parser.exit()

class _VersionAction(Action):

    def __init__(self,

                 option_strings,

                 version=None,

                 dest=SUPPRESS,

                 default=SUPPRESS,

                 help="show program's version number and exit"):

        super(_VersionAction, self).__init__(

            option_strings=option_strings,

            dest=dest,

            default=default,