[thunderbird-lightning/el6] Add mozilla-python.patch from TB el6
Orion Poplawski
orion at fedoraproject.org
Sun Dec 15 05:17:52 UTC 2013
commit d1fe355a4d3f225abf3904b2062300d2d212dcdd
Author: Orion Poplawski <orion at cora.nwra.com>
Date: Sat Dec 14 22:17:56 2013 -0700
Add mozilla-python.patch from TB el6
mozilla-python.patch | 2820 ++++++++++++++++++++++++++++++++++++++++++++
thunderbird-lightning.spec | 4 +
2 files changed, 2824 insertions(+), 0 deletions(-)
---
diff --git a/mozilla-python.patch b/mozilla-python.patch
new file mode 100644
index 0000000..5c2114e
--- /dev/null
+++ b/mozilla-python.patch
@@ -0,0 +1,2820 @@
+diff -up mozilla-esr24/build/virtualenv/populate_virtualenv.py.python mozilla-esr24/build/virtualenv/populate_virtualenv.py
+--- mozilla-esr24/build/virtualenv/populate_virtualenv.py.python 2013-09-11 05:22:20.000000000 +0200
++++ mozilla-esr24/build/virtualenv/populate_virtualenv.py 2013-10-22 14:29:24.560993882 +0200
+@@ -16,7 +16,8 @@ import sys
+
+ # Minimum version of Python required to build.
+ MINIMUM_PYTHON_MAJOR = 2
+-MINIMUM_PYTHON_MINOR = 7
++# Override for RHEL
++MINIMUM_PYTHON_MINOR = 4
+
+
+ class VirtualenvManager(object):
+diff -up mozilla-esr24/dom/bindings/Codegen.py.python mozilla-esr24/dom/bindings/Codegen.py
+--- mozilla-esr24/dom/bindings/Codegen.py.python 2013-09-11 05:22:23.000000000 +0200
++++ mozilla-esr24/dom/bindings/Codegen.py 2013-10-22 14:29:24.561993885 +0200
+@@ -8440,7 +8440,7 @@ class CGBindingRoot(CGThing):
+ def getParentDescriptor(desc):
+ if not desc.interface.parent:
+ return set()
+- return { desc.getDescriptor(desc.interface.parent.identifier.name) }
++ return set ([desc.getDescriptor(desc.interface.parent.identifier.name)])
+ for x in dependencySortObjects(jsImplemented, getParentDescriptor,
+ lambda d: d.interface.identifier.name):
+ cgthings.append(CGCallbackInterface(x))
+diff -up mozilla-esr24/python/mach/mach/logging.py.python mozilla-esr24/python/mach/mach/logging.py
+--- mozilla-esr24/python/mach/mach/logging.py.python 2013-09-11 05:22:49.000000000 +0200
++++ mozilla-esr24/python/mach/mach/logging.py 2013-10-22 14:29:24.562993887 +0200
+@@ -18,6 +18,10 @@ import logging
+ import sys
+ import time
+
++class NullHandler(logging.Handler):
++ def emit(self, record):
++ pass
++logging.NullHandler = NullHandler
+
+ def format_seconds(total):
+ """Format number of seconds to MM:SS.DD form."""
+@@ -166,7 +170,7 @@ class LoggingManager(object):
+ """Enable JSON logging on the specified file object."""
+
+ # Configure the consumer of structured messages.
+- handler = logging.StreamHandler(stream=fh)
++ handler = logging.StreamHandler(fh)
+ handler.setFormatter(StructuredJSONFormatter())
+ handler.setLevel(logging.DEBUG)
+
+@@ -188,7 +192,7 @@ class LoggingManager(object):
+ write_interval=write_interval)
+ formatter.set_terminal(self.terminal)
+
+- handler = logging.StreamHandler(stream=fh)
++ handler = logging.StreamHandler(fh)
+ handler.setFormatter(formatter)
+ handler.setLevel(level)
+
+diff -up mozilla-esr24/python/mozbuild/mozbuild/backend/base.py.python mozilla-esr24/python/mozbuild/mozbuild/backend/base.py
+--- mozilla-esr24/python/mozbuild/mozbuild/backend/base.py.python 2013-09-11 05:22:49.000000000 +0200
++++ mozilla-esr24/python/mozbuild/mozbuild/backend/base.py 2013-10-22 14:29:24.562993887 +0200
+@@ -57,13 +57,13 @@ class BackendConsumeSummary(object):
+
+ @property
+ def reader_summary(self):
+- return 'Finished reading {:d} moz.build files into {:d} descriptors in {:.2f}s'.format(
++ return 'Finished reading {0:d} moz.build files into {1:d} descriptors in {2:.2f}s'.format(
+ self.mozbuild_count, self.object_count,
+ self.mozbuild_execution_time)
+
+ @property
+ def backend_summary(self):
+- return 'Backend executed in {:.2f}s'.format(self.backend_execution_time)
++ return 'Backend executed in {0:.2f}s'.format(self.backend_execution_time)
+
+ def backend_detailed_summary(self):
+ """Backend summary to be supplied by BuildBackend implementations."""
+@@ -72,7 +72,7 @@ class BackendConsumeSummary(object):
+ @property
+ def total_summary(self):
+ efficiency_value = self.cpu_time / self.wall_time if self.wall_time else 100
+- return 'Total wall time: {:.2f}s; CPU time: {:.2f}s; Efficiency: {:.0%}'.format(
++ return 'Total wall time: {0:.2f}s; CPU time: {1:.2f}s; Efficiency: {2:.0%}'.format(
+ self.wall_time, self.cpu_time, efficiency_value)
+
+ def summaries(self):
+diff -up mozilla-esr24/python/mozbuild/mozbuild/backend/recursivemake.py.python mozilla-esr24/python/mozbuild/mozbuild/backend/recursivemake.py
+--- mozilla-esr24/python/mozbuild/mozbuild/backend/recursivemake.py.python 2013-09-11 05:22:49.000000000 +0200
++++ mozilla-esr24/python/mozbuild/mozbuild/backend/recursivemake.py 2013-10-22 14:29:24.562993887 +0200
+@@ -114,7 +114,7 @@ class RecursiveMakeBackend(BuildBackend)
+ self.summary.unchanged_count = 0
+
+ def detailed(summary):
+- return '{:d} total backend files. {:d} created; {:d} updated; {:d} unchanged'.format(
++ return '{0:d} total backend files. {1:d} created; {2:d} updated; {3:d} unchanged'.format(
+ summary.managed_count, summary.created_count,
+ summary.updated_count, summary.unchanged_count)
+
+diff -up mozilla-esr24/python/mozbuild/mozbuild/frontend/data.py.python mozilla-esr24/python/mozbuild/mozbuild/frontend/data.py
+--- mozilla-esr24/python/mozbuild/mozbuild/frontend/data.py.python 2013-09-11 05:22:49.000000000 +0200
++++ mozilla-esr24/python/mozbuild/mozbuild/frontend/data.py 2013-10-22 14:29:24.562993887 +0200
+@@ -17,7 +17,7 @@ structures.
+
+ from __future__ import unicode_literals
+
+-from collections import OrderedDict
++from ordereddict import OrderedDict
+
+
+ class TreeMetadata(object):
+diff -up mozilla-esr24/python/mozbuild/mozbuild/frontend/reader.py.python mozilla-esr24/python/mozbuild/mozbuild/frontend/reader.py
+--- mozilla-esr24/python/mozbuild/mozbuild/frontend/reader.py.python 2013-09-11 05:22:49.000000000 +0200
++++ mozilla-esr24/python/mozbuild/mozbuild/frontend/reader.py 2013-10-22 14:29:24.562993887 +0200
+@@ -52,7 +52,7 @@ from .sandbox_symbols import (
+ )
+
+
+-if sys.version_info.major == 2:
++if sys.version_info[0] == 2:
+ text_type = unicode
+ type_type = types.TypeType
+ else:
+diff -up mozilla-esr24/python/mozbuild/mozbuild/frontend/sandbox_symbols.py.python mozilla-esr24/python/mozbuild/mozbuild/frontend/sandbox_symbols.py
+--- mozilla-esr24/python/mozbuild/mozbuild/frontend/sandbox_symbols.py.python 2013-09-11 05:22:49.000000000 +0200
++++ mozilla-esr24/python/mozbuild/mozbuild/frontend/sandbox_symbols.py 2013-10-22 14:29:24.563993889 +0200
+@@ -17,7 +17,7 @@ the Sandbox consists of, you've come to
+
+ from __future__ import unicode_literals
+
+-from collections import OrderedDict
++from ordereddict import OrderedDict
+ from mozbuild.util import (
+ HierarchicalStringList,
+ StrictOrderingOnAppendList,
+diff -up mozilla-esr24/python/mozbuild/mozpack/chrome/flags.py.python mozilla-esr24/python/mozbuild/mozpack/chrome/flags.py
+--- mozilla-esr24/python/mozbuild/mozpack/chrome/flags.py.python 2013-09-11 05:22:49.000000000 +0200
++++ mozilla-esr24/python/mozbuild/mozpack/chrome/flags.py 2013-10-22 14:29:24.563993889 +0200
+@@ -5,7 +5,7 @@
+ import re
+ from distutils.version import LooseVersion
+ from mozpack.errors import errors
+-from collections import OrderedDict
++from ordereddict import OrderedDict
+
+
+ class Flag(object):
+diff -up mozilla-esr24/python/mozbuild/mozpack/copier.py.python mozilla-esr24/python/mozbuild/mozpack/copier.py
+--- mozilla-esr24/python/mozbuild/mozpack/copier.py.python 2013-09-11 05:22:49.000000000 +0200
++++ mozilla-esr24/python/mozbuild/mozpack/copier.py 2013-10-22 14:29:24.563993889 +0200
+@@ -11,10 +11,9 @@ from mozpack.files import (
+ import mozpack.path
+ import errno
+ from collections import (
+- namedtuple,
+- OrderedDict,
++ namedtuple
+ )
+-
++from ordereddict import OrderedDict
+
+ def ensure_parent_dir(file):
+ '''Ensures the directory parent to the given file exists'''
+@@ -157,6 +156,7 @@ class FileCopier(FileRegistry):
+ destfile = os.path.normpath(os.path.join(destination, path))
+ dest_files.add(destfile)
+ ensure_parent_dir(destfile)
++ print "file.copy", destfile
+ file.copy(destfile, skip_if_older)
+
+ actual_dest_files = set()
+@@ -272,9 +272,12 @@ class Jarrer(FileRegistry, BaseFile):
+ old_jar = JarReader(fileobj=dest)
+ except Exception:
+ old_jar = []
+-
++ print "old jar", old_jar
++ for f in old_jar:
++ print f.filename, f
+ old_contents = dict([(f.filename, f) for f in old_jar])
+-
++ print "Old content", old_contents
++ print "JarWriter"
+ with JarWriter(fileobj=dest, compress=self.compress,
+ optimize=self.optimize) as jar:
+ for path, file in self:
+diff -up mozilla-esr24/python/mozbuild/mozpack/files.py.python mozilla-esr24/python/mozbuild/mozpack/files.py
+--- mozilla-esr24/python/mozbuild/mozpack/files.py.python 2013-09-11 05:22:49.000000000 +0200
++++ mozilla-esr24/python/mozbuild/mozpack/files.py 2013-10-22 14:29:24.563993889 +0200
+@@ -17,7 +17,7 @@ from io import BytesIO
+ from mozpack.errors import ErrorMessage
+ from mozpack.mozjar import JarReader
+ import mozpack.path
+-from collections import OrderedDict
++from ordereddict import OrderedDict
+
+
+ class Dest(object):
+@@ -150,8 +150,10 @@ class ExecutableFile(File):
+ return False
+ try:
+ if may_strip(dest):
++ print "strip", dest
+ strip(dest)
+ if may_elfhack(dest):
++ print "elfhack", dest
+ elfhack(dest)
+ except ErrorMessage:
+ os.remove(dest)
+diff -up mozilla-esr24/python/mozbuild/mozpack/mozjar.py.python mozilla-esr24/python/mozbuild/mozpack/mozjar.py
+--- mozilla-esr24/python/mozbuild/mozpack/mozjar.py.python 2013-09-11 05:22:49.000000000 +0200
++++ mozilla-esr24/python/mozbuild/mozpack/mozjar.py 2013-10-22 14:29:24.563993889 +0200
+@@ -10,7 +10,7 @@ from zipfile import (
+ ZIP_STORED,
+ ZIP_DEFLATED,
+ )
+-from collections import OrderedDict
++from ordereddict import OrderedDict
+ from urlparse import urlparse, ParseResult
+ import mozpack.path
+
+@@ -94,8 +94,6 @@ class JarStruct(object):
+ else:
+ size = sizes[t]
+ value = data[offset:offset + size]
+- if isinstance(value, memoryview):
+- value = value.tobytes()
+ if not name in sizes:
+ self._values[name] = value
+ else:
+@@ -122,8 +120,6 @@ class JarStruct(object):
+ assert data is not None
+ format, size = JarStruct.TYPE_MAPPING[type]
+ data = data[:size]
+- if isinstance(data, memoryview):
+- data = data.tobytes()
+ return struct.unpack('<' + format, data)[0], size
+
+ def serialize(self):
+@@ -261,12 +257,12 @@ class JarFileReader(object):
+ the file data.
+ '''
+ assert header['compression'] in [JAR_DEFLATED, JAR_STORED]
+- self._data = data
+ # Copy some local file header fields.
+ for name in ['filename', 'compressed_size',
+ 'uncompressed_size', 'crc32']:
+ setattr(self, name, header[name])
+ self.compressed = header['compression'] == JAR_DEFLATED
++ self._data = data[:header['compressed_size']]
+
+ def read(self, length=-1):
+ '''
+@@ -316,9 +312,7 @@ class JarFileReader(object):
+ return self._uncompressed_data
+ data = self.compressed_data
+ if self.compressed:
+- data = zlib.decompress(data.tobytes(), -MAX_WBITS)
+- else:
+- data = data.tobytes()
++ data = zlib.decompress(data, -MAX_WBITS)
+ if len(data) != self.uncompressed_size:
+ raise JarReaderError('Corrupted file? %s' % self.filename)
+ self._uncompressed_data = BytesIO(data)
+@@ -339,7 +333,7 @@ class JarReader(object):
+ data = fileobj.read()
+ else:
+ data = open(file, 'rb').read()
+- self._data = memoryview(data)
++ self._data = buffer(data)
+ # The End of Central Directory Record has a variable size because of
+ # comments it may contain, so scan for it from the end of the file.
+ offset = -CDIR_END_SIZE
+@@ -661,8 +655,6 @@ class Deflater(object):
+ self._data.write(data)
+ if self.compress:
+ if self._deflater:
+- if isinstance(data, memoryview):
+- data = data.tobytes()
+ self._deflated.write(self._deflater.compress(data))
+ else:
+ raise JarWriterError("Can't write after flush")
+diff -up mozilla-esr24/python/mozbuild/mozpack/unify.py.python mozilla-esr24/python/mozbuild/mozpack/unify.py
+--- mozilla-esr24/python/mozbuild/mozpack/unify.py.python 2013-09-11 05:22:49.000000000 +0200
++++ mozilla-esr24/python/mozbuild/mozpack/unify.py 2013-10-22 14:29:24.564993891 +0200
+@@ -19,7 +19,7 @@ import mozpack.path
+ import struct
+ import os
+ import subprocess
+-from collections import OrderedDict
++from ordereddict import OrderedDict
+
+
+ def may_unify_binary(file):
+diff -up mozilla-esr24/rebase/argparse.py.python mozilla-esr24/rebase/argparse.py
+--- mozilla-esr24/rebase/argparse.py.python 2013-10-22 16:49:19.310375183 +0200
++++ mozilla-esr24/rebase/argparse.py 2011-03-31 23:43:27.000000000 +0200
+@@ -0,0 +1,2362 @@
++# Author: Steven J. Bethard <steven.bethard at 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.2.1'
++__all__ = [
++ 'ArgumentParser',
++ 'ArgumentError',
++ 'ArgumentTypeError',
++ 'FileType',
++ 'HelpFormatter',
++ 'ArgumentDefaultsHelpFormatter',
++ 'RawDescriptionHelpFormatter',
++ 'RawTextHelpFormatter',
++ 'Namespace',
++ 'Action',
++ 'ONE_OR_MORE',
++ 'OPTIONAL',
++ 'PARSER',
++ 'REMAINDER',
++ 'SUPPRESS',
++ 'ZERO_OR_MORE',
++]
++
++
++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 _
++
++try:
++ set
++except NameError:
++ # for python < 2.4 compatibility (sets module is there since 2.3):
++ from sets import Set as set
++
++try:
++ basestring
++except NameError:
++ basestring = str
++
++try:
++ sorted
++except NameError:
++ # for python < 2.4 compatibility:
++ 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__')
++
++
++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 = []
++ 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:
++ if start in inserts:
++ inserts[start] += ' ['
++ else:
++ inserts[start] = '['
++ inserts[end] = ']'
++ else:
++ if start in inserts:
++ inserts[start] += ' ('
++ 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,
++ nargs=0,
++ help=help)
++ self.version = version
++
++ def __call__(self, parser, namespace, values, option_string=None):
++ version = self.version
++ if version is None:
++ version = parser.version
++ formatter = parser._get_formatter()
++ formatter.add_text(version)
++ parser.exit(message=formatter.format_help())
++
++
++class _SubParsersAction(Action):
++
++ class _ChoicesPseudoAction(Action):
++
++ def __init__(self, name, help):
++ sup = super(_SubParsersAction._ChoicesPseudoAction, self)
++ sup.__init__(option_strings=[], dest=name, help=help)
++
++ def __init__(self,
++ option_strings,
++ prog,
++ parser_class,
++ dest=SUPPRESS,
++ help=None,
++ metavar=None):
++
++ self._prog_prefix = prog
++ self._parser_class = parser_class
++ self._name_parser_map = {}
++ self._choices_actions = []
++
++ super(_SubParsersAction, self).__init__(
++ option_strings=option_strings,
++ dest=dest,
++ nargs=PARSER,
++ choices=self._name_parser_map,
++ help=help,
++ metavar=metavar)
++
++ def add_parser(self, name, **kwargs):
++ # set prog from the existing prefix
++ if kwargs.get('prog') is None:
++ kwargs['prog'] = '%s %s' % (self._prog_prefix, name)
++
++ # create a pseudo-action to hold the choice help
++ if 'help' in kwargs:
++ help = kwargs.pop('help')
++ choice_action = self._ChoicesPseudoAction(name, help)
++ self._choices_actions.append(choice_action)
++
++ # create the parser and add it to the map
++ parser = self._parser_class(**kwargs)
++ self._name_parser_map[name] = parser
++ return parser
++
++ def _get_subactions(self):
++ return self._choices_actions
++
++ def __call__(self, parser, namespace, values, option_string=None):
++ parser_name = values[0]
++ arg_strings = values[1:]
++
++ # set the parser name if requested
++ if self.dest is not SUPPRESS:
++ setattr(namespace, self.dest, parser_name)
++
++ # select the parser
++ try:
++ parser = self._name_parser_map[parser_name]
++ except KeyError:
++ tup = parser_name, ', '.join(self._name_parser_map)
++ msg = _('unknown parser %r (choices: %s)' % tup)
++ raise ArgumentError(self, msg)
++
++ # parse all the remaining options into the namespace
++ # store any unrecognized options on the object, so that the top
++ # level parser can decide what to do with them
++ namespace, arg_strings = parser.parse_known_args(arg_strings, namespace)
++ if arg_strings:
++ vars(namespace).setdefault(_UNRECOGNIZED_ARGS_ATTR, [])
++ getattr(namespace, _UNRECOGNIZED_ARGS_ATTR).extend(arg_strings)
++
++
++# ==============
++# Type classes
++# ==============
++
++class FileType(object):
++ """Factory for creating file object types
++
++ Instances of FileType are typically passed as type= arguments to the
++ ArgumentParser add_argument() method.
++
++ Keyword Arguments:
++ - mode -- A string indicating how the file is to be opened. Accepts the
++ same values as the builtin open() function.
++ - bufsize -- The file's desired buffer size. Accepts the same values as
++ the builtin open() function.
++ """
++
++ def __init__(self, mode='r', bufsize=None):
++ self._mode = mode
++ self._bufsize = bufsize
++
++ def __call__(self, string):
++ # the special argument "-" means sys.std{in,out}
++ if string == '-':
++ if 'r' in self._mode:
++ return _sys.stdin
++ elif 'w' in self._mode:
++ return _sys.stdout
++ else:
++ msg = _('argument "-" with mode %r' % self._mode)
++ raise ValueError(msg)
++
++ # all other arguments are used as file names
++ if self._bufsize:
++ return open(string, self._mode, self._bufsize)
++ else:
++ return open(string, self._mode)
++
++ def __repr__(self):
++ args = [self._mode, self._bufsize]
++ args_str = ', '.join([repr(arg) for arg in args if arg is not None])
++ return '%s(%s)' % (type(self).__name__, args_str)
++
++# ===========================
++# Optional and Positional Parsing
++# ===========================
++
++class Namespace(_AttributeHolder):
++ """Simple object for storing attributes.
++
++ Implements equality by attribute names and values, and provides a simple
++ string representation.
++ """
++
++ def __init__(self, **kwargs):
++ for name in kwargs:
++ setattr(self, name, kwargs[name])
++
++ __hash__ = None
++
++ def __eq__(self, other):
++ return vars(self) == vars(other)
++
++ def __ne__(self, other):
++ return not (self == other)
++
++ def __contains__(self, key):
++ return key in self.__dict__
++
++
++class _ActionsContainer(object):
++
++ def __init__(self,
++ description,
++ prefix_chars,
++ argument_default,
++ conflict_handler):
++ super(_ActionsContainer, self).__init__()
++
++ self.description = description
++ self.argument_default = argument_default
++ self.prefix_chars = prefix_chars
++ self.conflict_handler = conflict_handler
++
++ # set up registries
++ self._registries = {}
++
++ # register actions
++ self.register('action', None, _StoreAction)
++ self.register('action', 'store', _StoreAction)
++ self.register('action', 'store_const', _StoreConstAction)
++ self.register('action', 'store_true', _StoreTrueAction)
++ self.register('action', 'store_false', _StoreFalseAction)
++ self.register('action', 'append', _AppendAction)
++ self.register('action', 'append_const', _AppendConstAction)
++ self.register('action', 'count', _CountAction)
++ self.register('action', 'help', _HelpAction)
++ self.register('action', 'version', _VersionAction)
++ self.register('action', 'parsers', _SubParsersAction)
++
++ # raise an exception if the conflict handler is invalid
++ self._get_handler()
++
++ # action storage
++ self._actions = []
++ self._option_string_actions = {}
++
++ # groups
++ self._action_groups = []
++ self._mutually_exclusive_groups = []
++
++ # defaults storage
++ self._defaults = {}
++
++ # determines whether an "option" looks like a negative number
++ self._negative_number_matcher = _re.compile(r'^-\d+$|^-\d*\.\d+$')
++
++ # whether or not there are any optionals that look like negative
++ # numbers -- uses a list so it can be shared and edited
++ self._has_negative_number_optionals = []
++
++ # ====================
++ # Registration methods
++ # ====================
++ def register(self, registry_name, value, object):
++ registry = self._registries.setdefault(registry_name, {})
++ registry[value] = object
++
++ def _registry_get(self, registry_name, value, default=None):
++ return self._registries[registry_name].get(value, default)
++
++ # ==================================
++ # Namespace default accessor methods
++ # ==================================
++ def set_defaults(self, **kwargs):
++ self._defaults.update(kwargs)
++
++ # if these defaults match any existing arguments, replace
++ # the previous default on the object with the new one
++ for action in self._actions:
++ if action.dest in kwargs:
++ action.default = kwargs[action.dest]
++
++ def get_default(self, dest):
++ for action in self._actions:
++ if action.dest == dest and action.default is not None:
++ return action.default
++ return self._defaults.get(dest, None)
++
++
++ # =======================
++ # Adding argument actions
++ # =======================
++ def add_argument(self, *args, **kwargs):
++ """
++ add_argument(dest, ..., name=value, ...)
++ add_argument(option_string, option_string, ..., name=value, ...)
++ """
++
++ # if no positional args are supplied or only one is supplied and
++ # it doesn't look like an option string, parse a positional
++ # argument
++ chars = self.prefix_chars
++ if not args or len(args) == 1 and args[0][0] not in chars:
++ if args and 'dest' in kwargs:
++ raise ValueError('dest supplied twice for positional argument')
++ kwargs = self._get_positional_kwargs(*args, **kwargs)
++
++ # otherwise, we're adding an optional argument
++ else:
++ kwargs = self._get_optional_kwargs(*args, **kwargs)
++
++ # if no default was supplied, use the parser-level default
++ if 'default' not in kwargs:
++ dest = kwargs['dest']
++ if dest in self._defaults:
++ kwargs['default'] = self._defaults[dest]
++ elif self.argument_default is not None:
++ kwargs['default'] = self.argument_default
++
++ # create the action object, and add it to the parser
++ action_class = self._pop_action_class(kwargs)
++ if not _callable(action_class):
++ raise ValueError('unknown action "%s"' % action_class)
++ action = action_class(**kwargs)
++
++ # raise an error if the action type is not callable
++ type_func = self._registry_get('type', action.type, action.type)
++ if not _callable(type_func):
++ raise ValueError('%r is not callable' % type_func)
++
++ return self._add_action(action)
++
++ def add_argument_group(self, *args, **kwargs):
++ group = _ArgumentGroup(self, *args, **kwargs)
++ self._action_groups.append(group)
++ return group
++
++ def add_mutually_exclusive_group(self, **kwargs):
++ group = _MutuallyExclusiveGroup(self, **kwargs)
++ self._mutually_exclusive_groups.append(group)
++ return group
++
++ def _add_action(self, action):
++ # resolve any conflicts
++ self._check_conflict(action)
++
++ # add to actions list
++ self._actions.append(action)
++ action.container = self
++
++ # index the action by any option strings it has
++ for option_string in action.option_strings:
++ self._option_string_actions[option_string] = action
++
++ # set the flag if any option strings look like negative numbers
++ for option_string in action.option_strings:
++ if self._negative_number_matcher.match(option_string):
++ if not self._has_negative_number_optionals:
++ self._has_negative_number_optionals.append(True)
++
++ # return the created action
++ return action
++
++ def _remove_action(self, action):
++ self._actions.remove(action)
++
++ def _add_container_actions(self, container):
++ # collect groups by titles
++ title_group_map = {}
++ for group in self._action_groups:
++ if group.title in title_group_map:
++ msg = _('cannot merge actions - two groups are named %r')
++ raise ValueError(msg % (group.title))
++ title_group_map[group.title] = group
++
++ # map each action to its group
++ group_map = {}
++ for group in container._action_groups:
++
++ # if a group with the title exists, use that, otherwise
++ # create a new group matching the container's group
++ if group.title not in title_group_map:
++ title_group_map[group.title] = self.add_argument_group(
++ title=group.title,
++ description=group.description,
++ conflict_handler=group.conflict_handler)
++
++ # map the actions to their new group
++ for action in group._group_actions:
++ group_map[action] = title_group_map[group.title]
++
++ # add container's mutually exclusive groups
++ # NOTE: if add_mutually_exclusive_group ever gains title= and
++ # description= then this code will need to be expanded as above
++ for group in container._mutually_exclusive_groups:
++ mutex_group = self.add_mutually_exclusive_group(
++ required=group.required)
++
++ # map the actions to their new mutex group
++ for action in group._group_actions:
++ group_map[action] = mutex_group
++
++ # add all actions to this container or their group
++ for action in container._actions:
++ group_map.get(action, self)._add_action(action)
++
++ def _get_positional_kwargs(self, dest, **kwargs):
++ # make sure required is not specified
++ if 'required' in kwargs:
++ msg = _("'required' is an invalid argument for positionals")
++ raise TypeError(msg)
++
++ # mark positional arguments as required if at least one is
++ # always required
++ if kwargs.get('nargs') not in [OPTIONAL, ZERO_OR_MORE]:
++ kwargs['required'] = True
++ if kwargs.get('nargs') == ZERO_OR_MORE and 'default' not in kwargs:
++ kwargs['required'] = True
++
++ # return the keyword arguments with no option strings
++ return dict(kwargs, dest=dest, option_strings=[])
++
++ def _get_optional_kwargs(self, *args, **kwargs):
++ # determine short and long option strings
++ option_strings = []
++ long_option_strings = []
++ for option_string in args:
++ # error on strings that don't start with an appropriate prefix
++ if not option_string[0] in self.prefix_chars:
++ msg = _('invalid option string %r: '
++ 'must start with a character %r')
++ tup = option_string, self.prefix_chars
++ raise ValueError(msg % tup)
++
++ # strings starting with two prefix characters are long options
++ option_strings.append(option_string)
++ if option_string[0] in self.prefix_chars:
++ if len(option_string) > 1:
++ if option_string[1] in self.prefix_chars:
++ long_option_strings.append(option_string)
++
++ # infer destination, '--foo-bar' -> 'foo_bar' and '-x' -> 'x'
++ dest = kwargs.pop('dest', None)
++ if dest is None:
++ if long_option_strings:
++ dest_option_string = long_option_strings[0]
++ else:
++ dest_option_string = option_strings[0]
++ dest = dest_option_string.lstrip(self.prefix_chars)
++ if not dest:
++ msg = _('dest= is required for options like %r')
++ raise ValueError(msg % option_string)
++ dest = dest.replace('-', '_')
++
++ # return the updated keyword arguments
++ return dict(kwargs, dest=dest, option_strings=option_strings)
++
++ def _pop_action_class(self, kwargs, default=None):
++ action = kwargs.pop('action', default)
++ return self._registry_get('action', action, action)
++
++ def _get_handler(self):
++ # determine function from conflict handler string
++ handler_func_name = '_handle_conflict_%s' % self.conflict_handler
++ try:
++ return getattr(self, handler_func_name)
++ except AttributeError:
++ msg = _('invalid conflict_resolution value: %r')
++ raise ValueError(msg % self.conflict_handler)
++
++ def _check_conflict(self, action):
++
++ # find all options that conflict with this option
++ confl_optionals = []
++ for option_string in action.option_strings:
++ if option_string in self._option_string_actions:
++ confl_optional = self._option_string_actions[option_string]
++ confl_optionals.append((option_string, confl_optional))
++
++ # resolve any conflicts
++ if confl_optionals:
++ conflict_handler = self._get_handler()
++ conflict_handler(action, confl_optionals)
++
++ def _handle_conflict_error(self, action, conflicting_actions):
++ message = _('conflicting option string(s): %s')
++ conflict_string = ', '.join([option_string
++ for option_string, action
++ in conflicting_actions])
++ raise ArgumentError(action, message % conflict_string)
++
++ def _handle_conflict_resolve(self, action, conflicting_actions):
++
++ # remove all conflicting options
++ for option_string, action in conflicting_actions:
++
++ # remove the conflicting option
++ action.option_strings.remove(option_string)
++ self._option_string_actions.pop(option_string, None)
++
++ # if the option now has no option string, remove it from the
++ # container holding it
++ if not action.option_strings:
++ action.container._remove_action(action)
++
++
++class _ArgumentGroup(_ActionsContainer):
++
++ def __init__(self, container, title=None, description=None, **kwargs):
++ # add any missing keyword arguments by checking the container
++ update = kwargs.setdefault
++ update('conflict_handler', container.conflict_handler)
++ update('prefix_chars', container.prefix_chars)
++ update('argument_default', container.argument_default)
++ super_init = super(_ArgumentGroup, self).__init__
++ super_init(description=description, **kwargs)
++
++ # group attributes
++ self.title = title
++ self._group_actions = []
++
++ # share most attributes with the container
++ self._registries = container._registries
++ self._actions = container._actions
++ self._option_string_actions = container._option_string_actions
++ self._defaults = container._defaults
++ self._has_negative_number_optionals = \
++ container._has_negative_number_optionals
++
++ def _add_action(self, action):
++ action = super(_ArgumentGroup, self)._add_action(action)
++ self._group_actions.append(action)
++ return action
++
++ def _remove_action(self, action):
++ super(_ArgumentGroup, self)._remove_action(action)
++ self._group_actions.remove(action)
++
++
++class _MutuallyExclusiveGroup(_ArgumentGroup):
++
++ def __init__(self, container, required=False):
++ super(_MutuallyExclusiveGroup, self).__init__(container)
++ self.required = required
++ self._container = container
++
++ def _add_action(self, action):
++ if action.required:
++ msg = _('mutually exclusive arguments must be optional')
++ raise ValueError(msg)
++ action = self._container._add_action(action)
++ self._group_actions.append(action)
++ return action
++
++ def _remove_action(self, action):
++ self._container._remove_action(action)
++ self._group_actions.remove(action)
++
++
++class ArgumentParser(_AttributeHolder, _ActionsContainer):
++ """Object for parsing command line strings into Python objects.
++
++ Keyword Arguments:
++ - prog -- The name of the program (default: sys.argv[0])
++ - usage -- A usage message (default: auto-generated from arguments)
++ - description -- A description of what the program does
++ - epilog -- Text following the argument descriptions
++ - parents -- Parsers whose arguments should be copied into this one
++ - formatter_class -- HelpFormatter class for printing help messages
++ - prefix_chars -- Characters that prefix optional arguments
++ - fromfile_prefix_chars -- Characters that prefix files containing
++ additional arguments
++ - argument_default -- The default value for all arguments
++ - conflict_handler -- String indicating how to handle conflicts
++ - add_help -- Add a -h/-help option
++ """
++
++ def __init__(self,
++ prog=None,
++ usage=None,
++ description=None,
++ epilog=None,
++ version=None,
++ parents=[],
++ formatter_class=HelpFormatter,
++ prefix_chars='-',
++ fromfile_prefix_chars=None,
++ argument_default=None,
++ conflict_handler='error',
++ add_help=True):
++
++ if version is not None:
++ import warnings
++ warnings.warn(
++ """The "version" argument to ArgumentParser is deprecated. """
++ """Please use """
++ """"add_argument(..., action='version', version="N", ...)" """
++ """instead""", DeprecationWarning)
++
++ superinit = super(ArgumentParser, self).__init__
++ superinit(description=description,
++ prefix_chars=prefix_chars,
++ argument_default=argument_default,
++ conflict_handler=conflict_handler)
++
++ # default setting for prog
++ if prog is None:
++ prog = _os.path.basename(_sys.argv[0])
++
++ self.prog = prog
++ self.usage = usage
++ self.epilog = epilog
++ self.version = version
++ self.formatter_class = formatter_class
++ self.fromfile_prefix_chars = fromfile_prefix_chars
++ self.add_help = add_help
++
++ add_group = self.add_argument_group
++ self._positionals = add_group(_('positional arguments'))
++ self._optionals = add_group(_('optional arguments'))
++ self._subparsers = None
++
++ # register types
++ def identity(string):
++ return string
++ self.register('type', None, identity)
++
++ # add help and version arguments if necessary
++ # (using explicit default to override global argument_default)
++ if '-' in prefix_chars:
++ default_prefix = '-'
++ else:
++ default_prefix = prefix_chars[0]
++ if self.add_help:
++ self.add_argument(
++ default_prefix+'h', default_prefix*2+'help',
++ action='help', default=SUPPRESS,
++ help=_('show this help message and exit'))
++ if self.version:
++ self.add_argument(
++ default_prefix+'v', default_prefix*2+'version',
++ action='version', default=SUPPRESS,
++ version=self.version,
++ help=_("show program's version number and exit"))
++
++ # add parent arguments and defaults
++ for parent in parents:
++ self._add_container_actions(parent)
++ try:
++ defaults = parent._defaults
++ except AttributeError:
++ pass
++ else:
++ self._defaults.update(defaults)
++
++ # =======================
++ # Pretty __repr__ methods
++ # =======================
++ def _get_kwargs(self):
++ names = [
++ 'prog',
++ 'usage',
++ 'description',
++ 'version',
++ 'formatter_class',
++ 'conflict_handler',
++ 'add_help',
++ ]
++ return [(name, getattr(self, name)) for name in names]
++
++ # ==================================
++ # Optional/Positional adding methods
++ # ==================================
++ def add_subparsers(self, **kwargs):
++ if self._subparsers is not None:
++ self.error(_('cannot have multiple subparser arguments'))
++
++ # add the parser class to the arguments if it's not present
++ kwargs.setdefault('parser_class', type(self))
++
++ if 'title' in kwargs or 'description' in kwargs:
++ title = _(kwargs.pop('title', 'subcommands'))
++ description = _(kwargs.pop('description', None))
++ self._subparsers = self.add_argument_group(title, description)
++ else:
++ self._subparsers = self._positionals
++
++ # prog defaults to the usage message of this parser, skipping
++ # optional arguments and with no "usage:" prefix
++ if kwargs.get('prog') is None:
++ formatter = self._get_formatter()
++ positionals = self._get_positional_actions()
++ groups = self._mutually_exclusive_groups
++ formatter.add_usage(self.usage, positionals, groups, '')
++ kwargs['prog'] = formatter.format_help().strip()
++
++ # create the parsers action and add it to the positionals list
++ parsers_class = self._pop_action_class(kwargs, 'parsers')
++ action = parsers_class(option_strings=[], **kwargs)
++ self._subparsers._add_action(action)
++
++ # return the created parsers action
++ return action
++
++ def _add_action(self, action):
++ if action.option_strings:
++ self._optionals._add_action(action)
++ else:
++ self._positionals._add_action(action)
++ return action
++
++ def _get_optional_actions(self):
++ return [action
++ for action in self._actions
++ if action.option_strings]
++
++ def _get_positional_actions(self):
++ return [action
++ for action in self._actions
++ if not action.option_strings]
++
++ # =====================================
++ # Command line argument parsing methods
++ # =====================================
++ def parse_args(self, args=None, namespace=None):
++ args, argv = self.parse_known_args(args, namespace)
++ if argv:
++ msg = _('unrecognized arguments: %s')
++ self.error(msg % ' '.join(argv))
++ return args
++
++ def parse_known_args(self, args=None, namespace=None):
++ # args default to the system args
++ if args is None:
++ args = _sys.argv[1:]
++
++ # default Namespace built from parser defaults
++ if namespace is None:
++ namespace = Namespace()
++
++ # add any action defaults that aren't present
++ for action in self._actions:
++ if action.dest is not SUPPRESS:
++ if not hasattr(namespace, action.dest):
++ if action.default is not SUPPRESS:
++ default = action.default
++ if isinstance(action.default, basestring):
++ default = self._get_value(action, default)
++ setattr(namespace, action.dest, default)
++
++ # add any parser defaults that aren't present
++ for dest in self._defaults:
++ if not hasattr(namespace, dest):
++ setattr(namespace, dest, self._defaults[dest])
++
++ # parse the arguments and exit if there are any errors
++ try:
++ namespace, args = self._parse_known_args(args, namespace)
++ if hasattr(namespace, _UNRECOGNIZED_ARGS_ATTR):
++ args.extend(getattr(namespace, _UNRECOGNIZED_ARGS_ATTR))
++ delattr(namespace, _UNRECOGNIZED_ARGS_ATTR)
++ return namespace, args
++ except ArgumentError:
++ err = _sys.exc_info()[1]
++ self.error(str(err))
++
++ def _parse_known_args(self, arg_strings, namespace):
++ # replace arg strings that are file references
++ if self.fromfile_prefix_chars is not None:
++ arg_strings = self._read_args_from_files(arg_strings)
++
++ # map all mutually exclusive arguments to the other arguments
++ # they can't occur with
++ action_conflicts = {}
++ for mutex_group in self._mutually_exclusive_groups:
++ group_actions = mutex_group._group_actions
++ for i, mutex_action in enumerate(mutex_group._group_actions):
++ conflicts = action_conflicts.setdefault(mutex_action, [])
++ conflicts.extend(group_actions[:i])
++ conflicts.extend(group_actions[i + 1:])
++
++ # find all option indices, and determine the arg_string_pattern
++ # which has an 'O' if there is an option at an index,
++ # an 'A' if there is an argument, or a '-' if there is a '--'
++ option_string_indices = {}
++ arg_string_pattern_parts = []
++ arg_strings_iter = iter(arg_strings)
++ for i, arg_string in enumerate(arg_strings_iter):
++
++ # all args after -- are non-options
++ if arg_string == '--':
++ arg_string_pattern_parts.append('-')
++ for arg_string in arg_strings_iter:
++ arg_string_pattern_parts.append('A')
++
++ # otherwise, add the arg to the arg strings
++ # and note the index if it was an option
++ else:
++ option_tuple = self._parse_optional(arg_string)
++ if option_tuple is None:
++ pattern = 'A'
++ else:
++ option_string_indices[i] = option_tuple
++ pattern = 'O'
++ arg_string_pattern_parts.append(pattern)
++
++ # join the pieces together to form the pattern
++ arg_strings_pattern = ''.join(arg_string_pattern_parts)
++
++ # converts arg strings to the appropriate and then takes the action
++ seen_actions = set()
++ seen_non_default_actions = set()
++
++ def take_action(action, argument_strings, option_string=None):
++ seen_actions.add(action)
++ argument_values = self._get_values(action, argument_strings)
++
++ # error if this argument is not allowed with other previously
++ # seen arguments, assuming that actions that use the default
++ # value don't really count as "present"
++ if argument_values is not action.default:
++ seen_non_default_actions.add(action)
++ for conflict_action in action_conflicts.get(action, []):
++ if conflict_action in seen_non_default_actions:
++ msg = _('not allowed with argument %s')
++ action_name = _get_action_name(conflict_action)
++ raise ArgumentError(action, msg % action_name)
++
++ # take the action if we didn't receive a SUPPRESS value
++ # (e.g. from a default)
++ if argument_values is not SUPPRESS:
++ action(self, namespace, argument_values, option_string)
++
++ # function to convert arg_strings into an optional action
++ def consume_optional(start_index):
++
++ # get the optional identified at this index
++ option_tuple = option_string_indices[start_index]
++ action, option_string, explicit_arg = option_tuple
++
++ # identify additional optionals in the same arg string
++ # (e.g. -xyz is the same as -x -y -z if no args are required)
++ match_argument = self._match_argument
++ action_tuples = []
++ while True:
++
++ # if we found no optional action, skip it
++ if action is None:
++ extras.append(arg_strings[start_index])
++ return start_index + 1
++
++ # if there is an explicit argument, try to match the
++ # optional's string arguments to only this
++ if explicit_arg is not None:
++ arg_count = match_argument(action, 'A')
++
++ # if the action is a single-dash option and takes no
++ # arguments, try to parse more single-dash options out
++ # of the tail of the option string
++ chars = self.prefix_chars
++ if arg_count == 0 and option_string[1] not in chars:
++ action_tuples.append((action, [], option_string))
++ char = option_string[0]
++ option_string = char + explicit_arg[0]
++ new_explicit_arg = explicit_arg[1:] or None
++ optionals_map = self._option_string_actions
++ if option_string in optionals_map:
++ action = optionals_map[option_string]
++ explicit_arg = new_explicit_arg
++ else:
++ msg = _('ignored explicit argument %r')
++ raise ArgumentError(action, msg % explicit_arg)
++
++ # if the action expect exactly one argument, we've
++ # successfully matched the option; exit the loop
++ elif arg_count == 1:
++ stop = start_index + 1
++ args = [explicit_arg]
++ action_tuples.append((action, args, option_string))
++ break
++
++ # error if a double-dash option did not use the
++ # explicit argument
++ else:
++ msg = _('ignored explicit argument %r')
++ raise ArgumentError(action, msg % explicit_arg)
++
++ # if there is no explicit argument, try to match the
++ # optional's string arguments with the following strings
++ # if successful, exit the loop
++ else:
++ start = start_index + 1
++ selected_patterns = arg_strings_pattern[start:]
++ arg_count = match_argument(action, selected_patterns)
++ stop = start + arg_count
++ args = arg_strings[start:stop]
++ action_tuples.append((action, args, option_string))
++ break
++
++ # add the Optional to the list and return the index at which
++ # the Optional's string args stopped
++ assert action_tuples
++ for action, args, option_string in action_tuples:
++ take_action(action, args, option_string)
++ return stop
++
++ # the list of Positionals left to be parsed; this is modified
++ # by consume_positionals()
++ positionals = self._get_positional_actions()
++
++ # function to convert arg_strings into positional actions
++ def consume_positionals(start_index):
++ # match as many Positionals as possible
++ match_partial = self._match_arguments_partial
++ selected_pattern = arg_strings_pattern[start_index:]
++ arg_counts = match_partial(positionals, selected_pattern)
++
++ # slice off the appropriate arg strings for each Positional
++ # and add the Positional and its args to the list
++ for action, arg_count in zip(positionals, arg_counts):
++ args = arg_strings[start_index: start_index + arg_count]
++ start_index += arg_count
++ take_action(action, args)
++
++ # slice off the Positionals that we just parsed and return the
++ # index at which the Positionals' string args stopped
++ positionals[:] = positionals[len(arg_counts):]
++ return start_index
++
++ # consume Positionals and Optionals alternately, until we have
++ # passed the last option string
++ extras = []
++ start_index = 0
++ if option_string_indices:
++ max_option_string_index = max(option_string_indices)
++ else:
++ max_option_string_index = -1
++ while start_index <= max_option_string_index:
++
++ # consume any Positionals preceding the next option
++ next_option_string_index = min([
++ index
++ for index in option_string_indices
++ if index >= start_index])
++ if start_index != next_option_string_index:
++ positionals_end_index = consume_positionals(start_index)
++
++ # only try to parse the next optional if we didn't consume
++ # the option string during the positionals parsing
++ if positionals_end_index > start_index:
++ start_index = positionals_end_index
++ continue
++ else:
++ start_index = positionals_end_index
++
++ # if we consumed all the positionals we could and we're not
++ # at the index of an option string, there were extra arguments
++ if start_index not in option_string_indices:
++ strings = arg_strings[start_index:next_option_string_index]
++ extras.extend(strings)
++ start_index = next_option_string_index
++
++ # consume the next optional and any arguments for it
++ start_index = consume_optional(start_index)
++
++ # consume any positionals following the last Optional
++ stop_index = consume_positionals(start_index)
++
++ # if we didn't consume all the argument strings, there were extras
++ extras.extend(arg_strings[stop_index:])
++
++ # if we didn't use all the Positional objects, there were too few
++ # arg strings supplied.
++ if positionals:
++ self.error(_('too few arguments'))
++
++ # make sure all required actions were present
++ for action in self._actions:
++ if action.required:
++ if action not in seen_actions:
++ name = _get_action_name(action)
++ self.error(_('argument %s is required') % name)
++
++ # make sure all required groups had one option present
++ for group in self._mutually_exclusive_groups:
++ if group.required:
++ for action in group._group_actions:
++ if action in seen_non_default_actions:
++ break
++
++ # if no actions were used, report the error
++ else:
++ names = [_get_action_name(action)
++ for action in group._group_actions
++ if action.help is not SUPPRESS]
++ msg = _('one of the arguments %s is required')
++ self.error(msg % ' '.join(names))
++
++ # return the updated namespace and the extra arguments
++ return namespace, extras
++
++ def _read_args_from_files(self, arg_strings):
++ # expand arguments referencing files
++ new_arg_strings = []
++ for arg_string in arg_strings:
++
++ # for regular arguments, just add them back into the list
++ if arg_string[0] not in self.fromfile_prefix_chars:
++ new_arg_strings.append(arg_string)
++
++ # replace arguments referencing files with the file content
++ else:
++ try:
++ args_file = open(arg_string[1:])
++ try:
++ arg_strings = []
++ for arg_line in args_file.read().splitlines():
++ for arg in self.convert_arg_line_to_args(arg_line):
++ arg_strings.append(arg)
++ arg_strings = self._read_args_from_files(arg_strings)
++ new_arg_strings.extend(arg_strings)
++ finally:
++ args_file.close()
++ except IOError:
++ err = _sys.exc_info()[1]
++ self.error(str(err))
++
++ # return the modified argument list
++ return new_arg_strings
++
++ def convert_arg_line_to_args(self, arg_line):
++ return [arg_line]
++
++ def _match_argument(self, action, arg_strings_pattern):
++ # match the pattern for this action to the arg strings
++ nargs_pattern = self._get_nargs_pattern(action)
++ match = _re.match(nargs_pattern, arg_strings_pattern)
++
++ # raise an exception if we weren't able to find a match
++ if match is None:
++ nargs_errors = {
++ None: _('expected one argument'),
++ OPTIONAL: _('expected at most one argument'),
++ ONE_OR_MORE: _('expected at least one argument'),
++ }
++ default = _('expected %s argument(s)') % action.nargs
++ msg = nargs_errors.get(action.nargs, default)
++ raise ArgumentError(action, msg)
++
++ # return the number of arguments matched
++ return len(match.group(1))
++
++ def _match_arguments_partial(self, actions, arg_strings_pattern):
++ # progressively shorten the actions list by slicing off the
++ # final actions until we find a match
++ result = []
++ for i in range(len(actions), 0, -1):
++ actions_slice = actions[:i]
++ pattern = ''.join([self._get_nargs_pattern(action)
++ for action in actions_slice])
++ match = _re.match(pattern, arg_strings_pattern)
++ if match is not None:
++ result.extend([len(string) for string in match.groups()])
++ break
++
++ # return the list of arg string counts
++ return result
++
++ def _parse_optional(self, arg_string):
++ # if it's an empty string, it was meant to be a positional
++ if not arg_string:
++ return None
++
++ # if it doesn't start with a prefix, it was meant to be positional
++ if not arg_string[0] in self.prefix_chars:
++ return None
++
++ # if the option string is present in the parser, return the action
++ if arg_string in self._option_string_actions:
++ action = self._option_string_actions[arg_string]
++ return action, arg_string, None
++
++ # if it's just a single character, it was meant to be positional
++ if len(arg_string) == 1:
++ return None
++
++ # if the option string before the "=" is present, return the action
++ if '=' in arg_string:
++ option_string, explicit_arg = arg_string.split('=', 1)
++ if option_string in self._option_string_actions:
++ action = self._option_string_actions[option_string]
++ return action, option_string, explicit_arg
++
++ # search through all possible prefixes of the option string
++ # and all actions in the parser for possible interpretations
++ option_tuples = self._get_option_tuples(arg_string)
++
++ # if multiple actions match, the option string was ambiguous
++ if len(option_tuples) > 1:
++ options = ', '.join([option_string
++ for action, option_string, explicit_arg in option_tuples])
++ tup = arg_string, options
++ self.error(_('ambiguous option: %s could match %s') % tup)
++
++ # if exactly one action matched, this segmentation is good,
++ # so return the parsed action
++ elif len(option_tuples) == 1:
++ option_tuple, = option_tuples
++ return option_tuple
++
++ # if it was not found as an option, but it looks like a negative
++ # number, it was meant to be positional
++ # unless there are negative-number-like options
++ if self._negative_number_matcher.match(arg_string):
++ if not self._has_negative_number_optionals:
++ return None
++
++ # if it contains a space, it was meant to be a positional
++ if ' ' in arg_string:
++ return None
++
++ # it was meant to be an optional but there is no such option
++ # in this parser (though it might be a valid option in a subparser)
++ return None, arg_string, None
++
++ def _get_option_tuples(self, option_string):
++ result = []
++
++ # option strings starting with two prefix characters are only
++ # split at the '='
++ chars = self.prefix_chars
++ if option_string[0] in chars and option_string[1] in chars:
++ if '=' in option_string:
++ option_prefix, explicit_arg = option_string.split('=', 1)
++ else:
++ option_prefix = option_string
++ explicit_arg = None
++ for option_string in self._option_string_actions:
++ if option_string.startswith(option_prefix):
++ action = self._option_string_actions[option_string]
++ tup = action, option_string, explicit_arg
++ result.append(tup)
++
++ # single character options can be concatenated with their arguments
++ # but multiple character options always have to have their argument
++ # separate
++ elif option_string[0] in chars and option_string[1] not in chars:
++ option_prefix = option_string
++ explicit_arg = None
++ short_option_prefix = option_string[:2]
++ short_explicit_arg = option_string[2:]
++
++ for option_string in self._option_string_actions:
++ if option_string == short_option_prefix:
++ action = self._option_string_actions[option_string]
++ tup = action, option_string, short_explicit_arg
++ result.append(tup)
++ elif option_string.startswith(option_prefix):
++ action = self._option_string_actions[option_string]
++ tup = action, option_string, explicit_arg
++ result.append(tup)
++
++ # shouldn't ever get here
++ else:
++ self.error(_('unexpected option string: %s') % option_string)
++
++ # return the collected option tuples
++ return result
++
++ def _get_nargs_pattern(self, action):
++ # in all examples below, we have to allow for '--' args
++ # which are represented as '-' in the pattern
++ nargs = action.nargs
++
++ # the default (None) is assumed to be a single argument
++ if nargs is None:
++ nargs_pattern = '(-*A-*)'
++
++ # allow zero or one arguments
++ elif nargs == OPTIONAL:
++ nargs_pattern = '(-*A?-*)'
++
++ # allow zero or more arguments
++ elif nargs == ZERO_OR_MORE:
++ nargs_pattern = '(-*[A-]*)'
++
++ # allow one or more arguments
++ elif nargs == ONE_OR_MORE:
++ nargs_pattern = '(-*A[A-]*)'
++
++ # allow any number of options or arguments
++ elif nargs == REMAINDER:
++ nargs_pattern = '([-AO]*)'
++
++ # allow one argument followed by any number of options or arguments
++ elif nargs == PARSER:
++ nargs_pattern = '(-*A[-AO]*)'
++
++ # all others should be integers
++ else:
++ nargs_pattern = '(-*%s-*)' % '-*'.join('A' * nargs)
++
++ # if this is an optional action, -- is not allowed
++ if action.option_strings:
++ nargs_pattern = nargs_pattern.replace('-*', '')
++ nargs_pattern = nargs_pattern.replace('-', '')
++
++ # return the pattern
++ return nargs_pattern
++
++ # ========================
++ # Value conversion methods
++ # ========================
++ def _get_values(self, action, arg_strings):
++ # for everything but PARSER args, strip out '--'
++ if action.nargs not in [PARSER, REMAINDER]:
++ arg_strings = [s for s in arg_strings if s != '--']
++
++ # optional argument produces a default when not present
++ if not arg_strings and action.nargs == OPTIONAL:
++ if action.option_strings:
++ value = action.const
++ else:
++ value = action.default
++ if isinstance(value, basestring):
++ value = self._get_value(action, value)
++ self._check_value(action, value)
++
++ # when nargs='*' on a positional, if there were no command-line
++ # args, use the default if it is anything other than None
++ elif (not arg_strings and action.nargs == ZERO_OR_MORE and
++ not action.option_strings):
++ if action.default is not None:
++ value = action.default
++ else:
++ value = arg_strings
++ self._check_value(action, value)
++
++ # single argument or optional argument produces a single value
++ elif len(arg_strings) == 1 and action.nargs in [None, OPTIONAL]:
++ arg_string, = arg_strings
++ value = self._get_value(action, arg_string)
++ self._check_value(action, value)
++
++ # REMAINDER arguments convert all values, checking none
++ elif action.nargs == REMAINDER:
++ value = [self._get_value(action, v) for v in arg_strings]
++
++ # PARSER arguments convert all values, but check only the first
++ elif action.nargs == PARSER:
++ value = [self._get_value(action, v) for v in arg_strings]
++ self._check_value(action, value[0])
++
++ # all other types of nargs produce a list
++ else:
++ value = [self._get_value(action, v) for v in arg_strings]
++ for v in value:
++ self._check_value(action, v)
++
++ # return the converted value
++ return value
++
++ def _get_value(self, action, arg_string):
++ type_func = self._registry_get('type', action.type, action.type)
++ if not _callable(type_func):
++ msg = _('%r is not callable')
++ raise ArgumentError(action, msg % type_func)
++
++ # convert the value to the appropriate type
++ try:
++ result = type_func(arg_string)
++
++ # ArgumentTypeErrors indicate errors
++ except ArgumentTypeError:
++ name = getattr(action.type, '__name__', repr(action.type))
++ msg = str(_sys.exc_info()[1])
++ raise ArgumentError(action, msg)
++
++ # TypeErrors or ValueErrors also indicate errors
++ except (TypeError, ValueError):
++ name = getattr(action.type, '__name__', repr(action.type))
++ msg = _('invalid %s value: %r')
++ raise ArgumentError(action, msg % (name, arg_string))
++
++ # return the converted value
++ return result
++
++ def _check_value(self, action, value):
++ # converted value must be one of the choices (if specified)
++ if action.choices is not None and value not in action.choices:
++ tup = value, ', '.join(map(repr, action.choices))
++ msg = _('invalid choice: %r (choose from %s)') % tup
++ raise ArgumentError(action, msg)
++
++ # =======================
++ # Help-formatting methods
++ # =======================
++ def format_usage(self):
++ formatter = self._get_formatter()
++ formatter.add_usage(self.usage, self._actions,
++ self._mutually_exclusive_groups)
++ return formatter.format_help()
++
++ def format_help(self):
++ formatter = self._get_formatter()
++
++ # usage
++ formatter.add_usage(self.usage, self._actions,
++ self._mutually_exclusive_groups)
++
++ # description
++ formatter.add_text(self.description)
++
++ # positionals, optionals and user-defined groups
++ for action_group in self._action_groups:
++ formatter.start_section(action_group.title)
++ formatter.add_text(action_group.description)
++ formatter.add_arguments(action_group._group_actions)
++ formatter.end_section()
++
++ # epilog
++ formatter.add_text(self.epilog)
++
++ # determine help from format above
++ return formatter.format_help()
++
++ def format_version(self):
++ import warnings
++ warnings.warn(
++ 'The format_version method is deprecated -- the "version" '
++ 'argument to ArgumentParser is no longer supported.',
++ DeprecationWarning)
++ formatter = self._get_formatter()
++ formatter.add_text(self.version)
++ return formatter.format_help()
++
++ def _get_formatter(self):
++ return self.formatter_class(prog=self.prog)
++
++ # =====================
++ # Help-printing methods
++ # =====================
++ def print_usage(self, file=None):
++ if file is None:
++ file = _sys.stdout
++ self._print_message(self.format_usage(), file)
++
++ def print_help(self, file=None):
++ if file is None:
++ file = _sys.stdout
++ self._print_message(self.format_help(), file)
++
++ def print_version(self, file=None):
++ import warnings
++ warnings.warn(
++ 'The print_version method is deprecated -- the "version" '
++ 'argument to ArgumentParser is no longer supported.',
++ DeprecationWarning)
++ self._print_message(self.format_version(), file)
++
++ def _print_message(self, message, file=None):
++ if message:
++ if file is None:
++ file = _sys.stderr
++ file.write(message)
++
++ # ===============
++ # Exiting methods
++ # ===============
++ def exit(self, status=0, message=None):
++ if message:
++ self._print_message(message, _sys.stderr)
++ _sys.exit(status)
++
++ def error(self, message):
++ """error(message: string)
++
++ Prints a usage message incorporating the message to stderr and
++ exits.
++
++ If you override this in a subclass, it should not return -- it
++ should either exit or raise an exception.
++ """
++ self.print_usage(_sys.stderr)
++ self.exit(2, _('%s: error: %s\n') % (self.prog, message))
+diff -up mozilla-esr24/rebase/ordereddict.py.python mozilla-esr24/rebase/ordereddict.py
+--- mozilla-esr24/rebase/ordereddict.py.python 2013-10-22 16:49:25.033378278 +0200
++++ mozilla-esr24/rebase/ordereddict.py 2013-10-22 14:29:24.000000000 +0200
+@@ -0,0 +1,127 @@
++# Copyright (c) 2009 Raymond Hettinger
++#
++# Permission is hereby granted, free of charge, to any person
++# obtaining a copy of this software and associated documentation files
++# (the "Software"), to deal in the Software without restriction,
++# including without limitation the rights to use, copy, modify, merge,
++# publish, distribute, sublicense, and/or sell copies of the Software,
++# and to permit persons to whom the Software is furnished to do so,
++# subject to the following conditions:
++#
++# The above copyright notice and this permission notice shall be
++# included in all copies or substantial portions of the Software.
++#
++# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
++# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
++# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
++# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
++# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
++# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
++# OTHER DEALINGS IN THE SOFTWARE.
++
++from UserDict import DictMixin
++
++class OrderedDict(dict, DictMixin):
++
++ def __init__(self, *args, **kwds):
++ if len(args) > 1:
++ raise TypeError('expected at most 1 arguments, got %d' % len(args))
++ try:
++ self.__end
++ except AttributeError:
++ self.clear()
++ self.update(*args, **kwds)
++
++ def clear(self):
++ self.__end = end = []
++ end += [None, end, end] # sentinel node for doubly linked list
++ self.__map = {} # key --> [key, prev, next]
++ dict.clear(self)
++
++ def __setitem__(self, key, value):
++ if key not in self:
++ end = self.__end
++ curr = end[1]
++ curr[2] = end[1] = self.__map[key] = [key, curr, end]
++ dict.__setitem__(self, key, value)
++
++ def __delitem__(self, key):
++ dict.__delitem__(self, key)
++ key, prev, next = self.__map.pop(key)
++ prev[2] = next
++ next[1] = prev
++
++ def __iter__(self):
++ end = self.__end
++ curr = end[2]
++ while curr is not end:
++ yield curr[0]
++ curr = curr[2]
++
++ def __reversed__(self):
++ end = self.__end
++ curr = end[1]
++ while curr is not end:
++ yield curr[0]
++ curr = curr[1]
++
++ def popitem(self, last=True):
++ if not self:
++ raise KeyError('dictionary is empty')
++ if last:
++ key = reversed(self).next()
++ else:
++ key = iter(self).next()
++ value = self.pop(key)
++ return key, value
++
++ def __reduce__(self):
++ items = [[k, self[k]] for k in self]
++ tmp = self.__map, self.__end
++ del self.__map, self.__end
++ inst_dict = vars(self).copy()
++ self.__map, self.__end = tmp
++ if inst_dict:
++ return (self.__class__, (items,), inst_dict)
++ return self.__class__, (items,)
++
++ def keys(self):
++ return list(self)
++
++ setdefault = DictMixin.setdefault
++ update = DictMixin.update
++ pop = DictMixin.pop
++ values = DictMixin.values
++ items = DictMixin.items
++ iterkeys = DictMixin.iterkeys
++ itervalues = DictMixin.itervalues
++ iteritems = DictMixin.iteritems
++
++ def __repr__(self):
++ if not self:
++ return '%s()' % (self.__class__.__name__,)
++ return '%s(%r)' % (self.__class__.__name__, self.items())
++
++ def copy(self):
++ return self.__class__(self)
++
++ @classmethod
++ def fromkeys(cls, iterable, value=None):
++ d = cls()
++ for key in iterable:
++ d[key] = value
++ return d
++
++ def __eq__(self, other):
++ if isinstance(other, OrderedDict):
++ if len(self) != len(other):
++ return False
++ for p, q in zip(self.items(), other.items()):
++ if p != q:
++ return False
++ return True
++ return dict.__eq__(self, other)
++
++ def __ne__(self, other):
++ return not self == other
+diff -up mozilla-esr24/toolkit/components/telemetry/histogram_tools.py.python mozilla-esr24/toolkit/components/telemetry/histogram_tools.py
+--- mozilla-esr24/toolkit/components/telemetry/histogram_tools.py.python 2013-09-11 05:22:53.000000000 +0200
++++ mozilla-esr24/toolkit/components/telemetry/histogram_tools.py 2013-10-22 14:29:24.564993891 +0200
+@@ -5,13 +5,8 @@
+ import math
+
+ # For compatibility with Python 2.6
+-try:
+- from collections import OrderedDict
+-except ImportError:
+- from simplejson import OrderedDict
+- import simplejson as json
+-else:
+- import json
++from simplejson import OrderedDict
++import simplejson as json
+
+ def table_dispatch(kind, table, body):
+ """Call body with table[kind] if it exists. Raise an error otherwise."""
+diff -up mozilla-esr24/toolkit/mozapps/installer/find-dupes.py.python mozilla-esr24/toolkit/mozapps/installer/find-dupes.py
+--- mozilla-esr24/toolkit/mozapps/installer/find-dupes.py.python 2013-09-11 05:22:55.000000000 +0200
++++ mozilla-esr24/toolkit/mozapps/installer/find-dupes.py 2013-10-22 14:29:24.564993891 +0200
+@@ -5,7 +5,7 @@
+ import sys
+ import hashlib
+ from mozpack.packager.unpack import UnpackFinder
+-from collections import OrderedDict
++from ordereddict import OrderedDict
+
+ '''
+ Find files duplicated in a given packaged directory, independently of its
diff --git a/thunderbird-lightning.spec b/thunderbird-lightning.spec
index 792d31e..807fdb1 100644
--- a/thunderbird-lightning.spec
+++ b/thunderbird-lightning.spec
@@ -51,6 +51,8 @@ Patch0: thunderbird-version.patch
Patch1: mozilla-build-arm.patch
# Fix build on secondary arches (patches copied from xulrunner)
Patch2: xulrunner-10.0-secondary-ipc.patch
+
+Patch097: mozilla-python.patch
Patch099: mozilla-build.patch
Patch100: xulrunner-2.0-chromium-types.patch
Patch103: xulrunner-gc-sections-ppc.patch
@@ -127,6 +129,8 @@ sed -e 's/__RPM_VERSION_INTERNAL__/%{version_internal}/' %{P:%%PATCH0} \
cd mozilla
%patch1 -p2 -b .arm-fix
%patch2 -p3 -b .secondary-ipc
+%patch097 -p1 -b .python
+%patch099 -p1 -b .build
%patch099 -p1 -b .build
%patch100 -p2 -b .chromium-types
More information about the scm-commits
mailing list