__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

import warnings

from gettext import gettext as _, ngettext

SUPPRESS = '==SUPPRESS=='

OPTIONAL = '?'

ZERO_OR_MORE = '*'

ONE_OR_MORE = '+'

PARSER = 'A...'

REMAINDER = '...'

_UNRECOGNIZED_ARGS_ATTR = '_unrecognized_args'

class _AttributeHolder(object):

"""Abstract base class that provides __repr__.

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)

class HelpFormatter(object):

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

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 = '%*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(map(len, 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|$)|'

r'\[.*?\]+(?=\s|$)|'

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 and line:

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:

if not group._group_actions:

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

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:

if start in inserts:

inserts[start] += ' ['

else:

inserts[start] = '['

if end in inserts:

inserts[end] += ']'

else:

inserts[end] = ']'

else:

if start in inserts:

inserts[start] += ' ('

else:

inserts[start] = '('

if end in inserts:

inserts[end] += ')'

else:

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:

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]

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

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

metavar, = self._metavar_formatter(action, default)(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 = self._get_default_metavar_for_optional(action)

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:

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.

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.

def _split_lines(self, text, width):

return text.splitlines()

class ArgumentDefaultsHelpFormatter(HelpFormatter):

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

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

def _get_default_metavar_for_optional(self, action):

return action.type.__name__

def _get_default_metavar_for_positional(self, action):

return action.type.__name__

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

elif argument.choices:

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

else:

return None

class ArgumentError(Exception):

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

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

class Action(_AttributeHolder):

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

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

'required',

'help',

'metavar',

]

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,

type=None,

choices=None,

required=False,

help=None,

metavar=None):

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

super().__init__(

option_strings=_option_strings,

dest=dest,

nargs=0,

default=default,

type=type,

choices=choices,

required=required,

help=help,

metavar=metavar)

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

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=None,

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