# -*- coding: utf-8 -*-

# Copyright © 2006-2009 Steven J. Bethard <[email protected]>.

#

# Licensed under the Apache License, Version 2.0 (the "License"); you may not

# use this file except in compliance with the License. You may obtain a copy

# of the License at

#

# http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

# License for the specific language governing permissions and limitations

# under the License.

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

def _(s):

return s

try:

_set = set

except NameError:

from sets import Set as _set

try:

_basestring = basestring

except NameError:

_basestring = str

try:

_sorted = sorted

except NameError:

def _sorted(iterable, reverse=False):

result = list(iterable)

result.sort()

if reverse:

result.reverse()

return result

def _callable(obj):

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

# silence Python 2.6 buggy warnings about Exception.message

if _sys.version_info[:2] == (2, 6):

import warnings

warnings.filterwarnings(

action='ignore',

message='BaseException.message has been deprecated as of Python 2.6',

category=DeprecationWarning,

module='argparse')

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,